proxmox-mirrors/mirror_smartmontools-debian
1
0
Fork 0
mirror of https://git.proxmox.com/git/mirror_smartmontools-debian synced 2025-05-13 05:24:14 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
34ad0c5ffe
mirror_smartmontools-debian/smartd.cpp
Guido Guenther 34ad0c5ffe Imported Upstream version 5.38
2008-03-11 20:38:35 +01:00

4516 lines
148 KiB
C++
Raw Blame History

/*
* Home page of code is: http://smartmontools.sourceforge.net
*
* Copyright (C) 2002-8 Bruce Allen <smartmontools-support@lists.sourceforge.net>
* Copyright (C) 2000 Michael Cornwell <cornwell@acm.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, or (at your option)
* any later version.
*
* You should have received a copy of the GNU General Public License
* (for example COPYING); if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
* This code was originally developed as a Senior Thesis by Michael Cornwell
* at the Concurrent Systems Laboratory (now part of the Storage Systems
* Research Center), Jack Baskin School of Engineering, University of
* California, Santa Cruz. http://ssrc.soe.ucsc.edu/
*
*/
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
// unconditionally included files
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h> // umask
#ifndef _WIN32
#include <sys/wait.h>
#include <unistd.h>
#endif
#include <signal.h>
#include <fcntl.h>
#include <string.h>
#include <syslog.h>
#include <stdarg.h>
#include <stdlib.h>
#include <errno.h>
#include <time.h>
#include <limits.h>
#if SCSITIMEOUT
#include <setjmp.h>
#endif
// see which system files to conditionally include
#include "config.h"
// conditionally included files
#ifdef HAVE_GETOPT_LONG
#include <getopt.h>
#endif
#ifdef HAVE_NETDB_H
#include <netdb.h>
#endif
#ifdef _WIN32
#ifdef _MSC_VER
#pragma warning(disable:4761) // "conversion supplied"
typedef unsigned short mode_t;
typedef int pid_t;
#endif
#include <io.h> // umask()
#include <process.h> // getpid()
#endif // _WIN32
#ifdef __CYGWIN__
// From <windows.h>:
// BOOL WINAPI FreeConsole(void);
extern "C" int __stdcall FreeConsole(void);
#include <io.h> // setmode()
#endif // __CYGWIN__
// locally included files
#include "int64.h"
#include "atacmds.h"
#include "ataprint.h"
#include "extern.h"
#include "knowndrives.h"
#include "scsicmds.h"
#include "scsiata.h"
#include "smartd.h"
#include "utility.h"
#ifdef _WIN32
#include "hostname_win32.h" // gethost/domainname()
#define HAVE_GETHOSTNAME 1
#define HAVE_GETDOMAINNAME 1
// fork()/signal()/initd simulation for native Windows
#include "daemon_win32.h" // daemon_main/detach/signal()
#undef SIGNALFN
#define SIGNALFN daemon_signal
#define strsignal daemon_strsignal
#define sleep daemon_sleep
#undef EXIT // see utility.h
#define EXIT(x) { exitstatus = daemon_winsvc_exitcode = (x); exit((x)); }
// SIGQUIT does not exits, CONTROL-Break signals SIGBREAK.
#define SIGQUIT SIGBREAK
#define SIGQUIT_KEYNAME "CONTROL-Break"
#else // _WIN32
#ifdef __CYGWIN__
// 2x CONTROL-C simulates missing SIGQUIT via keyboard
#define SIGQUIT_KEYNAME "2x CONTROL-C"
#else // __CYGWIN__
#define SIGQUIT_KEYNAME "CONTROL-\\"
#endif // __CYGWIN__
#endif // _WIN32
#if defined (__SVR4) && defined (__sun)
extern "C" int getdomainname(char *, int); // no declaration in header files!
#endif
#define ARGUSED(x) ((void)(x))
// These are CVS identification information for *.cpp and *.h files
extern const char *atacmdnames_c_cvsid, *atacmds_c_cvsid, *ataprint_c_cvsid, *escalade_c_cvsid,
*knowndrives_c_cvsid, *os_XXXX_c_cvsid, *scsicmds_c_cvsid, *utility_c_cvsid;
static const char *filenameandversion="$Id: smartd.cpp,v 1.397 2008/03/04 22:09:47 ballen4705 Exp $";
#ifdef NEED_SOLARIS_ATA_CODE
extern const char *os_solaris_ata_s_cvsid;
#endif
#ifdef _WIN32
extern const char *daemon_win32_c_cvsid, *hostname_win32_c_cvsid, *syslog_win32_c_cvsid;
#endif
const char *smartd_c_cvsid="$Id: smartd.cpp,v 1.397 2008/03/04 22:09:47 ballen4705 Exp $"
ATACMDS_H_CVSID ATAPRINT_H_CVSID CONFIG_H_CVSID
#ifdef DAEMON_WIN32_H_CVSID
DAEMON_WIN32_H_CVSID
#endif
EXTERN_H_CVSID INT64_H_CVSID
#ifdef HOSTNAME_WIN32_H_CVSID
HOSTNAME_WIN32_H_CVSID
#endif
KNOWNDRIVES_H_CVSID SCSICMDS_H_CVSID SMARTD_H_CVSID
#ifdef SYSLOG_H_CVSID
SYSLOG_H_CVSID
#endif
UTILITY_H_CVSID;
extern const char *reportbug;
// GNU copyleft statement. Needed for GPL purposes.
const char *copyleftstring="smartd comes with ABSOLUTELY NO WARRANTY. This is\n"
"free software, and you are welcome to redistribute it\n"
"under the terms of the GNU General Public License\n"
"Version 2. See http://www.gnu.org for further details.\n\n";
extern unsigned char debugmode;
// command-line: how long to sleep between checks
static int checktime=CHECKTIME;
// command-line: name of PID file (NULL for no pid file)
static char* pid_file=NULL;
// configuration file name
#ifndef _WIN32
static char* configfile = SMARTMONTOOLS_SYSCONFDIR "/" CONFIGFILENAME ;
#else
static char* configfile = "./" CONFIGFILENAME ;
#endif
// configuration file "name" if read from stdin
static /*const*/ char * const configfile_stdin = "<stdin>";
// allocated memory for alternate configuration file name
static char* configfile_alt = NULL;
// command-line: when should we exit?
static int quit=0;
// command-line; this is the default syslog(3) log facility to use.
static int facility=LOG_DAEMON;
#ifndef _WIN32
// command-line: fork into background?
static bool do_fork=true;
#endif
// used for control of printing, passing arguments to atacmds.c
smartmonctrl *con=NULL;
// pointers to (real or simulated) entries in configuration file, and
// maximum space currently allocated for these entries.
cfgfile **cfgentries=NULL;
int cfgentries_max=0;
// pointers to ATA and SCSI devices being monitored, maximum and
// actual numbers
cfgfile **ATAandSCSIdevlist=NULL;
int ATAandSCSIdevlist_max=0;
int numdevata=0, numdevscsi=0;
// track memory usage
extern int64_t bytes;
// exit status
extern int exitstatus;
// set to one if we catch a USR1 (check devices now)
volatile int caughtsigUSR1=0;
#ifdef _WIN32
// set to one if we catch a USR2 (toggle debug mode)
volatile int caughtsigUSR2=0;
#endif
// set to one if we catch a HUP (reload config file). In debug mode,
// set to two, if we catch INT (also reload config file).
volatile int caughtsigHUP=0;
// set to signal value if we catch INT, QUIT, or TERM
volatile int caughtsigEXIT=0;
#if SCSITIMEOUT
// stack environment if we time out during SCSI access (USB devices)
jmp_buf registerscsienv;
#endif
// tranlate cfg->pending into the correct Attribute numbers
void TranslatePending(unsigned short pending, unsigned char *current, unsigned char *offline) {
unsigned char curr = CURR_PEND(pending);
unsigned char off = OFF_PEND(pending);
// look for special value of CUR_UNC_DEFAULT that means DONT
// monitor. 0 means DO test.
if (curr==CUR_UNC_DEFAULT)
curr=0;
else if (curr==0)
curr=CUR_UNC_DEFAULT;
// look for special value of OFF_UNC_DEFAULT that means DONT
// monitor. 0 means DO TEST.
if (off==OFF_UNC_DEFAULT)
off=0;
else if (off==0)
off=OFF_UNC_DEFAULT;
*current=curr;
*offline=off;
return;
}
// free all memory associated with selftest part of configfile entry. Return NULL
testinfo* FreeTestData(testinfo *data){
// make sure we have something to do.
if (!data)
return NULL;
// free space for text pattern
data->regex=FreeNonZero(data->regex, -1, __LINE__, filenameandversion);
// free compiled expression
regfree(&(data->cregex));
// make sure that no sign of the compiled expression is left behind
// (just in case, to help detect bugs if we ever try and refer to
// that again).
memset(&(data->cregex), '0', sizeof(regex_t));
// free remaining memory space
data=FreeNonZero(data, sizeof(testinfo), __LINE__, filenameandversion);
return NULL;
}
cfgfile **AllocateMoreSpace(cfgfile **oldarray, int *oldsize, char *listname){
// for now keep BLOCKSIZE small to help detect coding problems.
// Perhaps increase in the future.
const int BLOCKSIZE=8;
int i;
int olds = *oldsize;
int news = olds + BLOCKSIZE;
cfgfile **newptr=(cfgfile **)realloc(oldarray, news*sizeof(cfgfile *));
// did we get more space?
if (newptr) {
// clear remaining entries ala calloc()
for (i=olds; i<news; i++)
newptr[i]=NULL;
bytes += BLOCKSIZE*sizeof(cfgfile *);
*oldsize=news;
#if 0
PrintOut(LOG_INFO, "allocating %d slots for %s\n", BLOCKSIZE, listname);
#endif
return newptr;
}
PrintOut(LOG_CRIT, "out of memory for allocating %s list\n", listname);
EXIT(EXIT_NOMEM);
}
void PrintOneCVS(const char *a_cvs_id){
char out[CVSMAXLEN];
printone(out,a_cvs_id);
PrintOut(LOG_INFO,"%s",out);
return;
}
// prints CVS identity information for the executable
void PrintCVS(void){
const char *configargs=strlen(SMARTMONTOOLS_CONFIGURE_ARGS)?SMARTMONTOOLS_CONFIGURE_ARGS:"[no arguments given]";
PrintOut(LOG_INFO,(char *)copyleftstring);
PrintOut(LOG_INFO,"CVS version IDs of files used to build this code are:\n");
PrintOneCVS(atacmdnames_c_cvsid);
PrintOneCVS(atacmds_c_cvsid);
PrintOneCVS(ataprint_c_cvsid);
#ifdef _WIN32
PrintOneCVS(daemon_win32_c_cvsid);
#endif
#ifdef _WIN32
PrintOneCVS(hostname_win32_c_cvsid);
#endif
PrintOneCVS(knowndrives_c_cvsid);
PrintOneCVS(os_XXXX_c_cvsid);
#ifdef NEED_SOLARIS_ATA_CODE
PrintOneCVS( os_solaris_ata_s_cvsid);
#endif
PrintOneCVS(scsicmds_c_cvsid);
PrintOneCVS(smartd_c_cvsid);
#ifdef _WIN32
PrintOneCVS(syslog_win32_c_cvsid);
#endif
PrintOneCVS(utility_c_cvsid);
PrintOut(LOG_INFO, "\nsmartmontools release " PACKAGE_VERSION " dated " SMARTMONTOOLS_RELEASE_DATE " at " SMARTMONTOOLS_RELEASE_TIME "\n");
PrintOut(LOG_INFO, "smartmontools build host: " SMARTMONTOOLS_BUILD_HOST "\n");
PrintOut(LOG_INFO, "smartmontools build configured: " SMARTMONTOOLS_CONFIGURE_DATE "\n");
PrintOut(LOG_INFO, "smartd compile dated " __DATE__ " at "__TIME__ "\n");
PrintOut(LOG_INFO, "smartmontools configure arguments: %s\n", configargs);
return;
}
// Removes config file entry, freeing all memory
void RmConfigEntry(cfgfile **anentry, int whatline){
cfgfile *cfg;
// pointer should never be null!
if (!anentry){
PrintOut(LOG_CRIT,"Internal error in RmConfigEntry() at line %d of file %s\n%s",
whatline, filenameandversion, reportbug);
EXIT(EXIT_BADCODE);
}
// only remove entries that exist!
if (!(cfg=*anentry))
return;
// entry exists -- free all of its memory
cfg->name = FreeNonZero(cfg->name, -1,__LINE__,filenameandversion);
cfg->smartthres = FreeNonZero(cfg->smartthres, sizeof(struct ata_smart_thresholds_pvt),__LINE__,filenameandversion);
cfg->smartval = FreeNonZero(cfg->smartval, sizeof(struct ata_smart_values),__LINE__,filenameandversion);
cfg->monitorattflags = FreeNonZero(cfg->monitorattflags, NMONITOR*32,__LINE__,filenameandversion);
cfg->attributedefs = FreeNonZero(cfg->attributedefs, MAX_ATTRIBUTE_NUM,__LINE__,filenameandversion);
if (cfg->mailwarn){
cfg->mailwarn->address = FreeNonZero(cfg->mailwarn->address, -1,__LINE__,filenameandversion);
cfg->mailwarn->emailcmdline = FreeNonZero(cfg->mailwarn->emailcmdline, -1,__LINE__,filenameandversion);
cfg->mailwarn = FreeNonZero(cfg->mailwarn, sizeof(maildata),__LINE__,filenameandversion);
}
cfg->testdata = FreeTestData(cfg->testdata);
*anentry = FreeNonZero(cfg, sizeof(cfgfile),__LINE__,filenameandversion);
return;
}
// deallocates all memory associated with cfgentries list
void RmAllConfigEntries(){
int i;
for (i=0; i<cfgentries_max; i++)
RmConfigEntry(cfgentries+i, __LINE__);
cfgentries=FreeNonZero(cfgentries, sizeof(cfgfile *)*cfgentries_max, __LINE__, filenameandversion);
cfgentries_max=0;
return;
}
// deallocates all memory associated with ATA/SCSI device lists
void RmAllDevEntries(){
int i;
for (i=0; i<ATAandSCSIdevlist_max; i++)
RmConfigEntry(ATAandSCSIdevlist+i, __LINE__);
ATAandSCSIdevlist=FreeNonZero(ATAandSCSIdevlist, sizeof(cfgfile *)*ATAandSCSIdevlist_max, __LINE__, filenameandversion);
ATAandSCSIdevlist_max=0;
return;
}
// remove the PID file
void RemovePidFile(){
if (pid_file) {
if ( -1==unlink(pid_file) )
PrintOut(LOG_CRIT,"Can't unlink PID file %s (%s).\n",
pid_file, strerror(errno));
pid_file=FreeNonZero(pid_file, -1,__LINE__,filenameandversion);
}
return;
}
// Note if we catch a SIGUSR1
void USR1handler(int sig){
if (SIGUSR1==sig)
caughtsigUSR1=1;
return;
}
#ifdef _WIN32
// Note if we catch a SIGUSR2
void USR2handler(int sig){
if (SIGUSR2==sig)
caughtsigUSR2=1;
return;
}
#endif
// Note if we catch a HUP (or INT in debug mode)
void HUPhandler(int sig){
if (sig==SIGHUP)
caughtsigHUP=1;
else
caughtsigHUP=2;
return;
}
// signal handler for TERM, QUIT, and INT (if not in debug mode)
void sighandler(int sig){
if (!caughtsigEXIT)
caughtsigEXIT=sig;
return;
}
// signal handler that prints Goodbye message and removes pidfile
void Goodbye(void){
// clean up memory -- useful for debugging
RmAllConfigEntries();
RmAllDevEntries();
// delete PID file, if one was created
RemovePidFile();
// remove alternate configfile name
configfile_alt=FreeNonZero(configfile_alt, -1,__LINE__,filenameandversion);
// useful for debugging -- have we managed memory correctly?
if (debugmode || (bytes && exitstatus!=EXIT_NOMEM))
PrintOut(LOG_INFO, "Memory still allocated for devices at exit is %" PRId64 " bytes.\n", bytes);
// if we are exiting because of a code bug, tell user
if (exitstatus==EXIT_BADCODE || (bytes && exitstatus!=EXIT_NOMEM))
PrintOut(LOG_CRIT, "Please inform " PACKAGE_BUGREPORT ", including output of smartd -V.\n");
if (exitstatus==0 && bytes)
exitstatus=EXIT_BADCODE;
// and this should be the final output from smartd before it exits
PrintOut(exitstatus?LOG_CRIT:LOG_INFO, "smartd is exiting (exit status %d)\n", exitstatus);
return;
}
#define ENVLENGTH 1024
// a replacement for setenv() which is not available on all platforms.
// Note that the string passed to putenv must not be freed or made
// invalid, since a pointer to it is kept by putenv(). This means that
// it must either be a static buffer or allocated off the heap. The
// string can be freed if the environment variable is redefined or
// deleted via another call to putenv(). So we keep these on the stack
// as long as the popen() call is underway.
int exportenv(char* stackspace, const char *name, const char *value){
snprintf(stackspace,ENVLENGTH, "%s=%s", name, value);
return putenv(stackspace);
}
char* dnsdomain(const char* hostname) {
char *p = NULL;
#ifdef HAVE_GETHOSTBYNAME
struct hostent *hp;
if ((hp = gethostbyname(hostname))) {
// Does this work if gethostbyname() returns an IPv6 name in
// colon/dot notation? [BA]
if ((p = strchr(hp->h_name, '.')))
p++; // skip "."
}
#else
ARGUSED(hostname);
#endif
return p;
}
#define EBUFLEN 1024
// If either address or executable path is non-null then send and log
// a warning email, or execute executable
void MailWarning(cfgfile *cfg, int which, char *fmt, ...){
char command[2048], message[256], hostname[256], domainname[256], additional[256],fullmessage[1024];
char original[256], further[256], nisdomain[256], subject[256],dates[DATEANDEPOCHLEN];
char environ_strings[11][ENVLENGTH];
time_t epoch;
va_list ap;
const int day=24*3600;
int days=0;
char *whichfail[]={
"EmailTest", // 0
"Health", // 1
"Usage", // 2
"SelfTest", // 3
"ErrorCount", // 4
"FailedHealthCheck", // 5
"FailedReadSmartData", // 6
"FailedReadSmartErrorLog", // 7
"FailedReadSmartSelfTestLog", // 8
"FailedOpenDevice", // 9
"CurrentPendingSector", // 10
"OfflineUncorrectableSector", // 11
"Temperature" // 12
};
char *address, *executable;
mailinfo *mail;
maildata* data=cfg->mailwarn;
#ifndef _WIN32
FILE *pfp=NULL;
#else
char stdinbuf[1024]; int boxmsgoffs, boxtype;
#endif
const char *newadd=NULL, *newwarn=NULL;
const char *unknown="[Unknown]";
// See if user wants us to send mail
if(!data)
return;
address=data->address;
executable=data->emailcmdline;
if (!address && !executable)
return;
// which type of mail are we sending?
mail=(data->maillog)+which;
// checks for sanity
if (data->emailfreq<1 || data->emailfreq>3) {
PrintOut(LOG_CRIT,"internal error in MailWarning(): cfg->mailwarn->emailfreq=%d\n",data->emailfreq);
return;
}
if (which<0 || which>=SMARTD_NMAIL || sizeof(whichfail)!=SMARTD_NMAIL*sizeof(char *)) {
PrintOut(LOG_CRIT,"Contact " PACKAGE_BUGREPORT "; internal error in MailWarning(): which=%d, size=%d\n",
which, (int)sizeof(whichfail));
return;
}
// Return if a single warning mail has been sent.
if ((data->emailfreq==1) && mail->logged)
return;
// Return if this is an email test and one has already been sent.
if (which == 0 && mail->logged)
return;
// To decide if to send mail, we need to know what time it is.
epoch=time(NULL);
// Return if less than one day has gone by
if (data->emailfreq==2 && mail->logged && epoch<(mail->lastsent+day))
return;
// Return if less than 2^(logged-1) days have gone by
if (data->emailfreq==3 && mail->logged){
days=0x01<<(mail->logged-1);
days*=day;
if (epoch<(mail->lastsent+days))
return;
}
// record the time of this mail message, and the first mail message
if (!mail->logged)
mail->firstsent=epoch;
mail->lastsent=epoch;
// get system host & domain names (not null terminated if length=MAX)
#ifdef HAVE_GETHOSTNAME
if (gethostname(hostname, 256))
strcpy(hostname, unknown);
else {
char *p=NULL;
hostname[255]='\0';
p = dnsdomain(hostname);
if (p && *p) {
strncpy(domainname, p, 255);
domainname[255]='\0';
} else
strcpy(domainname, unknown);
}
#else
strcpy(hostname, unknown);
strcpy(domainname, unknown);
#endif
#ifdef HAVE_GETDOMAINNAME
if (getdomainname(nisdomain, 256))
strcpy(nisdomain, unknown);
else
nisdomain[255]='\0';
#else
strcpy(nisdomain, unknown);
#endif
// print warning string into message
va_start(ap, fmt);
vsnprintf(message, 256, fmt, ap);
va_end(ap);
// appropriate message about further information
additional[0]=original[0]=further[0]='\0';
if (which) {
sprintf(further,"You can also use the smartctl utility for further investigation.\n");
switch (data->emailfreq){
case 1:
sprintf(additional,"No additional email messages about this problem will be sent.\n");
break;
case 2:
sprintf(additional,"Another email message will be sent in 24 hours if the problem persists.\n");
break;
case 3:
sprintf(additional,"Another email message will be sent in %d days if the problem persists\n",
(0x01)<<mail->logged);
break;
}
if (data->emailfreq>1 && mail->logged){
dateandtimezoneepoch(dates, mail->firstsent);
sprintf(original,"The original email about this issue was sent at %s\n", dates);
}
}
snprintf(subject, 256,"SMART error (%s) detected on host: %s", whichfail[which], hostname);
// If the user has set cfg->emailcmdline, use that as mailer, else "mail" or "mailx".
if (!executable)
#ifdef DEFAULT_MAILER
executable = DEFAULT_MAILER ;
#else
#ifndef _WIN32
executable = "mail";
#else
executable = "blat"; // http://blat.sourceforge.net/
#endif
#endif
// make a private copy of address with commas replaced by spaces
// to separate recipients
if (address) {
address=CustomStrDup(data->address, 1, __LINE__, filenameandversion);
#ifndef _WIN32 // blat mailer needs comma
{
char *comma=address;
while ((comma=strchr(comma, ',')))
*comma=' ';
}
#endif
}
// Export information in environment variables that will be useful
// for user scripts
exportenv(environ_strings[0], "SMARTD_MAILER", executable);
exportenv(environ_strings[1], "SMARTD_MESSAGE", message);
exportenv(environ_strings[2], "SMARTD_SUBJECT", subject);
dateandtimezoneepoch(dates, mail->firstsent);
exportenv(environ_strings[3], "SMARTD_TFIRST", dates);
snprintf(dates, DATEANDEPOCHLEN,"%d", (int)mail->firstsent);
exportenv(environ_strings[4], "SMARTD_TFIRSTEPOCH", dates);
exportenv(environ_strings[5], "SMARTD_FAILTYPE", whichfail[which]);
if (address)
exportenv(environ_strings[6], "SMARTD_ADDRESS", address);
exportenv(environ_strings[7], "SMARTD_DEVICESTRING", cfg->name);
switch (cfg->controller_type) {
case CONTROLLER_3WARE_678K:
case CONTROLLER_3WARE_9000_CHAR:
case CONTROLLER_3WARE_678K_CHAR:
{
char *s,devicetype[16];
sprintf(devicetype, "3ware,%d", cfg->controller_port-1);
exportenv(environ_strings[8], "SMARTD_DEVICETYPE", devicetype);
if ((s=strchr(cfg->name, ' ')))
*s='\0';
exportenv(environ_strings[9], "SMARTD_DEVICE", cfg->name);
if (s)
*s=' ';
}
break;
case CONTROLLER_CCISS:
{
char *s,devicetype[16];
sprintf(devicetype, "cciss,%d", cfg->controller_port-1);
exportenv(environ_strings[8], "SMARTD_DEVICETYPE", devicetype);
if ((s=strchr(cfg->name, ' ')))
*s='\0';
exportenv(environ_strings[9], "SMARTD_DEVICE", cfg->name);
if (s)
*s=' ';
}
break;
case CONTROLLER_ATA:
exportenv(environ_strings[8], "SMARTD_DEVICETYPE", "ata");
exportenv(environ_strings[9], "SMARTD_DEVICE", cfg->name);
break;
case CONTROLLER_MARVELL_SATA:
exportenv(environ_strings[8], "SMARTD_DEVICETYPE", "marvell");
exportenv(environ_strings[9], "SMARTD_DEVICE", cfg->name);
break;
case CONTROLLER_SCSI:
exportenv(environ_strings[8], "SMARTD_DEVICETYPE", "scsi");
exportenv(environ_strings[9], "SMARTD_DEVICE", cfg->name);
break;
case CONTROLLER_SAT:
exportenv(environ_strings[8], "SMARTD_DEVICETYPE", "sat");
exportenv(environ_strings[9], "SMARTD_DEVICE", cfg->name);
break;
case CONTROLLER_HPT:
{
char *s,devicetype[16];
sprintf(devicetype, "hpt,%d/%d/%d", cfg->hpt_data[0],
cfg->hpt_data[1], cfg->hpt_data[2]);
exportenv(environ_strings[8], "SMARTD_DEVICETYPE", devicetype);
if ((s=strchr(cfg->name, ' ')))
*s='\0';
exportenv(environ_strings[9], "SMARTD_DEVICE", cfg->name);
if (s)
*s=' ';
}
break;
}
snprintf(fullmessage, 1024,
"This email was generated by the smartd daemon running on:\n\n"
" host name: %s\n"
" DNS domain: %s\n"
" NIS domain: %s\n\n"
"The following warning/error was logged by the smartd daemon:\n\n"
"%s\n\n"
"For details see host's SYSLOG (default: /var/log/messages).\n\n"
"%s%s%s",
hostname, domainname, nisdomain, message, further, original, additional);
exportenv(environ_strings[10], "SMARTD_FULLMESSAGE", fullmessage);
// now construct a command to send this as EMAIL
#ifndef _WIN32
if (address)
snprintf(command, 2048,
"$SMARTD_MAILER -s '%s' %s 2>&1 << \"ENDMAIL\"\n"
"%sENDMAIL\n", subject, address, fullmessage);
else
snprintf(command, 2048, "%s 2>&1", executable);
// tell SYSLOG what we are about to do...
newadd=address?address:"<nomailer>";
newwarn=which?"Warning via":"Test of";
PrintOut(LOG_INFO,"%s %s to %s ...\n",
which?"Sending warning via":"Executing test of", executable, newadd);
// issue the command to send mail or to run the user's executable
errno=0;
if (!(pfp=popen(command, "r")))
// failed to popen() mail process
PrintOut(LOG_CRIT,"%s %s to %s: failed (fork or pipe failed, or no memory) %s\n",
newwarn, executable, newadd, errno?strerror(errno):"");
else {
// pipe suceeded!
int len, status;
char buffer[EBUFLEN];
// if unexpected output on stdout/stderr, null terminate, print, and flush
if ((len=fread(buffer, 1, EBUFLEN, pfp))) {
int count=0;
int newlen = len<EBUFLEN ? len : EBUFLEN-1;
buffer[newlen]='\0';
PrintOut(LOG_CRIT,"%s %s to %s produced unexpected output (%s%d bytes) to STDOUT/STDERR: \n%s\n",
newwarn, executable, newadd, len!=newlen?"here truncated to ":"", newlen, buffer);
// flush pipe if needed
while (fread(buffer, 1, EBUFLEN, pfp) && count<EBUFLEN)
count++;
// tell user that pipe was flushed, or that something is really wrong
if (count && count<EBUFLEN)
PrintOut(LOG_CRIT,"%s %s to %s: flushed remaining STDOUT/STDERR\n",
newwarn, executable, newadd);
else if (count)
PrintOut(LOG_CRIT,"%s %s to %s: more than 1 MB STDOUT/STDERR flushed, breaking pipe\n",
newwarn, executable, newadd);
}
// if something went wrong with mail process, print warning
errno=0;
if (-1==(status=pclose(pfp)))
PrintOut(LOG_CRIT,"%s %s to %s: pclose(3) failed %s\n", newwarn, executable, newadd,
errno?strerror(errno):"");
else {
// mail process apparently succeeded. Check and report exit status
int status8;
if (WIFEXITED(status)) {
// exited 'normally' (but perhaps with nonzero status)
status8=WEXITSTATUS(status);
if (status8>128)
PrintOut(LOG_CRIT,"%s %s to %s: failed (32-bit/8-bit exit status: %d/%d) perhaps caught signal %d [%s]\n",
newwarn, executable, newadd, status, status8, status8-128, strsignal(status8-128));
else if (status8)
PrintOut(LOG_CRIT,"%s %s to %s: failed (32-bit/8-bit exit status: %d/%d)\n",
newwarn, executable, newadd, status, status8);
else
PrintOut(LOG_INFO,"%s %s to %s: successful\n", newwarn, executable, newadd);
}
if (WIFSIGNALED(status))
PrintOut(LOG_INFO,"%s %s to %s: exited because of uncaught signal %d [%s]\n",
newwarn, executable, newadd, WTERMSIG(status), strsignal(WTERMSIG(status)));
// this branch is probably not possible. If subprocess is
// stopped then pclose() should not return.
if (WIFSTOPPED(status))
PrintOut(LOG_CRIT,"%s %s to %s: process STOPPED because it caught signal %d [%s]\n",
newwarn, executable, newadd, WSTOPSIG(status), strsignal(WSTOPSIG(status)));
}
}
#else // _WIN32
// No "here-documents" on Windows, so must use separate commandline and stdin
command[0] = stdinbuf[0] = 0;
boxtype = -1; boxmsgoffs = 0;
newadd = "<nomailer>";
if (address) {
// address "[sys]msgbox ..." => show warning (also) as [system modal ]messagebox
int addroffs = (!strncmp(address, "sys", 3) ? 3 : 0);
if (!strncmp(address+addroffs, "msgbox", 6) && (!address[addroffs+6] || address[addroffs+6] == ',')) {
boxtype = (addroffs > 0 ? 1 : 0);
addroffs += 6;
if (address[addroffs])
addroffs++;
}
else
addroffs = 0;
if (address[addroffs]) {
// Use "blat" parameter syntax (TODO: configure via -M for other mailers)
snprintf(command, sizeof(command),
"%s - -q -subject \"%s\" -to \"%s\"",
executable, subject, address+addroffs);
newadd = address+addroffs;
}
// Message for mail [0...] and messagebox [boxmsgoffs...]
snprintf(stdinbuf, sizeof(stdinbuf),
"This email was generated by the smartd daemon running on:\n\n"
" host name: %s\n"
" DNS domain: %s\n"
// " NIS domain: %s\n"
"\n%n"
"The following warning/error was logged by the smartd daemon:\n\n"
"%s\n\n"
"For details see the event log or log file of smartd.\n\n"
"%s%s%s"
"\n",
hostname, /*domainname, */ nisdomain, &boxmsgoffs, message, further, original, additional);
}
else
snprintf(command, sizeof(command), "%s", executable);
newwarn=which?"Warning via":"Test of";
if (boxtype >= 0) {
// show message box
daemon_messagebox(boxtype, subject, stdinbuf+boxmsgoffs);
PrintOut(LOG_INFO,"%s message box\n", newwarn);
}
if (command[0]) {
char stdoutbuf[800]; // < buffer in syslog_win32::vsyslog()
int rc;
// run command
PrintOut(LOG_INFO,"%s %s to %s ...\n",
(which?"Sending warning via":"Executing test of"), executable, newadd);
rc = daemon_spawn(command, stdinbuf, strlen(stdinbuf), stdoutbuf, sizeof(stdoutbuf));
if (rc >= 0 && stdoutbuf[0])
PrintOut(LOG_CRIT,"%s %s to %s produced unexpected output (%d bytes) to STDOUT/STDERR:\n%s\n",
newwarn, executable, newadd, strlen(stdoutbuf), stdoutbuf);
if (rc != 0)
PrintOut(LOG_CRIT,"%s %s to %s: failed, exit status %d\n",
newwarn, executable, newadd, rc);
else
PrintOut(LOG_INFO,"%s %s to %s: successful\n", newwarn, executable, newadd);
}
#endif // _WIN32
// increment mail sent counter
mail->logged++;
// free copy of address (without commas)
address=FreeNonZero(address, -1, __LINE__, filenameandversion);
return;
}
// Printing function for watching ataprint commands, or losing them
// [From GLIBC Manual: Since the prototype doesn't specify types for
// optional arguments, in a call to a variadic function the default
// argument promotions are performed on the optional argument
// values. This means the objects of type char or short int (whether
// signed or not) are promoted to either int or unsigned int, as
// appropriate.]
void pout(const char *fmt, ...){
va_list ap;
// get the correct time in syslog()
FixGlibcTimeZoneBug();
// initialize variable argument list
va_start(ap,fmt);
// in debug==1 mode we will print the output from the ataprint.o functions!
if (debugmode && debugmode!=2)
#ifdef _WIN32
if (facility == LOG_LOCAL1) // logging to stdout
vfprintf(stderr,fmt,ap);
else
#endif
vprintf(fmt,ap);
// in debug==2 mode we print output from knowndrives.o functions
else if (debugmode==2 || con->reportataioctl || con->reportscsiioctl || con->controller_port) {
openlog("smartd", LOG_PID, facility);
vsyslog(LOG_INFO, fmt, ap);
closelog();
}
va_end(ap);
fflush(NULL);
return;
}
// This function prints either to stdout or to the syslog as needed.
// This function is also used by utility.cpp to report LOG_CRIT errors.
void PrintOut(int priority, const char *fmt, ...){
va_list ap;
// get the correct time in syslog()
FixGlibcTimeZoneBug();
// initialize variable argument list
va_start(ap,fmt);
if (debugmode)
#ifdef _WIN32
if (facility == LOG_LOCAL1) // logging to stdout
vfprintf(stderr,fmt,ap);
else
#endif
vprintf(fmt,ap);
else {
openlog("smartd", LOG_PID, facility);
vsyslog(priority,fmt,ap);
closelog();
}
va_end(ap);
return;
}
// Wait for the pid file to show up, this makes sure a calling program knows
// that the daemon is really up and running and has a pid to kill it
bool WaitForPidFile()
{
int waited, max_wait = 10;
struct stat stat_buf;
if(!pid_file || debugmode)
return true;
for(waited = 0; waited < max_wait; ++waited) {
if(stat(pid_file, &stat_buf) == 0) {
return true;
} else
sleep(1);
}
return false;
}
// Forks new process, closes ALL file descriptors, redirects stdin,
// stdout, and stderr. Not quite daemon(). See
// http://www.iar.unlp.edu.ar/~fede/revistas/lj/Magazines/LJ47/2335.html
// for a good description of why we do things this way.
void DaemonInit(){
#ifndef _WIN32
pid_t pid;
int i;
// flush all buffered streams. Else we might get two copies of open
// streams since both parent and child get copies of the buffers.
fflush(NULL);
if (do_fork) {
if ((pid=fork()) < 0) {
// unable to fork!
PrintOut(LOG_CRIT,"smartd unable to fork daemon process!\n");
EXIT(EXIT_STARTUP);
}
else if (pid)
// we are the parent process, wait for pid file, then exit cleanly
if(!WaitForPidFile()) {
PrintOut(LOG_CRIT,"PID file %s didn't show up!\n", pid_file);
EXIT(EXIT_STARTUP);
} else
EXIT(0);
// from here on, we are the child process.
setsid();
// Fork one more time to avoid any possibility of having terminals
if ((pid=fork()) < 0) {
// unable to fork!
PrintOut(LOG_CRIT,"smartd unable to fork daemon process!\n");
EXIT(EXIT_STARTUP);
}
else if (pid)
// we are the parent process -- exit cleanly
EXIT(0);
// Now we are the child's child...
}
// close any open file descriptors
for (i=getdtablesize();i>=0;--i)
close(i);
#ifdef __CYGWIN__
// Cygwin's setsid() does not detach the process from Windows console
FreeConsole();
#endif // __CYGWIN__
// redirect any IO attempts to /dev/null for stdin
i=open("/dev/null",O_RDWR);
// stdout
dup(i);
// stderr
dup(i);
umask(0);
chdir("/");
if (do_fork)
PrintOut(LOG_INFO, "smartd has fork()ed into background mode. New PID=%d.\n", (int)getpid());
#else // _WIN32
// No fork() on native Win32
// Detach this process from console
fflush(NULL);
if (daemon_detach("smartd")) {
PrintOut(LOG_CRIT,"smartd unable to detach from console!\n");
EXIT(EXIT_STARTUP);
}
// stdin/out/err now closed if not redirected
#endif // _WIN32
return;
}
// create a PID file containing the current process id
void WritePidFile() {
if (pid_file) {
int error = 0;
pid_t pid = getpid();
mode_t old_umask;
FILE* fp;
#ifndef __CYGWIN__
old_umask = umask(0077); // rwx------
#else
// Cygwin: smartd service runs on system account, ensure PID file can be read by admins
old_umask = umask(0033); // rwxr--r--
#endif
fp = fopen(pid_file, "w");
umask(old_umask);
if (fp == NULL) {
error = 1;
} else if (fprintf(fp, "%d\n", (int)pid) <= 0) {
error = 1;
} else if (fclose(fp) != 0) {
error = 1;
}
if (error) {
PrintOut(LOG_CRIT, "unable to write PID file %s - exiting.\n", pid_file);
EXIT(EXIT_PID);
}
PrintOut(LOG_INFO, "file %s written containing PID %d\n", pid_file, (int)pid);
}
return;
}
// Prints header identifying version of code and home
void PrintHead(){
#ifdef HAVE_GET_OS_VERSION_STR
const char * ver = get_os_version_str();
#else
const char * ver = SMARTMONTOOLS_BUILD_HOST;
#endif
PrintOut(LOG_INFO,"smartd version %s [%s] Copyright (C) 2002-8 Bruce Allen\n", PACKAGE_VERSION, ver);
PrintOut(LOG_INFO,"Home page is " PACKAGE_HOMEPAGE "\n\n");
return;
}
// prints help info for configuration file Directives
void Directives() {
PrintOut(LOG_INFO,
"Configuration file (%s) Directives (after device name):\n"
" -d TYPE Set the device type: ata, scsi, marvell, removable, sat, 3ware,N, hpt,L/M/N, cciss,N\n"
" -T TYPE Set the tolerance to one of: normal, permissive\n"
" -o VAL Enable/disable automatic offline tests (on/off)\n"
" -S VAL Enable/disable attribute autosave (on/off)\n"
" -n MODE No check if: never[,q], sleep[,q], standby[,q], idle[,q]\n"
" -H Monitor SMART Health Status, report if failed\n"
" -s REG Do Self-Test at time(s) given by regular expression REG\n"
" -l TYPE Monitor SMART log. Type is one of: error, selftest\n"
" -f Monitor 'Usage' Attributes, report failures\n"
" -m ADD Send email warning to address ADD\n"
" -M TYPE Modify email warning behavior (see man page)\n"
" -p Report changes in 'Prefailure' Attributes\n"
" -u Report changes in 'Usage' Attributes\n"
" -t Equivalent to -p and -u Directives\n"
" -r ID Also report Raw values of Attribute ID with -p, -u or -t\n"
" -R ID Track changes in Attribute ID Raw value with -p, -u or -t\n"
" -i ID Ignore Attribute ID for -f Directive\n"
" -I ID Ignore Attribute ID for -p, -u or -t Directive\n"
" -C ID Monitor Current Pending Sectors in Attribute ID\n"
" -U ID Monitor Offline Uncorrectable Sectors in Attribute ID\n"
" -W D,I,C Monitor Temperature D)ifference, I)nformal limit, C)ritical limit\n"
" -v N,ST Modifies labeling of Attribute N (see man page) \n"
" -P TYPE Drive-specific presets: use, ignore, show, showall\n"
" -a Default: -H -f -t -l error -l selftest -C 197 -U 198\n"
" -F TYPE Firmware bug workaround: none, samsung, samsung2, samsung3\n"
" # Comment: text after a hash sign is ignored\n"
" \\ Line continuation character\n"
"Attribute ID is a decimal integer 1 <= ID <= 255\n"
"Use ID = 0 to turn off -C and/or -U Directives\n"
"Example: /dev/hda -a\n",
configfile);
return;
}
/* Returns a pointer to a static string containing a formatted list of the valid
arguments to the option opt or NULL on failure. */
const char *GetValidArgList(char opt) {
switch (opt) {
case 'c':
return "<FILE_NAME>, -";
case 's':
return "valid_regular_expression";
case 'l':
return "daemon, local0, local1, local2, local3, local4, local5, local6, local7";
case 'q':
return "nodev, errors, nodevstartup, never, onecheck, showtests";
case 'r':
return "ioctl[,N], ataioctl[,N], scsiioctl[,N]";
case 'p':
return "<FILE_NAME>";
case 'i':
return "<INTEGER_SECONDS>";
default:
return NULL;
}
}
/* prints help information for command syntax */
void Usage (void){
PrintOut(LOG_INFO,"Usage: smartd [options]\n\n");
#ifdef HAVE_GETOPT_LONG
PrintOut(LOG_INFO," -c NAME|-, --configfile=NAME|-\n");
PrintOut(LOG_INFO," Read configuration file NAME or stdin [default is %s]\n\n", configfile);
PrintOut(LOG_INFO," -d, --debug\n");
PrintOut(LOG_INFO," Start smartd in debug mode\n\n");
PrintOut(LOG_INFO," -D, --showdirectives\n");
PrintOut(LOG_INFO," Print the configuration file Directives and exit\n\n");
PrintOut(LOG_INFO," -h, --help, --usage\n");
PrintOut(LOG_INFO," Display this help and exit\n\n");
PrintOut(LOG_INFO," -i N, --interval=N\n");
PrintOut(LOG_INFO," Set interval between disk checks to N seconds, where N >= 10\n\n");
PrintOut(LOG_INFO," -l local[0-7], --logfacility=local[0-7]\n");
#ifndef _WIN32
PrintOut(LOG_INFO," Use syslog facility local0 - local7 or daemon [default]\n\n");
#else
PrintOut(LOG_INFO," Log to \"./smartd.log\", stdout, stderr [default is event log]\n\n");
#endif
#ifndef _WIN32
PrintOut(LOG_INFO," -n, --no-fork\n");
PrintOut(LOG_INFO," Do not fork into background\n\n");
#endif // _WIN32
PrintOut(LOG_INFO," -p NAME, --pidfile=NAME\n");
PrintOut(LOG_INFO," Write PID file NAME\n\n");
PrintOut(LOG_INFO," -q WHEN, --quit=WHEN\n");
PrintOut(LOG_INFO," Quit on one of: %s\n\n", GetValidArgList('q'));
PrintOut(LOG_INFO," -r, --report=TYPE\n");
PrintOut(LOG_INFO," Report transactions for one of: %s\n\n", GetValidArgList('r'));
#ifdef _WIN32
PrintOut(LOG_INFO," --service\n");
PrintOut(LOG_INFO," Running as windows service (see man page), install with:\n");
PrintOut(LOG_INFO," smartd install [options]\n");
PrintOut(LOG_INFO," Remove service with:\n");
PrintOut(LOG_INFO," smartd remove\n\n");
#else
#endif // _WIN32 || __CYGWIN__
PrintOut(LOG_INFO," -V, --version, --license, --copyright\n");
PrintOut(LOG_INFO," Print License, Copyright, and version information\n");
#else
PrintOut(LOG_INFO," -c NAME|- Read configuration file NAME or stdin [default is %s]\n", configfile);
PrintOut(LOG_INFO," -d Start smartd in debug mode\n");
PrintOut(LOG_INFO," -D Print the configuration file Directives and exit\n");
PrintOut(LOG_INFO," -h Display this help and exit\n");
PrintOut(LOG_INFO," -i N Set interval between disk checks to N seconds, where N >= 10\n");
PrintOut(LOG_INFO," -l local? Use syslog facility local0 - local7, or daemon\n");
PrintOut(LOG_INFO," -n Do not fork into background\n");
PrintOut(LOG_INFO," -p NAME Write PID file NAME\n");
PrintOut(LOG_INFO," -q WHEN Quit on one of: %s\n", GetValidArgList('q'));
PrintOut(LOG_INFO," -r TYPE Report transactions for one of: %s\n", GetValidArgList('r'));
PrintOut(LOG_INFO," -V Print License, Copyright, and version information\n");
#endif
}
// returns negative if problem, else fd>=0
static int OpenDevice(char *device, char *mode, int scanning) {
int fd;
char *s=device;
// If there is an ASCII "space" character in the device name,
// terminate string there. This is for 3ware and highpoint devices only.
if ((s=strchr(device,' ')))
*s='\0';
// open the device
fd = deviceopen(device, mode);
// if we removed a space, put it back in please
if (s)
*s=' ';
// if we failed to open the device, complain!
if (fd < 0) {
// For linux+devfs, a nonexistent device gives a strange error
// message. This makes the error message a bit more sensible.
// If no debug and scanning - don't print errors
if (debugmode || !scanning) {
if (errno==ENOENT || errno==ENOTDIR)
errno=ENODEV;
PrintOut(LOG_INFO,"Device: %s, %s, open() failed\n",
device, strerror(errno));
}
return -1;
}
// device opened sucessfully
return fd;
}
int CloseDevice(int fd, char *name){
if (deviceclose(fd)){
PrintOut(LOG_INFO,"Device: %s, %s, close(%d) failed\n", name, strerror(errno), fd);
return 1;
}
// device sucessfully closed
return 0;
}
// returns <0 on failure
int ATAErrorCount(int fd, char *name){
struct ata_smart_errorlog log;
if (-1==ataReadErrorLog(fd,&log)){
PrintOut(LOG_INFO,"Device: %s, Read SMART Error Log Failed\n",name);
return -1;
}
// return current number of ATA errors
return log.error_log_pointer?log.ata_error_count:0;
}
// returns <0 if problem. Otherwise, bottom 8 bits are the self test
// error count, and top bits are the power-on hours of the last error.
int SelfTestErrorCount(int fd, char *name){
struct ata_smart_selftestlog log;
if (-1==ataReadSelfTestLog(fd,&log)){
PrintOut(LOG_INFO,"Device: %s, Read SMART Self Test Log Failed\n",name);
return -1;
}
// return current number of self-test errors
return ataPrintSmartSelfTestlog(&log,0);
}
// scan to see what ata devices there are, and if they support SMART
int ATADeviceScan(cfgfile *cfg, int scanning){
int fd, supported=0;
struct ata_identify_device drive;
char *name=cfg->name;
int retainsmartdata=0;
int retid;
char *mode;
// should we try to register this as an ATA device?
switch (cfg->controller_type) {
case CONTROLLER_ATA:
case CONTROLLER_3WARE_678K:
case CONTROLLER_MARVELL_SATA:
case CONTROLLER_HPT:
case CONTROLLER_UNKNOWN:
mode="ATA";
break;
case CONTROLLER_3WARE_678K_CHAR:
mode="ATA_3WARE_678K";
break;
case CONTROLLER_3WARE_9000_CHAR:
mode="ATA_3WARE_9000";
break;
case CONTROLLER_SAT:
mode="SCSI";
break;
default:
// not a recognized ATA or SATA device. We should never enter
// this branch.
return 1;
}
// open the device
if ((fd=OpenDevice(name, mode, scanning))<0)
// device open failed
return 1;
PrintOut(LOG_INFO,"Device: %s, opened\n", name);
// pass user settings on to low-level ATA commands
con->controller_port=cfg->controller_port;
con->hpt_data[0]=cfg->hpt_data[0];
con->hpt_data[1]=cfg->hpt_data[1];
con->hpt_data[2]=cfg->hpt_data[2];
con->controller_type=cfg->controller_type;
con->controller_explicit=cfg->controller_explicit;
con->fixfirmwarebug = cfg->fixfirmwarebug;
con->satpassthrulen = cfg->satpassthrulen;
// Get drive identity structure
if ((retid=ataReadHDIdentity (fd,&drive))){
if (retid<0)
// Unable to read Identity structure
PrintOut(LOG_INFO,"Device: %s, not ATA, no IDENTIFY DEVICE Structure\n",name);
else
PrintOut(LOG_INFO,"Device: %s, packet devices [this device %s] not SMART capable\n",
name, packetdevicetype(retid-1));
CloseDevice(fd, name);
return 2;
}
// Show if device in database, and use preset vendor attribute
// options unless user has requested otherwise.
if (cfg->ignorepresets)
PrintOut(LOG_INFO, "Device: %s, smartd database not searched (Directive: -P ignore).\n", name);
else {
// do whatever applypresets decides to do. Will allocate memory if
// cfg->attributedefs is needed.
if (applypresets(&drive, &cfg->attributedefs, con)<0)
PrintOut(LOG_INFO, "Device: %s, not found in smartd database.\n", name);
else
PrintOut(LOG_INFO, "Device: %s, found in smartd database.\n", name);
// then save the correct state of the flag (applypresets may have changed it)
cfg->fixfirmwarebug = con->fixfirmwarebug;
}
// If requested, show which presets would be used for this drive
if (cfg->showpresets) {
int savedebugmode=debugmode;
PrintOut(LOG_INFO, "Device %s: presets are:\n", name);
if (!debugmode)
debugmode=2;
showpresets(&drive);
debugmode=savedebugmode;
}
// see if drive supports SMART
supported=ataSmartSupport(&drive);
if (supported!=1) {
if (supported==0)
// drive does NOT support SMART
PrintOut(LOG_INFO,"Device: %s, lacks SMART capability\n",name);
else
// can't tell if drive supports SMART
PrintOut(LOG_INFO,"Device: %s, ATA IDENTIFY DEVICE words 82-83 don't specify if SMART capable.\n",name);
// should we proceed anyway?
if (cfg->permissive){
PrintOut(LOG_INFO,"Device: %s, proceeding since '-T permissive' Directive given.\n",name);
}
else {
PrintOut(LOG_INFO,"Device: %s, to proceed anyway, use '-T permissive' Directive.\n",name);
CloseDevice(fd, name);
return 2;
}
}
if (ataEnableSmart(fd)){
// Enable SMART command has failed
PrintOut(LOG_INFO,"Device: %s, could not enable SMART capability\n",name);
CloseDevice(fd, name);
return 2;
}
// disable device attribute autosave...
if (cfg->autosave==1){
if (ataDisableAutoSave(fd))
PrintOut(LOG_INFO,"Device: %s, could not disable SMART Attribute Autosave.\n",name);
else
PrintOut(LOG_INFO,"Device: %s, disabled SMART Attribute Autosave.\n",name);
}
// or enable device attribute autosave
if (cfg->autosave==2){
if (ataEnableAutoSave(fd))
PrintOut(LOG_INFO,"Device: %s, could not enable SMART Attribute Autosave.\n",name);
else
PrintOut(LOG_INFO,"Device: %s, enabled SMART Attribute Autosave.\n",name);
}
// capability check: SMART status
if (cfg->smartcheck && ataSmartStatus2(fd)==-1){
PrintOut(LOG_INFO,"Device: %s, not capable of SMART Health Status check\n",name);
cfg->smartcheck=0;
}
// capability check: Read smart values and thresholds. Note that
// smart values are ALSO needed even if we ONLY want to know if the
// device is self-test log or error-log capable! After ATA-5, this
// information was ALSO reproduced in the IDENTIFY DEVICE response,
// but sadly not for ATA-5. Sigh.
// do we need to retain SMART data after returning from this routine?
retainsmartdata=cfg->usagefailed || cfg->prefail || cfg->usage || cfg->tempdiff || cfg->tempinfo || cfg->tempcrit;
// do we need to get SMART data?
if (retainsmartdata || cfg->autoofflinetest || cfg->selftest || cfg->errorlog || cfg->pending!=DONT_MONITOR_UNC) {
unsigned char currentpending, offlinepending;
cfg->smartval=(struct ata_smart_values *)Calloc(1,sizeof(struct ata_smart_values));
cfg->smartthres=(struct ata_smart_thresholds_pvt *)Calloc(1,sizeof(struct ata_smart_thresholds_pvt));
if (!cfg->smartval || !cfg->smartthres){
PrintOut(LOG_CRIT,"Not enough memory to obtain SMART data\n");
EXIT(EXIT_NOMEM);
}
if (ataReadSmartValues(fd,cfg->smartval) ||
ataReadSmartThresholds (fd,cfg->smartthres)){
PrintOut(LOG_INFO,"Device: %s, Read SMART Values and/or Thresholds Failed\n",name);
retainsmartdata=cfg->usagefailed=cfg->prefail=cfg->usage=0;
cfg->tempdiff = cfg->tempinfo = cfg->tempcrit = 0;
cfg->pending=DONT_MONITOR_UNC;
}
// see if the necessary Attribute is there to monitor offline or
// current pending sectors or temperature
TranslatePending(cfg->pending, &currentpending, &offlinepending);
if (currentpending && ATAReturnAttributeRawValue(currentpending, cfg->smartval)<0) {
PrintOut(LOG_INFO,"Device: %s, can't monitor Current Pending Sector count - no Attribute %d\n",
name, (int)currentpending);
cfg->pending &= 0xff00;
cfg->pending |= CUR_UNC_DEFAULT;
}
if (offlinepending && ATAReturnAttributeRawValue(offlinepending, cfg->smartval)<0) {
PrintOut(LOG_INFO,"Device: %s, can't monitor Offline Uncorrectable Sector count - no Attribute %d\n",
name, (int)offlinepending);
cfg->pending &= 0x00ff;
cfg->pending |= OFF_UNC_DEFAULT<<8;
}
if ( (cfg->tempdiff || cfg->tempinfo || cfg->tempcrit)
&& !ATAReturnTemperatureValue(cfg->smartval, cfg->attributedefs)) {
PrintOut(LOG_CRIT, "Device: %s, can't monitor Temperature, ignoring -W Directive\n", name);
cfg->tempdiff = cfg->tempinfo = cfg->tempcrit = 0;
}
}
// enable/disable automatic on-line testing
if (cfg->autoofflinetest){
// is this an enable or disable request?
const char *what=(cfg->autoofflinetest==1)?"disable":"enable";
if (!cfg->smartval)
PrintOut(LOG_INFO,"Device: %s, could not %s SMART Automatic Offline Testing.\n",name, what);
else {
// if command appears unsupported, issue a warning...
if (!isSupportAutomaticTimer(cfg->smartval))
PrintOut(LOG_INFO,"Device: %s, SMART Automatic Offline Testing unsupported...\n",name);
// ... but then try anyway
if ((cfg->autoofflinetest==1)?ataDisableAutoOffline(fd):ataEnableAutoOffline(fd))
PrintOut(LOG_INFO,"Device: %s, %s SMART Automatic Offline Testing failed.\n", name, what);
else
PrintOut(LOG_INFO,"Device: %s, %sd SMART Automatic Offline Testing.\n", name, what);
}
}
// capability check: self-test-log
if (cfg->selftest){
int retval;
// start with service disabled, and re-enable it if all works OK
cfg->selftest=0;
cfg->selflogcount=0;
cfg->selfloghour=0;
if (!cfg->smartval)
PrintOut(LOG_INFO, "Device: %s, no SMART Self-Test log (SMART READ DATA failed); disabling -l selftest\n", name);
else if (!cfg->permissive && !isSmartTestLogCapable(cfg->smartval, &drive))
PrintOut(LOG_INFO, "Device: %s, appears to lack SMART Self-Test log; disabling -l selftest (override with -T permissive Directive)\n", name);
else if ((retval=SelfTestErrorCount(fd, name))<0)
PrintOut(LOG_INFO, "Device: %s, no SMART Self-Test log; remove -l selftest Directive from smartd.conf\n", name);
else {
cfg->selftest=1;
cfg->selflogcount=SELFTEST_ERRORCOUNT(retval);
cfg->selfloghour =SELFTEST_ERRORHOURS(retval);
}
}
// capability check: ATA error log
if (cfg->errorlog){
int val;
// start with service disabled, and re-enable it if all works OK
cfg->errorlog=0;
cfg->ataerrorcount=0;
if (!cfg->smartval)
PrintOut(LOG_INFO, "Device: %s, no SMART Error log (SMART READ DATA failed); disabling -l error\n", name);
else if (!cfg->permissive && !isSmartErrorLogCapable(cfg->smartval, &drive))
PrintOut(LOG_INFO, "Device: %s, appears to lack SMART Error log; disabling -l error (override with -T permissive Directive)\n", name);
else if ((val=ATAErrorCount(fd, name))<0)
PrintOut(LOG_INFO, "Device: %s, no SMART Error log; remove -l error Directive from smartd.conf\n", name);
else {
cfg->errorlog=1;
cfg->ataerrorcount=val;
}
}
// If we don't need to save SMART data, get rid of it now
if (!retainsmartdata) {
if (cfg->smartval) {
cfg->smartval=CheckFree(cfg->smartval, __LINE__,filenameandversion);
bytes-=sizeof(struct ata_smart_values);
}
if (cfg->smartthres) {
cfg->smartthres=CheckFree(cfg->smartthres, __LINE__,filenameandversion);
bytes-=sizeof(struct ata_smart_thresholds_pvt);
}
}
// capabilities check -- does it support powermode?
if (cfg->powermode) {
int powermode=ataCheckPowerMode(fd);
if (-1 == powermode) {
PrintOut(LOG_CRIT, "Device: %s, no ATA CHECK POWER STATUS support, ignoring -n Directive\n", name);
cfg->powermode=0;
}
else if (powermode!=0 && powermode!=0x80 && powermode!=0xff) {
PrintOut(LOG_CRIT, "Device: %s, CHECK POWER STATUS returned %d, not ATA compliant, ignoring -n Directive\n",
name, powermode);
cfg->powermode=0;
}
}
// If no tests available or selected, return
if (!(cfg->errorlog || cfg->selftest || cfg->smartcheck ||
cfg->usagefailed || cfg->prefail || cfg->usage ||
cfg->tempdiff || cfg->tempinfo || cfg->tempcrit )) {
CloseDevice(fd, name);
return 3;
}
// Do we still have entries available?
while (numdevata+numdevscsi>=ATAandSCSIdevlist_max)
ATAandSCSIdevlist=AllocateMoreSpace(ATAandSCSIdevlist, &ATAandSCSIdevlist_max, "ATA and SCSI devices");
// register device
PrintOut(LOG_INFO,"Device: %s, is SMART capable. Adding to \"monitor\" list.\n",name);
// record number of device, type of device, increment device count
if (cfg->controller_type == CONTROLLER_UNKNOWN)
cfg->controller_type=CONTROLLER_ATA;
// close file descriptor
CloseDevice(fd, name);
return 0;
}
// Returns 0 if normal SCSI device.
// Returns -1 if INQUIRY fails.
// Returns 2 if ATA device detected behind SAT layer.
// Returns 3 if ATA device detected behind Marvell controller.
// Returns 1 if other device detected that we don't want to treat
// as a normal SCSI device.
static int SCSIFilterKnown(int fd, char * device)
{
char req_buff[256];
int req_len, avail_len, len;
memset(req_buff, 0, 96);
req_len = 36;
if (scsiStdInquiry(fd, (unsigned char *)req_buff, req_len)) {
/* Marvell controllers fail on a 36 bytes StdInquiry, but 64 suffices */
/* watch this spot ... other devices could lock up here */
req_len = 64;
if (scsiStdInquiry(fd, (unsigned char *)req_buff, req_len)) {
PrintOut(LOG_INFO, "Device: %s, failed on INQUIRY; skip device\n", device);
// device doesn't like INQUIRY commands
return SCSIFK_FAILED;
}
}
avail_len = req_buff[4] + 5;
len = (avail_len < req_len) ? avail_len : req_len;
if (len >= 36) {
if (0 == strncmp(req_buff + 8, "3ware", 5) || 0 == strncmp(req_buff + 8, "AMCC", 4) ) {
PrintOut(LOG_INFO, "Device %s, please try adding '-d 3ware,N'\n", device);
PrintOut(LOG_INFO, "Device %s, you may need to replace %s with /dev/twaN or /dev/tweN\n", device, device);
return SCSIFK_3WARE;
} else if ((len >= 42) && (0 == strncmp(req_buff + 36, "MVSATA", 6))) {
PrintOut(LOG_INFO, "Device %s: using '-d marvell' for ATA disk with Marvell driver\n", device);
return SCSIFK_MARVELL;
} else if ((avail_len >= 36) &&
(0 == strncmp(req_buff + 8, "ATA ", 8)) &&
has_sat_pass_through(fd, 0 /* non-packet dev */)) {
PrintOut(LOG_INFO, "Device %s: using '-d sat' for ATA disk behind SAT layer.\n",
device);
return SCSIFK_SAT;
}
}
return SCSIFK_NORMAL;
}
// on success, return 0. On failure, return >0. Never return <0,
// please.
static int SCSIDeviceScan(cfgfile *cfg, int scanning) {
int k, fd, err, retval;
char *device = cfg->name;
struct scsi_iec_mode_page iec;
UINT8 tBuf[64];
char *mode=NULL;
// should we try to register this as a SCSI device?
switch (cfg->controller_type) {
case CONTROLLER_SCSI:
case CONTROLLER_UNKNOWN:
mode="SCSI";
break;
case CONTROLLER_CCISS:
mode="CCISS";
break;
default:
return 1;
}
// pass user settings on to low-level SCSI commands
con->controller_port=cfg->controller_port;
con->controller_type=cfg->controller_type;
// open the device
if ((fd = OpenDevice(device, mode, scanning)) < 0)
return 1;
PrintOut(LOG_INFO,"Device: %s, opened\n", device);
// early skip if device known and needs to be handled by some other
// device type (e.g. '-d 3ware,<n>')
if ((retval = SCSIFilterKnown(fd, device))) {
CloseDevice(fd, device);
if (retval==SCSIFK_SAT)
// SATA Device behind SAT layer
return SCSIFK_SAT;
if (retval==SCSIFK_MARVELL)
// ATA/SATA device behind Marvell driver
return SCSIFK_MARVELL;
return 2;
}
// check that device is ready for commands. IE stores its stuff on
// the media.
if ((err = scsiTestUnitReady(fd))) {
if (SIMPLE_ERR_NOT_READY == err)
PrintOut(LOG_INFO, "Device: %s, NOT READY (e.g. spun down); skip device\n", device);
else if (SIMPLE_ERR_NO_MEDIUM == err)
PrintOut(LOG_INFO, "Device: %s, NO MEDIUM present; skip device\n", device);
else if (SIMPLE_ERR_BECOMING_READY == err)
PrintOut(LOG_INFO, "Device: %s, BECOMING (but not yet) READY; skip device\n", device);
else
PrintOut(LOG_CRIT, "Device: %s, failed Test Unit Ready [err=%d]\n", device, err);
CloseDevice(fd, device);
return 2;
}
// Badly-conforming USB storage devices may fail this check.
// The response to the following IE mode page fetch (current and
// changeable values) is carefully examined. It has been found
// that various USB devices that malform the response will lock up
// if asked for a log page (e.g. temperature) so it is best to
// bail out now.
if (!(err = scsiFetchIECmpage(fd, &iec, cfg->modese_len)))
cfg->modese_len = iec.modese_len;
else if (SIMPLE_ERR_BAD_FIELD == err)
; /* continue since it is reasonable not to support IE mpage */
else { /* any other error (including malformed response) unreasonable */
PrintOut(LOG_INFO,
"Device: %s, Bad IEC (SMART) mode page, err=%d, skip device\n",
device, err);
CloseDevice(fd, device);
return 3;
}
// N.B. The following is passive (i.e. it doesn't attempt to turn on
// smart if it is off). This may change to be the same as the ATA side.
if (!scsi_IsExceptionControlEnabled(&iec)) {
PrintOut(LOG_INFO, "Device: %s, IE (SMART) not enabled, skip device\n"
"Try 'smartctl -s on %s' to turn on SMART features\n",
device, device);
CloseDevice(fd, device);
return 3;
}
// Device exists, and does SMART. Add to list (allocating more space if needed)
while (numdevscsi+numdevata >= ATAandSCSIdevlist_max)
ATAandSCSIdevlist=AllocateMoreSpace(ATAandSCSIdevlist, &ATAandSCSIdevlist_max, "ATA and SCSI devices");
// Flag that certain log pages are supported (information may be
// available from other sources).
if (0 == scsiLogSense(fd, SUPPORTED_LPAGES, 0, tBuf, sizeof(tBuf), 0)) {
for (k = 4; k < tBuf[3] + LOGPAGEHDRSIZE; ++k) {
switch (tBuf[k]) {
case TEMPERATURE_LPAGE:
cfg->TempPageSupported = 1;
break;
case IE_LPAGE:
cfg->SmartPageSupported = 1;
break;
default:
break;
}
}
}
// record type of device
if (cfg->controller_type == CONTROLLER_UNKNOWN)
cfg->controller_type = CONTROLLER_SCSI;
// get rid of allocated memory only needed for ATA devices. These
// might have been allocated if the user specified Ignore options or
// other ATA-only Attribute-specific options on the DEVICESCAN line.
cfg->monitorattflags = FreeNonZero(cfg->monitorattflags, NMONITOR*32,__LINE__,filenameandversion);
cfg->attributedefs = FreeNonZero(cfg->attributedefs, MAX_ATTRIBUTE_NUM,__LINE__,filenameandversion);
cfg->smartval = FreeNonZero(cfg->smartval, sizeof(struct ata_smart_values),__LINE__,filenameandversion);
cfg->smartthres = FreeNonZero(cfg->smartthres, sizeof(struct ata_smart_thresholds_pvt),__LINE__,filenameandversion);
// Check if scsiCheckIE() is going to work
{
UINT8 asc = 0;
UINT8 ascq = 0;
UINT8 currenttemp = 0;
UINT8 triptemp = 0;
if (scsiCheckIE(fd, cfg->SmartPageSupported, cfg->TempPageSupported,
&asc, &ascq, &currenttemp, &triptemp)) {
PrintOut(LOG_INFO, "Device: %s, unexpectedly failed to read SMART values\n", device);
cfg->SuppressReport = 1;
if (cfg->tempdiff || cfg->tempinfo || cfg->tempcrit) {
PrintOut(LOG_CRIT, "Device: %s, can't monitor Temperature, ignoring -W Directive\n", device);
cfg->tempdiff = cfg->tempinfo = cfg->tempcrit = 0;
}
}
}
// capability check: self-test-log
if (cfg->selftest){
int retval=scsiCountFailedSelfTests(fd, 0);
if (retval<0) {
// no self-test log, turn off monitoring
PrintOut(LOG_INFO, "Device: %s, does not support SMART Self-Test Log.\n", device);
cfg->selftest=0;
cfg->selflogcount=0;
cfg->selfloghour=0;
}
else {
// register starting values to watch for changes
cfg->selflogcount=SELFTEST_ERRORCOUNT(retval);
cfg->selfloghour =SELFTEST_ERRORHOURS(retval);
}
}
// disable autosave (set GLTSD bit)
if (cfg->autosave==1){
if (scsiSetControlGLTSD(fd, 1, cfg->modese_len))
PrintOut(LOG_INFO,"Device: %s, could not disable autosave (set GLTSD bit).\n",device);
else
PrintOut(LOG_INFO,"Device: %s, disabled autosave (set GLTSD bit).\n",device);
}
// or enable autosave (clear GLTSD bit)
if (cfg->autosave==2){
if (scsiSetControlGLTSD(fd, 0, cfg->modese_len))
PrintOut(LOG_INFO,"Device: %s, could not enable autosave (clear GLTSD bit).\n",device);
else
PrintOut(LOG_INFO,"Device: %s, enabled autosave (cleared GLTSD bit).\n",device);
}
// tell user we are registering device
PrintOut(LOG_INFO, "Device: %s, is SMART capable. Adding to \"monitor\" list.\n", device);
// close file descriptor
CloseDevice(fd, device);
return 0;
}
// modified treatment of SCSI device behind SAT layer
static int SCSIandSATDeviceScan(cfgfile *cfg, int scanning) {
int retval = SCSIDeviceScan(cfg, scanning);
cfg->WhichCheckDevice=1; // default SCSI device
if (retval==SCSIFK_SAT) {
// found SATA device behind SAT translation layer
cfg->controller_type=CONTROLLER_SAT;
cfg->WhichCheckDevice=0; // actually SATA device!
return ATADeviceScan(cfg, scanning);
}
if (retval==SCSIFK_MARVELL) {
// found SATA device behind Marvell controller
cfg->controller_type=CONTROLLER_MARVELL_SATA;
cfg->WhichCheckDevice=0; // actually SATA device!
return ATADeviceScan(cfg, scanning);
}
return retval;
}
// We compare old and new values of the n'th attribute. Note that n
// is NOT the attribute ID number.. If (Normalized & Raw) equal,
// then return 0, else nonzero.
int ATACompareValues(changedattribute_t *delta,
struct ata_smart_values *newv,
struct ata_smart_values *oldv,
struct ata_smart_thresholds_pvt *thresholds,
int n, char *name){
struct ata_smart_attribute *now,*was;
struct ata_smart_threshold_entry *thre;
unsigned char oldval,newval;
int sameraw;
// check that attribute number in range, and no null pointers
if (n<0 || n>=NUMBER_ATA_SMART_ATTRIBUTES || !newv || !oldv || !thresholds)
return 0;
// pointers to disk's values and vendor's thresholds
now=newv->vendor_attributes+n;
was=oldv->vendor_attributes+n;
thre=thresholds->thres_entries+n;
// consider only valid attributes
if (!now->id || !was->id || !thre->id)
return 0;
// issue warning if they don't have the same ID in all structures:
if ( (now->id != was->id) || (now->id != thre->id) ){
PrintOut(LOG_INFO,"Device: %s, same Attribute has different ID numbers: %d = %d = %d\n",
name, (int)now->id, (int)was->id, (int)thre->id);
return 0;
}
// new and old values of Normalized Attributes
newval=now->current;
oldval=was->current;
// See if the RAW values are unchanged (ie, the same)
if (memcmp(now->raw, was->raw, 6))
sameraw=0;
else
sameraw=1;
// if any values out of the allowed range, or if the values haven't
// changed, return 0
if (!newval || !oldval || newval>0xfe || oldval>0xfe || (oldval==newval && sameraw))
return 0;
// values have changed. Construct output and return
delta->newval=newval;
delta->oldval=oldval;
delta->id=now->id;
delta->prefail=ATTRIBUTE_FLAGS_PREFAILURE(now->flags);
delta->sameraw=sameraw;
return 1;
}
// This looks to see if the corresponding bit of the 32 bytes is set.
// This wastes a few bytes of storage but eliminates all searching and
// sorting functions! Entry is ZERO <==> the attribute ON. Calling
// with set=0 tells you if the attribute is being tracked or not.
// Calling with set=1 turns the attribute OFF.
int IsAttributeOff(unsigned char attr, unsigned char **datap, int set, int which, int whatline){
unsigned char *data;
int loc=attr>>3;
int bit=attr & 0x07;
unsigned char mask=0x01<<bit;
if (which>=NMONITOR || which < 0){
PrintOut(LOG_CRIT, "Internal error in IsAttributeOff() at line %d of file %s (which=%d)\n%s",
whatline, filenameandversion, which, reportbug);
EXIT(EXIT_BADCODE);
}
if (*datap == NULL){
// NULL data implies Attributes are ON...
if (!set)
return 0;
// we are writing
if (!(*datap=(unsigned char *)Calloc(NMONITOR*32, 1))){
PrintOut(LOG_CRIT,"No memory to create monattflags\n");
EXIT(EXIT_NOMEM);
}
}
// pointer to the 256 bits that we need
data=*datap+which*32;
// attribute zero is always OFF
if (!attr)
return 1;
if (!set)
return (data[loc] & mask);
data[loc]|=mask;
// return value when setting has no sense
return 0;
}
// If the self-test log has got more self-test errors (or more recent
// self-test errors) recorded, then notify user.
void CheckSelfTestLogs(cfgfile *cfg, int newi){
char *name=cfg->name;
if (newi<0)
// command failed
MailWarning(cfg, 8, "Device: %s, Read SMART Self-Test Log Failed", name);
else {
// old and new error counts
int oldc=cfg->selflogcount;
int newc=SELFTEST_ERRORCOUNT(newi);
// old and new error timestamps in hours
int oldh=cfg->selfloghour;
int newh=SELFTEST_ERRORHOURS(newi);
if (oldc<newc) {
// increase in error count
PrintOut(LOG_CRIT, "Device: %s, Self-Test Log error count increased from %d to %d\n",
name, oldc, newc);
MailWarning(cfg, 3, "Device: %s, Self-Test Log error count increased from %d to %d",
name, oldc, newc);
} else if (oldh!=newh) {
// more recent error
// a 'more recent' error might actually be a smaller hour number,
// if the hour number has wrapped.
// There's still a bug here. You might just happen to run a new test
// exactly 32768 hours after the previous failure, and have run exactly
// 20 tests between the two, in which case smartd will miss the
// new failure.
PrintOut(LOG_CRIT, "Device: %s, new Self-Test Log error at hour timestamp %d\n",
name, newh);
MailWarning(cfg, 3, "Device: %s, new Self-Test Log error at hour timestamp %d\n",
name, newh);
}
// Needed since self-test error count may DECREASE. Hour might
// also have changed.
cfg->selflogcount= newc;
cfg->selfloghour = newh;
}
return;
}
// returns 1 if time to do test of type testtype, 0 if not time to do
// test, < 0 if error
int DoTestNow(cfgfile *cfg, char testtype, time_t testtime) {
// start by finding out the time:
struct tm *timenow;
time_t epochnow;
char matchpattern[16];
regmatch_t substring;
int weekday, length;
unsigned short hours;
testinfo *dat=cfg->testdata;
// check that self-testing has been requested
if (!dat)
return 0;
// since we are about to call localtime(), be sure glibc is informed
// of any timezone changes we make.
if (!testtime)
FixGlibcTimeZoneBug();
// construct pattern containing the month, day of month, day of
// week, and hour
epochnow = (!testtime ? time(NULL) : testtime);
timenow=localtime(&epochnow);
// tm_wday is 0 (Sunday) to 6 (Saturday). We use 1 (Monday) to 7
// (Sunday).
weekday=timenow->tm_wday?timenow->tm_wday:7;
sprintf(matchpattern, "%c/%02d/%02d/%1d/%02d", testtype, timenow->tm_mon+1,
timenow->tm_mday, weekday, timenow->tm_hour);
// if no match, we are done
if (regexec(&(dat->cregex), matchpattern, 1, &substring, 0))
return 0;
// must match the ENTIRE type/date/time string
length=strlen(matchpattern);
if (substring.rm_so!=0 || substring.rm_eo!=length)
return 0;
// never do a second test in the same hour as another test (the % 7 ensures
// that the RHS will never be greater than 65535 and so will always fit into
// an unsigned short)
hours=1+timenow->tm_hour+24*(timenow->tm_yday+366*(timenow->tm_year % 7));
if (hours==dat->hour) {
if (!testtime && testtype!=dat->testtype)
PrintOut(LOG_INFO, "Device: %s, did test of type %c in current hour, skipping test of type %c\n",
cfg->name, dat->testtype, testtype);
return 0;
}
// save time and type of the current test; we are ready to do a test
dat->hour=hours;
dat->testtype=testtype;
return 1;
}
// Print a list of future tests.
void PrintTestSchedule(cfgfile **ATAandSCSIdevices){
int i, t;
cfgfile * cfg;
char datenow[DATEANDEPOCHLEN], date[DATEANDEPOCHLEN];
time_t now; long seconds;
int numdev = numdevata+numdevscsi;
typedef int cnt_t[4];
cnt_t * testcnts; // testcnts[numdev][4]
if (numdev <= 0)
return;
testcnts = (cnt_t *)calloc(numdev, sizeof(testcnts[0]));
if (!testcnts)
return;
PrintOut(LOG_INFO, "\nNext scheduled self tests (at most 5 of each type per device):\n");
// FixGlibcTimeZoneBug(); // done in PrintOut()
now=time(NULL);
dateandtimezoneepoch(datenow, now);
for (seconds=checktime; seconds<3600L*24*90; seconds+=checktime) {
// Check for each device whether a test will be run
time_t testtime = now + seconds;
for (i=0; i<numdev; i++) {
cfg = ATAandSCSIdevices[i];
for (t=0; t<(cfg->WhichCheckDevice==0?4:2); t++) {
char testtype = "LSCO"[t];
if (DoTestNow(cfg, testtype, testtime)) {
// Report at most 5 tests of each type
if (++testcnts[i][t] <= 5) {
dateandtimezoneepoch(date, testtime);
PrintOut(LOG_INFO, "Device: %s, will do test %d of type %c at %s\n", cfg->name,
testcnts[i][t], testtype, date);
}
}
}
}
}
// Report totals
dateandtimezoneepoch(date, now+seconds);
PrintOut(LOG_INFO, "\nTotals [%s - %s]:\n", datenow, date);
for (i=0; i<numdev; i++) {
cfg = ATAandSCSIdevices[i];
for (t=0; t<(cfg->WhichCheckDevice==0?4:2); t++) {
PrintOut(LOG_INFO, "Device: %s, will do %3d test%s of type %c\n", cfg->name, testcnts[i][t],
(testcnts[i][t]==1?"":"s"), "LSCO"[t]);
}
}
free(testcnts);
}
// Return zero on success, nonzero on failure. Perform offline (background)
// short or long (extended) self test on given scsi device.
int DoSCSISelfTest(int fd, cfgfile *cfg, char testtype) {
int retval = 0;
char *testname = NULL;
char *name = cfg->name;
int inProgress;
if (scsiSelfTestInProgress(fd, &inProgress)) {
PrintOut(LOG_CRIT, "Device: %s, does not support Self-Tests\n", name);
cfg->testdata->not_cap_short=cfg->testdata->not_cap_long=1;
return 1;
}
if (1 == inProgress) {
PrintOut(LOG_INFO, "Device: %s, skip since Self-Test already in "
"progress.\n", name);
return 1;
}
switch (testtype) {
case 'S':
testname = "Short Self";
retval = scsiSmartShortSelfTest(fd);
break;
case 'L':
testname = "Long Self";
retval = scsiSmartExtendSelfTest(fd);
break;
}
// If we can't do the test, exit
if (NULL == testname) {
PrintOut(LOG_CRIT, "Device: %s, not capable of %c Self-Test\n", name,
testtype);
return 1;
}
if (retval) {
if ((SIMPLE_ERR_BAD_OPCODE == retval) ||
(SIMPLE_ERR_BAD_FIELD == retval)) {
PrintOut(LOG_CRIT, "Device: %s, not capable of %s-Test\n", name,
testname);
if ('L'==testtype)
cfg->testdata->not_cap_long=1;
else
cfg->testdata->not_cap_short=1;
return 1;
}
PrintOut(LOG_CRIT, "Device: %s, execute %s-Test failed (err: %d)\n", name,
testname, retval);
return 1;
}
PrintOut(LOG_INFO, "Device: %s, starting scheduled %s-Test.\n", name, testname);
return 0;
}
// Do an offline immediate or self-test. Return zero on success,
// nonzero on failure.
int DoATASelfTest(int fd, cfgfile *cfg, char testtype) {
struct ata_smart_values data;
char *testname=NULL;
int retval, dotest=-1;
char *name=cfg->name;
// Read current smart data and check status/capability
if (ataReadSmartValues(fd, &data) || !(data.offline_data_collection_capability)) {
PrintOut(LOG_CRIT, "Device: %s, not capable of Offline or Self-Testing.\n", name);
return 1;
}
// Check for capability to do the test
switch (testtype) {
case 'O':
testname="Offline Immediate ";
if (isSupportExecuteOfflineImmediate(&data))
dotest=OFFLINE_FULL_SCAN;
else
cfg->testdata->not_cap_offline=1;
break;
case 'C':
testname="Conveyance Self-";
if (isSupportConveyanceSelfTest(&data))
dotest=CONVEYANCE_SELF_TEST;
else
cfg->testdata->not_cap_conveyance=1;
break;
case 'S':
testname="Short Self-";
if (isSupportSelfTest(&data))
dotest=SHORT_SELF_TEST;
else
cfg->testdata->not_cap_short=1;
break;
case 'L':
testname="Long Self-";
if (isSupportSelfTest(&data))
dotest=EXTEND_SELF_TEST;
else
cfg->testdata->not_cap_long=1;
break;
}
// If we can't do the test, exit
if (dotest<0) {
PrintOut(LOG_CRIT, "Device: %s, not capable of %sTest\n", name, testname);
return 1;
}
// If currently running a self-test, do not interrupt it to start another.
if (15==(data.self_test_exec_status >> 4)) {
if (cfg->fixfirmwarebug == FIX_SAMSUNG3 && data.self_test_exec_status == 0xf0) {
PrintOut(LOG_INFO, "Device: %s, will not skip scheduled %sTest "
"despite unclear Self-Test byte (SAMSUNG Firmware bug).\n", name, testname);
} else {
PrintOut(LOG_INFO, "Device: %s, skip scheduled %sTest; %1d0%% remaining of current Self-Test.\n",
name, testname, (int)(data.self_test_exec_status & 0x0f));
return 1;
}
}
// else execute the test, and return status
if ((retval=smartcommandhandler(fd, IMMEDIATE_OFFLINE, dotest, NULL)))
PrintOut(LOG_CRIT, "Device: %s, execute %sTest failed.\n", name, testname);
else
PrintOut(LOG_INFO, "Device: %s, starting scheduled %sTest.\n", name, testname);
return retval;
}
// Check Temperature limits
static void CheckTemperature(cfgfile * cfg, unsigned char currtemp, unsigned char triptemp)
{
const char *minchg = "", *maxchg = "";
if (!(0 < currtemp && currtemp < 255)) {
PrintOut(LOG_INFO, "Device: %s, failed to read Temperature\n", cfg->name);
return;
}
if (!cfg->temperature) {
PrintOut(LOG_INFO, "Device: %s, initial Temperature is %d Celsius\n",
cfg->name, (int)currtemp);
if (triptemp)
PrintOut(LOG_INFO, " [trip Temperature is %d Celsius]\n", (int)triptemp);
cfg->temperature = cfg->tempmin = cfg->tempmax = currtemp;
}
else {
// Update [min,max]
if (currtemp < cfg->tempmin) {
cfg->tempmin = currtemp; minchg = "!";
cfg->tempmininc = 0;
}
else if (cfg->tempmininc) {
// increase min Temperature during first 30 minutes
cfg->tempmin = currtemp;
cfg->tempmininc--;
}
if (currtemp > cfg->tempmax) {
cfg->tempmax = currtemp; maxchg = "!";
}
// Track changes
if (cfg->tempdiff && (*minchg || *maxchg || abs((int)currtemp - (int)cfg->temperature) >= cfg->tempdiff)) {
PrintOut(LOG_INFO, "Device: %s, Temperature changed %+d Celsius to %u Celsius (Min/Max %u%s/%u%s)\n",
cfg->name, (int)currtemp-(int)cfg->temperature, currtemp, cfg->tempmin, minchg, cfg->tempmax, maxchg);
cfg->temperature = currtemp;
}
}
// Check limits
if (cfg->tempcrit && currtemp >= cfg->tempcrit) {
PrintOut(LOG_CRIT, "Device: %s, Temperature %u Celsius reached critical limit of %u Celsius (Min/Max %u%s/%u%s)\n",
cfg->name, currtemp, cfg->tempcrit, cfg->tempmin, minchg, cfg->tempmax, maxchg);
MailWarning(cfg, 12, "Device: %s, Temperature %d Celsius reached critical limit of %u Celsius (Min/Max %u%s/%u%s)\n",
cfg->name, currtemp, cfg->tempcrit, cfg->tempmin, minchg, cfg->tempmax, maxchg);
}
else if (cfg->tempinfo && currtemp >= cfg->tempinfo) {
PrintOut(LOG_INFO, "Device: %s, Temperature %u Celsius reached limit of %u Celsius (Min/Max %u%s/%u%s)\n",
cfg->name, currtemp, cfg->tempinfo, cfg->tempmin, minchg, cfg->tempmax, maxchg);
}
}
int ATACheckDevice(cfgfile *cfg, bool allow_selftests){
int fd,i;
char *name=cfg->name;
char *mode="ATA";
char testtype=0;
// fix firmware bug if requested
con->fixfirmwarebug=cfg->fixfirmwarebug;
con->controller_port=cfg->controller_port;
con->controller_type=cfg->controller_type;
con->controller_explicit=cfg->controller_explicit;
// Highpoint-specific data
con->hpt_data[0]=cfg->hpt_data[0];
con->hpt_data[1]=cfg->hpt_data[1];
con->hpt_data[2]=cfg->hpt_data[2];
// If user has asked, test the email warning system
if (cfg->mailwarn && cfg->mailwarn->emailtest)
MailWarning(cfg, 0, "TEST EMAIL from smartd for device: %s", name);
if (cfg->controller_type == CONTROLLER_3WARE_9000_CHAR)
mode="ATA_3WARE_9000";
if (cfg->controller_type == CONTROLLER_3WARE_678K_CHAR)
mode="ATA_3WARE_678K";
// if we can't open device, fail gracefully rather than hard --
// perhaps the next time around we'll be able to open it. ATAPI
// cd/dvd devices will hang awaiting media if O_NONBLOCK is not
// given (see linux cdrom driver).
if ((fd=OpenDevice(name, mode, 0))<0){
MailWarning(cfg, 9, "Device: %s, unable to open device", name);
return 1;
}
// if the user has asked, and device is capable (or we're not yet
// sure) check whether a self test should be done now.
// This check is done before powermode check to avoid missing self
// tests on idle or sleeping disks.
if (allow_selftests && cfg->testdata) {
// long test
if (!cfg->testdata->not_cap_long && DoTestNow(cfg, 'L', 0)>0)
testtype = 'L';
// short test
else if (!cfg->testdata->not_cap_short && DoTestNow(cfg, 'S', 0)>0)
testtype = 'S';
// conveyance test
else if (!cfg->testdata->not_cap_conveyance && DoTestNow(cfg, 'C', 0)>0)
testtype = 'C';
// offline immediate
else if (!cfg->testdata->not_cap_offline && DoTestNow(cfg, 'O', 0)>0)
testtype = 'O';
}
// user may have requested (with the -n Directive) to leave the disk
// alone if it is in idle or sleeping mode. In this case check the
// power mode and exit without check if needed
if (cfg->powermode){
int dontcheck=0, powermode=ataCheckPowerMode(fd);
char *mode=NULL;
if (0 <= powermode && powermode < 0xff) {
// wait for possible spin up and check again
int powermode2;
sleep(5);
powermode2 = ataCheckPowerMode(fd);
if (powermode2 > powermode)
PrintOut(LOG_INFO, "Device: %s, CHECK POWER STATUS spins up disk (0x%02x -> 0x%02x)\n", name, powermode, powermode2);
powermode = powermode2;
}
switch (powermode){
case -1:
// SLEEP
mode="SLEEP";
if (cfg->powermode>=1)
dontcheck=1;
break;
case 0:
// STANDBY
mode="STANDBY";
if (cfg->powermode>=2)
dontcheck=1;
break;
case 0x80:
// IDLE
mode="IDLE";
if (cfg->powermode>=3)
dontcheck=1;
break;
case 0xff:
// ACTIVE/IDLE
mode="ACTIVE or IDLE";
break;
default:
// UNKNOWN
PrintOut(LOG_CRIT, "Device: %s, CHECK POWER STATUS returned %d, not ATA compliant, ignoring -n Directive\n",
name, powermode);
cfg->powermode=0;
break;
}
// if we are going to skip a check, return now
if (dontcheck){
// but ignore powermode on scheduled selftest
if (!testtype) {
CloseDevice(fd, name);
if (!cfg->powerskipcnt && !cfg->powerquiet) // report first only and avoid waking up system disk
PrintOut(LOG_INFO, "Device: %s, is in %s mode, suspending checks\n", name, mode);
cfg->powerskipcnt++;
return 0;
}
PrintOut(LOG_INFO, "Device: %s, %s mode ignored due to scheduled self test (%d check%s skipped)\n",
name, mode, cfg->powerskipcnt, (cfg->powerskipcnt==1?"":"s"));
cfg->powerskipcnt = 0;
}
else if (cfg->powerskipcnt) {
PrintOut(LOG_INFO, "Device: %s, is back in %s mode, resuming checks (%d check%s skipped)\n",
name, mode, cfg->powerskipcnt, (cfg->powerskipcnt==1?"":"s"));
cfg->powerskipcnt = 0;
}
}
// check smart status
if (cfg->smartcheck){
int status=ataSmartStatus2(fd);
if (status==-1){
PrintOut(LOG_INFO,"Device: %s, not capable of SMART self-check\n",name);
MailWarning(cfg, 5, "Device: %s, not capable of SMART self-check", name);
}
else if (status==1){
PrintOut(LOG_CRIT, "Device: %s, FAILED SMART self-check. BACK UP DATA NOW!\n", name);
MailWarning(cfg, 1, "Device: %s, FAILED SMART self-check. BACK UP DATA NOW!", name);
}
}
// Check everything that depends upon SMART Data (eg, Attribute values)
if ( cfg->usagefailed || cfg->prefail || cfg->usage || cfg->pending!=DONT_MONITOR_UNC
|| cfg->tempdiff || cfg->tempinfo || cfg->tempcrit ){
struct ata_smart_values curval;
struct ata_smart_thresholds_pvt *thresh=cfg->smartthres;
// Read current attribute values. *drive contains old values and thresholds
if (ataReadSmartValues(fd,&curval)){
PrintOut(LOG_CRIT, "Device: %s, failed to read SMART Attribute Data\n", name);
MailWarning(cfg, 6, "Device: %s, failed to read SMART Attribute Data", name);
}
else {
// look for current or offline pending sectors
if (cfg->pending != DONT_MONITOR_UNC) {
int64_t rawval;
unsigned char currentpending, offlinepending;
TranslatePending(cfg->pending, &currentpending, &offlinepending);
if (currentpending && (rawval=ATAReturnAttributeRawValue(currentpending, &curval))>0) {
// Unreadable pending sectors!!
PrintOut(LOG_CRIT, "Device: %s, %"PRId64" Currently unreadable (pending) sectors\n", name, rawval);
MailWarning(cfg, 10, "Device: %s, %"PRId64" Currently unreadable (pending) sectors", name, rawval);
}
if (offlinepending && (rawval=ATAReturnAttributeRawValue(offlinepending, &curval))>0) {
// Unreadable offline sectors!!
PrintOut(LOG_CRIT, "Device: %s, %"PRId64" Offline uncorrectable sectors\n", name, rawval);
MailWarning(cfg, 11, "Device: %s, %"PRId64" Offline uncorrectable sectors", name, rawval);
}
}
// check temperature limits
if (cfg->tempdiff || cfg->tempinfo || cfg->tempcrit)
CheckTemperature(cfg, ATAReturnTemperatureValue(&curval, cfg->attributedefs), 0);
if (cfg->usagefailed || cfg->prefail || cfg->usage) {
// look for failed usage attributes, or track usage or prefail attributes
for (i=0; i<NUMBER_ATA_SMART_ATTRIBUTES; i++){
int att;
changedattribute_t delta;
// This block looks for usage attributes that have failed.
// Prefail attributes that have failed are returned with a
// positive sign. No failure returns 0. Usage attributes<0.
if (cfg->usagefailed && ((att=ataCheckAttribute(&curval, thresh, i))<0)){
// are we ignoring failures of this attribute?
att *= -1;
if (!IsAttributeOff(att, &cfg->monitorattflags, 0, MONITOR_FAILUSE, __LINE__)){
char attname[64], *loc=attname;
// get attribute name & skip white space
ataPrintSmartAttribName(loc, att, cfg->attributedefs);
while (*loc && *loc==' ') loc++;
// warning message
PrintOut(LOG_CRIT, "Device: %s, Failed SMART usage Attribute: %s.\n", name, loc);
MailWarning(cfg, 2, "Device: %s, Failed SMART usage Attribute: %s.", name, loc);
}
}
// This block tracks usage or prefailure attributes to see if
// they are changing. It also looks for changes in RAW values
// if this has been requested by user.
if ((cfg->usage || cfg->prefail) && ATACompareValues(&delta, &curval, cfg->smartval, thresh, i, name)){
unsigned char id=delta.id;
// if the only change is the raw value, and we're not
// tracking raw value, then continue loop over attributes
if (!delta.sameraw && delta.newval==delta.oldval && !IsAttributeOff(id, &cfg->monitorattflags, 0, MONITOR_RAW, __LINE__))
continue;
// are we tracking this attribute?
if (!IsAttributeOff(id, &cfg->monitorattflags, 0, MONITOR_IGNORE, __LINE__)){
char newrawstring[64], oldrawstring[64], attname[64], *loc=attname;
// get attribute name, skip spaces
ataPrintSmartAttribName(loc, id, cfg->attributedefs);
while (*loc && *loc==' ') loc++;
// has the user asked for us to print raw values?
if (IsAttributeOff(id, &cfg->monitorattflags, 0, MONITOR_RAWPRINT, __LINE__)) {
// get raw values (as a string) and add to printout
char rawstring[64];
ataPrintSmartAttribRawValue(rawstring, curval.vendor_attributes+i, cfg->attributedefs);
sprintf(newrawstring, " [Raw %s]", rawstring);
ataPrintSmartAttribRawValue(rawstring, cfg->smartval->vendor_attributes+i, cfg->attributedefs);
sprintf(oldrawstring, " [Raw %s]", rawstring);
}
else
newrawstring[0]=oldrawstring[0]='\0';
// prefailure attribute
if (cfg->prefail && delta.prefail)
PrintOut(LOG_INFO, "Device: %s, SMART Prefailure Attribute: %s changed from %d%s to %d%s\n",
name, loc, delta.oldval, oldrawstring, delta.newval, newrawstring);
// usage attribute
if (cfg->usage && !delta.prefail)
PrintOut(LOG_INFO, "Device: %s, SMART Usage Attribute: %s changed from %d%s to %d%s\n",
name, loc, delta.oldval, oldrawstring, delta.newval, newrawstring);
}
} // endof block tracking usage or prefailure
} // end of loop over attributes
// Save the new values into *drive for the next time around
*(cfg->smartval)=curval;
}
}
}
// check if number of selftest errors has increased (note: may also DECREASE)
if (cfg->selftest)
CheckSelfTestLogs(cfg, SelfTestErrorCount(fd, name));
// check if number of ATA errors has increased
if (cfg->errorlog){
int newc,oldc=cfg->ataerrorcount;
// new number of errors
newc=ATAErrorCount(fd, name);
// did command fail?
if (newc<0)
// lack of PrintOut here is INTENTIONAL
MailWarning(cfg, 7, "Device: %s, Read SMART Error Log Failed", name);
// has error count increased?
if (newc>oldc){
PrintOut(LOG_CRIT, "Device: %s, ATA error count increased from %d to %d\n",
name, oldc, newc);
MailWarning(cfg, 4, "Device: %s, ATA error count increased from %d to %d",
name, oldc, newc);
}
// this last line is probably not needed, count always increases
if (newc>=0)
cfg->ataerrorcount=newc;
}
// carry out scheduled self-test
if (testtype)
DoATASelfTest(fd, cfg, testtype);
// Don't leave device open -- the OS/user may want to access it
// before the next smartd cycle!
CloseDevice(fd, name);
return 0;
}
int SCSICheckDevice(cfgfile *cfg, bool allow_selftests)
{
UINT8 asc, ascq;
UINT8 currenttemp;
UINT8 triptemp;
int fd;
char *name=cfg->name;
const char *cp;
char *mode=NULL;
// should we try to register this as a SCSI device?
switch (cfg->controller_type) {
case CONTROLLER_CCISS:
mode="CCISS";
break;
case CONTROLLER_SCSI:
case CONTROLLER_UNKNOWN:
mode="SCSI";
break;
default:
return 1;
}
// pass user settings on to low-level SCSI commands
con->controller_port=cfg->controller_port;
con->controller_type=cfg->controller_type;
// If the user has asked for it, test the email warning system
if (cfg->mailwarn && cfg->mailwarn->emailtest)
MailWarning(cfg, 0, "TEST EMAIL from smartd for device: %s", name);
// if we can't open device, fail gracefully rather than hard --
// perhaps the next time around we'll be able to open it
if ((fd=OpenDevice(name, mode, 0))<0) {
// Lack of PrintOut() here is intentional!
MailWarning(cfg, 9, "Device: %s, unable to open device", name);
return 1;
} else if (debugmode)
PrintOut(LOG_INFO,"Device: %s, opened SCSI device\n", name);
currenttemp = 0;
asc = 0;
ascq = 0;
if (! cfg->SuppressReport) {
if (scsiCheckIE(fd, cfg->SmartPageSupported, cfg->TempPageSupported,
&asc, &ascq, &currenttemp, &triptemp)) {
PrintOut(LOG_INFO, "Device: %s, failed to read SMART values\n",
name);
MailWarning(cfg, 6, "Device: %s, failed to read SMART values", name);
cfg->SuppressReport = 1;
}
}
if (asc > 0) {
cp = scsiGetIEString(asc, ascq);
if (cp) {
PrintOut(LOG_CRIT, "Device: %s, SMART Failure: %s\n", name, cp);
MailWarning(cfg, 1,"Device: %s, SMART Failure: %s", name, cp);
} else if (debugmode)
PrintOut(LOG_INFO,"Device: %s, non-SMART asc,ascq: %d,%d\n",
name, (int)asc, (int)ascq);
} else if (debugmode)
PrintOut(LOG_INFO,"Device: %s, SMART health: passed\n", name);
// check temperature limits
if (cfg->tempdiff || cfg->tempinfo || cfg->tempcrit)
CheckTemperature(cfg, currenttemp, triptemp);
// check if number of selftest errors has increased (note: may also DECREASE)
if (cfg->selftest)
CheckSelfTestLogs(cfg, scsiCountFailedSelfTests(fd, 0));
if (allow_selftests && cfg->testdata) {
// long (extended) background test
if (!cfg->testdata->not_cap_long && DoTestNow(cfg, 'L', 0)>0)
DoSCSISelfTest(fd, cfg, 'L');
// short background test
else if (!cfg->testdata->not_cap_short && DoTestNow(cfg, 'S', 0)>0)
DoSCSISelfTest(fd, cfg, 'S');
}
CloseDevice(fd, name);
return 0;
}
// Checks the SMART status of all ATA and SCSI devices
void CheckDevicesOnce(cfgfile **ATAandSCSIdevices, bool allow_selftests){
int i;
for (i=0; i<numdevata+numdevscsi; i++) {
if (ATAandSCSIdevices[i]->WhichCheckDevice==1)
SCSICheckDevice(ATAandSCSIdevices[i], allow_selftests);
else
ATACheckDevice(ATAandSCSIdevices[i], allow_selftests);
}
return;
}
#if SCSITIMEOUT
// This alarm means that a SCSI USB device was hanging
void AlarmHandler(int signal) {
longjmp(registerscsienv, 1);
}
#endif
// Does initialization right after fork to daemon mode
void Initialize(time_t *wakeuptime){
// install goobye message and remove pidfile handler
atexit(Goodbye);
// write PID file only after installing exit handler
if (!debugmode)
WritePidFile();
// install signal handlers. On Solaris, can't use signal() because
// it resets the handler to SIG_DFL after each call. So use sigset()
// instead. So SIGNALFN()==signal() or SIGNALFN()==sigset().
// normal and abnormal exit
if (SIGNALFN(SIGTERM, sighandler)==SIG_IGN)
SIGNALFN(SIGTERM, SIG_IGN);
if (SIGNALFN(SIGQUIT, sighandler)==SIG_IGN)
SIGNALFN(SIGQUIT, SIG_IGN);
// in debug mode, <CONTROL-C> ==> HUP
if (SIGNALFN(SIGINT, debugmode?HUPhandler:sighandler)==SIG_IGN)
SIGNALFN(SIGINT, SIG_IGN);
// Catch HUP and USR1
if (SIGNALFN(SIGHUP, HUPhandler)==SIG_IGN)
SIGNALFN(SIGHUP, SIG_IGN);
if (SIGNALFN(SIGUSR1, USR1handler)==SIG_IGN)
SIGNALFN(SIGUSR1, SIG_IGN);
#ifdef _WIN32
if (SIGNALFN(SIGUSR2, USR2handler)==SIG_IGN)
SIGNALFN(SIGUSR2, SIG_IGN);
#endif
// initialize wakeup time to CURRENT time
*wakeuptime=time(NULL);
return;
}
#ifdef _WIN32
// Toggle debug mode implemented for native windows only
// (there is no easy way to reopen tty on *nix)
static void ToggleDebugMode()
{
if (!debugmode) {
PrintOut(LOG_INFO,"Signal USR2 - enabling debug mode\n");
if (!daemon_enable_console("smartd [Debug]")) {
debugmode = 1;
daemon_signal(SIGINT, HUPhandler);
PrintOut(LOG_INFO,"smartd debug mode enabled, PID=%d\n", getpid());
}
else
PrintOut(LOG_INFO,"enable console failed\n");
}
else if (debugmode == 1) {
daemon_disable_console();
debugmode = 0;
daemon_signal(SIGINT, sighandler);
PrintOut(LOG_INFO,"Signal USR2 - debug mode disabled\n");
}
else
PrintOut(LOG_INFO,"Signal USR2 - debug mode %d not changed\n", debugmode);
}
#endif
time_t dosleep(time_t wakeuptime){
time_t timenow=0;
// If past wake-up-time, compute next wake-up-time
timenow=time(NULL);
while (wakeuptime<=timenow){
int intervals=1+(timenow-wakeuptime)/checktime;
wakeuptime+=intervals*checktime;
}
// sleep until we catch SIGUSR1 or have completed sleeping
while (timenow<wakeuptime && !caughtsigUSR1 && !caughtsigHUP && !caughtsigEXIT){
// protect user again system clock being adjusted backwards
if (wakeuptime>timenow+checktime){
PrintOut(LOG_CRIT, "System clock time adjusted to the past. Resetting next wakeup time.\n");
wakeuptime=timenow+checktime;
}
// Exit sleep when time interval has expired or a signal is received
sleep(wakeuptime-timenow);
#ifdef _WIN32
// toggle debug mode?
if (caughtsigUSR2) {
ToggleDebugMode();
caughtsigUSR2 = 0;
}
#endif
timenow=time(NULL);
}
// if we caught a SIGUSR1 then print message and clear signal
if (caughtsigUSR1){
PrintOut(LOG_INFO,"Signal USR1 - checking devices now rather than in %d seconds.\n",
wakeuptime-timenow>0?(int)(wakeuptime-timenow):0);
caughtsigUSR1=0;
}
// return adjusted wakeuptime
return wakeuptime;
}
// Print out a list of valid arguments for the Directive d
void printoutvaliddirectiveargs(int priority, char d) {
char *s=NULL;
switch (d) {
case 'n':
PrintOut(priority, "never[,q], sleep[,q], standby[,q], idle[,q]");
break;
case 's':
PrintOut(priority, "valid_regular_expression");
break;
case 'd':
PrintOut(priority, "ata, scsi, marvell, removable, sat, 3ware,N, hpt,L/M/N");
break;
case 'T':
PrintOut(priority, "normal, permissive");
break;
case 'o':
case 'S':
PrintOut(priority, "on, off");
break;
case 'l':
PrintOut(priority, "error, selftest");
break;
case 'M':
PrintOut(priority, "\"once\", \"daily\", \"diminishing\", \"test\", \"exec\"");
break;
case 'v':
if (!(s = create_vendor_attribute_arg_list())) {
PrintOut(LOG_CRIT,"Insufficient memory to construct argument list\n");
EXIT(EXIT_NOMEM);
}
PrintOut(priority, "\n%s\n", s);
s=CheckFree(s, __LINE__,filenameandversion);
break;
case 'P':
PrintOut(priority, "use, ignore, show, showall");
break;
case 'F':
PrintOut(priority, "none, samsung, samsung2, samsung3");
break;
}
}
// exits with an error message, or returns integer value of token
int GetInteger(char *arg, char *name, char *token, int lineno, char *configfile, int min, int max){
char *endptr;
int val;
// check input range
if (min<0){
PrintOut(LOG_CRIT, "min =%d passed to GetInteger() must be >=0\n", min);
return -1;
}
// make sure argument is there
if (!arg) {
PrintOut(LOG_CRIT,"File %s line %d (drive %s): Directive: %s takes integer argument from %d to %d.\n",
configfile, lineno, name, token, min, max);
return -1;
}
// get argument value (base 10), check that it's integer, and in-range
val=strtol(arg,&endptr,10);
if (*endptr!='\0' || val<min || val>max ) {
PrintOut(LOG_CRIT,"File %s line %d (drive %s): Directive: %s has argument: %s; needs integer from %d to %d.\n",
configfile, lineno, name, token, arg, min, max);
return -1;
}
// all is well; return value
return val;
}
// Get 1-3 small integer(s) for '-W' directive
int Get3Integers(const char *arg, const char *name, const char *token, int lineno, const char *configfile,
unsigned char * val1, unsigned char * val2, unsigned char * val3){
unsigned v1 = 0, v2 = 0, v3 = 0;
int n1 = -1, n2 = -1, n3 = -1, len;
if (!arg) {
PrintOut(LOG_CRIT,"File %s line %d (drive %s): Directive: %s takes 1-3 integer argument(s) from 0 to 255.\n",
configfile, lineno, name, token);
return -1;
}
len = strlen(arg);
if (!( sscanf(arg, "%u%n,%u%n,%u%n", &v1, &n1, &v2, &n2, &v3, &n3) >= 1
&& (n1 == len || n2 == len || n3 == len) && v1 <= 255 && v2 <= 255 && v3 <= 255)) {
PrintOut(LOG_CRIT,"File %s line %d (drive %s): Directive: %s has argument: %s; needs 1-3 integer(s) from 0 to 255.\n",
configfile, lineno, name, token, arg);
return -1;
}
*val1 = (unsigned char)v1; *val2 = (unsigned char)v2; *val3 = (unsigned char)v3;
return 0;
}
// This function returns 1 if it has correctly parsed one token (and
// any arguments), else zero if no tokens remain. It returns -1 if an
// error was encountered.
int ParseToken(char *token,cfgfile *cfg){
char sym;
char *name=cfg->name;
int lineno=cfg->lineno;
char *delim = " \n\t";
int badarg = 0;
int missingarg = 0;
char *arg = NULL;
int makemail=0;
maildata *mdat=NULL, tempmail;
// is the rest of the line a comment
if (*token=='#')
return 1;
// is the token not recognized?
if (*token!='-' || strlen(token)!=2) {
PrintOut(LOG_CRIT,"File %s line %d (drive %s): unknown Directive: %s\n",
configfile, lineno, name, token);
PrintOut(LOG_CRIT, "Run smartd -D to print a list of valid Directives.\n");
return -1;
}
// token we will be parsing:
sym=token[1];
// create temporary maildata structure. This means we can postpone
// allocating space in the data segment until we are sure there are
// no errors.
if ('m'==sym || 'M'==sym){
if (!cfg->mailwarn){
memset(&tempmail, 0, sizeof(maildata));
mdat=&tempmail;
makemail=1;
}
else
mdat=cfg->mailwarn;
}
// parse the token and swallow its argument
switch (sym) {
int val;
case 'C':
// monitor current pending sector count (default 197)
if ((val=GetInteger(arg=strtok(NULL,delim), name, token, lineno, configfile, 0, 255))<0)
return -1;
if (val==CUR_UNC_DEFAULT)
val=0;
else if (val==0)
val=CUR_UNC_DEFAULT;
// set bottom 8 bits to correct value
cfg->pending &= 0xff00;
cfg->pending |= val;
break;
case 'U':
// monitor offline uncorrectable sectors (default 198)
if ((val=GetInteger(arg=strtok(NULL,delim), name, token, lineno, configfile, 0, 255))<0)
return -1;
if (val==OFF_UNC_DEFAULT)
val=0;
else if (val==0)
val=OFF_UNC_DEFAULT;
// turn off top 8 bits, then set to correct value
cfg->pending &= 0xff;
cfg->pending |= (val<<8);
break;
case 'T':
// Set tolerance level for SMART command failures
if ((arg = strtok(NULL, delim)) == NULL) {
missingarg = 1;
} else if (!strcmp(arg, "normal")) {
// Normal mode: exit on failure of a mandatory S.M.A.R.T. command, but
// not on failure of an optional S.M.A.R.T. command.
// This is the default so we don't need to actually do anything here.
cfg->permissive=0;
} else if (!strcmp(arg, "permissive")) {
// Permissive mode; ignore errors from Mandatory SMART commands
cfg->permissive=1;
} else {
badarg = 1;
}
break;
case 'd':
// specify the device type
cfg->controller_explicit = 1;
if ((arg = strtok(NULL, delim)) == NULL) {
missingarg = 1;
} else if (!strcmp(arg, "ata")) {
cfg->controller_port = 0;
cfg->controller_type = CONTROLLER_ATA;
} else if (!strcmp(arg, "scsi")) {
cfg->controller_port =0;
cfg->controller_type = CONTROLLER_SCSI;
} else if (!strcmp(arg, "marvell")) {
cfg->controller_port =0;
cfg->controller_type = CONTROLLER_MARVELL_SATA;
} else if (!strncmp(arg, "sat", 3)) {
cfg->controller_type = CONTROLLER_SAT;
cfg->controller_port = 0;
cfg->satpassthrulen = 0;
if (strlen(arg) > 3) {
int k;
char * cp;
cp = strchr(arg, ',');
if (cp && (1 == sscanf(cp + 1, "%d", &k)) &&
((0 == k) || (12 == k) || (16 == k)))
cfg->satpassthrulen = k;
else {
PrintOut(LOG_CRIT, "File %s line %d (drive %s): Directive "
"'-d sat,<n>' requires <n> to be 0, 12 or 16\n",
configfile, lineno, name);
badarg = 1;
}
}
} else if (!strncmp(arg, "hpt", 3)){
unsigned char i, slash = 0;
cfg->hpt_data[0] = 0;
cfg->hpt_data[1] = 0;
cfg->hpt_data[2] = 0;
cfg->controller_type = CONTROLLER_HPT;
for (i=4; i < strlen(arg); i++) {
if(arg[i] == '/') {
slash++;
if(slash == 3) {
PrintOut(LOG_CRIT, "File %s line %d (drive %s): Directive "
"'-d hpt,L/M/N' supports 2-3 items\n",
configfile, lineno, name);
badarg = TRUE;
break;
}
}
else if ((arg[i])>='0' && (arg[i])<='9') {
if (cfg->hpt_data[slash]>1) { /* hpt_data[x] max 19 */
badarg = TRUE;
break;
}
cfg->hpt_data[slash] = cfg->hpt_data[slash]*10 + arg[i] - '0';
}
else {
badarg = TRUE;
break;
}
}
if ( slash == 0 ) {
badarg = TRUE;
} else if (badarg != TRUE) {
if (cfg->hpt_data[0]==0 || cfg->hpt_data[0]>8){
PrintOut(LOG_CRIT, "File %s line %d (drive %s): Directive "
"'-d hpt,L/M/N' no/invalid controller id L supplied\n",
configfile, lineno, name);
badarg = TRUE;
}
if (cfg->hpt_data[1]==0 || cfg->hpt_data[1]>8){
PrintOut(LOG_CRIT, "File %s line %d (drive %s): Directive "
"'-d hpt,L/M/N' no/invalid channel number M supplied\n",
configfile, lineno, name);
badarg = TRUE;
}
if (slash==2){
if (cfg->hpt_data[2]==0 || cfg->hpt_data[2]>15){
PrintOut(LOG_CRIT, "File %s line %d (drive %s): Directive "
"'-d hpt,L/M/N' no/invalid pmport number N supplied\n",
configfile, lineno, name);
badarg = TRUE;
}
} else { /* no pmport device */
cfg->hpt_data[2]=1;
}
}
} else if (!strcmp(arg, "removable")) {
cfg->removable = 1;
} else {
// look 3ware,N RAID device
int i;
char *s;
// make a copy of the string to mess with
if (!(s = strdup(arg))) {
PrintOut(LOG_CRIT,
"No memory to copy argument to -d option - exiting\n");
EXIT(EXIT_NOMEM);
} else if (!strncmp(s,"3ware,",6)) {
if (split_report_arg2(s, &i)){
PrintOut(LOG_CRIT, "File %s line %d (drive %s): Directive -d 3ware,N requires N integer\n",
configfile, lineno, name);
badarg=1;
} else if ( i<0 || i>31) {
PrintOut(LOG_CRIT, "File %s line %d (drive %s): Directive -d 3ware,N (N=%d) must have 0 <= N <= 31\n",
configfile, lineno, name, i);
badarg=1;
} else {
// determine type of escalade device from name of device
cfg->controller_type = guess_device_type(name);
if (cfg->controller_type!=CONTROLLER_3WARE_9000_CHAR && cfg->controller_type!=CONTROLLER_3WARE_678K_CHAR)
cfg->controller_type=CONTROLLER_3WARE_678K;
// NOTE: controller_port == disk number + 1
cfg->controller_port = i+1;
}
} else if (!strncmp(s,"cciss,",6)) {
if (split_report_arg2(s, &i)){
PrintOut(LOG_CRIT, "File %s line %d (drive %s): Directive -d cciss,N requires N integer\n",
configfile, lineno, name);
badarg=1;
} else if ( i<0 || i>127) {
PrintOut(LOG_CRIT, "File %s line %d (drive %s): Directive -d cciss,N (N=%d) must have 0 <= N <= 127\n",
configfile, lineno, name, i);
badarg=1;
} else {
// NOTE: controller_port == disk number + 1
cfg->controller_type = CONTROLLER_CCISS;
cfg->controller_port = i+1;
}
} else {
badarg=1;
}
s=CheckFree(s, __LINE__,filenameandversion);
}
break;
case 'F':
// fix firmware bug
if ((arg = strtok(NULL, delim)) == NULL) {
missingarg = 1;
} else if (!strcmp(arg, "none")) {
cfg->fixfirmwarebug = FIX_NONE;
} else if (!strcmp(arg, "samsung")) {
cfg->fixfirmwarebug = FIX_SAMSUNG;
} else if (!strcmp(arg, "samsung2")) {
cfg->fixfirmwarebug = FIX_SAMSUNG2;
} else if (!strcmp(arg, "samsung3")) {
cfg->fixfirmwarebug = FIX_SAMSUNG3;
} else {
badarg = 1;
}
break;
case 'H':
// check SMART status
cfg->smartcheck=1;
break;
case 'f':
// check for failure of usage attributes
cfg->usagefailed=1;
break;
case 't':
// track changes in all vendor attributes
cfg->prefail=1;
cfg->usage=1;
break;
case 'p':
// track changes in prefail vendor attributes
cfg->prefail=1;
break;
case 'u':
// track changes in usage vendor attributes
cfg->usage=1;
break;
case 'l':
// track changes in SMART logs
if ((arg = strtok(NULL, delim)) == NULL) {
missingarg = 1;
} else if (!strcmp(arg, "selftest")) {
// track changes in self-test log
cfg->selftest=1;
} else if (!strcmp(arg, "error")) {
// track changes in ATA error log
cfg->errorlog=1;
} else {
badarg = 1;
}
break;
case 'a':
// monitor everything
cfg->smartcheck=1;
cfg->prefail=1;
cfg->usagefailed=1;
cfg->usage=1;
cfg->selftest=1;
cfg->errorlog=1;
break;
case 'o':
// automatic offline testing enable/disable
if ((arg = strtok(NULL, delim)) == NULL) {
missingarg = 1;
} else if (!strcmp(arg, "on")) {
cfg->autoofflinetest = 2;
} else if (!strcmp(arg, "off")) {
cfg->autoofflinetest = 1;
} else {
badarg = 1;
}
break;
case 'n':
// skip disk check if in idle or standby mode
if (!(arg = strtok(NULL, delim)))
missingarg = 1;
else if (!strcmp(arg, "never") || !strcmp(arg, "never,q"))
cfg->powermode = 0;
else if (!strcmp(arg, "sleep") || !strcmp(arg, "sleep,q"))
cfg->powermode = 1;
else if (!strcmp(arg, "standby") || !strcmp(arg, "standby,q"))
cfg->powermode = 2;
else if (!strcmp(arg, "idle") || !strcmp(arg, "idle,q"))
cfg->powermode = 3;
else
badarg = 1;
cfg->powerquiet = !!strchr(arg, ',');
break;
case 'S':
// automatic attribute autosave enable/disable
if ((arg = strtok(NULL, delim)) == NULL) {
missingarg = 1;
} else if (!strcmp(arg, "on")) {
cfg->autosave = 2;
} else if (!strcmp(arg, "off")) {
cfg->autosave = 1;
} else {
badarg = 1;
}
break;
case 's':
// warn user, and delete any previously given -s REGEXP Directives
if (cfg->testdata){
PrintOut(LOG_INFO, "File %s line %d (drive %s): ignoring previous Test Directive -s %s\n",
configfile, lineno, name, cfg->testdata->regex);
cfg->testdata=FreeTestData(cfg->testdata);
}
// check for missing argument
if (!(arg = strtok(NULL, delim))) {
missingarg = 1;
}
// allocate space for structure and string
else if (!(cfg->testdata=(testinfo *)Calloc(1, sizeof(testinfo))) || !(cfg->testdata->regex=CustomStrDup(arg, 1, __LINE__,filenameandversion))) {
PrintOut(LOG_INFO, "File %s line %d (drive %s): no memory to create Test Directive -s %s!\n",
configfile, lineno, name, arg);
EXIT(EXIT_NOMEM);
}
else if ((val=regcomp(&(cfg->testdata->cregex), arg, REG_EXTENDED))) {
char errormsg[512];
// not a valid regular expression!
regerror(val, &(cfg->testdata->cregex), errormsg, 512);
PrintOut(LOG_CRIT, "File %s line %d (drive %s): -s argument \"%s\" is INVALID extended regular expression. %s.\n",
configfile, lineno, name, arg, errormsg);
cfg->testdata=FreeTestData(cfg->testdata);
return -1;
}
// Do a bit of sanity checking and warn user if we think that
// their regexp is "strange". User probably confused about shell
// glob(3) syntax versus regular expression syntax regexp(7).
else if ((int)strlen(arg) != (val=strspn(arg,"0123456789/.-+*|()?^$[]SLCO")))
PrintOut(LOG_INFO, "File %s line %d (drive %s): warning, character %d (%c) looks odd in extended regular expression %s\n",
configfile, lineno, name, val+1, arg[val], arg);
break;
case 'm':
// send email to address that follows
if (!(arg = strtok(NULL,delim)))
missingarg = 1;
else {
if (mdat->address) {
PrintOut(LOG_INFO, "File %s line %d (drive %s): ignoring previous Address Directive -m %s\n",
configfile, lineno, name, mdat->address);
mdat->address=FreeNonZero(mdat->address, -1,__LINE__,filenameandversion);
}
mdat->address=CustomStrDup(arg, 1, __LINE__,filenameandversion);
}
break;
case 'M':
// email warning options
if (!(arg = strtok(NULL, delim)))
missingarg = 1;
else if (!strcmp(arg, "once"))
mdat->emailfreq = 1;
else if (!strcmp(arg, "daily"))
mdat->emailfreq = 2;
else if (!strcmp(arg, "diminishing"))
mdat->emailfreq = 3;
else if (!strcmp(arg, "test"))
mdat->emailtest = 1;
else if (!strcmp(arg, "exec")) {
// Get the next argument (the command line)
if (!(arg = strtok(NULL, delim))) {
PrintOut(LOG_CRIT, "File %s line %d (drive %s): Directive %s 'exec' argument must be followed by executable path.\n",
configfile, lineno, name, token);
return -1;
}
// Free the last cmd line given if any, and copy new one
if (mdat->emailcmdline) {
PrintOut(LOG_INFO, "File %s line %d (drive %s): ignoring previous mail Directive -M exec %s\n",
configfile, lineno, name, mdat->emailcmdline);
mdat->emailcmdline=FreeNonZero(mdat->emailcmdline, -1,__LINE__,filenameandversion);
}
mdat->emailcmdline=CustomStrDup(arg, 1, __LINE__,filenameandversion);
}
else
badarg = 1;
break;
case 'i':
// ignore failure of usage attribute
if ((val=GetInteger(arg=strtok(NULL,delim), name, token, lineno, configfile, 1, 255))<0)
return -1;
IsAttributeOff(val, &cfg->monitorattflags, 1, MONITOR_FAILUSE, __LINE__);
break;
case 'I':
// ignore attribute for tracking purposes
if ((val=GetInteger(arg=strtok(NULL,delim), name, token, lineno, configfile, 1, 255))<0)
return -1;
IsAttributeOff(val, &cfg->monitorattflags, 1, MONITOR_IGNORE, __LINE__);
break;
case 'r':
// print raw value when tracking
if ((val=GetInteger(arg=strtok(NULL,delim), name, token, lineno, configfile, 1, 255))<0)
return -1;
IsAttributeOff(val, &cfg->monitorattflags, 1, MONITOR_RAWPRINT, __LINE__);
break;
case 'R':
// track changes in raw value (forces printing of raw value)
if ((val=GetInteger(arg=strtok(NULL,delim), name, token, lineno, configfile, 1, 255))<0)
return -1;
IsAttributeOff(val, &cfg->monitorattflags, 1, MONITOR_RAWPRINT, __LINE__);
IsAttributeOff(val, &cfg->monitorattflags, 1, MONITOR_RAW, __LINE__);
break;
case 'W':
// track Temperature
if ((val=Get3Integers(arg=strtok(NULL,delim), name, token, lineno, configfile,
&cfg->tempdiff, &cfg->tempinfo, &cfg->tempcrit))<0)
return -1;
// increase min Temperature during first 30 minutes
if (!(cfg->tempmininc = (unsigned char)(CHECKTIME / checktime)))
cfg->tempmininc = 1;
break;
case 'v':
// non-default vendor-specific attribute meaning
if (!(arg=strtok(NULL,delim))) {
missingarg = 1;
} else if (parse_attribute_def(arg, &cfg->attributedefs)){
badarg = 1;
}
break;
case 'P':
// Define use of drive-specific presets.
if (!(arg = strtok(NULL, delim))) {
missingarg = 1;
} else if (!strcmp(arg, "use")) {
cfg->ignorepresets = FALSE;
} else if (!strcmp(arg, "ignore")) {
cfg->ignorepresets = TRUE;
} else if (!strcmp(arg, "show")) {
cfg->showpresets = TRUE;
} else if (!strcmp(arg, "showall")) {
showallpresets();
} else {
badarg = 1;
}
break;
default:
// Directive not recognized
PrintOut(LOG_CRIT,"File %s line %d (drive %s): unknown Directive: %s\n",
configfile, lineno, name, token);
Directives();
return -1;
}
if (missingarg) {
PrintOut(LOG_CRIT, "File %s line %d (drive %s): Missing argument to %s Directive\n",
configfile, lineno, name, token);
}
if (badarg) {
PrintOut(LOG_CRIT, "File %s line %d (drive %s): Invalid argument to %s Directive: %s\n",
configfile, lineno, name, token, arg);
}
if (missingarg || badarg) {
PrintOut(LOG_CRIT, "Valid arguments to %s Directive are: ", token);
printoutvaliddirectiveargs(LOG_CRIT, sym);
PrintOut(LOG_CRIT, "\n");
return -1;
}
// If this did something to fill the mail structure, and that didn't
// already exist, create it and copy.
if (makemail) {
if (!(cfg->mailwarn=(maildata *)Calloc(1, sizeof(maildata)))) {
PrintOut(LOG_INFO, "File %s line %d (drive %s): no memory to create mail warning entry!\n",
configfile, lineno, name);
EXIT(EXIT_NOMEM);
}
memcpy(cfg->mailwarn, mdat, sizeof(maildata));
}
return 1;
}
// Allocate storage for a new cfgfile entry. If original!=NULL, it's
// a copy of the original, but with private data storage. Else all is
// zeroed. Returns address, and fails if non memory available.
cfgfile *CreateConfigEntry(cfgfile *original){
cfgfile *add;
// allocate memory for new structure
if (!(add=(cfgfile *)Calloc(1,sizeof(cfgfile))))
goto badexit;
// if old structure was pointed to, copy it
if (original)
memcpy(add, original, sizeof(cfgfile));
// make private copies of data items ONLY if they are in use (non
// NULL)
add->name = CustomStrDup(add->name, 0, __LINE__,filenameandversion);
if (add->testdata) {
int val;
if (!(add->testdata=(testinfo *)Calloc(1,sizeof(testinfo))))
goto badexit;
memcpy(add->testdata, original->testdata, sizeof(testinfo));
add->testdata->regex = CustomStrDup(add->testdata->regex, 1, __LINE__,filenameandversion);
// only POSIX-portable way to make fresh copy of compiled regex is
// to recompile it completely. There is no POSIX
// compiled-regex-copy command.
if ((val=regcomp(&(add->testdata->cregex), add->testdata->regex, REG_EXTENDED))) {
char errormsg[512];
regerror(val, &(add->testdata->cregex), errormsg, 512);
PrintOut(LOG_CRIT, "unable to recompile regular expression %s. %s\n", add->testdata->regex, errormsg);
goto badexit;
}
}
if (add->mailwarn) {
if (!(add->mailwarn=(maildata *)Calloc(1,sizeof(maildata))))
goto badexit;
memcpy(add->mailwarn, original->mailwarn, sizeof(maildata));
add->mailwarn->address = CustomStrDup(add->mailwarn->address, 0, __LINE__,filenameandversion);
add->mailwarn->emailcmdline = CustomStrDup(add->mailwarn->emailcmdline, 0, __LINE__,filenameandversion);
}
if (add->attributedefs) {
if (!(add->attributedefs=(unsigned char *)Calloc(MAX_ATTRIBUTE_NUM,1)))
goto badexit;
memcpy(add->attributedefs, original->attributedefs, MAX_ATTRIBUTE_NUM);
}
if (add->monitorattflags) {
if (!(add->monitorattflags=(unsigned char *)Calloc(NMONITOR*32, 1)))
goto badexit;
memcpy(add->monitorattflags, original->monitorattflags, NMONITOR*32);
}
if (add->smartval) {
if (!(add->smartval=(struct ata_smart_values *)Calloc(1,sizeof(struct ata_smart_values))))
goto badexit;
}
if (add->smartthres) {
if (!(add->smartthres=(struct ata_smart_thresholds_pvt *)Calloc(1,sizeof(struct ata_smart_thresholds_pvt))))
goto badexit;
}
return add;
badexit:
PrintOut(LOG_CRIT, "No memory to create entry from configuration file\n");
EXIT(EXIT_NOMEM);
}
// This is the routine that adds things to the cfgentries list. To
// prevent memory leaks when re-reading the configuration file many
// times, this routine MUST deallocate any memory other than that
// pointed to within cfg-> before it returns.
//
// Return values are:
// 1: parsed a normal line
// 0: found comment or blank line
// -1: found SCANDIRECTIVE line
// -2: found an error
//
// Note: this routine modifies *line from the caller!
int ParseConfigLine(int entry, int lineno,char *line){
char *token=NULL;
char *name=NULL;
char *delim = " \n\t";
cfgfile *cfg=NULL;
int devscan=0;
// get first token: device name. If a comment, skip line
if (!(name=strtok(line,delim)) || *name=='#') {
return 0;
}
// Have we detected the SCANDIRECTIVE directive?
if (!strcmp(SCANDIRECTIVE,name)){
devscan=1;
if (entry) {
PrintOut(LOG_INFO,"Scan Directive %s (line %d) must be the first entry in %s\n",name, lineno, configfile);
return -2;
}
}
// Is there space for another entry? If not, allocate more
while (entry>=cfgentries_max)
cfgentries=AllocateMoreSpace(cfgentries, &cfgentries_max, "configuration file device");
// We've got a legit entry, make space to store it
cfg=cfgentries[entry]=CreateConfigEntry(NULL);
cfg->name = CustomStrDup(name, 1, __LINE__,filenameandversion);
// Store line number, and by default check for both device types.
cfg->lineno=lineno;
// Try and recognize if a IDE or SCSI device. These can be
// overwritten by configuration file directives.
if (cfg->controller_type==CONTROLLER_UNKNOWN)
cfg->controller_type = guess_device_type(cfg->name);
// parse tokens one at a time from the file.
while ((token=strtok(NULL,delim))){
int retval=ParseToken(token,cfg);
if (retval==0)
// No tokens left:
break;
if (retval>0) {
// Parsed token
#if (0)
PrintOut(LOG_INFO,"Parsed token %s\n",token);
#endif
continue;
}
if (retval<0) {
// error found on the line
return -2;
}
}
// If we found 3ware/cciss controller, then modify device name by adding a SPACE
if (cfg->controller_port) {
int len=17+strlen(cfg->name);
char *newname;
if (devscan){
PrintOut(LOG_CRIT, "smartd: can not scan for 3ware/cciss devices (line %d of file %s)\n",
lineno, configfile);
return -2;
}
if (!(newname=(char *)calloc(len,1))) {
PrintOut(LOG_INFO,"No memory to parse file: %s line %d, %s\n", configfile, lineno, strerror(errno));
EXIT(EXIT_NOMEM);
}
// Make new device name by adding a space then RAID disk number
snprintf(newname, len, "%s [%s_disk_%02d]", cfg->name, (cfg->controller_type == CONTROLLER_CCISS) ? "cciss" : "3ware",
cfg->controller_port-1);
cfg->name=CheckFree(cfg->name, __LINE__,filenameandversion);
cfg->name=newname;
bytes+=16;
}
if (cfg->hpt_data[0]) {
int len=17+strlen(cfg->name);
char *newname;
if (devscan){
PrintOut(LOG_CRIT, "smartd: can not scan for highpoint devices (line %d of file %s)\n",
lineno, configfile);
return -2;
}
if (!(newname=(char *)calloc(len,1))) {
PrintOut(LOG_INFO,"No memory to parse file: %s line %d, %s\n", configfile, lineno, strerror(errno));
EXIT(EXIT_NOMEM);
}
// Make new device name by adding a space then RAID disk number
snprintf(newname, len, "%s [hpt_%d/%d/%d]", cfg->name, cfg->hpt_data[0],
cfg->hpt_data[1], cfg->hpt_data[2]);
cfg->name=CheckFree(cfg->name, __LINE__,filenameandversion);
cfg->name=newname;
bytes+=16;
}
// If NO monitoring directives are set, then set all of them.
if (!(cfg->smartcheck || cfg->usagefailed || cfg->prefail ||
cfg->usage || cfg->selftest || cfg->errorlog ||
cfg->tempdiff || cfg->tempinfo || cfg->tempcrit )) {
PrintOut(LOG_INFO,"Drive: %s, implied '-a' Directive on line %d of file %s\n",
cfg->name, cfg->lineno, configfile);
cfg->smartcheck=1;
cfg->usagefailed=1;
cfg->prefail=1;
cfg->usage=1;
cfg->selftest=1;
cfg->errorlog=1;
}
// additional sanity check. Has user set -M options without -m?
if (cfg->mailwarn && !cfg->mailwarn->address && (cfg->mailwarn->emailcmdline || cfg->mailwarn->emailfreq || cfg->mailwarn->emailtest)){
PrintOut(LOG_CRIT,"Drive: %s, -M Directive(s) on line %d of file %s need -m ADDRESS Directive\n",
cfg->name, cfg->lineno, configfile);
return -2;
}
// has the user has set <nomailer>?
if (cfg->mailwarn && cfg->mailwarn->address && !strcmp(cfg->mailwarn->address,"<nomailer>")){
// check that -M exec is also set
if (!cfg->mailwarn->emailcmdline){
PrintOut(LOG_CRIT,"Drive: %s, -m <nomailer> Directive on line %d of file %s needs -M exec Directive\n",
cfg->name, cfg->lineno, configfile);
return -2;
}
// now free memory. From here on the sign of <nomailer> is
// address==NULL and cfg->emailcmdline!=NULL
cfg->mailwarn->address=FreeNonZero(cfg->mailwarn->address, -1,__LINE__,filenameandversion);
}
// set cfg->emailfreq to 1 (once) if user hasn't set it
if (cfg->mailwarn && !cfg->mailwarn->emailfreq)
cfg->mailwarn->emailfreq = 1;
entry++;
if (devscan)
return -1;
else
return 1;
}
// clean up utility for ParseConfigFile()
void cleanup(FILE **fpp, int is_stdin){
if (*fpp){
// (*fpp != stdin) does not work here if stdin has been closed & reopened
if (!is_stdin)
fclose(*fpp);
*fpp=NULL;
}
return;
}
// Parses a configuration file. Return values are:
// N=>0: found N entries
// -1: syntax error in config file
// -2: config file does not exist
// -3: config file exists but cannot be read
//
// In the case where the return value is 0, there are three
// possiblities:
// Empty configuration file ==> cfgentries==NULL
// No configuration file ==> cfgentries[0]->lineno == 0
// SCANDIRECTIVE found ==> cfgentries[0]->lineno != 0
int ParseConfigFile(){
FILE *fp=NULL;
int entry=0,lineno=1,cont=0,contlineno=0;
char line[MAXLINELEN+2];
char fullline[MAXCONTLINE+1];
int is_stdin = (configfile == configfile_stdin); // pointer comparison ok here
// Open config file, if it exists and is not <stdin>
if (!is_stdin) {
fp=fopen(configfile,"r");
if (fp==NULL && (errno!=ENOENT || configfile_alt)) {
// file exists but we can't read it or it should exist due to '-c' option
int ret = (errno!=ENOENT ? -3 : -2);
PrintOut(LOG_CRIT,"%s: Unable to open configuration file %s\n",
strerror(errno),configfile);
return ret;
}
}
else // read from stdin ('-c -' option)
fp = stdin;
// No configuration file found -- use fake one
if (fp==NULL) {
int len=strlen(SCANDIRECTIVE)+4;
char *fakeconfig=(char *)calloc(len,1);
if (!fakeconfig ||
(len-1) != snprintf(fakeconfig, len, "%s -a", SCANDIRECTIVE) ||
-1 != ParseConfigLine(entry, 0, fakeconfig)
) {
PrintOut(LOG_CRIT,"Internal error in ParseConfigFile() at line %d of file %s\n%s",
__LINE__, filenameandversion, reportbug);
EXIT(EXIT_BADCODE);
}
fakeconfig=CheckFree(fakeconfig, __LINE__,filenameandversion);
return 0;
}
#ifdef __CYGWIN__
setmode(fileno(fp), O_TEXT); // Allow files with \r\n
#endif
// configuration file exists
PrintOut(LOG_INFO,"Opened configuration file %s\n",configfile);
// parse config file line by line
while (1) {
int len=0,scandevice;
char *lastslash;
char *comment;
char *code;
// make debugging simpler
memset(line,0,sizeof(line));
// get a line
code=fgets(line,MAXLINELEN+2,fp);
// are we at the end of the file?
if (!code){
if (cont) {
scandevice=ParseConfigLine(entry,contlineno,fullline);
// See if we found a SCANDIRECTIVE directive
if (scandevice==-1) {
cleanup(&fp, is_stdin);
return 0;
}
// did we find a syntax error
if (scandevice==-2) {
cleanup(&fp, is_stdin);
return -1;
}
// the final line is part of a continuation line
cont=0;
entry+=scandevice;
}
break;
}
// input file line number
contlineno++;
// See if line is too long
len=strlen(line);
if (len>MAXLINELEN){
char *warn;
if (line[len-1]=='\n')
warn="(including newline!) ";
else
warn="";
PrintOut(LOG_CRIT,"Error: line %d of file %s %sis more than MAXLINELEN=%d characters.\n",
(int)contlineno,configfile,warn,(int)MAXLINELEN);
cleanup(&fp, is_stdin);
return -1;
}
// Ignore anything after comment symbol
if ((comment=strchr(line,'#'))){
*comment='\0';
len=strlen(line);
}
// is the total line (made of all continuation lines) too long?
if (cont+len>MAXCONTLINE){
PrintOut(LOG_CRIT,"Error: continued line %d (actual line %d) of file %s is more than MAXCONTLINE=%d characters.\n",
lineno, (int)contlineno, configfile, (int)MAXCONTLINE);
cleanup(&fp, is_stdin);
return -1;
}
// copy string so far into fullline, and increment length
strcpy(fullline+cont,line);
cont+=len;
// is this a continuation line. If so, replace \ by space and look at next line
if ( (lastslash=strrchr(line,'\\')) && !strtok(lastslash+1," \n\t")){
*(fullline+(cont-len)+(lastslash-line))=' ';
continue;
}
// Not a continuation line. Parse it
scandevice=ParseConfigLine(entry,contlineno,fullline);
// did we find a scandevice directive?
if (scandevice==-1) {
cleanup(&fp, is_stdin);
return 0;
}
// did we find a syntax error
if (scandevice==-2) {
cleanup(&fp, is_stdin);
return -1;
}
entry+=scandevice;
lineno++;
cont=0;
}
cleanup(&fp, is_stdin);
// note -- may be zero if syntax of file OK, but no valid entries!
return entry;
}
// Prints copyright, license and version information
void PrintCopyleft(void){
debugmode=1;
PrintHead();
PrintCVS();
return;
}
/* Prints the message "=======> VALID ARGUMENTS ARE: <LIST> <=======\n", where
<LIST> is the list of valid arguments for option opt. */
void PrintValidArgs(char opt) {
const char *s;
PrintOut(LOG_CRIT, "=======> VALID ARGUMENTS ARE: ");
if (!(s = GetValidArgList(opt)))
PrintOut(LOG_CRIT, "Error constructing argument list for option %c", opt);
else
PrintOut(LOG_CRIT, (char *)s);
PrintOut(LOG_CRIT, " <=======\n");
}
// Parses input line, prints usage message and
// version/license/copyright messages
void ParseOpts(int argc, char **argv){
extern char *optarg;
extern int optopt, optind, opterr;
int optchar;
int badarg;
char *tailptr;
long lchecktime;
// Please update GetValidArgList() if you edit shortopts
const char *shortopts = "c:l:q:dDni:p:r:Vh?";
#ifdef HAVE_GETOPT_LONG
char *arg;
// Please update GetValidArgList() if you edit longopts
struct option longopts[] = {
{ "configfile", required_argument, 0, 'c' },
{ "logfacility", required_argument, 0, 'l' },
{ "quit", required_argument, 0, 'q' },
{ "debug", no_argument, 0, 'd' },
{ "showdirectives", no_argument, 0, 'D' },
{ "interval", required_argument, 0, 'i' },
#ifndef _WIN32
{ "no-fork", no_argument, 0, 'n' },
#endif
{ "pidfile", required_argument, 0, 'p' },
{ "report", required_argument, 0, 'r' },
#if defined(_WIN32) || defined(__CYGWIN__)
{ "service", no_argument, 0, 'n' },
#endif
{ "version", no_argument, 0, 'V' },
{ "license", no_argument, 0, 'V' },
{ "copyright", no_argument, 0, 'V' },
{ "help", no_argument, 0, 'h' },
{ "usage", no_argument, 0, 'h' },
{ 0, 0, 0, 0 }
};
#endif
opterr=optopt=0;
badarg=FALSE;
// Parse input options. This horrible construction is so that emacs
// indents properly. Sorry.
while (-1 != (optchar =
#ifdef HAVE_GETOPT_LONG
getopt_long(argc, argv, shortopts, longopts, NULL)
#else
getopt(argc, argv, shortopts)
#endif
)) {
switch(optchar) {
case 'q':
// when to quit
if (!(strcmp(optarg,"nodev"))) {
quit=0;
} else if (!(strcmp(optarg,"nodevstartup"))) {
quit=1;
} else if (!(strcmp(optarg,"never"))) {
quit=2;
} else if (!(strcmp(optarg,"onecheck"))) {
quit=3;
debugmode=1;
} else if (!(strcmp(optarg,"showtests"))) {
quit=4;
debugmode=1;
} else if (!(strcmp(optarg,"errors"))) {
quit=5;
} else {
badarg = TRUE;
}
break;
case 'l':
// set the log facility level
if (!strcmp(optarg, "daemon"))
facility=LOG_DAEMON;
else if (!strcmp(optarg, "local0"))
facility=LOG_LOCAL0;
else if (!strcmp(optarg, "local1"))
facility=LOG_LOCAL1;
else if (!strcmp(optarg, "local2"))
facility=LOG_LOCAL2;
else if (!strcmp(optarg, "local3"))
facility=LOG_LOCAL3;
else if (!strcmp(optarg, "local4"))
facility=LOG_LOCAL4;
else if (!strcmp(optarg, "local5"))
facility=LOG_LOCAL5;
else if (!strcmp(optarg, "local6"))
facility=LOG_LOCAL6;
else if (!strcmp(optarg, "local7"))
facility=LOG_LOCAL7;
else
badarg = TRUE;
break;
case 'd':
// enable debug mode
debugmode = TRUE;
break;
case 'n':
// don't fork()
#ifndef _WIN32 // On Windows, --service is already handled by daemon_main()
do_fork = false;
#endif
break;
case 'D':
// print summary of all valid directives
debugmode = TRUE;
Directives();
EXIT(0);
break;
case 'i':
// Period (time interval) for checking
// strtol will set errno in the event of overflow, so we'll check it.
errno = 0;
lchecktime = strtol(optarg, &tailptr, 10);
if (*tailptr != '\0' || lchecktime < 10 || lchecktime > INT_MAX || errno) {
debugmode=1;
PrintHead();
PrintOut(LOG_CRIT, "======> INVALID INTERVAL: %s <=======\n", optarg);
PrintOut(LOG_CRIT, "======> INTERVAL MUST BE INTEGER BETWEEN %d AND %d <=======\n", 10, INT_MAX);
PrintOut(LOG_CRIT, "\nUse smartd -h to get a usage summary\n\n");
EXIT(EXIT_BADCMD);
}
checktime = (int)lchecktime;
break;
case 'r':
// report IOCTL transactions
{
int i;
char *s;
// split_report_arg() may modify its first argument string, so use a
// copy of optarg in case we want optarg for an error message.
if (!(s = strdup(optarg))) {
PrintOut(LOG_CRIT, "No memory to process -r option - exiting\n");
EXIT(EXIT_NOMEM);
}
if (split_report_arg(s, &i)) {
badarg = TRUE;
} else if (i<1 || i>3) {
debugmode=1;
PrintHead();
PrintOut(LOG_CRIT, "======> INVALID REPORT LEVEL: %s <=======\n", optarg);
PrintOut(LOG_CRIT, "======> LEVEL MUST BE INTEGER BETWEEN 1 AND 3<=======\n");
EXIT(EXIT_BADCMD);
} else if (!strcmp(s,"ioctl")) {
con->reportataioctl = con->reportscsiioctl = i;
} else if (!strcmp(s,"ataioctl")) {
con->reportataioctl = i;
} else if (!strcmp(s,"scsiioctl")) {
con->reportscsiioctl = i;
} else {
badarg = TRUE;
}
s=CheckFree(s, __LINE__,filenameandversion);
}
break;
case 'c':
// alternate configuration file
if (strcmp(optarg,"-"))
configfile=configfile_alt=CustomStrDup(optarg, 1, __LINE__,filenameandversion);
else // read from stdin
configfile=configfile_stdin;
break;
case 'p':
// output file with PID number
pid_file=CustomStrDup(optarg, 1, __LINE__,filenameandversion);
break;
case 'V':
// print version and CVS info
PrintCopyleft();
EXIT(0);
break;
case 'h':
// help: print summary of command-line options
debugmode=1;
PrintHead();
Usage();
EXIT(0);
break;
case '?':
default:
// unrecognized option
debugmode=1;
PrintHead();
#ifdef HAVE_GETOPT_LONG
// Point arg to the argument in which this option was found.
arg = argv[optind-1];
// Check whether the option is a long option that doesn't map to -h.
if (arg[1] == '-' && optchar != 'h') {
// Iff optopt holds a valid option then argument must be missing.
if (optopt && (strchr(shortopts, optopt) != NULL)) {
PrintOut(LOG_CRIT, "=======> ARGUMENT REQUIRED FOR OPTION: %s <=======\n",arg+2);
PrintValidArgs(optopt);
} else {
PrintOut(LOG_CRIT, "=======> UNRECOGNIZED OPTION: %s <=======\n\n",arg+2);
}
PrintOut(LOG_CRIT, "\nUse smartd --help to get a usage summary\n\n");
EXIT(EXIT_BADCMD);
}
#endif
if (optopt) {
// Iff optopt holds a valid option then argument must be missing.
if (strchr(shortopts, optopt) != NULL){
PrintOut(LOG_CRIT, "=======> ARGUMENT REQUIRED FOR OPTION: %c <=======\n",optopt);
PrintValidArgs(optopt);
} else {
PrintOut(LOG_CRIT, "=======> UNRECOGNIZED OPTION: %c <=======\n\n",optopt);
}
PrintOut(LOG_CRIT, "\nUse smartd -h to get a usage summary\n\n");
EXIT(EXIT_BADCMD);
}
Usage();
EXIT(0);
}
// Check to see if option had an unrecognized or incorrect argument.
if (badarg) {
debugmode=1;
PrintHead();
// It would be nice to print the actual option name given by the user
// here, but we just print the short form. Please fix this if you know
// a clean way to do it.
PrintOut(LOG_CRIT, "=======> INVALID ARGUMENT TO -%c: %s <======= \n", optchar, optarg);
PrintValidArgs(optchar);
PrintOut(LOG_CRIT, "\nUse smartd -h to get a usage summary\n\n");
EXIT(EXIT_BADCMD);
}
}
// non-option arguments are not allowed
if (argc > optind) {
debugmode=1;
PrintHead();
PrintOut(LOG_CRIT, "=======> UNRECOGNIZED ARGUMENT: %s <=======\n\n", argv[optind]);
PrintOut(LOG_CRIT, "\nUse smartd -h to get a usage summary\n\n");
EXIT(EXIT_BADCMD);
}
// no pidfile in debug mode
if (debugmode && pid_file) {
debugmode=1;
PrintHead();
PrintOut(LOG_CRIT, "=======> INVALID CHOICE OF OPTIONS: -d and -p <======= \n\n");
PrintOut(LOG_CRIT, "Error: pid file %s not written in debug (-d) mode\n\n", pid_file);
pid_file=FreeNonZero(pid_file, -1,__LINE__,filenameandversion);
EXIT(EXIT_BADCMD);
}
// print header
PrintHead();
return;
}
// Function we call if no configuration file was found or if the
// SCANDIRECTIVE Directive was found. It makes entries for device
// names returned by make_device_names() in os_OSNAME.c
int MakeConfigEntries(const char *type, int start){
int i;
int num;
char** devlist = NULL;
cfgfile *first=cfgentries[0],*cfg=first;
// Hack! This is to make DEVICESCAN work on ATA devices behind
// a SCSI to ATA Translation (SAT) Layer.
// This will work on a general OS if the way that SAT devices are
// named is the same as SCSI devices.
// The BETTER solution is to modify make_device_names to recognize
// the additional type "SAT". This requires changing os_*.cpp.
const char *basetype = type;
if (!strcmp(type,"SAT") )
basetype = "SCSI";
// make list of devices
if ((num=make_device_names(&devlist,basetype))<0)
PrintOut(LOG_CRIT,"Problem creating device name scan list\n");
// if no devices, or error constructing list, return
if (num<=0)
return 0;
// loop over entries to create
for (i=0; i<num; i++){
// make storage and copy for all but first entry
if (start+i) {
// allocate more storage if needed
while (cfgentries_max<=start+i)
cfgentries=AllocateMoreSpace(cfgentries, &cfgentries_max, "simulated configuration file device");
cfg=cfgentries[start+i]=CreateConfigEntry(first);
}
// ATA or SCSI?
if (!strcmp(type,"ATA") )
cfg->controller_type = CONTROLLER_ATA;
if (!strcmp(type,"SCSI") )
cfg->controller_type = CONTROLLER_SCSI;
if (!strcmp(type,"SAT") )
cfg->controller_type = CONTROLLER_SAT;
// remove device name, if it's there, and put in correct one
cfg->name=FreeNonZero(cfg->name, -1,__LINE__,filenameandversion);
// save pointer to the device name created within
// make_device_names
cfg->name=devlist[i];
}
// If needed, free memory used for devlist: pointers now in
// cfgentries[]->names. If num==0 we never get to this point, but
// that's OK. If we realloc()d the array length in
// make_device_names() that was ALREADY equivalent to calling
// free().
devlist = FreeNonZero(devlist,(sizeof (char*) * num),__LINE__, filenameandversion);
return num;
}
void CanNotRegister(char *name, char *type, int line, int scandirective){
if( !debugmode && scandirective == 1 ) { return; }
if (line)
PrintOut(scandirective?LOG_INFO:LOG_CRIT,
"Unable to register %s device %s at line %d of file %s\n",
type, name, line, configfile);
else
PrintOut(LOG_INFO,"Unable to register %s device %s\n",
type, name);
return;
}
// Returns negative value (see ParseConfigFile()) if config file
// had errors, else number of entries which may be zero or positive.
// If we found no configuration file, or it contained SCANDIRECTIVE,
// then *scanning is set to 1, else 0.
int ReadOrMakeConfigEntries(int *scanning){
int entries;
// deallocate any cfgfile data structures in memory
RmAllConfigEntries();
// parse configuration file configfile (normally /etc/smartd.conf)
if ((entries=ParseConfigFile())<0) {
// There was an error reading the configuration file.
RmAllConfigEntries();
if (entries == -1)
PrintOut(LOG_CRIT, "Configuration file %s has fatal syntax errors.\n", configfile);
return entries;
}
// did we find entries or scan?
*scanning=0;
// no error parsing config file.
if (entries) {
// we did not find a SCANDIRECTIVE and did find valid entries
PrintOut(LOG_INFO, "Configuration file %s parsed.\n", configfile);
}
else if (cfgentries && cfgentries[0]) {
// we found a SCANDIRECTIVE or there was no configuration file so
// scan. Configuration file's first entry contains all options
// that were set
cfgfile *first=cfgentries[0];
// By default scan for ATA, SCSI and SAT devices
int doata=1, doscsi=1, dosat=1;
if (first->controller_type==CONTROLLER_SCSI) {
doata = 0;
dosat = 0;
} else if (first->controller_type==CONTROLLER_ATA) {
doscsi = 0;
dosat = 0;
} else if (first->controller_type==CONTROLLER_SAT) {
doata = 0;
doscsi = 0;
} else
dosat = 0;
// The code in this block has been neutered by D. Gilbert
// on 20070226. smartd can't cope ATA disk behind a SAT
// transport seamlessly _without_ a bigger restructuring
// of smartd than this code tried. It made ATA disks
// behind a SAT interface automatically detected only by
// killing support for real SCSI disks. Sorry, no.
*scanning=1;
if (first->lineno)
PrintOut(LOG_INFO,"Configuration file %s was parsed, found %s, scanning devices\n", configfile, SCANDIRECTIVE);
else
PrintOut(LOG_INFO,"No configuration file %s found, scanning devices\n", configfile);
// make config list of ATA devices to search for
if (doata)
entries+=MakeConfigEntries("ATA", entries);
// make config list of SCSI devices to search for
if (doscsi)
entries+=MakeConfigEntries("SCSI", entries);
if (dosat)
entries+=MakeConfigEntries("SAT", entries);
// warn user if scan table found no devices
if (!entries) {
PrintOut(LOG_CRIT,"In the system's table of devices NO devices found to scan\n");
// get rid of fake entry with SCANDIRECTIVE as name
RmConfigEntry(cfgentries, __LINE__);
}
}
else
PrintOut(LOG_CRIT,"Configuration file %s parsed but has no entries (like /dev/hda)\n",configfile);
return entries;
}
// This function tries devices from cfgentries. Each one that can be
// registered is moved onto the [ata|scsi]devices lists and removed
// from the cfgentries list, else it's memory is deallocated.
void RegisterDevices(int scanning){
int i;
// start by clearing lists/memory of ALL existing devices
RmAllDevEntries();
numdevata=numdevscsi=0;
// Register entries
for (i=0; i<cfgentries_max ; i++){
cfgfile *ent=cfgentries[i];
// skip any NULL entries (holes)
if (!ent)
continue;
// register ATA devices
if (ent->controller_type!=CONTROLLER_SCSI && ent->controller_type!=CONTROLLER_CCISS){
if (ATADeviceScan(ent, scanning))
CanNotRegister(ent->name, "ATA", ent->lineno, scanning);
else {
// move onto the list of ata devices
cfgentries[i]=NULL;
while (numdevata+numdevscsi>=ATAandSCSIdevlist_max)
ATAandSCSIdevlist=AllocateMoreSpace(ATAandSCSIdevlist, &ATAandSCSIdevlist_max, "ATA and SCSI devices");
ent->WhichCheckDevice=0;
ATAandSCSIdevlist[numdevscsi+numdevata]=ent;
numdevata++;
}
}
// then register SCSI devices
if (ent->controller_type==CONTROLLER_SCSI || ent->controller_type==CONTROLLER_CCISS ||
ent->controller_type==CONTROLLER_UNKNOWN){
int retscsi=0;
#if SCSITIMEOUT
struct sigaction alarmAction, defaultaction;
// Set up an alarm handler to catch USB devices that hang on
// SCSI scanning...
alarmAction.sa_handler= AlarmHandler;
alarmAction.sa_flags = SA_RESTART;
if (sigaction(SIGALRM, &alarmAction, &defaultaction)) {
// if we can't set timeout, just scan device
PrintOut(LOG_CRIT, "Unable to initialize SCSI timeout mechanism.\n");
retscsi=SCSIandSATDeviceScan(ent, scanning);
}
else {
// prepare return point in case of bad SCSI device
if (setjmp(registerscsienv))
// SCSI device timed out!
retscsi=-1;
else {
// Set alarm, make SCSI call, reset alarm
alarm(SCSITIMEOUT);
retscsi=SCSIandSATDeviceScan(ent, scanning);
alarm(0);
}
if (sigaction(SIGALRM, &defaultaction, NULL)){
PrintOut(LOG_CRIT, "Unable to clear SCSI timeout mechanism.\n");
}
}
#else
retscsi=SCSIandSATDeviceScan(ent, scanning);
#endif
// Now scan SCSI device...
if (retscsi){
if (retscsi<0)
PrintOut(LOG_CRIT, "Device %s timed out (poorly-implemented USB device?)\n", ent->name);
CanNotRegister(ent->name, "SCSI", ent->lineno, scanning);
}
else {
// move onto the list of scsi devices
cfgentries[i]=NULL;
while (numdevscsi+numdevata>=ATAandSCSIdevlist_max)
ATAandSCSIdevlist=AllocateMoreSpace(ATAandSCSIdevlist, &ATAandSCSIdevlist_max, "ATA and SCSI devices");
ATAandSCSIdevlist[numdevata+numdevscsi]=ent;
numdevscsi++;
}
}
// if device is explictly listed and we can't register it, then
// exit unless the user has specified that the device is removable
if (cfgentries[i] && !scanning){
if (ent->removable || quit==2)
PrintOut(LOG_INFO, "Device %s not available\n", ent->name);
else {
PrintOut(LOG_CRIT, "Unable to register device %s (no Directive -d removable). Exiting.\n", ent->name);
EXIT(EXIT_BADDEV);
}
}
// free up memory if device could not be registered
RmConfigEntry(cfgentries+i, __LINE__);
}
return;
}
#ifndef _WIN32
// Main function
int main(int argc, char **argv)
#else
// Windows: internal main function started direct or by service control manager
static int smartd_main(int argc, char **argv)
#endif
{
// external control variables for ATA disks
smartmonctrl control;
// is it our first pass through?
int firstpass=1;
// next time to wake up
time_t wakeuptime;
// for simplicity, null all global communications variables/lists
con=&control;
memset(con, 0,sizeof(control));
// parse input and print header and usage info if needed
ParseOpts(argc,argv);
// do we mute printing from ataprint commands?
con->printing_switchable=0;
con->dont_print=debugmode?0:1;
// don't exit on bad checksums
con->checksumfail=0;
// the main loop of the code
while (1){
// are we exiting from a signal?
if (caughtsigEXIT) {
// are we exiting with SIGTERM?
int isterm=(caughtsigEXIT==SIGTERM);
int isquit=(caughtsigEXIT==SIGQUIT);
int isok=debugmode?isterm || isquit:isterm;
PrintOut(isok?LOG_INFO:LOG_CRIT, "smartd received signal %d: %s\n",
caughtsigEXIT, strsignal(caughtsigEXIT));
EXIT(isok?0:EXIT_SIGNAL);
}
// Should we (re)read the config file?
if (firstpass || caughtsigHUP){
int entries, scanning=0;
if (!firstpass) {
#ifdef __CYGWIN__
// Workaround for missing SIGQUIT via keyboard on Cygwin
if (caughtsigHUP==2) {
// Simulate SIGQUIT if another SIGINT arrives soon
caughtsigHUP=0;
sleep(1);
if (caughtsigHUP==2) {
caughtsigEXIT=SIGQUIT;
continue;
}
caughtsigHUP=2;
}
#endif
PrintOut(LOG_INFO,
caughtsigHUP==1?
"Signal HUP - rereading configuration file %s\n":
"\a\nSignal INT - rereading configuration file %s ("SIGQUIT_KEYNAME" quits)\n\n",
configfile);
}
// clears cfgentries, (re)reads config file, makes >=0 entries
entries=ReadOrMakeConfigEntries(&scanning);
if (entries>=0) {
// checks devices, then moves onto ata/scsi list or deallocates.
RegisterDevices(scanning);
}
else if (quit==2 || ((quit==0 || quit==1) && !firstpass)) {
// user has asked to continue on error in configuration file
if (!firstpass)
PrintOut(LOG_INFO,"Reusing previous configuration\n");
}
else {
// exit with configuration file error status
int status = (entries==-3 ? EXIT_READCONF : entries==-2 ? EXIT_NOCONF : EXIT_BADCONF);
EXIT(status);
}
// Log number of devices we are monitoring...
if (numdevata+numdevscsi || quit==2 || (quit==1 && !firstpass))
PrintOut(LOG_INFO,"Monitoring %d ATA and %d SCSI devices\n",
numdevata, numdevscsi);
else {
PrintOut(LOG_INFO,"Unable to monitor any SMART enabled devices. Try debug (-d) option. Exiting...\n");
EXIT(EXIT_NODEV);
}
if (quit==4) {
// user has asked to print test schedule
PrintTestSchedule(ATAandSCSIdevlist);
EXIT(0);
}
// reset signal
caughtsigHUP=0;
}
// check all devices once,
// self tests are not started in first pass unless '-q onecheck' is specified
CheckDevicesOnce(ATAandSCSIdevlist, (!firstpass || quit==3));
// user has asked us to exit after first check
if (quit==3) {
PrintOut(LOG_INFO,"Started with '-q onecheck' option. All devices sucessfully checked once.\n"
"smartd is exiting (exit status 0)\n");
EXIT(0);
}
// fork into background if needed
if (firstpass && !debugmode) {
DaemonInit();
}
// set exit and signal handlers, write PID file, set wake-up time
if (firstpass){
Initialize(&wakeuptime);
firstpass=0;
}
// sleep until next check time, or a signal arrives
wakeuptime=dosleep(wakeuptime);
}
}
#ifdef _WIN32
// Main function for Windows
int main(int argc, char **argv){
// Options for smartd windows service
static const daemon_winsvc_options svc_opts = {
"--service", // cmd_opt
"smartd", "SmartD Service", // servicename, displayname
// description
"Controls and monitors storage devices using the Self-Monitoring, "
"Analysis and Reporting Technology System (S.M.A.R.T.) "
"built into ATA and SCSI Hard Drives. "
PACKAGE_HOMEPAGE
};
// daemon_main() handles daemon and service specific commands
// and starts smartd_main() direct, from a new process,
// or via service control manager
return daemon_main("smartd", &svc_opts , smartd_main, argc, argv);
}
#endif
Reference in New Issue View Git Blame Copy Permalink