Annotation of embedaddon/smartmontools/smartd.cpp, revision 1.1.1.1
1.1 misho 1: /*
2: * Home page of code is: http://smartmontools.sourceforge.net
3: *
4: * Copyright (C) 2002-11 Bruce Allen <smartmontools-support@lists.sourceforge.net>
5: * Copyright (C) 2000 Michael Cornwell <cornwell@acm.org>
6: * Copyright (C) 2008 Oliver Bock <brevilo@users.sourceforge.net>
7: * Copyright (C) 2008-11 Christian Franke <smartmontools-support@lists.sourceforge.net>
8: *
9: * This program is free software; you can redistribute it and/or modify
10: * it under the terms of the GNU General Public License as published by
11: * the Free Software Foundation; either version 2, or (at your option)
12: * any later version.
13: *
14: * You should have received a copy of the GNU General Public License
15: * (for example COPYING); If not, see <http://www.gnu.org/licenses/>.
16: *
17: * This code was originally developed as a Senior Thesis by Michael Cornwell
18: * at the Concurrent Systems Laboratory (now part of the Storage Systems
19: * Research Center), Jack Baskin School of Engineering, University of
20: * California, Santa Cruz. http://ssrc.soe.ucsc.edu/
21: *
22: */
23:
24: #ifndef _GNU_SOURCE
25: // TODO: Why is this define necessary?
26: #define _GNU_SOURCE
27: #endif
28:
29: // unconditionally included files
30: #include <stdio.h>
31: #include <sys/types.h>
32: #include <sys/stat.h> // umask
33: #include <signal.h>
34: #include <fcntl.h>
35: #include <string.h>
36: #include <syslog.h>
37: #include <stdarg.h>
38: #include <stdlib.h>
39: #include <errno.h>
40: #include <time.h>
41: #include <limits.h>
42: #include <getopt.h>
43:
44: #include <stdexcept>
45: #include <string>
46: #include <vector>
47: #include <algorithm> // std::replace()
48:
49: // see which system files to conditionally include
50: #include "config.h"
51:
52: // conditionally included files
53: #ifndef _WIN32
54: #include <sys/wait.h>
55: #endif
56: #ifdef HAVE_UNISTD_H
57: #include <unistd.h>
58: #endif
59: #ifdef HAVE_NETDB_H
60: #include <netdb.h>
61: #endif
62:
63: #ifdef _WIN32
64: #ifdef _MSC_VER
65: #pragma warning(disable:4761) // "conversion supplied"
66: typedef unsigned short mode_t;
67: typedef int pid_t;
68: #endif
69: #include <io.h> // umask()
70: #include <process.h> // getpid()
71: #endif // _WIN32
72:
73: #ifdef __CYGWIN__
74: #include <io.h> // setmode()
75: #endif // __CYGWIN__
76:
77: #ifdef HAVE_LIBCAP_NG
78: #include <cap-ng.h>
79: #endif // LIBCAP_NG
80:
81: // locally included files
82: #include "int64.h"
83: #include "atacmds.h"
84: #include "dev_interface.h"
85: #include "knowndrives.h"
86: #include "scsicmds.h"
87: #include "utility.h"
88:
89: // This is for solaris, where signal() resets the handler to SIG_DFL
90: // after the first signal is caught.
91: #ifdef HAVE_SIGSET
92: #define SIGNALFN sigset
93: #else
94: #define SIGNALFN signal
95: #endif
96:
97: #ifdef _WIN32
98: #include "hostname_win32.h" // gethost/domainname()
99: #define HAVE_GETHOSTNAME 1
100: #define HAVE_GETDOMAINNAME 1
101: // fork()/signal()/initd simulation for native Windows
102: #include "daemon_win32.h" // daemon_main/detach/signal()
103: #undef SIGNALFN
104: #define SIGNALFN daemon_signal
105: #define strsignal daemon_strsignal
106: #define sleep daemon_sleep
107: // SIGQUIT does not exist, CONTROL-Break signals SIGBREAK.
108: #define SIGQUIT SIGBREAK
109: #define SIGQUIT_KEYNAME "CONTROL-Break"
110: #else // _WIN32
111: #ifdef __CYGWIN__
112: // 2x CONTROL-C simulates missing SIGQUIT via keyboard
113: #define SIGQUIT_KEYNAME "2x CONTROL-C"
114: #else // __CYGWIN__
115: #define SIGQUIT_KEYNAME "CONTROL-\\"
116: #endif // __CYGWIN__
117: #endif // _WIN32
118:
119: #if defined (__SVR4) && defined (__sun)
120: extern "C" int getdomainname(char *, int); // no declaration in header files!
121: #endif
122:
123: #define ARGUSED(x) ((void)(x))
124:
125: const char * smartd_cpp_cvsid = "$Id: smartd.cpp 3451 2011-10-15 14:27:08Z chrfranke $"
126: CONFIG_H_CVSID;
127:
128: // smartd exit codes
129: #define EXIT_BADCMD 1 // command line did not parse
130: #define EXIT_BADCONF 2 // syntax error in config file
131: #define EXIT_STARTUP 3 // problem forking daemon
132: #define EXIT_PID 4 // problem creating pid file
133: #define EXIT_NOCONF 5 // config file does not exist
134: #define EXIT_READCONF 6 // config file exists but cannot be read
135:
136: #define EXIT_NOMEM 8 // out of memory
137: #define EXIT_BADCODE 10 // internal error - should NEVER happen
138:
139: #define EXIT_BADDEV 16 // we can't monitor this device
140: #define EXIT_NODEV 17 // no devices to monitor
141:
142: #define EXIT_SIGNAL 254 // abort on signal
143:
144:
145: // command-line: 1=debug mode, 2=print presets
146: static unsigned char debugmode = 0;
147:
148: // command-line: how long to sleep between checks
149: #define CHECKTIME 1800
150: static int checktime=CHECKTIME;
151:
152: // command-line: name of PID file (empty for no pid file)
153: static std::string pid_file;
154:
155: // command-line: path prefix of persistent state file, empty if no persistence.
156: static std::string state_path_prefix
157: #ifdef SMARTMONTOOLS_SAVESTATES
158: = SMARTMONTOOLS_SAVESTATES
159: #endif
160: ;
161:
162: // command-line: path prefix of attribute log file, empty if no logs.
163: static std::string attrlog_path_prefix
164: #ifdef SMARTMONTOOLS_ATTRIBUTELOG
165: = SMARTMONTOOLS_ATTRIBUTELOG
166: #endif
167: ;
168:
169: // configuration file name
170: static const char * configfile;
171: // configuration file "name" if read from stdin
172: static const char * const configfile_stdin = "<stdin>";
173: // path of alternate configuration file
174: static std::string configfile_alt;
175:
176: // command-line: when should we exit?
177: static int quit=0;
178:
179: // command-line; this is the default syslog(3) log facility to use.
180: static int facility=LOG_DAEMON;
181:
182: #ifndef _WIN32
183: // command-line: fork into background?
184: static bool do_fork=true;
185: #endif
186:
187: #ifdef HAVE_LIBCAP_NG
188: // command-line: enable capabilities?
189: static bool enable_capabilities = false;
190: #endif
191:
192: #if defined(_WIN32) || defined(__CYGWIN__)
193: // TODO: This smartctl only variable is also used in os_win32.cpp
194: unsigned char failuretest_permissive = 0;
195: #endif
196:
197: // set to one if we catch a USR1 (check devices now)
198: static volatile int caughtsigUSR1=0;
199:
200: #ifdef _WIN32
201: // set to one if we catch a USR2 (toggle debug mode)
202: static volatile int caughtsigUSR2=0;
203: #endif
204:
205: // set to one if we catch a HUP (reload config file). In debug mode,
206: // set to two, if we catch INT (also reload config file).
207: static volatile int caughtsigHUP=0;
208:
209: // set to signal value if we catch INT, QUIT, or TERM
210: static volatile int caughtsigEXIT=0;
211:
212: // This function prints either to stdout or to the syslog as needed.
213: static void PrintOut(int priority, const char *fmt, ...)
214: __attribute__ ((format(printf, 2, 3)));
215:
216: // Attribute monitoring flags.
217: // See monitor_attr_flags below.
218: enum {
219: MONITOR_IGN_FAILUSE = 0x01,
220: MONITOR_IGNORE = 0x02,
221: MONITOR_RAW_PRINT = 0x04,
222: MONITOR_RAW = 0x08,
223: MONITOR_AS_CRIT = 0x10,
224: MONITOR_RAW_AS_CRIT = 0x20,
225: };
226:
227: // Array of flags for each attribute.
228: class attribute_flags
229: {
230: public:
231: attribute_flags()
232: { memset(m_flags, 0, sizeof(m_flags)); }
233:
234: bool is_set(int id, unsigned char flag) const
235: { return (0 < id && id < (int)sizeof(m_flags) && (m_flags[id] & flag)); }
236:
237: void set(int id, unsigned char flags)
238: {
239: if (0 < id && id < (int)sizeof(m_flags))
240: m_flags[id] |= flags;
241: }
242:
243: private:
244: unsigned char m_flags[256];
245: };
246:
247:
248: /// Configuration data for a device. Read from smartd.conf.
249: /// Supports copy & assignment and is compatible with STL containers.
250: struct dev_config
251: {
252: int lineno; // Line number of entry in file
253: std::string name; // Device name (with optional extra info)
254: std::string dev_name; // Device name (plain, for SMARTD_DEVICE variable)
255: std::string dev_type; // Device type argument from -d directive, empty if none
256: std::string state_file; // Path of the persistent state file, empty if none
257: std::string attrlog_file; // Path of the persistent attrlog file, empty if none
258: bool smartcheck; // Check SMART status
259: bool usagefailed; // Check for failed Usage Attributes
260: bool prefail; // Track changes in Prefail Attributes
261: bool usage; // Track changes in Usage Attributes
262: bool selftest; // Monitor number of selftest errors
263: bool errorlog; // Monitor number of ATA errors
264: bool xerrorlog; // Monitor number of ATA errors (Extended Comprehensive error log)
265: bool offlinests; // Monitor changes in offline data collection status
266: bool selfteststs; // Monitor changes in self-test execution status
267: bool permissive; // Ignore failed SMART commands
268: char autosave; // 1=disable, 2=enable Autosave Attributes
269: char autoofflinetest; // 1=disable, 2=enable Auto Offline Test
270: unsigned char fix_firmwarebug; // FIX_*, see atacmds.h
271: bool ignorepresets; // Ignore database of -v options
272: bool showpresets; // Show database entry for this device
273: bool removable; // Device may disappear (not be present)
274: char powermode; // skip check, if disk in idle or standby mode
275: bool powerquiet; // skip powermode 'skipping checks' message
276: int powerskipmax; // how many times can be check skipped
277: unsigned char tempdiff; // Track Temperature changes >= this limit
278: unsigned char tempinfo, tempcrit; // Track Temperatures >= these limits as LOG_INFO, LOG_CRIT+mail
279: regular_expression test_regex; // Regex for scheduled testing
280:
281: // Configuration of email warning messages
282: std::string emailcmdline; // script to execute, empty if no messages
283: std::string emailaddress; // email address, or empty
284: unsigned char emailfreq; // Emails once (1) daily (2) diminishing (3)
285: bool emailtest; // Send test email?
286:
287: // ATA ONLY
288: bool sct_erc_set; // set SCT ERC to:
289: unsigned short sct_erc_readtime; // ERC read time (deciseconds)
290: unsigned short sct_erc_writetime; // ERC write time (deciseconds)
291:
292: unsigned char curr_pending_id; // ID of current pending sector count, 0 if none
293: unsigned char offl_pending_id; // ID of offline uncorrectable sector count, 0 if none
294: bool curr_pending_incr, offl_pending_incr; // True if current/offline pending values increase
295: bool curr_pending_set, offl_pending_set; // True if '-C', '-U' set in smartd.conf
296:
297: attribute_flags monitor_attr_flags; // MONITOR_* flags for each attribute
298:
299: ata_vendor_attr_defs attribute_defs; // -v options
300:
301: dev_config();
302: };
303:
304: dev_config::dev_config()
305: : lineno(0),
306: smartcheck(false),
307: usagefailed(false),
308: prefail(false),
309: usage(false),
310: selftest(false),
311: errorlog(false),
312: xerrorlog(false),
313: offlinests(false),
314: selfteststs(false),
315: permissive(false),
316: autosave(0),
317: autoofflinetest(0),
318: fix_firmwarebug(FIX_NOTSPECIFIED),
319: ignorepresets(false),
320: showpresets(false),
321: removable(false),
322: powermode(0),
323: powerquiet(false),
324: powerskipmax(0),
325: tempdiff(0),
326: tempinfo(0), tempcrit(0),
327: emailfreq(0),
328: emailtest(false),
329: sct_erc_set(false),
330: sct_erc_readtime(0), sct_erc_writetime(0),
331: curr_pending_id(0), offl_pending_id(0),
332: curr_pending_incr(false), offl_pending_incr(false),
333: curr_pending_set(false), offl_pending_set(false)
334: {
335: }
336:
337:
338: // Number of allowed mail message types
339: static const int SMARTD_NMAIL = 13;
340: // Type for '-M test' mails (state not persistent)
341: static const int MAILTYPE_TEST = 0;
342: // TODO: Add const or enum for all mail types.
343:
344: struct mailinfo {
345: int logged;// number of times an email has been sent
346: time_t firstsent;// time first email was sent, as defined by time(2)
347: time_t lastsent; // time last email was sent, as defined by time(2)
348:
349: mailinfo()
350: : logged(0), firstsent(0), lastsent(0) { }
351: };
352:
353: /// Persistent state data for a device.
354: struct persistent_dev_state
355: {
356: unsigned char tempmin, tempmax; // Min/Max Temperatures
357:
358: unsigned char selflogcount; // total number of self-test errors
359: unsigned short selfloghour; // lifetime hours of last self-test error
360:
361: time_t scheduled_test_next_check; // Time of next check for scheduled self-tests
362:
363: uint64_t selective_test_last_start; // Start LBA of last scheduled selective self-test
364: uint64_t selective_test_last_end; // End LBA of last scheduled selective self-test
365:
366: mailinfo maillog[SMARTD_NMAIL]; // log info on when mail sent
367:
368: // ATA ONLY
369: int ataerrorcount; // Total number of ATA errors
370:
371: // Persistent part of ata_smart_values:
372: struct ata_attribute {
373: unsigned char id;
374: unsigned char val;
375: unsigned char worst; // Byte needed for 'raw64' attribute only.
376: uint64_t raw;
377: unsigned char resvd;
378:
379: ata_attribute() : id(0), val(0), worst(0), raw(0), resvd(0) { }
380: };
381: ata_attribute ata_attributes[NUMBER_ATA_SMART_ATTRIBUTES];
382:
383: persistent_dev_state();
384: };
385:
386: persistent_dev_state::persistent_dev_state()
387: : tempmin(0), tempmax(0),
388: selflogcount(0),
389: selfloghour(0),
390: scheduled_test_next_check(0),
391: selective_test_last_start(0),
392: selective_test_last_end(0),
393: ataerrorcount(0)
394: {
395: }
396:
397: /// Non-persistent state data for a device.
398: struct temp_dev_state
399: {
400: bool must_write; // true if persistent part should be written
401:
402: bool not_cap_offline; // true == not capable of offline testing
403: bool not_cap_conveyance;
404: bool not_cap_short;
405: bool not_cap_long;
406: bool not_cap_selective;
407:
408: unsigned char temperature; // last recorded Temperature (in Celsius)
409: time_t tempmin_delay; // time where Min Temperature tracking will start
410:
411: bool powermodefail; // true if power mode check failed
412: int powerskipcnt; // Number of checks skipped due to idle or standby mode
413:
414: // SCSI ONLY
415: unsigned char SmartPageSupported; // has log sense IE page (0x2f)
416: unsigned char TempPageSupported; // has log sense temperature page (0xd)
417: unsigned char SuppressReport; // minimize nuisance reports
418: unsigned char modese_len; // mode sense/select cmd len: 0 (don't
419: // know yet) 6 or 10
420:
421: // ATA ONLY
422: uint64_t num_sectors; // Number of sectors
423: ata_smart_values smartval; // SMART data
424: ata_smart_thresholds_pvt smartthres; // SMART thresholds
425:
426: temp_dev_state();
427: };
428:
429: temp_dev_state::temp_dev_state()
430: : must_write(false),
431: not_cap_offline(false),
432: not_cap_conveyance(false),
433: not_cap_short(false),
434: not_cap_long(false),
435: not_cap_selective(false),
436: temperature(0),
437: tempmin_delay(0),
438: powermodefail(false),
439: powerskipcnt(0),
440: SmartPageSupported(false),
441: TempPageSupported(false),
442: SuppressReport(false),
443: modese_len(0),
444: num_sectors(0)
445: {
446: memset(&smartval, 0, sizeof(smartval));
447: memset(&smartthres, 0, sizeof(smartthres));
448: }
449:
450: /// Runtime state data for a device.
451: struct dev_state
452: : public persistent_dev_state,
453: public temp_dev_state
454: {
455: void update_persistent_state();
456: void update_temp_state();
457: };
458:
459: /// Container for configuration info for each device.
460: typedef std::vector<dev_config> dev_config_vector;
461:
462: /// Container for state info for each device.
463: typedef std::vector<dev_state> dev_state_vector;
464:
465: // Copy ATA attributes to persistent state.
466: void dev_state::update_persistent_state()
467: {
468: for (int i = 0; i < NUMBER_ATA_SMART_ATTRIBUTES; i++) {
469: const ata_smart_attribute & ta = smartval.vendor_attributes[i];
470: ata_attribute & pa = ata_attributes[i];
471: pa.id = ta.id;
472: if (ta.id == 0) {
473: pa.val = pa.worst = 0; pa.raw = 0;
474: continue;
475: }
476: pa.val = ta.current;
477: pa.worst = ta.worst;
478: pa.raw = ta.raw[0]
479: | ( ta.raw[1] << 8)
480: | ( ta.raw[2] << 16)
481: | ((uint64_t)ta.raw[3] << 24)
482: | ((uint64_t)ta.raw[4] << 32)
483: | ((uint64_t)ta.raw[5] << 40);
484: pa.resvd = ta.reserv;
485: }
486: }
487:
488: // Copy ATA from persistent to temp state.
489: void dev_state::update_temp_state()
490: {
491: for (int i = 0; i < NUMBER_ATA_SMART_ATTRIBUTES; i++) {
492: const ata_attribute & pa = ata_attributes[i];
493: ata_smart_attribute & ta = smartval.vendor_attributes[i];
494: ta.id = pa.id;
495: if (pa.id == 0) {
496: ta.current = ta.worst = 0;
497: memset(ta.raw, 0, sizeof(ta.raw));
498: continue;
499: }
500: ta.current = pa.val;
501: ta.worst = pa.worst;
502: ta.raw[0] = (unsigned char) pa.raw;
503: ta.raw[1] = (unsigned char)(pa.raw >> 8);
504: ta.raw[2] = (unsigned char)(pa.raw >> 16);
505: ta.raw[3] = (unsigned char)(pa.raw >> 24);
506: ta.raw[4] = (unsigned char)(pa.raw >> 32);
507: ta.raw[5] = (unsigned char)(pa.raw >> 40);
508: ta.reserv = pa.resvd;
509: }
510: }
511:
512: // Parse a line from a state file.
513: static bool parse_dev_state_line(const char * line, persistent_dev_state & state)
514: {
515: static const regular_expression regex(
516: "^ *"
517: "((temperature-min)" // (1 (2)
518: "|(temperature-max)" // (3)
519: "|(self-test-errors)" // (4)
520: "|(self-test-last-err-hour)" // (5)
521: "|(scheduled-test-next-check)" // (6)
522: "|(selective-test-last-start)" // (7)
523: "|(selective-test-last-end)" // (8)
524: "|(ata-error-count)" // (9)
525: "|(mail\\.([0-9]+)\\." // (10 (11)
526: "((count)" // (12 (13)
527: "|(first-sent-time)" // (14)
528: "|(last-sent-time)" // (15)
529: ")" // 12)
530: ")" // 10)
531: "|(ata-smart-attribute\\.([0-9]+)\\." // (16 (17)
532: "((id)" // (18 (19)
533: "|(val)" // (20)
534: "|(worst)" // (21)
535: "|(raw)" // (22)
536: "|(resvd)" // (23)
537: ")" // 18)
538: ")" // 16)
539: ")" // 1)
540: " *= *([0-9]+)[ \n]*$", // (24)
541: REG_EXTENDED
542: );
543:
544: const int nmatch = 1+24;
545: regmatch_t match[nmatch];
546: if (!regex.execute(line, nmatch, match))
547: return false;
548: if (match[nmatch-1].rm_so < 0)
549: return false;
550:
551: uint64_t val = strtoull(line + match[nmatch-1].rm_so, (char **)0, 10);
552:
553: int m = 1;
554: if (match[++m].rm_so >= 0)
555: state.tempmin = (unsigned char)val;
556: else if (match[++m].rm_so >= 0)
557: state.tempmax = (unsigned char)val;
558: else if (match[++m].rm_so >= 0)
559: state.selflogcount = (unsigned char)val;
560: else if (match[++m].rm_so >= 0)
561: state.selfloghour = (unsigned short)val;
562: else if (match[++m].rm_so >= 0)
563: state.scheduled_test_next_check = (time_t)val;
564: else if (match[++m].rm_so >= 0)
565: state.selective_test_last_start = val;
566: else if (match[++m].rm_so >= 0)
567: state.selective_test_last_end = val;
568: else if (match[++m].rm_so >= 0)
569: state.ataerrorcount = (int)val;
570: else if (match[m+=2].rm_so >= 0) {
571: int i = atoi(line+match[m].rm_so);
572: if (!(0 <= i && i < SMARTD_NMAIL))
573: return false;
574: if (i == MAILTYPE_TEST) // Don't suppress test mails
575: return true;
576: if (match[m+=2].rm_so >= 0)
577: state.maillog[i].logged = (int)val;
578: else if (match[++m].rm_so >= 0)
579: state.maillog[i].firstsent = (time_t)val;
580: else if (match[++m].rm_so >= 0)
581: state.maillog[i].lastsent = (time_t)val;
582: else
583: return false;
584: }
585: else if (match[m+=5+1].rm_so >= 0) {
586: int i = atoi(line+match[m].rm_so);
587: if (!(0 <= i && i < NUMBER_ATA_SMART_ATTRIBUTES))
588: return false;
589: if (match[m+=2].rm_so >= 0)
590: state.ata_attributes[i].id = (unsigned char)val;
591: else if (match[++m].rm_so >= 0)
592: state.ata_attributes[i].val = (unsigned char)val;
593: else if (match[++m].rm_so >= 0)
594: state.ata_attributes[i].worst = (unsigned char)val;
595: else if (match[++m].rm_so >= 0)
596: state.ata_attributes[i].raw = val;
597: else if (match[++m].rm_so >= 0)
598: state.ata_attributes[i].resvd = (unsigned char)val;
599: else
600: return false;
601: }
602: else
603: return false;
604: return true;
605: }
606:
607: // Read a state file.
608: static bool read_dev_state(const char * path, persistent_dev_state & state)
609: {
610: stdio_file f(path, "r");
611: if (!f) {
612: if (errno != ENOENT)
613: pout("Cannot read state file \"%s\"\n", path);
614: return false;
615: }
616: #ifdef __CYGWIN__
617: setmode(fileno(f), O_TEXT); // Allow files with \r\n
618: #endif
619:
620: persistent_dev_state new_state;
621: int good = 0, bad = 0;
622: char line[256];
623: while (fgets(line, sizeof(line), f)) {
624: const char * s = line + strspn(line, " \t");
625: if (!*s || *s == '#')
626: continue;
627: if (!parse_dev_state_line(line, new_state))
628: bad++;
629: else
630: good++;
631: }
632:
633: if (bad) {
634: if (!good) {
635: pout("%s: format error\n", path);
636: return false;
637: }
638: pout("%s: %d invalid line(s) ignored\n", path, bad);
639: }
640:
641: // This sets the values missing in the file to 0.
642: state = new_state;
643: return true;
644: }
645:
646: static void write_dev_state_line(FILE * f, const char * name, uint64_t val)
647: {
648: if (val)
649: fprintf(f, "%s = %"PRIu64"\n", name, val);
650: }
651:
652: static void write_dev_state_line(FILE * f, const char * name1, int id, const char * name2, uint64_t val)
653: {
654: if (val)
655: fprintf(f, "%s.%d.%s = %"PRIu64"\n", name1, id, name2, val);
656: }
657:
658: // Write a state file
659: static bool write_dev_state(const char * path, const persistent_dev_state & state)
660: {
661: // Rename old "file" to "file~"
662: std::string pathbak = path; pathbak += '~';
663: unlink(pathbak.c_str());
664: rename(path, pathbak.c_str());
665:
666: stdio_file f(path, "w");
667: if (!f) {
668: pout("Cannot create state file \"%s\"\n", path);
669: return false;
670: }
671:
672: fprintf(f, "# smartd state file\n");
673: write_dev_state_line(f, "temperature-min", state.tempmin);
674: write_dev_state_line(f, "temperature-max", state.tempmax);
675: write_dev_state_line(f, "self-test-errors", state.selflogcount);
676: write_dev_state_line(f, "self-test-last-err-hour", state.selfloghour);
677: write_dev_state_line(f, "scheduled-test-next-check", state.scheduled_test_next_check);
678: write_dev_state_line(f, "selective-test-last-start", state.selective_test_last_start);
679: write_dev_state_line(f, "selective-test-last-end", state.selective_test_last_end);
680:
681: int i;
682: for (i = 0; i < SMARTD_NMAIL; i++) {
683: if (i == MAILTYPE_TEST) // Don't suppress test mails
684: continue;
685: const mailinfo & mi = state.maillog[i];
686: if (!mi.logged)
687: continue;
688: write_dev_state_line(f, "mail", i, "count", mi.logged);
689: write_dev_state_line(f, "mail", i, "first-sent-time", mi.firstsent);
690: write_dev_state_line(f, "mail", i, "last-sent-time", mi.lastsent);
691: }
692:
693: // ATA ONLY
694: write_dev_state_line(f, "ata-error-count", state.ataerrorcount);
695:
696: for (i = 0; i < NUMBER_ATA_SMART_ATTRIBUTES; i++) {
697: const persistent_dev_state::ata_attribute & pa = state.ata_attributes[i];
698: if (!pa.id)
699: continue;
700: write_dev_state_line(f, "ata-smart-attribute", i, "id", pa.id);
701: write_dev_state_line(f, "ata-smart-attribute", i, "val", pa.val);
702: write_dev_state_line(f, "ata-smart-attribute", i, "worst", pa.worst);
703: write_dev_state_line(f, "ata-smart-attribute", i, "raw", pa.raw);
704: write_dev_state_line(f, "ata-smart-attribute", i, "resvd", pa.resvd);
705: }
706:
707: return true;
708: }
709:
710: // Write to the attrlog file
711: static bool write_dev_attrlog(const char * path, const persistent_dev_state & state)
712: {
713: stdio_file f(path, "a");
714: if (!f) {
715: pout("Cannot create attribute log file \"%s\"\n", path);
716: return false;
717: }
718:
719: // ATA ONLY
720: time_t now = time(0);
721: struct tm * tms = gmtime(&now);
722: fprintf(f, "%d-%02d-%02d %02d:%02d:%02d;",
723: 1900+tms->tm_year, 1+tms->tm_mon, tms->tm_mday,
724: tms->tm_hour, tms->tm_min, tms->tm_sec);
725: for (int i = 0; i < NUMBER_ATA_SMART_ATTRIBUTES; i++) {
726: const persistent_dev_state::ata_attribute & pa = state.ata_attributes[i];
727: if (!pa.id)
728: continue;
729: fprintf(f, "\t%d;%d;%"PRIu64";", pa.id, pa.val, pa.raw);
730: }
731: fprintf(f, "\n");
732:
733: return true;
734: }
735:
736: // Write all state files. If write_always is false, don't write
737: // unless must_write is set.
738: static void write_all_dev_states(const dev_config_vector & configs,
739: dev_state_vector & states,
740: bool write_always = true)
741: {
742: for (unsigned i = 0; i < states.size(); i++) {
743: const dev_config & cfg = configs.at(i);
744: if (cfg.state_file.empty())
745: continue;
746: dev_state & state = states[i];
747: if (!write_always && !state.must_write)
748: continue;
749: if (!write_dev_state(cfg.state_file.c_str(), state))
750: continue;
751: state.must_write = false;
752: if (write_always || debugmode)
753: PrintOut(LOG_INFO, "Device: %s, state written to %s\n",
754: cfg.name.c_str(), cfg.state_file.c_str());
755: }
756: }
757:
758: // Write to all attrlog files
759: static void write_all_dev_attrlogs(const dev_config_vector & configs,
760: dev_state_vector & states)
761: {
762: for (unsigned i = 0; i < states.size(); i++) {
763: const dev_config & cfg = configs.at(i);
764: if (cfg.attrlog_file.empty())
765: continue;
766: dev_state & state = states[i];
767: write_dev_attrlog(cfg.attrlog_file.c_str(), state);
768: }
769: }
770:
771: // remove the PID file
772: static void RemovePidFile()
773: {
774: if (!pid_file.empty()) {
775: if (unlink(pid_file.c_str()))
776: PrintOut(LOG_CRIT,"Can't unlink PID file %s (%s).\n",
777: pid_file.c_str(), strerror(errno));
778: pid_file.clear();
779: }
780: return;
781: }
782:
783: extern "C" { // signal handlers require C-linkage
784:
785: // Note if we catch a SIGUSR1
786: static void USR1handler(int sig)
787: {
788: if (SIGUSR1==sig)
789: caughtsigUSR1=1;
790: return;
791: }
792:
793: #ifdef _WIN32
794: // Note if we catch a SIGUSR2
795: static void USR2handler(int sig)
796: {
797: if (SIGUSR2==sig)
798: caughtsigUSR2=1;
799: return;
800: }
801: #endif
802:
803: // Note if we catch a HUP (or INT in debug mode)
804: static void HUPhandler(int sig)
805: {
806: if (sig==SIGHUP)
807: caughtsigHUP=1;
808: else
809: caughtsigHUP=2;
810: return;
811: }
812:
813: // signal handler for TERM, QUIT, and INT (if not in debug mode)
814: static void sighandler(int sig)
815: {
816: if (!caughtsigEXIT)
817: caughtsigEXIT=sig;
818: return;
819: }
820:
821: } // extern "C"
822:
823: // Cleanup, print Goodbye message and remove pidfile
824: static int Goodbye(int status)
825: {
826: // delete PID file, if one was created
827: RemovePidFile();
828:
829: // if we are exiting because of a code bug, tell user
830: if (status==EXIT_BADCODE)
831: PrintOut(LOG_CRIT, "Please inform " PACKAGE_BUGREPORT ", including output of smartd -V.\n");
832:
833: // and this should be the final output from smartd before it exits
834: PrintOut(status?LOG_CRIT:LOG_INFO, "smartd is exiting (exit status %d)\n", status);
835:
836: return status;
837: }
838:
839: #define ENVLENGTH 1024
840:
841: // a replacement for setenv() which is not available on all platforms.
842: // Note that the string passed to putenv must not be freed or made
843: // invalid, since a pointer to it is kept by putenv(). This means that
844: // it must either be a static buffer or allocated off the heap. The
845: // string can be freed if the environment variable is redefined or
846: // deleted via another call to putenv(). So we keep these on the stack
847: // as long as the popen() call is underway.
848: static int exportenv(char *stackspace, const char *name, const char *value)
849: {
850: snprintf(stackspace,ENVLENGTH, "%s=%s", name, value);
851: return putenv(stackspace);
852: }
853:
854: static char *dnsdomain(const char *hostname)
855: {
856: char *p = NULL;
857: #ifdef HAVE_GETADDRINFO
858: static char canon_name[NI_MAXHOST];
859: struct addrinfo *info = NULL;
860: struct addrinfo hints;
861: int err;
862:
863: memset(&hints, 0, sizeof(hints));
864: hints.ai_flags = AI_CANONNAME;
865: if ((err = getaddrinfo(hostname, NULL, &hints, &info)) || (!info)) {
866: PrintOut(LOG_CRIT, "Error retrieving getaddrinfo(%s): %s\n", hostname, gai_strerror(err));
867: return NULL;
868: }
869: if (info->ai_canonname) {
870: strncpy(canon_name, info->ai_canonname, sizeof(canon_name));
871: canon_name[NI_MAXHOST - 1] = '\0';
872: p = canon_name;
873: if ((p = strchr(canon_name, '.')))
874: p++;
875: }
876: freeaddrinfo(info);
877: #elif HAVE_GETHOSTBYNAME
878: struct hostent *hp;
879: if ((hp = gethostbyname(hostname))) {
880: // Does this work if gethostbyname() returns an IPv6 name in
881: // colon/dot notation? [BA]
882: if ((p = strchr(hp->h_name, '.')))
883: p++; // skip "."
884: }
885: #else
886: ARGUSED(hostname);
887: #endif
888: return p;
889: }
890:
891: #define EBUFLEN 1024
892:
893: static void MailWarning(const dev_config & cfg, dev_state & state, int which, const char *fmt, ...)
894: __attribute__ ((format (printf, 4, 5)));
895:
896: // If either address or executable path is non-null then send and log
897: // a warning email, or execute executable
898: static void MailWarning(const dev_config & cfg, dev_state & state, int which, const char *fmt, ...){
899: char command[2048], message[256], hostname[256], domainname[256], additional[256],fullmessage[1024];
900: char original[256], further[256], nisdomain[256], subject[256],dates[DATEANDEPOCHLEN];
901: char environ_strings[11][ENVLENGTH];
902: time_t epoch;
903: va_list ap;
904: const int day=24*3600;
905: int days=0;
906: const char * const whichfail[]={
907: "EmailTest", // 0
908: "Health", // 1
909: "Usage", // 2
910: "SelfTest", // 3
911: "ErrorCount", // 4
912: "FailedHealthCheck", // 5
913: "FailedReadSmartData", // 6
914: "FailedReadSmartErrorLog", // 7
915: "FailedReadSmartSelfTestLog", // 8
916: "FailedOpenDevice", // 9
917: "CurrentPendingSector", // 10
918: "OfflineUncorrectableSector", // 11
919: "Temperature" // 12
920: };
921:
922: const char *unknown="[Unknown]";
923:
924: // See if user wants us to send mail
925: if (cfg.emailaddress.empty() && cfg.emailcmdline.empty())
926: return;
927:
928: std::string address = cfg.emailaddress;
929: const char * executable = cfg.emailcmdline.c_str();
930:
931: // which type of mail are we sending?
932: mailinfo * mail=(state.maillog)+which;
933:
934: // checks for sanity
935: if (cfg.emailfreq<1 || cfg.emailfreq>3) {
936: PrintOut(LOG_CRIT,"internal error in MailWarning(): cfg.mailwarn->emailfreq=%d\n",cfg.emailfreq);
937: return;
938: }
939: if (which<0 || which>=SMARTD_NMAIL || sizeof(whichfail)!=SMARTD_NMAIL*sizeof(char *)) {
940: PrintOut(LOG_CRIT,"Contact " PACKAGE_BUGREPORT "; internal error in MailWarning(): which=%d, size=%d\n",
941: which, (int)sizeof(whichfail));
942: return;
943: }
944:
945: // Return if a single warning mail has been sent.
946: if ((cfg.emailfreq==1) && mail->logged)
947: return;
948:
949: // Return if this is an email test and one has already been sent.
950: if (which == 0 && mail->logged)
951: return;
952:
953: // To decide if to send mail, we need to know what time it is.
954: epoch=time(NULL);
955:
956: // Return if less than one day has gone by
957: if (cfg.emailfreq==2 && mail->logged && epoch<(mail->lastsent+day))
958: return;
959:
960: // Return if less than 2^(logged-1) days have gone by
961: if (cfg.emailfreq==3 && mail->logged) {
962: days=0x01<<(mail->logged-1);
963: days*=day;
964: if (epoch<(mail->lastsent+days))
965: return;
966: }
967:
968: #ifdef HAVE_LIBCAP_NG
969: if (enable_capabilities) {
970: PrintOut(LOG_ERR, "Sending a mail was supressed. "
971: "Mails can't be send when capabilites are enabled\n");
972: return;
973: }
974: #endif
975:
976: // record the time of this mail message, and the first mail message
977: if (!mail->logged)
978: mail->firstsent=epoch;
979: mail->lastsent=epoch;
980:
981: // get system host & domain names (not null terminated if length=MAX)
982: #ifdef HAVE_GETHOSTNAME
983: if (gethostname(hostname, 256))
984: strcpy(hostname, unknown);
985: else {
986: char *p=NULL;
987: hostname[255]='\0';
988: p = dnsdomain(hostname);
989: if (p && *p) {
990: strncpy(domainname, p, 255);
991: domainname[255]='\0';
992: } else
993: strcpy(domainname, unknown);
994: }
995: #else
996: strcpy(hostname, unknown);
997: strcpy(domainname, unknown);
998: #endif
999:
1000: #ifdef HAVE_GETDOMAINNAME
1001: if (getdomainname(nisdomain, 256))
1002: strcpy(nisdomain, unknown);
1003: else
1004: nisdomain[255]='\0';
1005: #else
1006: strcpy(nisdomain, unknown);
1007: #endif
1008:
1009: // print warning string into message
1010: va_start(ap, fmt);
1011: vsnprintf(message, 256, fmt, ap);
1012: va_end(ap);
1013:
1014: // appropriate message about further information
1015: additional[0]=original[0]=further[0]='\0';
1016: if (which) {
1017: sprintf(further,"You can also use the smartctl utility for further investigation.\n");
1018:
1019: switch (cfg.emailfreq) {
1020: case 1:
1021: sprintf(additional,"No additional email messages about this problem will be sent.\n");
1022: break;
1023: case 2:
1024: sprintf(additional,"Another email message will be sent in 24 hours if the problem persists.\n");
1025: break;
1026: case 3:
1027: sprintf(additional,"Another email message will be sent in %d days if the problem persists\n",
1028: (0x01)<<mail->logged);
1029: break;
1030: }
1031: if (cfg.emailfreq>1 && mail->logged) {
1032: dateandtimezoneepoch(dates, mail->firstsent);
1033: sprintf(original,"The original email about this issue was sent at %s\n", dates);
1034: }
1035: }
1036:
1037: snprintf(subject, 256,"SMART error (%s) detected on host: %s", whichfail[which], hostname);
1038:
1039: // If the user has set cfg.emailcmdline, use that as mailer, else "mail" or "mailx".
1040: if (!*executable)
1041: #ifdef DEFAULT_MAILER
1042: executable = DEFAULT_MAILER ;
1043: #else
1044: #ifndef _WIN32
1045: executable = "mail";
1046: #else
1047: executable = "blat"; // http://blat.sourceforge.net/
1048: #endif
1049: #endif
1050:
1051: #ifndef _WIN32 // blat mailer needs comma
1052: // replace commas by spaces to separate recipients
1053: std::replace(address.begin(), address.end(), ',', ' ');
1054: #endif
1055: // Export information in environment variables that will be useful
1056: // for user scripts
1057: exportenv(environ_strings[0], "SMARTD_MAILER", executable);
1058: exportenv(environ_strings[1], "SMARTD_MESSAGE", message);
1059: exportenv(environ_strings[2], "SMARTD_SUBJECT", subject);
1060: dateandtimezoneepoch(dates, mail->firstsent);
1061: exportenv(environ_strings[3], "SMARTD_TFIRST", dates);
1062: snprintf(dates, DATEANDEPOCHLEN,"%d", (int)mail->firstsent);
1063: exportenv(environ_strings[4], "SMARTD_TFIRSTEPOCH", dates);
1064: exportenv(environ_strings[5], "SMARTD_FAILTYPE", whichfail[which]);
1065: if (!address.empty())
1066: exportenv(environ_strings[6], "SMARTD_ADDRESS", address.c_str());
1067: exportenv(environ_strings[7], "SMARTD_DEVICESTRING", cfg.name.c_str());
1068:
1069: // Allow 'smartctl ... -d $SMARTD_DEVICETYPE $SMARTD_DEVICE'
1070: exportenv(environ_strings[8], "SMARTD_DEVICETYPE",
1071: (!cfg.dev_type.empty() ? cfg.dev_type.c_str() : "auto"));
1072: exportenv(environ_strings[9], "SMARTD_DEVICE", cfg.dev_name.c_str());
1073:
1074: snprintf(fullmessage, 1024,
1075: "This email was generated by the smartd daemon running on:\n\n"
1076: " host name: %s\n"
1077: " DNS domain: %s\n"
1078: " NIS domain: %s\n\n"
1079: "The following warning/error was logged by the smartd daemon:\n\n"
1080: "%s\n\n"
1081: "For details see host's SYSLOG.\n\n"
1082: "%s%s%s",
1083: hostname, domainname, nisdomain, message, further, original, additional);
1084: exportenv(environ_strings[10], "SMARTD_FULLMESSAGE", fullmessage);
1085:
1086: // now construct a command to send this as EMAIL
1087: #ifndef _WIN32
1088: if (!address.empty())
1089: snprintf(command, 2048,
1090: "$SMARTD_MAILER -s '%s' %s 2>&1 << \"ENDMAIL\"\n"
1091: "%sENDMAIL\n", subject, address.c_str(), fullmessage);
1092: else
1093: snprintf(command, 2048, "%s 2>&1", executable);
1094:
1095: // tell SYSLOG what we are about to do...
1096: const char * newadd = (!address.empty()? address.c_str() : "<nomailer>");
1097: const char * newwarn = (which? "Warning via" : "Test of");
1098:
1099: PrintOut(LOG_INFO,"%s %s to %s ...\n",
1100: which?"Sending warning via":"Executing test of", executable, newadd);
1101:
1102: // issue the command to send mail or to run the user's executable
1103: errno=0;
1104: FILE * pfp;
1105: if (!(pfp=popen(command, "r")))
1106: // failed to popen() mail process
1107: PrintOut(LOG_CRIT,"%s %s to %s: failed (fork or pipe failed, or no memory) %s\n",
1108: newwarn, executable, newadd, errno?strerror(errno):"");
1109: else {
1110: // pipe suceeded!
1111: int len, status;
1112: char buffer[EBUFLEN];
1113:
1114: // if unexpected output on stdout/stderr, null terminate, print, and flush
1115: if ((len=fread(buffer, 1, EBUFLEN, pfp))) {
1116: int count=0;
1117: int newlen = len<EBUFLEN ? len : EBUFLEN-1;
1118: buffer[newlen]='\0';
1119: PrintOut(LOG_CRIT,"%s %s to %s produced unexpected output (%s%d bytes) to STDOUT/STDERR: \n%s\n",
1120: newwarn, executable, newadd, len!=newlen?"here truncated to ":"", newlen, buffer);
1121:
1122: // flush pipe if needed
1123: while (fread(buffer, 1, EBUFLEN, pfp) && count<EBUFLEN)
1124: count++;
1125:
1126: // tell user that pipe was flushed, or that something is really wrong
1127: if (count && count<EBUFLEN)
1128: PrintOut(LOG_CRIT,"%s %s to %s: flushed remaining STDOUT/STDERR\n",
1129: newwarn, executable, newadd);
1130: else if (count)
1131: PrintOut(LOG_CRIT,"%s %s to %s: more than 1 MB STDOUT/STDERR flushed, breaking pipe\n",
1132: newwarn, executable, newadd);
1133: }
1134:
1135: // if something went wrong with mail process, print warning
1136: errno=0;
1137: if (-1==(status=pclose(pfp)))
1138: PrintOut(LOG_CRIT,"%s %s to %s: pclose(3) failed %s\n", newwarn, executable, newadd,
1139: errno?strerror(errno):"");
1140: else {
1141: // mail process apparently succeeded. Check and report exit status
1142: int status8;
1143:
1144: if (WIFEXITED(status)) {
1145: // exited 'normally' (but perhaps with nonzero status)
1146: status8=WEXITSTATUS(status);
1147:
1148: if (status8>128)
1149: PrintOut(LOG_CRIT,"%s %s to %s: failed (32-bit/8-bit exit status: %d/%d) perhaps caught signal %d [%s]\n",
1150: newwarn, executable, newadd, status, status8, status8-128, strsignal(status8-128));
1151: else if (status8)
1152: PrintOut(LOG_CRIT,"%s %s to %s: failed (32-bit/8-bit exit status: %d/%d)\n",
1153: newwarn, executable, newadd, status, status8);
1154: else
1155: PrintOut(LOG_INFO,"%s %s to %s: successful\n", newwarn, executable, newadd);
1156: }
1157:
1158: if (WIFSIGNALED(status))
1159: PrintOut(LOG_INFO,"%s %s to %s: exited because of uncaught signal %d [%s]\n",
1160: newwarn, executable, newadd, WTERMSIG(status), strsignal(WTERMSIG(status)));
1161:
1162: // this branch is probably not possible. If subprocess is
1163: // stopped then pclose() should not return.
1164: if (WIFSTOPPED(status))
1165: PrintOut(LOG_CRIT,"%s %s to %s: process STOPPED because it caught signal %d [%s]\n",
1166: newwarn, executable, newadd, WSTOPSIG(status), strsignal(WSTOPSIG(status)));
1167:
1168: }
1169: }
1170:
1171: #else // _WIN32
1172:
1173: // No "here-documents" on Windows, so must use separate commandline and stdin
1174: char stdinbuf[1024];
1175: command[0] = stdinbuf[0] = 0;
1176: int boxtype = -1, boxmsgoffs = 0;
1177: const char * newadd = "<nomailer>";
1178: if (!address.empty()) {
1179: // address "[sys]msgbox ..." => show warning (also) as [system modal ]messagebox
1180: char addr1[9+1+13] = ""; int n1 = -1, n2 = -1;
1181: if (sscanf(address.c_str(), "%9[a-z]%n,%n", addr1, &n1, &n2) == 1 && (n1 == (int)address.size() || n2 > 0)) {
1182: if (!strcmp(addr1, "msgbox"))
1183: boxtype = 0;
1184: else if (!strcmp(addr1, "sysmsgbox"))
1185: boxtype = 1;
1186: if (boxtype >= 0)
1187: address.erase(0, (n2 > n1 ? n2 : n1));
1188: }
1189:
1190: if (!address.empty()) {
1191: // Use "blat" parameter syntax (TODO: configure via -M for other mailers)
1192: snprintf(command, sizeof(command),
1193: "%s - -q -subject \"%s\" -to \"%s\"",
1194: executable, subject, address.c_str());
1195: newadd = address.c_str();
1196: }
1197:
1198: // Message for mail [0...] and messagebox [boxmsgoffs...]
1199: snprintf(stdinbuf, sizeof(stdinbuf),
1200: "This email was generated by the smartd daemon running on:\n\n"
1201: " host name: %s\n"
1202: " DNS domain: %s\n"
1203: // " NIS domain: %s\n"
1204: "\n",
1205: hostname, /*domainname, */ nisdomain);
1206: boxmsgoffs = strlen(stdinbuf);
1207: snprintf(stdinbuf+boxmsgoffs, sizeof(stdinbuf)-boxmsgoffs,
1208: "The following warning/error was logged by the smartd daemon:\n\n"
1209: "%s\n\n"
1210: "For details see the event log or log file of smartd.\n\n"
1211: "%s%s%s"
1212: "\n",
1213: message, further, original, additional);
1214: }
1215: else
1216: snprintf(command, sizeof(command), "%s", executable);
1217:
1218: const char * newwarn = (which ? "Warning via" : "Test of");
1219: if (boxtype >= 0) {
1220: // show message box
1221: daemon_messagebox(boxtype, subject, stdinbuf+boxmsgoffs);
1222: PrintOut(LOG_INFO,"%s message box\n", newwarn);
1223: }
1224: if (command[0]) {
1225: char stdoutbuf[800]; // < buffer in syslog_win32::vsyslog()
1226: int rc;
1227: // run command
1228: PrintOut(LOG_INFO,"%s %s to %s ...\n",
1229: (which?"Sending warning via":"Executing test of"), executable, newadd);
1230: rc = daemon_spawn(command, stdinbuf, strlen(stdinbuf), stdoutbuf, sizeof(stdoutbuf));
1231: if (rc >= 0 && stdoutbuf[0])
1232: PrintOut(LOG_CRIT,"%s %s to %s produced unexpected output (%d bytes) to STDOUT/STDERR:\n%s\n",
1233: newwarn, executable, newadd, (int)strlen(stdoutbuf), stdoutbuf);
1234: if (rc != 0)
1235: PrintOut(LOG_CRIT,"%s %s to %s: failed, exit status %d\n",
1236: newwarn, executable, newadd, rc);
1237: else
1238: PrintOut(LOG_INFO,"%s %s to %s: successful\n", newwarn, executable, newadd);
1239: }
1240:
1241: #endif // _WIN32
1242:
1243: // increment mail sent counter
1244: mail->logged++;
1245: }
1246:
1247: static void reset_warning_mail(const dev_config & cfg, dev_state & state, int which, const char *fmt, ...)
1248: __attribute__ ((format (printf, 4, 5)));
1249:
1250: static void reset_warning_mail(const dev_config & cfg, dev_state & state, int which, const char *fmt, ...)
1251: {
1252: if (!(0 <= which && which < SMARTD_NMAIL))
1253: return;
1254:
1255: // Return if no mail sent yet
1256: mailinfo & mi = state.maillog[which];
1257: if (!mi.logged)
1258: return;
1259:
1260: // Format & print message
1261: char msg[256];
1262: va_list ap;
1263: va_start(ap, fmt);
1264: vsnprintf(msg, sizeof(msg), fmt, ap);
1265: va_end(ap);
1266:
1267: PrintOut(LOG_INFO, "Device: %s, %s, warning condition reset after %d email%s\n", cfg.name.c_str(),
1268: msg, mi.logged, (mi.logged==1 ? "" : "s"));
1269:
1270: // Clear mail counter and timestamps
1271: mi = mailinfo();
1272: state.must_write = true;
1273: }
1274:
1275: #ifndef _WIN32
1276:
1277: // Output multiple lines via separate syslog(3) calls.
1278: static void vsyslog_lines(int priority, const char * fmt, va_list ap)
1279: {
1280: char buf[512+EBUFLEN]; // enough space for exec cmd output in MailWarning()
1281: vsnprintf(buf, sizeof(buf), fmt, ap);
1282:
1283: for (char * p = buf, * q; p && *p; p = q) {
1284: if ((q = strchr(p, '\n')))
1285: *q++ = 0;
1286: if (*p)
1287: syslog(priority, "%s\n", p);
1288: }
1289: }
1290:
1291: #else // _WIN32
1292: // os_win32/syslog_win32.cpp supports multiple lines.
1293: #define vsyslog_lines vsyslog
1294: #endif // _WIN32
1295:
1296: // Printing function for watching ataprint commands, or losing them
1297: // [From GLIBC Manual: Since the prototype doesn't specify types for
1298: // optional arguments, in a call to a variadic function the default
1299: // argument promotions are performed on the optional argument
1300: // values. This means the objects of type char or short int (whether
1301: // signed or not) are promoted to either int or unsigned int, as
1302: // appropriate.]
1303: void pout(const char *fmt, ...){
1304: va_list ap;
1305:
1306: // get the correct time in syslog()
1307: FixGlibcTimeZoneBug();
1308: // initialize variable argument list
1309: va_start(ap,fmt);
1310: // in debugmode==1 mode we will print the output from the ataprint.o functions!
1311: if (debugmode && debugmode!=2)
1312: #ifdef _WIN32
1313: if (facility == LOG_LOCAL1) // logging to stdout
1314: vfprintf(stderr,fmt,ap);
1315: else
1316: #endif
1317: vprintf(fmt,ap);
1318: // in debugmode==2 mode we print output from knowndrives.o functions
1319: else if (debugmode==2 || ata_debugmode || scsi_debugmode) {
1320: openlog("smartd", LOG_PID, facility);
1321: vsyslog_lines(LOG_INFO, fmt, ap);
1322: closelog();
1323: }
1324: va_end(ap);
1325: fflush(NULL);
1326: return;
1327: }
1328:
1329: // This function prints either to stdout or to the syslog as needed.
1330: static void PrintOut(int priority, const char *fmt, ...){
1331: va_list ap;
1332:
1333: // get the correct time in syslog()
1334: FixGlibcTimeZoneBug();
1335: // initialize variable argument list
1336: va_start(ap,fmt);
1337: if (debugmode)
1338: #ifdef _WIN32
1339: if (facility == LOG_LOCAL1) // logging to stdout
1340: vfprintf(stderr,fmt,ap);
1341: else
1342: #endif
1343: vprintf(fmt,ap);
1344: else {
1345: openlog("smartd", LOG_PID, facility);
1346: vsyslog_lines(priority, fmt, ap);
1347: closelog();
1348: }
1349: va_end(ap);
1350: return;
1351: }
1352:
1353: // Used to warn users about invalid checksums. Called from atacmds.cpp.
1354: void checksumwarning(const char * string)
1355: {
1356: pout("Warning! %s error: invalid SMART checksum.\n", string);
1357: }
1358:
1359: #ifndef _WIN32
1360:
1361: // Wait for the pid file to show up, this makes sure a calling program knows
1362: // that the daemon is really up and running and has a pid to kill it
1363: static bool WaitForPidFile()
1364: {
1365: int waited, max_wait = 10;
1366: struct stat stat_buf;
1367:
1368: if (pid_file.empty() || debugmode)
1369: return true;
1370:
1371: for(waited = 0; waited < max_wait; ++waited) {
1372: if (!stat(pid_file.c_str(), &stat_buf)) {
1373: return true;
1374: } else
1375: sleep(1);
1376: }
1377: return false;
1378: }
1379:
1380: #endif // _WIN32
1381:
1382: // Forks new process, closes ALL file descriptors, redirects stdin,
1383: // stdout, and stderr. Not quite daemon(). See
1384: // http://www.linuxjournal.com/article/2335
1385: // for a good description of why we do things this way.
1386: static void DaemonInit()
1387: {
1388: #ifndef _WIN32
1389: pid_t pid;
1390: int i;
1391:
1392: // flush all buffered streams. Else we might get two copies of open
1393: // streams since both parent and child get copies of the buffers.
1394: fflush(NULL);
1395:
1396: if (do_fork) {
1397: if ((pid=fork()) < 0) {
1398: // unable to fork!
1399: PrintOut(LOG_CRIT,"smartd unable to fork daemon process!\n");
1400: EXIT(EXIT_STARTUP);
1401: }
1402: else if (pid) {
1403: // we are the parent process, wait for pid file, then exit cleanly
1404: if(!WaitForPidFile()) {
1405: PrintOut(LOG_CRIT,"PID file %s didn't show up!\n", pid_file.c_str());
1406: EXIT(EXIT_STARTUP);
1407: } else
1408: EXIT(0);
1409: }
1410:
1411: // from here on, we are the child process.
1412: setsid();
1413:
1414: // Fork one more time to avoid any possibility of having terminals
1415: if ((pid=fork()) < 0) {
1416: // unable to fork!
1417: PrintOut(LOG_CRIT,"smartd unable to fork daemon process!\n");
1418: EXIT(EXIT_STARTUP);
1419: }
1420: else if (pid)
1421: // we are the parent process -- exit cleanly
1422: EXIT(0);
1423:
1424: // Now we are the child's child...
1425: }
1426:
1427: // close any open file descriptors
1428: for (i=getdtablesize();i>=0;--i)
1429: close(i);
1430:
1431: #define NO_warn_unused_result(cmd) { if (cmd) {} ; }
1432:
1433: // redirect any IO attempts to /dev/null for stdin
1434: i=open("/dev/null",O_RDWR);
1435: if (i>=0) {
1436: // stdout
1437: NO_warn_unused_result(dup(i));
1438: // stderr
1439: NO_warn_unused_result(dup(i));
1440: };
1441: umask(0022);
1442: NO_warn_unused_result(chdir("/"));
1443:
1444: if (do_fork)
1445: PrintOut(LOG_INFO, "smartd has fork()ed into background mode. New PID=%d.\n", (int)getpid());
1446:
1447: #else // _WIN32
1448:
1449: // No fork() on native Win32
1450: // Detach this process from console
1451: fflush(NULL);
1452: if (daemon_detach("smartd")) {
1453: PrintOut(LOG_CRIT,"smartd unable to detach from console!\n");
1454: EXIT(EXIT_STARTUP);
1455: }
1456: // stdin/out/err now closed if not redirected
1457:
1458: #endif // _WIN32
1459: return;
1460: }
1461:
1462: // create a PID file containing the current process id
1463: static void WritePidFile()
1464: {
1465: if (!pid_file.empty()) {
1466: pid_t pid = getpid();
1467: mode_t old_umask;
1468: #ifndef __CYGWIN__
1469: old_umask = umask(0077); // rwx------
1470: #else
1471: // Cygwin: smartd service runs on system account, ensure PID file can be read by admins
1472: old_umask = umask(0033); // rwxr--r--
1473: #endif
1474:
1475: stdio_file f(pid_file.c_str(), "w");
1476: umask(old_umask);
1477: if (!(f && fprintf(f, "%d\n", (int)pid) > 0 && f.close())) {
1478: PrintOut(LOG_CRIT, "unable to write PID file %s - exiting.\n", pid_file.c_str());
1479: EXIT(EXIT_PID);
1480: }
1481: PrintOut(LOG_INFO, "file %s written containing PID %d\n", pid_file.c_str(), (int)pid);
1482: }
1483: }
1484:
1485: // Prints header identifying version of code and home
1486: static void PrintHead()
1487: {
1488: PrintOut(LOG_INFO, "%s\n", format_version_info("smartd").c_str());
1489: }
1490:
1491: // prints help info for configuration file Directives
1492: static void Directives()
1493: {
1494: PrintOut(LOG_INFO,
1495: "Configuration file (%s) Directives (after device name):\n"
1496: " -d TYPE Set the device type: %s, auto, removable\n"
1497: " -T TYPE Set the tolerance to one of: normal, permissive\n"
1498: " -o VAL Enable/disable automatic offline tests (on/off)\n"
1499: " -S VAL Enable/disable attribute autosave (on/off)\n"
1500: " -n MODE No check if: never, sleep[,N][,q], standby[,N][,q], idle[,N][,q]\n"
1501: " -H Monitor SMART Health Status, report if failed\n"
1502: " -s REG Do Self-Test at time(s) given by regular expression REG\n"
1503: " -l TYPE Monitor SMART log or self-test status\n"
1504: " Type is one of: error, selftest, xerror, offlinests, selfteststs\n"
1505: " -l scterc,R,W Set SCT Error Recovery Control\n"
1506: " -f Monitor 'Usage' Attributes, report failures\n"
1507: " -m ADD Send email warning to address ADD\n"
1508: " -M TYPE Modify email warning behavior (see man page)\n"
1509: " -p Report changes in 'Prefailure' Attributes\n"
1510: " -u Report changes in 'Usage' Attributes\n"
1511: " -t Equivalent to -p and -u Directives\n"
1512: " -r ID Also report Raw values of Attribute ID with -p, -u or -t\n"
1513: " -R ID Track changes in Attribute ID Raw value with -p, -u or -t\n"
1514: " -i ID Ignore Attribute ID for -f Directive\n"
1515: " -I ID Ignore Attribute ID for -p, -u or -t Directive\n"
1516: " -C ID[+] Monitor [increases of] Current Pending Sectors in Attribute ID\n"
1517: " -U ID[+] Monitor [increases of] Offline Uncorrectable Sectors in Attribute ID\n"
1518: " -W D,I,C Monitor Temperature D)ifference, I)nformal limit, C)ritical limit\n"
1519: " -v N,ST Modifies labeling of Attribute N (see man page) \n"
1520: " -P TYPE Drive-specific presets: use, ignore, show, showall\n"
1521: " -a Default: -H -f -t -l error -l selftest -l selfteststs -C 197 -U 198\n"
1522: " -F TYPE Firmware bug workaround: none, samsung, samsung2, samsung3\n"
1523: " # Comment: text after a hash sign is ignored\n"
1524: " \\ Line continuation character\n"
1525: "Attribute ID is a decimal integer 1 <= ID <= 255\n"
1526: "Use ID = 0 to turn off -C and/or -U Directives\n"
1527: "Example: /dev/hda -a\n",
1528: configfile, smi()->get_valid_dev_types_str().c_str());
1529: return;
1530: }
1531:
1532: /* Returns a pointer to a static string containing a formatted list of the valid
1533: arguments to the option opt or NULL on failure. */
1534: static const char *GetValidArgList(char opt)
1535: {
1536: switch (opt) {
1537: case 'A':
1538: case 's':
1539: return "<PATH_PREFIX>";
1540: case 'c':
1541: return "<FILE_NAME>, -";
1542: case 'l':
1543: return "daemon, local0, local1, local2, local3, local4, local5, local6, local7";
1544: case 'q':
1545: return "nodev, errors, nodevstartup, never, onecheck, showtests";
1546: case 'r':
1547: return "ioctl[,N], ataioctl[,N], scsiioctl[,N]";
1548: case 'B':
1549: case 'p':
1550: return "<FILE_NAME>";
1551: case 'i':
1552: return "<INTEGER_SECONDS>";
1553: default:
1554: return NULL;
1555: }
1556: }
1557:
1558: /* prints help information for command syntax */
1559: static void Usage()
1560: {
1561: PrintOut(LOG_INFO,"Usage: smartd [options]\n\n");
1562: PrintOut(LOG_INFO," -A PREFIX, --attributelog=PREFIX\n");
1563: PrintOut(LOG_INFO," Log ATA attribute information to {PREFIX}MODEL-SERIAL.ata.csv\n");
1564: #ifdef SMARTMONTOOLS_ATTRIBUTELOG
1565: PrintOut(LOG_INFO," [default is "SMARTMONTOOLS_ATTRIBUTELOG"MODEL-SERIAL.ata.csv]\n");
1566: #endif
1567: PrintOut(LOG_INFO,"\n");
1568: PrintOut(LOG_INFO," -B [+]FILE, --drivedb=[+]FILE\n");
1569: PrintOut(LOG_INFO," Read and replace [add] drive database from FILE\n");
1570: PrintOut(LOG_INFO," [default is +%s", get_drivedb_path_add());
1571: #ifdef SMARTMONTOOLS_DRIVEDBDIR
1572: PrintOut(LOG_INFO,"\n");
1573: PrintOut(LOG_INFO," and then %s", get_drivedb_path_default());
1574: #endif
1575: PrintOut(LOG_INFO,"]\n\n");
1576: PrintOut(LOG_INFO," -c NAME|-, --configfile=NAME|-\n");
1577: PrintOut(LOG_INFO," Read configuration file NAME or stdin\n");
1578: PrintOut(LOG_INFO," [default is %s]\n\n", configfile);
1579: #ifdef HAVE_LIBCAP_NG
1580: PrintOut(LOG_INFO," -C, --capabilities\n");
1581: PrintOut(LOG_INFO," Use capabilities.\n"
1582: " Warning: Mail notification does not work when used.\n\n");
1583: #endif
1584: PrintOut(LOG_INFO," -d, --debug\n");
1585: PrintOut(LOG_INFO," Start smartd in debug mode\n\n");
1586: PrintOut(LOG_INFO," -D, --showdirectives\n");
1587: PrintOut(LOG_INFO," Print the configuration file Directives and exit\n\n");
1588: PrintOut(LOG_INFO," -h, --help, --usage\n");
1589: PrintOut(LOG_INFO," Display this help and exit\n\n");
1590: PrintOut(LOG_INFO," -i N, --interval=N\n");
1591: PrintOut(LOG_INFO," Set interval between disk checks to N seconds, where N >= 10\n\n");
1592: PrintOut(LOG_INFO," -l local[0-7], --logfacility=local[0-7]\n");
1593: #ifndef _WIN32
1594: PrintOut(LOG_INFO," Use syslog facility local0 - local7 or daemon [default]\n\n");
1595: #else
1596: PrintOut(LOG_INFO," Log to \"./smartd.log\", stdout, stderr [default is event log]\n\n");
1597: #endif
1598: #ifndef _WIN32
1599: PrintOut(LOG_INFO," -n, --no-fork\n");
1600: PrintOut(LOG_INFO," Do not fork into background\n\n");
1601: #endif // _WIN32
1602: PrintOut(LOG_INFO," -p NAME, --pidfile=NAME\n");
1603: PrintOut(LOG_INFO," Write PID file NAME\n\n");
1604: PrintOut(LOG_INFO," -q WHEN, --quit=WHEN\n");
1605: PrintOut(LOG_INFO," Quit on one of: %s\n\n", GetValidArgList('q'));
1606: PrintOut(LOG_INFO," -r, --report=TYPE\n");
1607: PrintOut(LOG_INFO," Report transactions for one of: %s\n\n", GetValidArgList('r'));
1608: PrintOut(LOG_INFO," -s PREFIX, --savestates=PREFIX\n");
1609: PrintOut(LOG_INFO," Save disk states to {PREFIX}MODEL-SERIAL.TYPE.state\n");
1610: #ifdef SMARTMONTOOLS_SAVESTATES
1611: PrintOut(LOG_INFO," [default is "SMARTMONTOOLS_SAVESTATES"MODEL-SERIAL.TYPE.state]\n");
1612: #endif
1613: PrintOut(LOG_INFO,"\n");
1614: #ifdef _WIN32
1615: PrintOut(LOG_INFO," --service\n");
1616: PrintOut(LOG_INFO," Running as windows service (see man page), install with:\n");
1617: PrintOut(LOG_INFO," smartd install [options]\n");
1618: PrintOut(LOG_INFO," Remove service with:\n");
1619: PrintOut(LOG_INFO," smartd remove\n\n");
1620: #endif // _WIN32
1621: PrintOut(LOG_INFO," -V, --version, --license, --copyright\n");
1622: PrintOut(LOG_INFO," Print License, Copyright, and version information\n");
1623: }
1624:
1625: static int CloseDevice(smart_device * device, const char * name)
1626: {
1627: if (!device->close()){
1628: PrintOut(LOG_INFO,"Device: %s, %s, close() failed\n", name, device->get_errmsg());
1629: return 1;
1630: }
1631: // device sucessfully closed
1632: return 0;
1633: }
1634:
1635: // return true if a char is not allowed in a state file name
1636: static bool not_allowed_in_filename(char c)
1637: {
1638: return !( ('0' <= c && c <= '9')
1639: || ('A' <= c && c <= 'Z')
1640: || ('a' <= c && c <= 'z'));
1641: }
1642:
1643: // Read error count from Summary or Extended Comprehensive SMART error log
1644: // Return -1 on error
1645: static int read_ata_error_count(ata_device * device, const char * name,
1646: unsigned char fix_firmwarebug, bool extended)
1647: {
1648: if (!extended) {
1649: ata_smart_errorlog log;
1650: if (ataReadErrorLog(device, &log, fix_firmwarebug)){
1651: PrintOut(LOG_INFO,"Device: %s, Read Summary SMART Error Log failed\n",name);
1652: return -1;
1653: }
1654: return (log.error_log_pointer ? log.ata_error_count : 0);
1655: }
1656: else {
1657: ata_smart_exterrlog logx;
1658: if (!ataReadExtErrorLog(device, &logx, 1 /*first sector only*/)) {
1659: PrintOut(LOG_INFO,"Device: %s, Read Extended Comprehensive SMART Error Log failed\n",name);
1660: return -1;
1661: }
1662: // Some disks use the reserved byte as index, see ataprint.cpp.
1663: return (logx.error_log_index || logx.reserved1 ? logx.device_error_count : 0);
1664: }
1665: }
1666:
1667: // returns <0 if problem. Otherwise, bottom 8 bits are the self test
1668: // error count, and top bits are the power-on hours of the last error.
1669: static int SelfTestErrorCount(ata_device * device, const char * name,
1670: unsigned char fix_firmwarebug)
1671: {
1672: struct ata_smart_selftestlog log;
1673:
1674: if (ataReadSelfTestLog(device, &log, fix_firmwarebug)){
1675: PrintOut(LOG_INFO,"Device: %s, Read SMART Self Test Log Failed\n",name);
1676: return -1;
1677: }
1678:
1679: // return current number of self-test errors
1680: return ataPrintSmartSelfTestlog(&log, false, fix_firmwarebug);
1681: }
1682:
1683: #define SELFTEST_ERRORCOUNT(x) (x & 0xff)
1684: #define SELFTEST_ERRORHOURS(x) ((x >> 8) & 0xffff)
1685:
1686: // Log offline data collection status
1687: static void log_offline_data_coll_status(const char * name, unsigned char status)
1688: {
1689: const char * msg;
1690: switch (status & 0x7f) {
1691: case 0x00: msg = "was never started"; break;
1692: case 0x02: msg = "was completed without error"; break;
1693: case 0x03: msg = "is in progress"; break;
1694: case 0x04: msg = "was suspended by an interrupting command from host"; break;
1695: case 0x05: msg = "was aborted by an interrupting command from host"; break;
1696: case 0x06: msg = "was aborted by the device with a fatal error"; break;
1697: default: msg = 0;
1698: }
1699:
1700: if (msg)
1701: PrintOut(((status & 0x7f) == 0x06 ? LOG_CRIT : LOG_INFO),
1702: "Device: %s, offline data collection %s%s\n", name, msg,
1703: ((status & 0x80) ? " (auto:on)" : ""));
1704: else
1705: PrintOut(LOG_INFO, "Device: %s, unknown offline data collection status 0x%02x\n",
1706: name, status);
1707: }
1708:
1709: // Log self-test execution status
1710: static void log_self_test_exec_status(const char * name, unsigned char status)
1711: {
1712: const char * msg;
1713: switch (status >> 4) {
1714: case 0x0: msg = "completed without error"; break;
1715: case 0x1: msg = "was aborted by the host"; break;
1716: case 0x2: msg = "was interrupted by the host with a reset"; break;
1717: case 0x3: msg = "could not complete due to a fatal or unknown error"; break;
1718: case 0x4: msg = "completed with error (unknown test element)"; break;
1719: case 0x5: msg = "completed with error (electrical test element)"; break;
1720: case 0x6: msg = "completed with error (servo/seek test element)"; break;
1721: case 0x7: msg = "completed with error (read test element)"; break;
1722: case 0x8: msg = "completed with error (handling damage?)"; break;
1723: default: msg = 0;
1724: }
1725:
1726: if (msg)
1727: PrintOut(((status >> 4) >= 0x4 ? LOG_CRIT : LOG_INFO),
1728: "Device: %s, previous self-test %s\n", name, msg);
1729: else if ((status >> 4) == 0xf)
1730: PrintOut(LOG_INFO, "Device: %s, self-test in progress, %u0%% remaining\n",
1731: name, status & 0x0f);
1732: else
1733: PrintOut(LOG_INFO, "Device: %s, unknown self-test status 0x%02x\n",
1734: name, status);
1735: }
1736:
1737: // Check pending sector count id (-C, -U directives).
1738: static bool check_pending_id(const dev_config & cfg, const dev_state & state,
1739: unsigned char id, const char * msg)
1740: {
1741: // Check attribute index
1742: int i = ata_find_attr_index(id, state.smartval);
1743: if (i < 0) {
1744: PrintOut(LOG_INFO, "Device: %s, can't monitor %s count - no Attribute %d\n",
1745: cfg.name.c_str(), msg, id);
1746: return false;
1747: }
1748:
1749: // Check value
1750: uint64_t rawval = ata_get_attr_raw_value(state.smartval.vendor_attributes[i],
1751: cfg.attribute_defs);
1752: if (rawval >= (state.num_sectors ? state.num_sectors : 0xffffffffULL)) {
1753: PrintOut(LOG_INFO, "Device: %s, ignoring %s count - bogus Attribute %d value %"PRIu64" (0x%"PRIx64")\n",
1754: cfg.name.c_str(), msg, id, rawval, rawval);
1755: return false;
1756: }
1757:
1758: return true;
1759: }
1760:
1761: // Called by ATA/SCSIDeviceScan() after successful device check
1762: static void finish_device_scan(dev_config & cfg, dev_state & state)
1763: {
1764: // Set cfg.emailfreq if user hasn't set it
1765: if ((!cfg.emailaddress.empty() || !cfg.emailcmdline.empty()) && !cfg.emailfreq) {
1766: // Avoid that emails are suppressed forever due to state persistence
1767: if (cfg.state_file.empty())
1768: cfg.emailfreq = 1; // '-M once'
1769: else
1770: cfg.emailfreq = 2; // '-M daily'
1771: }
1772:
1773: // Start self-test regex check now if time was not read from state file
1774: if (!cfg.test_regex.empty() && !state.scheduled_test_next_check)
1775: state.scheduled_test_next_check = time(0);
1776: }
1777:
1778:
1779: // TODO: Add '-F swapid' directive
1780: const bool fix_swapped_id = false;
1781:
1782: // scan to see what ata devices there are, and if they support SMART
1783: static int ATADeviceScan(dev_config & cfg, dev_state & state, ata_device * atadev)
1784: {
1785: int supported=0;
1786: struct ata_identify_device drive;
1787: const char *name = cfg.name.c_str();
1788: int retid;
1789:
1790: // Device must be open
1791:
1792: // Get drive identity structure
1793: if ((retid = ata_read_identity(atadev, &drive, fix_swapped_id))) {
1794: if (retid<0)
1795: // Unable to read Identity structure
1796: PrintOut(LOG_INFO,"Device: %s, not ATA, no IDENTIFY DEVICE Structure\n",name);
1797: else
1798: PrintOut(LOG_INFO,"Device: %s, packet devices [this device %s] not SMART capable\n",
1799: name, packetdevicetype(retid-1));
1800: CloseDevice(atadev, name);
1801: return 2;
1802: }
1803:
1804: // Log drive identity and size
1805: char model[40+1], serial[20+1], firmware[8+1];
1806: ata_format_id_string(model, drive.model, sizeof(model)-1);
1807: ata_format_id_string(serial, drive.serial_no, sizeof(serial)-1);
1808: ata_format_id_string(firmware, drive.fw_rev, sizeof(firmware)-1);
1809:
1810: ata_size_info sizes;
1811: ata_get_size_info(&drive, sizes);
1812: state.num_sectors = sizes.sectors;
1813:
1814: char wwn[30]; wwn[0] = 0;
1815: unsigned oui = 0; uint64_t unique_id = 0;
1816: int naa = ata_get_wwn(&drive, oui, unique_id);
1817: if (naa >= 0)
1818: snprintf(wwn, sizeof(wwn), "WWN:%x-%06x-%09"PRIx64", ", naa, oui, unique_id);
1819:
1820: char cap[32];
1821: PrintOut(LOG_INFO, "Device: %s, %s, S/N:%s, %sFW:%s, %s\n", name,
1822: model, serial, wwn, firmware,
1823: format_capacity(cap, sizeof(cap), sizes.capacity, "."));
1824:
1825: // Show if device in database, and use preset vendor attribute
1826: // options unless user has requested otherwise.
1827: if (cfg.ignorepresets)
1828: PrintOut(LOG_INFO, "Device: %s, smartd database not searched (Directive: -P ignore).\n", name);
1829: else {
1830: // Apply vendor specific presets, print warning if present
1831: const drive_settings * dbentry = lookup_drive_apply_presets(
1832: &drive, cfg.attribute_defs, cfg.fix_firmwarebug);
1833: if (!dbentry)
1834: PrintOut(LOG_INFO, "Device: %s, not found in smartd database.\n", name);
1835: else {
1836: PrintOut(LOG_INFO, "Device: %s, found in smartd database%s%s\n",
1837: name, (*dbentry->modelfamily ? ": " : "."), (*dbentry->modelfamily ? dbentry->modelfamily : ""));
1838: if (*dbentry->warningmsg)
1839: PrintOut(LOG_CRIT, "Device: %s, WARNING: %s\n", name, dbentry->warningmsg);
1840: }
1841: }
1842:
1843: // Set default '-C 197[+]' if no '-C ID' is specified.
1844: if (!cfg.curr_pending_set)
1845: cfg.curr_pending_id = get_unc_attr_id(false, cfg.attribute_defs, cfg.curr_pending_incr);
1846: // Set default '-U 198[+]' if no '-U ID' is specified.
1847: if (!cfg.offl_pending_set)
1848: cfg.offl_pending_id = get_unc_attr_id(true, cfg.attribute_defs, cfg.offl_pending_incr);
1849:
1850: // If requested, show which presets would be used for this drive
1851: if (cfg.showpresets) {
1852: int savedebugmode=debugmode;
1853: PrintOut(LOG_INFO, "Device %s: presets are:\n", name);
1854: if (!debugmode)
1855: debugmode=2;
1856: show_presets(&drive);
1857: debugmode=savedebugmode;
1858: }
1859:
1860: // see if drive supports SMART
1861: supported=ataSmartSupport(&drive);
1862: if (supported!=1) {
1863: if (supported==0)
1864: // drive does NOT support SMART
1865: PrintOut(LOG_INFO,"Device: %s, lacks SMART capability\n",name);
1866: else
1867: // can't tell if drive supports SMART
1868: PrintOut(LOG_INFO,"Device: %s, ATA IDENTIFY DEVICE words 82-83 don't specify if SMART capable.\n",name);
1869:
1870: // should we proceed anyway?
1871: if (cfg.permissive) {
1872: PrintOut(LOG_INFO,"Device: %s, proceeding since '-T permissive' Directive given.\n",name);
1873: }
1874: else {
1875: PrintOut(LOG_INFO,"Device: %s, to proceed anyway, use '-T permissive' Directive.\n",name);
1876: CloseDevice(atadev, name);
1877: return 2;
1878: }
1879: }
1880:
1881: if (ataEnableSmart(atadev)) {
1882: // Enable SMART command has failed
1883: PrintOut(LOG_INFO,"Device: %s, could not enable SMART capability\n",name);
1884: CloseDevice(atadev, name);
1885: return 2;
1886: }
1887:
1888: // disable device attribute autosave...
1889: if (cfg.autosave==1) {
1890: if (ataDisableAutoSave(atadev))
1891: PrintOut(LOG_INFO,"Device: %s, could not disable SMART Attribute Autosave.\n",name);
1892: else
1893: PrintOut(LOG_INFO,"Device: %s, disabled SMART Attribute Autosave.\n",name);
1894: }
1895:
1896: // or enable device attribute autosave
1897: if (cfg.autosave==2) {
1898: if (ataEnableAutoSave(atadev))
1899: PrintOut(LOG_INFO,"Device: %s, could not enable SMART Attribute Autosave.\n",name);
1900: else
1901: PrintOut(LOG_INFO,"Device: %s, enabled SMART Attribute Autosave.\n",name);
1902: }
1903:
1904: // capability check: SMART status
1905: if (cfg.smartcheck && ataSmartStatus2(atadev) == -1) {
1906: PrintOut(LOG_INFO,"Device: %s, not capable of SMART Health Status check\n",name);
1907: cfg.smartcheck = false;
1908: }
1909:
1910: // capability check: Read smart values and thresholds. Note that
1911: // smart values are ALSO needed even if we ONLY want to know if the
1912: // device is self-test log or error-log capable! After ATA-5, this
1913: // information was ALSO reproduced in the IDENTIFY DEVICE response,
1914: // but sadly not for ATA-5. Sigh.
1915:
1916: // do we need to get SMART data?
1917: bool smart_val_ok = false;
1918: if ( cfg.autoofflinetest || cfg.selftest
1919: || cfg.errorlog || cfg.xerrorlog
1920: || cfg.offlinests || cfg.selfteststs
1921: || cfg.usagefailed || cfg.prefail || cfg.usage
1922: || cfg.tempdiff || cfg.tempinfo || cfg.tempcrit
1923: || cfg.curr_pending_id || cfg.offl_pending_id ) {
1924:
1925: if (ataReadSmartValues(atadev, &state.smartval)) {
1926: PrintOut(LOG_INFO, "Device: %s, Read SMART Values failed\n", name);
1927: cfg.usagefailed = cfg.prefail = cfg.usage = false;
1928: cfg.tempdiff = cfg.tempinfo = cfg.tempcrit = 0;
1929: cfg.curr_pending_id = cfg.offl_pending_id = 0;
1930: }
1931: else {
1932: smart_val_ok = true;
1933: if (ataReadSmartThresholds(atadev, &state.smartthres)) {
1934: PrintOut(LOG_INFO, "Device: %s, Read SMART Thresholds failed%s\n",
1935: name, (cfg.usagefailed ? ", ignoring -f Directive" : ""));
1936: cfg.usagefailed = false;
1937: // Let ata_get_attr_state() return ATTRSTATE_NO_THRESHOLD:
1938: memset(&state.smartthres, 0, sizeof(state.smartthres));
1939: }
1940: }
1941:
1942: // see if the necessary Attribute is there to monitor offline or
1943: // current pending sectors or temperature
1944: if ( cfg.curr_pending_id
1945: && !check_pending_id(cfg, state, cfg.curr_pending_id,
1946: "Current_Pending_Sector"))
1947: cfg.curr_pending_id = 0;
1948:
1949: if ( cfg.offl_pending_id
1950: && !check_pending_id(cfg, state, cfg.offl_pending_id,
1951: "Offline_Uncorrectable"))
1952: cfg.offl_pending_id = 0;
1953:
1954: if ( (cfg.tempdiff || cfg.tempinfo || cfg.tempcrit)
1955: && !ata_return_temperature_value(&state.smartval, cfg.attribute_defs)) {
1956: PrintOut(LOG_CRIT, "Device: %s, can't monitor Temperature, ignoring -W Directive\n", name);
1957: cfg.tempdiff = cfg.tempinfo = cfg.tempcrit = 0;
1958: }
1959: }
1960:
1961: // enable/disable automatic on-line testing
1962: if (cfg.autoofflinetest) {
1963: // is this an enable or disable request?
1964: const char *what=(cfg.autoofflinetest==1)?"disable":"enable";
1965: if (!smart_val_ok)
1966: PrintOut(LOG_INFO,"Device: %s, could not %s SMART Automatic Offline Testing.\n",name, what);
1967: else {
1968: // if command appears unsupported, issue a warning...
1969: if (!isSupportAutomaticTimer(&state.smartval))
1970: PrintOut(LOG_INFO,"Device: %s, SMART Automatic Offline Testing unsupported...\n",name);
1971: // ... but then try anyway
1972: if ((cfg.autoofflinetest==1)?ataDisableAutoOffline(atadev):ataEnableAutoOffline(atadev))
1973: PrintOut(LOG_INFO,"Device: %s, %s SMART Automatic Offline Testing failed.\n", name, what);
1974: else
1975: PrintOut(LOG_INFO,"Device: %s, %sd SMART Automatic Offline Testing.\n", name, what);
1976: }
1977: }
1978:
1979: // Read log directories if required for capability check
1980: ata_smart_log_directory smart_logdir, gp_logdir;
1981: bool smart_logdir_ok = false, gp_logdir_ok = false;
1982:
1983: if ( isGeneralPurposeLoggingCapable(&drive)
1984: && (cfg.errorlog || cfg.selftest) ) {
1985: if (!ataReadLogDirectory(atadev, &smart_logdir, false))
1986: smart_logdir_ok = true;
1987: }
1988:
1989: if (cfg.xerrorlog) {
1990: if (!ataReadLogDirectory(atadev, &gp_logdir, true))
1991: gp_logdir_ok = true;
1992: }
1993:
1994: // capability check: self-test-log
1995: state.selflogcount = 0; state.selfloghour = 0;
1996: if (cfg.selftest) {
1997: int retval;
1998: if (!( cfg.permissive
1999: || ( smart_logdir_ok && smart_logdir.entry[0x06-1].numsectors)
2000: || (!smart_logdir_ok && smart_val_ok && isSmartTestLogCapable(&state.smartval, &drive)))) {
2001: PrintOut(LOG_INFO, "Device: %s, no SMART Self-test Log, ignoring -l selftest (override with -T permissive)\n", name);
2002: cfg.selftest = false;
2003: }
2004: else if ((retval = SelfTestErrorCount(atadev, name, cfg.fix_firmwarebug)) < 0) {
2005: PrintOut(LOG_INFO, "Device: %s, no SMART Self-test Log, ignoring -l selftest\n", name);
2006: cfg.selftest = false;
2007: }
2008: else {
2009: state.selflogcount=SELFTEST_ERRORCOUNT(retval);
2010: state.selfloghour =SELFTEST_ERRORHOURS(retval);
2011: }
2012: }
2013:
2014: // capability check: ATA error log
2015: state.ataerrorcount = 0;
2016: if (cfg.errorlog) {
2017: int errcnt1;
2018: if (!( cfg.permissive
2019: || ( smart_logdir_ok && smart_logdir.entry[0x01-1].numsectors)
2020: || (!smart_logdir_ok && smart_val_ok && isSmartErrorLogCapable(&state.smartval, &drive)))) {
2021: PrintOut(LOG_INFO, "Device: %s, no SMART Error Log, ignoring -l error (override with -T permissive)\n", name);
2022: cfg.errorlog = false;
2023: }
2024: else if ((errcnt1 = read_ata_error_count(atadev, name, cfg.fix_firmwarebug, false)) < 0) {
2025: PrintOut(LOG_INFO, "Device: %s, no SMART Error Log, ignoring -l error\n", name);
2026: cfg.errorlog = false;
2027: }
2028: else
2029: state.ataerrorcount = errcnt1;
2030: }
2031:
2032: if (cfg.xerrorlog) {
2033: int errcnt2;
2034: if (!(cfg.permissive || (gp_logdir_ok && gp_logdir.entry[0x03-1].numsectors))) {
2035: PrintOut(LOG_INFO, "Device: %s, no Extended Comprehensive SMART Error Log, ignoring -l xerror (override with -T permissive)\n",
2036: name);
2037: cfg.xerrorlog = false;
2038: }
2039: else if ((errcnt2 = read_ata_error_count(atadev, name, cfg.fix_firmwarebug, true)) < 0) {
2040: PrintOut(LOG_INFO, "Device: %s, no Extended Comprehensive SMART Error Log, ignoring -l xerror\n", name);
2041: cfg.xerrorlog = false;
2042: }
2043: else if (cfg.errorlog && state.ataerrorcount != errcnt2) {
2044: PrintOut(LOG_INFO, "Device: %s, SMART Error Logs report different error counts: %d != %d\n",
2045: name, state.ataerrorcount, errcnt2);
2046: // Record max error count
2047: if (errcnt2 > state.ataerrorcount)
2048: state.ataerrorcount = errcnt2;
2049: }
2050: else
2051: state.ataerrorcount = errcnt2;
2052: }
2053:
2054: // capability check: self-test and offline data collection status
2055: if (cfg.offlinests || cfg.selfteststs) {
2056: if (!(cfg.permissive || (smart_val_ok && state.smartval.offline_data_collection_capability))) {
2057: if (cfg.offlinests)
2058: PrintOut(LOG_INFO, "Device: %s, no SMART Offline Data Collection capability, ignoring -l offlinests (override with -T permissive)\n", name);
2059: if (cfg.selfteststs)
2060: PrintOut(LOG_INFO, "Device: %s, no SMART Self-test capability, ignoring -l selfteststs (override with -T permissive)\n", name);
2061: cfg.offlinests = cfg.selfteststs = false;
2062: }
2063: }
2064:
2065: // capabilities check -- does it support powermode?
2066: if (cfg.powermode) {
2067: int powermode = ataCheckPowerMode(atadev);
2068:
2069: if (-1 == powermode) {
2070: PrintOut(LOG_CRIT, "Device: %s, no ATA CHECK POWER STATUS support, ignoring -n Directive\n", name);
2071: cfg.powermode=0;
2072: }
2073: else if (powermode!=0 && powermode!=0x80 && powermode!=0xff) {
2074: PrintOut(LOG_CRIT, "Device: %s, CHECK POWER STATUS returned %d, not ATA compliant, ignoring -n Directive\n",
2075: name, powermode);
2076: cfg.powermode=0;
2077: }
2078: }
2079:
2080: // set SCT Error Recovery Control if requested
2081: if (cfg.sct_erc_set) {
2082: if (!isSCTErrorRecoveryControlCapable(&drive))
2083: PrintOut(LOG_INFO, "Device: %s, no SCT Error Recovery Control support, ignoring -l scterc\n",
2084: name);
2085: else if ( ataSetSCTErrorRecoveryControltime(atadev, 1, cfg.sct_erc_readtime )
2086: || ataSetSCTErrorRecoveryControltime(atadev, 2, cfg.sct_erc_writetime))
2087: PrintOut(LOG_INFO, "Device: %s, set of SCT Error Recovery Control failed\n", name);
2088: else
2089: PrintOut(LOG_INFO, "Device: %s, SCT Error Recovery Control set to: Read: %u, Write: %u\n",
2090: name, cfg.sct_erc_readtime, cfg.sct_erc_writetime);
2091: }
2092:
2093: // If no tests available or selected, return
2094: if (!( cfg.smartcheck || cfg.selftest
2095: || cfg.errorlog || cfg.xerrorlog
2096: || cfg.offlinests || cfg.selfteststs
2097: || cfg.usagefailed || cfg.prefail || cfg.usage
2098: || cfg.tempdiff || cfg.tempinfo || cfg.tempcrit)) {
2099: CloseDevice(atadev, name);
2100: return 3;
2101: }
2102:
2103: // tell user we are registering device
2104: PrintOut(LOG_INFO,"Device: %s, is SMART capable. Adding to \"monitor\" list.\n",name);
2105:
2106: // close file descriptor
2107: CloseDevice(atadev, name);
2108:
2109: if (!state_path_prefix.empty() || !attrlog_path_prefix.empty()) {
2110: // Build file name for state file
2111: std::replace_if(model, model+strlen(model), not_allowed_in_filename, '_');
2112: std::replace_if(serial, serial+strlen(serial), not_allowed_in_filename, '_');
2113: if (!state_path_prefix.empty()) {
2114: cfg.state_file = strprintf("%s%s-%s.ata.state", state_path_prefix.c_str(), model, serial);
2115: // Read previous state
2116: if (read_dev_state(cfg.state_file.c_str(), state)) {
2117: PrintOut(LOG_INFO, "Device: %s, state read from %s\n", name, cfg.state_file.c_str());
2118: // Copy ATA attribute values to temp state
2119: state.update_temp_state();
2120: }
2121: }
2122: if (!attrlog_path_prefix.empty())
2123: cfg.attrlog_file = strprintf("%s%s-%s.ata.csv", attrlog_path_prefix.c_str(), model, serial);
2124: }
2125:
2126: finish_device_scan(cfg, state);
2127:
2128: return 0;
2129: }
2130:
2131: // on success, return 0. On failure, return >0. Never return <0,
2132: // please.
2133: static int SCSIDeviceScan(dev_config & cfg, dev_state & state, scsi_device * scsidev)
2134: {
2135: int k, err, req_len, avail_len, version, len;
2136: const char *device = cfg.name.c_str();
2137: struct scsi_iec_mode_page iec;
2138: UINT8 tBuf[64];
2139: UINT8 inqBuf[96];
2140: UINT8 vpdBuf[252];
2141: char lu_id[64];
2142:
2143: // Device must be open
2144: memset(inqBuf, 0, 96);
2145: req_len = 36;
2146: if ((err = scsiStdInquiry(scsidev, inqBuf, req_len))) {
2147: /* Marvell controllers fail on a 36 bytes StdInquiry, but 64 suffices */
2148: req_len = 64;
2149: if ((err = scsiStdInquiry(scsidev, inqBuf, req_len))) {
2150: PrintOut(LOG_INFO, "Device: %s, Both 36 and 64 byte INQUIRY failed; "
2151: "skip device\n", device);
2152: return 2;
2153: }
2154: }
2155: version = inqBuf[2];
2156: avail_len = inqBuf[4] + 5;
2157: len = (avail_len < req_len) ? avail_len : req_len;
2158: // peri_dt = inqBuf[0] & 0x1f;
2159: if (len < 36) {
2160: PrintOut(LOG_INFO, "Device: %s, INQUIRY response less than 36 bytes; "
2161: "skip device\n", device);
2162: return 2;
2163: }
2164: lu_id[0] = '\0';
2165: if ((version >= 0x4) && (version < 0x8)) {
2166: /* SPC-2 to SPC-5 */
2167: if (0 == (err = scsiInquiryVpd(scsidev, 0x83, vpdBuf, sizeof(vpdBuf)))) {
2168: len = vpdBuf[3];
2169: scsi_decode_lu_dev_id(vpdBuf + 4, len, lu_id, sizeof(lu_id), NULL);
2170: }
2171: }
2172:
2173: unsigned int lb_size;
2174: char si_str[64];
2175: uint64_t capacity = scsiGetSize(scsidev, &lb_size);
2176:
2177: if (capacity)
2178: format_capacity(si_str, sizeof(si_str), capacity);
2179: else
2180: si_str[0] = '\0';
2181: PrintOut(LOG_INFO, "Device: %s, [%.8s %.16s %.4s]%s%s%s%s\n",
2182: device, (char *)&inqBuf[8], (char *)&inqBuf[16],
2183: (char *)&inqBuf[32],
2184: (lu_id[0] ? ", lu id: " : ""), (lu_id[0] ? lu_id : ""),
2185: (si_str[0] ? ", " : ""), (si_str[0] ? si_str : ""));
2186:
2187: // check that device is ready for commands. IE stores its stuff on
2188: // the media.
2189: if ((err = scsiTestUnitReady(scsidev))) {
2190: if (SIMPLE_ERR_NOT_READY == err)
2191: PrintOut(LOG_INFO, "Device: %s, NOT READY (e.g. spun down); skip device\n", device);
2192: else if (SIMPLE_ERR_NO_MEDIUM == err)
2193: PrintOut(LOG_INFO, "Device: %s, NO MEDIUM present; skip device\n", device);
2194: else if (SIMPLE_ERR_BECOMING_READY == err)
2195: PrintOut(LOG_INFO, "Device: %s, BECOMING (but not yet) READY; skip device\n", device);
2196: else
2197: PrintOut(LOG_CRIT, "Device: %s, failed Test Unit Ready [err=%d]\n", device, err);
2198: CloseDevice(scsidev, device);
2199: return 2;
2200: }
2201:
2202: // Badly-conforming USB storage devices may fail this check.
2203: // The response to the following IE mode page fetch (current and
2204: // changeable values) is carefully examined. It has been found
2205: // that various USB devices that malform the response will lock up
2206: // if asked for a log page (e.g. temperature) so it is best to
2207: // bail out now.
2208: if (!(err = scsiFetchIECmpage(scsidev, &iec, state.modese_len)))
2209: state.modese_len = iec.modese_len;
2210: else if (SIMPLE_ERR_BAD_FIELD == err)
2211: ; /* continue since it is reasonable not to support IE mpage */
2212: else { /* any other error (including malformed response) unreasonable */
2213: PrintOut(LOG_INFO,
2214: "Device: %s, Bad IEC (SMART) mode page, err=%d, skip device\n",
2215: device, err);
2216: CloseDevice(scsidev, device);
2217: return 3;
2218: }
2219:
2220: // N.B. The following is passive (i.e. it doesn't attempt to turn on
2221: // smart if it is off). This may change to be the same as the ATA side.
2222: if (!scsi_IsExceptionControlEnabled(&iec)) {
2223: PrintOut(LOG_INFO, "Device: %s, IE (SMART) not enabled, skip device\n"
2224: "Try 'smartctl -s on %s' to turn on SMART features\n",
2225: device, device);
2226: CloseDevice(scsidev, device);
2227: return 3;
2228: }
2229:
2230: // Flag that certain log pages are supported (information may be
2231: // available from other sources).
2232: if (0 == scsiLogSense(scsidev, SUPPORTED_LPAGES, 0, tBuf, sizeof(tBuf), 0)) {
2233: for (k = 4; k < tBuf[3] + LOGPAGEHDRSIZE; ++k) {
2234: switch (tBuf[k]) {
2235: case TEMPERATURE_LPAGE:
2236: state.TempPageSupported = 1;
2237: break;
2238: case IE_LPAGE:
2239: state.SmartPageSupported = 1;
2240: break;
2241: default:
2242: break;
2243: }
2244: }
2245: }
2246:
2247: // Check if scsiCheckIE() is going to work
2248: {
2249: UINT8 asc = 0;
2250: UINT8 ascq = 0;
2251: UINT8 currenttemp = 0;
2252: UINT8 triptemp = 0;
2253:
2254: if (scsiCheckIE(scsidev, state.SmartPageSupported, state.TempPageSupported,
2255: &asc, &ascq, ¤ttemp, &triptemp)) {
2256: PrintOut(LOG_INFO, "Device: %s, unexpectedly failed to read SMART values\n", device);
2257: state.SuppressReport = 1;
2258: if (cfg.tempdiff || cfg.tempinfo || cfg.tempcrit) {
2259: PrintOut(LOG_CRIT, "Device: %s, can't monitor Temperature, ignoring -W Directive\n", device);
2260: cfg.tempdiff = cfg.tempinfo = cfg.tempcrit = 0;
2261: }
2262: }
2263: }
2264:
2265: // capability check: self-test-log
2266: if (cfg.selftest){
2267: int retval = scsiCountFailedSelfTests(scsidev, 0);
2268: if (retval<0) {
2269: // no self-test log, turn off monitoring
2270: PrintOut(LOG_INFO, "Device: %s, does not support SMART Self-Test Log.\n", device);
2271: cfg.selftest = false;
2272: state.selflogcount = 0;
2273: state.selfloghour = 0;
2274: }
2275: else {
2276: // register starting values to watch for changes
2277: state.selflogcount=SELFTEST_ERRORCOUNT(retval);
2278: state.selfloghour =SELFTEST_ERRORHOURS(retval);
2279: }
2280: }
2281:
2282: // disable autosave (set GLTSD bit)
2283: if (cfg.autosave==1){
2284: if (scsiSetControlGLTSD(scsidev, 1, state.modese_len))
2285: PrintOut(LOG_INFO,"Device: %s, could not disable autosave (set GLTSD bit).\n",device);
2286: else
2287: PrintOut(LOG_INFO,"Device: %s, disabled autosave (set GLTSD bit).\n",device);
2288: }
2289:
2290: // or enable autosave (clear GLTSD bit)
2291: if (cfg.autosave==2){
2292: if (scsiSetControlGLTSD(scsidev, 0, state.modese_len))
2293: PrintOut(LOG_INFO,"Device: %s, could not enable autosave (clear GLTSD bit).\n",device);
2294: else
2295: PrintOut(LOG_INFO,"Device: %s, enabled autosave (cleared GLTSD bit).\n",device);
2296: }
2297:
2298: // tell user we are registering device
2299: PrintOut(LOG_INFO, "Device: %s, is SMART capable. Adding to \"monitor\" list.\n", device);
2300:
2301: // TODO: Build file name for state file
2302: if (!state_path_prefix.empty()) {
2303: PrintOut(LOG_INFO, "Device: %s, persistence not yet supported for SCSI; ignoring -s option.\n", device);
2304: }
2305: // TODO: Build file name for attribute log file
2306: if (!attrlog_path_prefix.empty()) {
2307: PrintOut(LOG_INFO, "Device: %s, attribute log not yet supported for SCSI; ignoring -A option.\n", device);
2308: }
2309:
2310: // close file descriptor
2311: CloseDevice(scsidev, device);
2312:
2313: finish_device_scan(cfg, state);
2314:
2315: return 0;
2316: }
2317:
2318: // If the self-test log has got more self-test errors (or more recent
2319: // self-test errors) recorded, then notify user.
2320: static void CheckSelfTestLogs(const dev_config & cfg, dev_state & state, int newi)
2321: {
2322: const char * name = cfg.name.c_str();
2323:
2324: if (newi<0)
2325: // command failed
2326: MailWarning(cfg, state, 8, "Device: %s, Read SMART Self-Test Log Failed", name);
2327: else {
2328: reset_warning_mail(cfg, state, 8, "Read SMART Self-Test Log worked again");
2329:
2330: // old and new error counts
2331: int oldc=state.selflogcount;
2332: int newc=SELFTEST_ERRORCOUNT(newi);
2333:
2334: // old and new error timestamps in hours
2335: int oldh=state.selfloghour;
2336: int newh=SELFTEST_ERRORHOURS(newi);
2337:
2338: if (oldc<newc) {
2339: // increase in error count
2340: PrintOut(LOG_CRIT, "Device: %s, Self-Test Log error count increased from %d to %d\n",
2341: name, oldc, newc);
2342: MailWarning(cfg, state, 3, "Device: %s, Self-Test Log error count increased from %d to %d",
2343: name, oldc, newc);
2344: state.must_write = true;
2345: }
2346: else if (newc > 0 && oldh != newh) {
2347: // more recent error
2348: // a 'more recent' error might actually be a smaller hour number,
2349: // if the hour number has wrapped.
2350: // There's still a bug here. You might just happen to run a new test
2351: // exactly 32768 hours after the previous failure, and have run exactly
2352: // 20 tests between the two, in which case smartd will miss the
2353: // new failure.
2354: PrintOut(LOG_CRIT, "Device: %s, new Self-Test Log error at hour timestamp %d\n",
2355: name, newh);
2356: MailWarning(cfg, state, 3, "Device: %s, new Self-Test Log error at hour timestamp %d\n",
2357: name, newh);
2358: state.must_write = true;
2359: }
2360:
2361: // Print info if error entries have disappeared
2362: // or newer successful successful extended self-test exits
2363: if (oldc > newc) {
2364: PrintOut(LOG_INFO, "Device: %s, Self-Test Log error count decreased from %d to %d\n",
2365: name, oldc, newc);
2366: if (newc == 0)
2367: reset_warning_mail(cfg, state, 3, "Self-Test Log does no longer report errors");
2368: }
2369:
2370: // Needed since self-test error count may DECREASE. Hour might
2371: // also have changed.
2372: state.selflogcount= newc;
2373: state.selfloghour = newh;
2374: }
2375: return;
2376: }
2377:
2378: // Test types, ordered by priority.
2379: static const char test_type_chars[] = "LncrSCO";
2380: static const unsigned num_test_types = sizeof(test_type_chars)-1;
2381:
2382: // returns test type if time to do test of type testtype,
2383: // 0 if not time to do test.
2384: static char next_scheduled_test(const dev_config & cfg, dev_state & state, bool scsi, time_t usetime = 0)
2385: {
2386: // check that self-testing has been requested
2387: if (cfg.test_regex.empty())
2388: return 0;
2389:
2390: // Exit if drive not capable of any test
2391: if ( state.not_cap_long && state.not_cap_short &&
2392: (scsi || (state.not_cap_conveyance && state.not_cap_offline)))
2393: return 0;
2394:
2395: // since we are about to call localtime(), be sure glibc is informed
2396: // of any timezone changes we make.
2397: if (!usetime)
2398: FixGlibcTimeZoneBug();
2399:
2400: // Is it time for next check?
2401: time_t now = (!usetime ? time(0) : usetime);
2402: if (now < state.scheduled_test_next_check)
2403: return 0;
2404:
2405: // Limit time check interval to 90 days
2406: if (state.scheduled_test_next_check + (3600L*24*90) < now)
2407: state.scheduled_test_next_check = now - (3600L*24*90);
2408:
2409: // Check interval [state.scheduled_test_next_check, now] for scheduled tests
2410: char testtype = 0;
2411: time_t testtime = 0; int testhour = 0;
2412: int maxtest = num_test_types-1;
2413:
2414: for (time_t t = state.scheduled_test_next_check; ; ) {
2415: struct tm * tms = localtime(&t);
2416: // tm_wday is 0 (Sunday) to 6 (Saturday). We use 1 (Monday) to 7 (Sunday).
2417: int weekday = (tms->tm_wday ? tms->tm_wday : 7);
2418: for (int i = 0; i <= maxtest; i++) {
2419: // Skip if drive not capable of this test
2420: switch (test_type_chars[i]) {
2421: case 'L': if (state.not_cap_long) continue; break;
2422: case 'S': if (state.not_cap_short) continue; break;
2423: case 'C': if (scsi || state.not_cap_conveyance) continue; break;
2424: case 'O': if (scsi || state.not_cap_offline) continue; break;
2425: case 'c': case 'n':
2426: case 'r': if (scsi || state.not_cap_selective) continue; break;
2427: default: continue;
2428: }
2429: // Try match of "T/MM/DD/d/HH"
2430: char pattern[16];
2431: snprintf(pattern, sizeof(pattern), "%c/%02d/%02d/%1d/%02d",
2432: test_type_chars[i], tms->tm_mon+1, tms->tm_mday, weekday, tms->tm_hour);
2433: if (cfg.test_regex.full_match(pattern)) {
2434: // Test found
2435: testtype = pattern[0];
2436: testtime = t; testhour = tms->tm_hour;
2437: // Limit further matches to higher priority self-tests
2438: maxtest = i-1;
2439: break;
2440: }
2441: }
2442: // Exit if no tests left or current time reached
2443: if (maxtest < 0)
2444: break;
2445: if (t >= now)
2446: break;
2447: // Check next hour
2448: if ((t += 3600) > now)
2449: t = now;
2450: }
2451:
2452: // Do next check not before next hour.
2453: struct tm * tmnow = localtime(&now);
2454: state.scheduled_test_next_check = now + (3600 - tmnow->tm_min*60 - tmnow->tm_sec);
2455:
2456: if (testtype) {
2457: state.must_write = true;
2458: // Tell user if an old test was found.
2459: if (!usetime && !(testhour == tmnow->tm_hour && testtime + 3600 > now)) {
2460: char datebuf[DATEANDEPOCHLEN]; dateandtimezoneepoch(datebuf, testtime);
2461: PrintOut(LOG_INFO, "Device: %s, old test of type %c not run at %s, starting now.\n",
2462: cfg.name.c_str(), testtype, datebuf);
2463: }
2464: }
2465:
2466: return testtype;
2467: }
2468:
2469: // Print a list of future tests.
2470: static void PrintTestSchedule(const dev_config_vector & configs, dev_state_vector & states, const smart_device_list & devices)
2471: {
2472: unsigned numdev = configs.size();
2473: if (!numdev)
2474: return;
2475: std::vector<int> testcnts(numdev * num_test_types, 0);
2476:
2477: PrintOut(LOG_INFO, "\nNext scheduled self tests (at most 5 of each type per device):\n");
2478:
2479: // FixGlibcTimeZoneBug(); // done in PrintOut()
2480: time_t now = time(0);
2481: char datenow[DATEANDEPOCHLEN], date[DATEANDEPOCHLEN];
2482: dateandtimezoneepoch(datenow, now);
2483:
2484: long seconds;
2485: for (seconds=checktime; seconds<3600L*24*90; seconds+=checktime) {
2486: // Check for each device whether a test will be run
2487: time_t testtime = now + seconds;
2488: for (unsigned i = 0; i < numdev; i++) {
2489: const dev_config & cfg = configs.at(i);
2490: dev_state & state = states.at(i);
2491: const char * p;
2492: char testtype = next_scheduled_test(cfg, state, devices.at(i)->is_scsi(), testtime);
2493: if (testtype && (p = strchr(test_type_chars, testtype))) {
2494: unsigned t = (p - test_type_chars);
2495: // Report at most 5 tests of each type
2496: if (++testcnts[i*num_test_types + t] <= 5) {
2497: dateandtimezoneepoch(date, testtime);
2498: PrintOut(LOG_INFO, "Device: %s, will do test %d of type %c at %s\n", cfg.name.c_str(),
2499: testcnts[i*num_test_types + t], testtype, date);
2500: }
2501: }
2502: }
2503: }
2504:
2505: // Report totals
2506: dateandtimezoneepoch(date, now+seconds);
2507: PrintOut(LOG_INFO, "\nTotals [%s - %s]:\n", datenow, date);
2508: for (unsigned i = 0; i < numdev; i++) {
2509: const dev_config & cfg = configs.at(i);
2510: bool scsi = devices.at(i)->is_scsi();
2511: for (unsigned t = 0; t < num_test_types; t++) {
2512: int cnt = testcnts[i*num_test_types + t];
2513: if (cnt == 0 && !strchr((scsi ? "LS" : "LSCO"), test_type_chars[t]))
2514: continue;
2515: PrintOut(LOG_INFO, "Device: %s, will do %3d test%s of type %c\n", cfg.name.c_str(),
2516: cnt, (cnt==1?"":"s"), test_type_chars[t]);
2517: }
2518: }
2519:
2520: }
2521:
2522: // Return zero on success, nonzero on failure. Perform offline (background)
2523: // short or long (extended) self test on given scsi device.
2524: static int DoSCSISelfTest(const dev_config & cfg, dev_state & state, scsi_device * device, char testtype)
2525: {
2526: int retval = 0;
2527: const char *testname = 0;
2528: const char *name = cfg.name.c_str();
2529: int inProgress;
2530:
2531: if (scsiSelfTestInProgress(device, &inProgress)) {
2532: PrintOut(LOG_CRIT, "Device: %s, does not support Self-Tests\n", name);
2533: state.not_cap_short = state.not_cap_long = true;
2534: return 1;
2535: }
2536:
2537: if (1 == inProgress) {
2538: PrintOut(LOG_INFO, "Device: %s, skip since Self-Test already in "
2539: "progress.\n", name);
2540: return 1;
2541: }
2542:
2543: switch (testtype) {
2544: case 'S':
2545: testname = "Short Self";
2546: retval = scsiSmartShortSelfTest(device);
2547: break;
2548: case 'L':
2549: testname = "Long Self";
2550: retval = scsiSmartExtendSelfTest(device);
2551: break;
2552: }
2553: // If we can't do the test, exit
2554: if (NULL == testname) {
2555: PrintOut(LOG_CRIT, "Device: %s, not capable of %c Self-Test\n", name,
2556: testtype);
2557: return 1;
2558: }
2559: if (retval) {
2560: if ((SIMPLE_ERR_BAD_OPCODE == retval) ||
2561: (SIMPLE_ERR_BAD_FIELD == retval)) {
2562: PrintOut(LOG_CRIT, "Device: %s, not capable of %s-Test\n", name,
2563: testname);
2564: if ('L'==testtype)
2565: state.not_cap_long = true;
2566: else
2567: state.not_cap_short = true;
2568:
2569: return 1;
2570: }
2571: PrintOut(LOG_CRIT, "Device: %s, execute %s-Test failed (err: %d)\n", name,
2572: testname, retval);
2573: return 1;
2574: }
2575:
2576: PrintOut(LOG_INFO, "Device: %s, starting scheduled %s-Test.\n", name, testname);
2577:
2578: return 0;
2579: }
2580:
2581: // Do an offline immediate or self-test. Return zero on success,
2582: // nonzero on failure.
2583: static int DoATASelfTest(const dev_config & cfg, dev_state & state, ata_device * device, char testtype)
2584: {
2585: const char *name = cfg.name.c_str();
2586:
2587: // Read current smart data and check status/capability
2588: struct ata_smart_values data;
2589: if (ataReadSmartValues(device, &data) || !(data.offline_data_collection_capability)) {
2590: PrintOut(LOG_CRIT, "Device: %s, not capable of Offline or Self-Testing.\n", name);
2591: return 1;
2592: }
2593:
2594: // Check for capability to do the test
2595: int dotest = -1, mode = 0;
2596: const char *testname = 0;
2597: switch (testtype) {
2598: case 'O':
2599: testname="Offline Immediate ";
2600: if (isSupportExecuteOfflineImmediate(&data))
2601: dotest=OFFLINE_FULL_SCAN;
2602: else
2603: state.not_cap_offline = true;
2604: break;
2605: case 'C':
2606: testname="Conveyance Self-";
2607: if (isSupportConveyanceSelfTest(&data))
2608: dotest=CONVEYANCE_SELF_TEST;
2609: else
2610: state.not_cap_conveyance = true;
2611: break;
2612: case 'S':
2613: testname="Short Self-";
2614: if (isSupportSelfTest(&data))
2615: dotest=SHORT_SELF_TEST;
2616: else
2617: state.not_cap_short = true;
2618: break;
2619: case 'L':
2620: testname="Long Self-";
2621: if (isSupportSelfTest(&data))
2622: dotest=EXTEND_SELF_TEST;
2623: else
2624: state.not_cap_long = true;
2625: break;
2626:
2627: case 'c': case 'n': case 'r':
2628: testname = "Selective Self-";
2629: if (isSupportSelectiveSelfTest(&data)) {
2630: dotest = SELECTIVE_SELF_TEST;
2631: switch (testtype) {
2632: case 'c': mode = SEL_CONT; break;
2633: case 'n': mode = SEL_NEXT; break;
2634: case 'r': mode = SEL_REDO; break;
2635: }
2636: }
2637: else
2638: state.not_cap_selective = true;
2639: break;
2640: }
2641:
2642: // If we can't do the test, exit
2643: if (dotest<0) {
2644: PrintOut(LOG_CRIT, "Device: %s, not capable of %sTest\n", name, testname);
2645: return 1;
2646: }
2647:
2648: // If currently running a self-test, do not interrupt it to start another.
2649: if (15==(data.self_test_exec_status >> 4)) {
2650: if (cfg.fix_firmwarebug == FIX_SAMSUNG3 && data.self_test_exec_status == 0xf0) {
2651: PrintOut(LOG_INFO, "Device: %s, will not skip scheduled %sTest "
2652: "despite unclear Self-Test byte (SAMSUNG Firmware bug).\n", name, testname);
2653: } else {
2654: PrintOut(LOG_INFO, "Device: %s, skip scheduled %sTest; %1d0%% remaining of current Self-Test.\n",
2655: name, testname, (int)(data.self_test_exec_status & 0x0f));
2656: return 1;
2657: }
2658: }
2659:
2660: if (dotest == SELECTIVE_SELF_TEST) {
2661: // Set test span
2662: ata_selective_selftest_args selargs, prev_args;
2663: selargs.num_spans = 1;
2664: selargs.span[0].mode = mode;
2665: prev_args.num_spans = 1;
2666: prev_args.span[0].start = state.selective_test_last_start;
2667: prev_args.span[0].end = state.selective_test_last_end;
2668: if (ataWriteSelectiveSelfTestLog(device, selargs, &data, state.num_sectors, &prev_args)) {
2669: PrintOut(LOG_CRIT, "Device: %s, prepare %sTest failed\n", name, testname);
2670: return 1;
2671: }
2672: uint64_t start = selargs.span[0].start, end = selargs.span[0].end;
2673: PrintOut(LOG_INFO, "Device: %s, %s test span at LBA %"PRIu64" - %"PRIu64" (%"PRIu64" sectors, %u%% - %u%% of disk).\n",
2674: name, (selargs.span[0].mode == SEL_NEXT ? "next" : "redo"),
2675: start, end, end - start + 1,
2676: (unsigned)((100 * start + state.num_sectors/2) / state.num_sectors),
2677: (unsigned)((100 * end + state.num_sectors/2) / state.num_sectors));
2678: state.selective_test_last_start = start;
2679: state.selective_test_last_end = end;
2680: }
2681:
2682: // execute the test, and return status
2683: int retval = smartcommandhandler(device, IMMEDIATE_OFFLINE, dotest, NULL);
2684: if (retval) {
2685: PrintOut(LOG_CRIT, "Device: %s, execute %sTest failed.\n", name, testname);
2686: return retval;
2687: }
2688:
2689: if (testtype != 'O')
2690: // Log next self-test execution status
2691: state.smartval.self_test_exec_status = 0xff;
2692:
2693: PrintOut(LOG_INFO, "Device: %s, starting scheduled %sTest.\n", name, testname);
2694: return 0;
2695: }
2696:
2697: // Check pending sector count attribute values (-C, -U directives).
2698: static void check_pending(const dev_config & cfg, dev_state & state,
2699: unsigned char id, bool increase_only,
2700: const ata_smart_values & smartval,
2701: int mailtype, const char * msg)
2702: {
2703: // Find attribute index
2704: int i = ata_find_attr_index(id, smartval);
2705: if (!(i >= 0 && ata_find_attr_index(id, state.smartval) == i))
2706: return;
2707:
2708: // No report if no sectors pending.
2709: uint64_t rawval = ata_get_attr_raw_value(smartval.vendor_attributes[i], cfg.attribute_defs);
2710: if (rawval == 0) {
2711: reset_warning_mail(cfg, state, mailtype, "No more %s", msg);
2712: return;
2713: }
2714:
2715: // If attribute is not reset, report only sector count increases.
2716: uint64_t prev_rawval = ata_get_attr_raw_value(state.smartval.vendor_attributes[i], cfg.attribute_defs);
2717: if (!(!increase_only || prev_rawval < rawval))
2718: return;
2719:
2720: // Format message.
2721: std::string s = strprintf("Device: %s, %"PRId64" %s", cfg.name.c_str(), rawval, msg);
2722: if (prev_rawval > 0 && rawval != prev_rawval)
2723: s += strprintf(" (changed %+"PRId64")", rawval - prev_rawval);
2724:
2725: PrintOut(LOG_CRIT, "%s\n", s.c_str());
2726: MailWarning(cfg, state, mailtype, "%s\n", s.c_str());
2727: state.must_write = true;
2728: }
2729:
2730: // Format Temperature value
2731: static const char * fmt_temp(unsigned char x, char * buf)
2732: {
2733: if (!x) // unset
2734: strcpy(buf, "??");
2735: else
2736: sprintf(buf, "%u", x);
2737: return buf;
2738: }
2739:
2740: // Check Temperature limits
2741: static void CheckTemperature(const dev_config & cfg, dev_state & state, unsigned char currtemp, unsigned char triptemp)
2742: {
2743: if (!(0 < currtemp && currtemp < 255)) {
2744: PrintOut(LOG_INFO, "Device: %s, failed to read Temperature\n", cfg.name.c_str());
2745: return;
2746: }
2747:
2748: // Update Max Temperature
2749: const char * minchg = "", * maxchg = "";
2750: if (currtemp > state.tempmax) {
2751: if (state.tempmax)
2752: maxchg = "!";
2753: state.tempmax = currtemp;
2754: state.must_write = true;
2755: }
2756:
2757: char buf[20];
2758: if (!state.temperature) {
2759: // First check
2760: if (!state.tempmin || currtemp < state.tempmin)
2761: // Delay Min Temperature update by ~ 30 minutes.
2762: state.tempmin_delay = time(0) + CHECKTIME - 60;
2763: PrintOut(LOG_INFO, "Device: %s, initial Temperature is %d Celsius (Min/Max %s/%u%s)\n",
2764: cfg.name.c_str(), (int)currtemp, fmt_temp(state.tempmin, buf), state.tempmax, maxchg);
2765: if (triptemp)
2766: PrintOut(LOG_INFO, " [trip Temperature is %d Celsius]\n", (int)triptemp);
2767: state.temperature = currtemp;
2768: }
2769: else {
2770: if (state.tempmin_delay) {
2771: // End Min Temperature update delay if ...
2772: if ( (state.tempmin && currtemp > state.tempmin) // current temp exceeds recorded min,
2773: || (state.tempmin_delay <= time(0))) { // or delay time is over.
2774: state.tempmin_delay = 0;
2775: if (!state.tempmin)
2776: state.tempmin = 255;
2777: }
2778: }
2779:
2780: // Update Min Temperature
2781: if (!state.tempmin_delay && currtemp < state.tempmin) {
2782: state.tempmin = currtemp;
2783: state.must_write = true;
2784: if (currtemp != state.temperature)
2785: minchg = "!";
2786: }
2787:
2788: // Track changes
2789: if (cfg.tempdiff && (*minchg || *maxchg || abs((int)currtemp - (int)state.temperature) >= cfg.tempdiff)) {
2790: PrintOut(LOG_INFO, "Device: %s, Temperature changed %+d Celsius to %u Celsius (Min/Max %s%s/%u%s)\n",
2791: cfg.name.c_str(), (int)currtemp-(int)state.temperature, currtemp, fmt_temp(state.tempmin, buf), minchg, state.tempmax, maxchg);
2792: state.temperature = currtemp;
2793: }
2794: }
2795:
2796: // Check limits
2797: if (cfg.tempcrit && currtemp >= cfg.tempcrit) {
2798: PrintOut(LOG_CRIT, "Device: %s, Temperature %u Celsius reached critical limit of %u Celsius (Min/Max %s%s/%u%s)\n",
2799: cfg.name.c_str(), currtemp, cfg.tempcrit, fmt_temp(state.tempmin, buf), minchg, state.tempmax, maxchg);
2800: MailWarning(cfg, state, 12, "Device: %s, Temperature %d Celsius reached critical limit of %u Celsius (Min/Max %s%s/%u%s)\n",
2801: cfg.name.c_str(), currtemp, cfg.tempcrit, fmt_temp(state.tempmin, buf), minchg, state.tempmax, maxchg);
2802: }
2803: else if (cfg.tempinfo && currtemp >= cfg.tempinfo) {
2804: PrintOut(LOG_INFO, "Device: %s, Temperature %u Celsius reached limit of %u Celsius (Min/Max %s%s/%u%s)\n",
2805: cfg.name.c_str(), currtemp, cfg.tempinfo, fmt_temp(state.tempmin, buf), minchg, state.tempmax, maxchg);
2806: }
2807: else if (cfg.tempcrit) {
2808: unsigned char limit = (cfg.tempinfo ? cfg.tempinfo : cfg.tempcrit-5);
2809: if (currtemp < limit)
2810: reset_warning_mail(cfg, state, 12, "Temperature %u Celsius dropped below %u Celsius", currtemp, limit);
2811: }
2812: }
2813:
2814: // Check normalized and raw attribute values.
2815: static void check_attribute(const dev_config & cfg, dev_state & state,
2816: const ata_smart_attribute & attr,
2817: const ata_smart_attribute & prev,
2818: int attridx,
2819: const ata_smart_threshold_entry * thresholds)
2820: {
2821: // Check attribute and threshold
2822: ata_attr_state attrstate = ata_get_attr_state(attr, attridx, thresholds, cfg.attribute_defs);
2823: if (attrstate == ATTRSTATE_NON_EXISTING)
2824: return;
2825:
2826: // If requested, check for usage attributes that have failed.
2827: if ( cfg.usagefailed && attrstate == ATTRSTATE_FAILED_NOW
2828: && !cfg.monitor_attr_flags.is_set(attr.id, MONITOR_IGN_FAILUSE)) {
2829: std::string attrname = ata_get_smart_attr_name(attr.id, cfg.attribute_defs);
2830: PrintOut(LOG_CRIT, "Device: %s, Failed SMART usage Attribute: %d %s.\n", cfg.name.c_str(), attr.id, attrname.c_str());
2831: MailWarning(cfg, state, 2, "Device: %s, Failed SMART usage Attribute: %d %s.", cfg.name.c_str(), attr.id, attrname.c_str());
2832: state.must_write = true;
2833: }
2834:
2835: // Return if we're not tracking this type of attribute
2836: bool prefail = !!ATTRIBUTE_FLAGS_PREFAILURE(attr.flags);
2837: if (!( ( prefail && cfg.prefail)
2838: || (!prefail && cfg.usage )))
2839: return;
2840:
2841: // Return if '-I ID' was specified
2842: if (cfg.monitor_attr_flags.is_set(attr.id, MONITOR_IGNORE))
2843: return;
2844:
2845: // Issue warning if they don't have the same ID in all structures.
2846: if (attr.id != prev.id) {
2847: PrintOut(LOG_INFO,"Device: %s, same Attribute has different ID numbers: %d = %d\n",
2848: cfg.name.c_str(), attr.id, prev.id);
2849: return;
2850: }
2851:
2852: // Compare normalized values if valid.
2853: bool valchanged = false;
2854: if (attrstate > ATTRSTATE_NO_NORMVAL) {
2855: if (attr.current != prev.current)
2856: valchanged = true;
2857: }
2858:
2859: // Compare raw values if requested.
2860: bool rawchanged = false;
2861: if (cfg.monitor_attr_flags.is_set(attr.id, MONITOR_RAW)) {
2862: if ( ata_get_attr_raw_value(attr, cfg.attribute_defs)
2863: != ata_get_attr_raw_value(prev, cfg.attribute_defs))
2864: rawchanged = true;
2865: }
2866:
2867: // Return if no change
2868: if (!(valchanged || rawchanged))
2869: return;
2870:
2871: // Format value strings
2872: std::string currstr, prevstr;
2873: if (attrstate == ATTRSTATE_NO_NORMVAL) {
2874: // Print raw values only
2875: currstr = strprintf("%s (Raw)",
2876: ata_format_attr_raw_value(attr, cfg.attribute_defs).c_str());
2877: prevstr = strprintf("%s (Raw)",
2878: ata_format_attr_raw_value(prev, cfg.attribute_defs).c_str());
2879: }
2880: else if (cfg.monitor_attr_flags.is_set(attr.id, MONITOR_RAW_PRINT)) {
2881: // Print normalized and raw values
2882: currstr = strprintf("%d [Raw %s]", attr.current,
2883: ata_format_attr_raw_value(attr, cfg.attribute_defs).c_str());
2884: prevstr = strprintf("%d [Raw %s]", prev.current,
2885: ata_format_attr_raw_value(prev, cfg.attribute_defs).c_str());
2886: }
2887: else {
2888: // Print normalized values only
2889: currstr = strprintf("%d", attr.current);
2890: prevstr = strprintf("%d", prev.current);
2891: }
2892:
2893: // Format message
2894: std::string msg = strprintf("Device: %s, SMART %s Attribute: %d %s changed from %s to %s",
2895: cfg.name.c_str(), (prefail ? "Prefailure" : "Usage"), attr.id,
2896: ata_get_smart_attr_name(attr.id, cfg.attribute_defs).c_str(),
2897: prevstr.c_str(), currstr.c_str());
2898:
2899: // Report this change as critical ?
2900: if ( (valchanged && cfg.monitor_attr_flags.is_set(attr.id, MONITOR_AS_CRIT))
2901: || (rawchanged && cfg.monitor_attr_flags.is_set(attr.id, MONITOR_RAW_AS_CRIT))) {
2902: PrintOut(LOG_CRIT, "%s\n", msg.c_str());
2903: MailWarning(cfg, state, 2, "%s", msg.c_str());
2904: }
2905: else {
2906: PrintOut(LOG_INFO, "%s\n", msg.c_str());
2907: }
2908: state.must_write = true;
2909: }
2910:
2911:
2912: static int ATACheckDevice(const dev_config & cfg, dev_state & state, ata_device * atadev,
2913: bool firstpass, bool allow_selftests)
2914: {
2915: const char * name = cfg.name.c_str();
2916:
2917: // If user has asked, test the email warning system
2918: if (cfg.emailtest)
2919: MailWarning(cfg, state, 0, "TEST EMAIL from smartd for device: %s", name);
2920:
2921: // if we can't open device, fail gracefully rather than hard --
2922: // perhaps the next time around we'll be able to open it. ATAPI
2923: // cd/dvd devices will hang awaiting media if O_NONBLOCK is not
2924: // given (see linux cdrom driver).
2925: if (!atadev->open()) {
2926: PrintOut(LOG_INFO, "Device: %s, open() failed: %s\n", name, atadev->get_errmsg());
2927: MailWarning(cfg, state, 9, "Device: %s, unable to open device", name);
2928: return 1;
2929: }
2930: if (debugmode)
2931: PrintOut(LOG_INFO,"Device: %s, opened ATA device\n", name);
2932: reset_warning_mail(cfg, state, 9, "open device worked again");
2933:
2934: // user may have requested (with the -n Directive) to leave the disk
2935: // alone if it is in idle or sleeping mode. In this case check the
2936: // power mode and exit without check if needed
2937: if (cfg.powermode && !state.powermodefail) {
2938: int dontcheck=0, powermode=ataCheckPowerMode(atadev);
2939: const char * mode = 0;
2940: if (0 <= powermode && powermode < 0xff) {
2941: // wait for possible spin up and check again
2942: int powermode2;
2943: sleep(5);
2944: powermode2 = ataCheckPowerMode(atadev);
2945: if (powermode2 > powermode)
2946: PrintOut(LOG_INFO, "Device: %s, CHECK POWER STATUS spins up disk (0x%02x -> 0x%02x)\n", name, powermode, powermode2);
2947: powermode = powermode2;
2948: }
2949:
2950: switch (powermode){
2951: case -1:
2952: // SLEEP
2953: mode="SLEEP";
2954: if (cfg.powermode>=1)
2955: dontcheck=1;
2956: break;
2957: case 0:
2958: // STANDBY
2959: mode="STANDBY";
2960: if (cfg.powermode>=2)
2961: dontcheck=1;
2962: break;
2963: case 0x80:
2964: // IDLE
2965: mode="IDLE";
2966: if (cfg.powermode>=3)
2967: dontcheck=1;
2968: break;
2969: case 0xff:
2970: // ACTIVE/IDLE
2971: mode="ACTIVE or IDLE";
2972: break;
2973: default:
2974: // UNKNOWN
2975: PrintOut(LOG_CRIT, "Device: %s, CHECK POWER STATUS returned %d, not ATA compliant, ignoring -n Directive\n",
2976: name, powermode);
2977: state.powermodefail = true;
2978: break;
2979: }
2980:
2981: // if we are going to skip a check, return now
2982: if (dontcheck){
2983: // skip at most powerskipmax checks
2984: if (!cfg.powerskipmax || state.powerskipcnt<cfg.powerskipmax) {
2985: CloseDevice(atadev, name);
2986: if (!state.powerskipcnt && !cfg.powerquiet) // report first only and avoid waking up system disk
2987: PrintOut(LOG_INFO, "Device: %s, is in %s mode, suspending checks\n", name, mode);
2988: state.powerskipcnt++;
2989: return 0;
2990: }
2991: else {
2992: PrintOut(LOG_INFO, "Device: %s, %s mode ignored due to reached limit of skipped checks (%d check%s skipped)\n",
2993: name, mode, state.powerskipcnt, (state.powerskipcnt==1?"":"s"));
2994: }
2995: state.powerskipcnt = 0;
2996: state.tempmin_delay = time(0) + CHECKTIME - 60; // Delay Min Temperature update
2997: }
2998: else if (state.powerskipcnt) {
2999: PrintOut(LOG_INFO, "Device: %s, is back in %s mode, resuming checks (%d check%s skipped)\n",
3000: name, mode, state.powerskipcnt, (state.powerskipcnt==1?"":"s"));
3001: state.powerskipcnt = 0;
3002: state.tempmin_delay = time(0) + CHECKTIME - 60; // Delay Min Temperature update
3003: }
3004: }
3005:
3006: // check smart status
3007: if (cfg.smartcheck) {
3008: int status=ataSmartStatus2(atadev);
3009: if (status==-1){
3010: PrintOut(LOG_INFO,"Device: %s, not capable of SMART self-check\n",name);
3011: MailWarning(cfg, state, 5, "Device: %s, not capable of SMART self-check", name);
3012: state.must_write = true;
3013: }
3014: else if (status==1){
3015: PrintOut(LOG_CRIT, "Device: %s, FAILED SMART self-check. BACK UP DATA NOW!\n", name);
3016: MailWarning(cfg, state, 1, "Device: %s, FAILED SMART self-check. BACK UP DATA NOW!", name);
3017: state.must_write = true;
3018: }
3019: }
3020:
3021: // Check everything that depends upon SMART Data (eg, Attribute values)
3022: if ( cfg.usagefailed || cfg.prefail || cfg.usage
3023: || cfg.curr_pending_id || cfg.offl_pending_id
3024: || cfg.tempdiff || cfg.tempinfo || cfg.tempcrit
3025: || cfg.selftest || cfg.offlinests || cfg.selfteststs) {
3026:
3027: // Read current attribute values.
3028: ata_smart_values curval;
3029: if (ataReadSmartValues(atadev, &curval)){
3030: PrintOut(LOG_CRIT, "Device: %s, failed to read SMART Attribute Data\n", name);
3031: MailWarning(cfg, state, 6, "Device: %s, failed to read SMART Attribute Data", name);
3032: state.must_write = true;
3033: }
3034: else {
3035: reset_warning_mail(cfg, state, 6, "read SMART Attribute Data worked again");
3036:
3037: // look for current or offline pending sectors
3038: if (cfg.curr_pending_id)
3039: check_pending(cfg, state, cfg.curr_pending_id, cfg.curr_pending_incr, curval, 10,
3040: (!cfg.curr_pending_incr ? "Currently unreadable (pending) sectors"
3041: : "Total unreadable (pending) sectors" ));
3042:
3043: if (cfg.offl_pending_id)
3044: check_pending(cfg, state, cfg.offl_pending_id, cfg.offl_pending_incr, curval, 11,
3045: (!cfg.offl_pending_incr ? "Offline uncorrectable sectors"
3046: : "Total offline uncorrectable sectors"));
3047:
3048: // check temperature limits
3049: if (cfg.tempdiff || cfg.tempinfo || cfg.tempcrit)
3050: CheckTemperature(cfg, state, ata_return_temperature_value(&curval, cfg.attribute_defs), 0);
3051:
3052: // look for failed usage attributes, or track usage or prefail attributes
3053: if (cfg.usagefailed || cfg.prefail || cfg.usage) {
3054: for (int i = 0; i < NUMBER_ATA_SMART_ATTRIBUTES; i++) {
3055: check_attribute(cfg, state,
3056: curval.vendor_attributes[i],
3057: state.smartval.vendor_attributes[i],
3058: i, state.smartthres.thres_entries);
3059: }
3060: }
3061:
3062: // Log changes of offline data collection status
3063: if (cfg.offlinests) {
3064: if ( curval.offline_data_collection_status
3065: != state.smartval.offline_data_collection_status
3066: || (firstpass && (debugmode || (curval.offline_data_collection_status & 0x7d))))
3067: log_offline_data_coll_status(name, curval.offline_data_collection_status);
3068: }
3069:
3070: // Log changes of self-test execution status
3071: if (cfg.selfteststs) {
3072: if ( curval.self_test_exec_status != state.smartval.self_test_exec_status
3073: || (firstpass && (debugmode || curval.self_test_exec_status != 0x00)))
3074: log_self_test_exec_status(name, curval.self_test_exec_status);
3075: }
3076:
3077: // Save the new values for the next time around
3078: state.smartval = curval;
3079: }
3080: }
3081:
3082: // check if number of selftest errors has increased (note: may also DECREASE)
3083: if (cfg.selftest)
3084: CheckSelfTestLogs(cfg, state, SelfTestErrorCount(atadev, name, cfg.fix_firmwarebug));
3085:
3086: // check if number of ATA errors has increased
3087: if (cfg.errorlog || cfg.xerrorlog) {
3088:
3089: int errcnt1 = -1, errcnt2 = -1;
3090: if (cfg.errorlog)
3091: errcnt1 = read_ata_error_count(atadev, name, cfg.fix_firmwarebug, false);
3092: if (cfg.xerrorlog)
3093: errcnt2 = read_ata_error_count(atadev, name, cfg.fix_firmwarebug, true);
3094:
3095: // new number of errors is max of both logs
3096: int newc = (errcnt1 >= errcnt2 ? errcnt1 : errcnt2);
3097:
3098: // did command fail?
3099: if (newc<0)
3100: // lack of PrintOut here is INTENTIONAL
3101: MailWarning(cfg, state, 7, "Device: %s, Read SMART Error Log Failed", name);
3102:
3103: // has error count increased?
3104: int oldc = state.ataerrorcount;
3105: if (newc>oldc){
3106: PrintOut(LOG_CRIT, "Device: %s, ATA error count increased from %d to %d\n",
3107: name, oldc, newc);
3108: MailWarning(cfg, state, 4, "Device: %s, ATA error count increased from %d to %d",
3109: name, oldc, newc);
3110: state.must_write = true;
3111: }
3112:
3113: if (newc>=0)
3114: state.ataerrorcount=newc;
3115: }
3116:
3117: // if the user has asked, and device is capable (or we're not yet
3118: // sure) check whether a self test should be done now.
3119: if (allow_selftests && !cfg.test_regex.empty()) {
3120: char testtype = next_scheduled_test(cfg, state, false/*!scsi*/);
3121: if (testtype)
3122: DoATASelfTest(cfg, state, atadev, testtype);
3123: }
3124:
3125: // Don't leave device open -- the OS/user may want to access it
3126: // before the next smartd cycle!
3127: CloseDevice(atadev, name);
3128:
3129: // Copy ATA attribute values to persistent state
3130: state.update_persistent_state();
3131:
3132: return 0;
3133: }
3134:
3135: static int SCSICheckDevice(const dev_config & cfg, dev_state & state, scsi_device * scsidev, bool allow_selftests)
3136: {
3137: UINT8 asc, ascq;
3138: UINT8 currenttemp;
3139: UINT8 triptemp;
3140: const char * name = cfg.name.c_str();
3141: const char *cp;
3142:
3143: // If the user has asked for it, test the email warning system
3144: if (cfg.emailtest)
3145: MailWarning(cfg, state, 0, "TEST EMAIL from smartd for device: %s", name);
3146:
3147: // if we can't open device, fail gracefully rather than hard --
3148: // perhaps the next time around we'll be able to open it
3149: if (!scsidev->open()) {
3150: PrintOut(LOG_INFO, "Device: %s, open() failed: %s\n", name, scsidev->get_errmsg());
3151: MailWarning(cfg, state, 9, "Device: %s, unable to open device", name);
3152: return 1;
3153: } else if (debugmode)
3154: PrintOut(LOG_INFO,"Device: %s, opened SCSI device\n", name);
3155: currenttemp = 0;
3156: asc = 0;
3157: ascq = 0;
3158: if (!state.SuppressReport) {
3159: if (scsiCheckIE(scsidev, state.SmartPageSupported, state.TempPageSupported,
3160: &asc, &ascq, ¤ttemp, &triptemp)) {
3161: PrintOut(LOG_INFO, "Device: %s, failed to read SMART values\n",
3162: name);
3163: MailWarning(cfg, state, 6, "Device: %s, failed to read SMART values", name);
3164: state.SuppressReport = 1;
3165: }
3166: }
3167: if (asc > 0) {
3168: cp = scsiGetIEString(asc, ascq);
3169: if (cp) {
3170: PrintOut(LOG_CRIT, "Device: %s, SMART Failure: %s\n", name, cp);
3171: MailWarning(cfg, state, 1,"Device: %s, SMART Failure: %s", name, cp);
3172: } else if (debugmode)
3173: PrintOut(LOG_INFO,"Device: %s, non-SMART asc,ascq: %d,%d\n",
3174: name, (int)asc, (int)ascq);
3175: } else if (debugmode)
3176: PrintOut(LOG_INFO,"Device: %s, SMART health: passed\n", name);
3177:
3178: // check temperature limits
3179: if (cfg.tempdiff || cfg.tempinfo || cfg.tempcrit)
3180: CheckTemperature(cfg, state, currenttemp, triptemp);
3181:
3182: // check if number of selftest errors has increased (note: may also DECREASE)
3183: if (cfg.selftest)
3184: CheckSelfTestLogs(cfg, state, scsiCountFailedSelfTests(scsidev, 0));
3185:
3186: if (allow_selftests && !cfg.test_regex.empty()) {
3187: char testtype = next_scheduled_test(cfg, state, true/*scsi*/);
3188: if (testtype)
3189: DoSCSISelfTest(cfg, state, scsidev, testtype);
3190: }
3191: CloseDevice(scsidev, name);
3192: return 0;
3193: }
3194:
3195: // Checks the SMART status of all ATA and SCSI devices
3196: static void CheckDevicesOnce(const dev_config_vector & configs, dev_state_vector & states,
3197: smart_device_list & devices, bool firstpass, bool allow_selftests)
3198: {
3199: for (unsigned i = 0; i < configs.size(); i++) {
3200: const dev_config & cfg = configs.at(i);
3201: dev_state & state = states.at(i);
3202: smart_device * dev = devices.at(i);
3203: if (dev->is_ata())
3204: ATACheckDevice(cfg, state, dev->to_ata(), firstpass, allow_selftests);
3205: else if (dev->is_scsi())
3206: SCSICheckDevice(cfg, state, dev->to_scsi(), allow_selftests);
3207: }
3208: }
3209:
3210: // Set if Initialize() was called
3211: static bool is_initialized = false;
3212:
3213: // Does initialization right after fork to daemon mode
3214: static void Initialize(time_t *wakeuptime)
3215: {
3216: // Call Goodbye() on exit
3217: is_initialized = true;
3218:
3219: // write PID file
3220: if (!debugmode)
3221: WritePidFile();
3222:
3223: // install signal handlers. On Solaris, can't use signal() because
3224: // it resets the handler to SIG_DFL after each call. So use sigset()
3225: // instead. So SIGNALFN()==signal() or SIGNALFN()==sigset().
3226:
3227: // normal and abnormal exit
3228: if (SIGNALFN(SIGTERM, sighandler)==SIG_IGN)
3229: SIGNALFN(SIGTERM, SIG_IGN);
3230: if (SIGNALFN(SIGQUIT, sighandler)==SIG_IGN)
3231: SIGNALFN(SIGQUIT, SIG_IGN);
3232:
3233: // in debug mode, <CONTROL-C> ==> HUP
3234: if (SIGNALFN(SIGINT, debugmode?HUPhandler:sighandler)==SIG_IGN)
3235: SIGNALFN(SIGINT, SIG_IGN);
3236:
3237: // Catch HUP and USR1
3238: if (SIGNALFN(SIGHUP, HUPhandler)==SIG_IGN)
3239: SIGNALFN(SIGHUP, SIG_IGN);
3240: if (SIGNALFN(SIGUSR1, USR1handler)==SIG_IGN)
3241: SIGNALFN(SIGUSR1, SIG_IGN);
3242: #ifdef _WIN32
3243: if (SIGNALFN(SIGUSR2, USR2handler)==SIG_IGN)
3244: SIGNALFN(SIGUSR2, SIG_IGN);
3245: #endif
3246:
3247: // initialize wakeup time to CURRENT time
3248: *wakeuptime=time(NULL);
3249:
3250: return;
3251: }
3252:
3253: #ifdef _WIN32
3254: // Toggle debug mode implemented for native windows only
3255: // (there is no easy way to reopen tty on *nix)
3256: static void ToggleDebugMode()
3257: {
3258: if (!debugmode) {
3259: PrintOut(LOG_INFO,"Signal USR2 - enabling debug mode\n");
3260: if (!daemon_enable_console("smartd [Debug]")) {
3261: debugmode = 1;
3262: daemon_signal(SIGINT, HUPhandler);
3263: PrintOut(LOG_INFO,"smartd debug mode enabled, PID=%d\n", getpid());
3264: }
3265: else
3266: PrintOut(LOG_INFO,"enable console failed\n");
3267: }
3268: else if (debugmode == 1) {
3269: daemon_disable_console();
3270: debugmode = 0;
3271: daemon_signal(SIGINT, sighandler);
3272: PrintOut(LOG_INFO,"Signal USR2 - debug mode disabled\n");
3273: }
3274: else
3275: PrintOut(LOG_INFO,"Signal USR2 - debug mode %d not changed\n", debugmode);
3276: }
3277: #endif
3278:
3279: static time_t dosleep(time_t wakeuptime, bool & sigwakeup)
3280: {
3281: // If past wake-up-time, compute next wake-up-time
3282: time_t timenow=time(NULL);
3283: while (wakeuptime<=timenow){
3284: int intervals=1+(timenow-wakeuptime)/checktime;
3285: wakeuptime+=intervals*checktime;
3286: }
3287:
3288: // sleep until we catch SIGUSR1 or have completed sleeping
3289: int addtime = 0;
3290: while (timenow < wakeuptime+addtime && !caughtsigUSR1 && !caughtsigHUP && !caughtsigEXIT) {
3291:
3292: // protect user again system clock being adjusted backwards
3293: if (wakeuptime>timenow+checktime){
3294: PrintOut(LOG_CRIT, "System clock time adjusted to the past. Resetting next wakeup time.\n");
3295: wakeuptime=timenow+checktime;
3296: }
3297:
3298: // Exit sleep when time interval has expired or a signal is received
3299: sleep(wakeuptime+addtime-timenow);
3300:
3301: #ifdef _WIN32
3302: // toggle debug mode?
3303: if (caughtsigUSR2) {
3304: ToggleDebugMode();
3305: caughtsigUSR2 = 0;
3306: }
3307: #endif
3308:
3309: timenow=time(NULL);
3310:
3311: // Actual sleep time too long?
3312: if (!addtime && timenow > wakeuptime+60) {
3313: if (debugmode)
3314: PrintOut(LOG_INFO, "Sleep time was %d seconds too long, assuming wakeup from standby mode.\n",
3315: (int)(timenow-wakeuptime));
3316: // Wait another 20 seconds to avoid I/O errors during disk spin-up
3317: addtime = timenow-wakeuptime+20;
3318: // Use next wake-up-time if close
3319: int nextcheck = checktime - addtime % checktime;
3320: if (nextcheck <= 20)
3321: addtime += nextcheck;
3322: }
3323: }
3324:
3325: // if we caught a SIGUSR1 then print message and clear signal
3326: if (caughtsigUSR1){
3327: PrintOut(LOG_INFO,"Signal USR1 - checking devices now rather than in %d seconds.\n",
3328: wakeuptime-timenow>0?(int)(wakeuptime-timenow):0);
3329: caughtsigUSR1=0;
3330: sigwakeup = true;
3331: }
3332:
3333: // return adjusted wakeuptime
3334: return wakeuptime;
3335: }
3336:
3337: // Print out a list of valid arguments for the Directive d
3338: static void printoutvaliddirectiveargs(int priority, char d)
3339: {
3340: switch (d) {
3341: case 'n':
3342: PrintOut(priority, "never[,N][,q], sleep[,N][,q], standby[,N][,q], idle[,N][,q]");
3343: break;
3344: case 's':
3345: PrintOut(priority, "valid_regular_expression");
3346: break;
3347: case 'd':
3348: PrintOut(priority, "%s", smi()->get_valid_dev_types_str().c_str());
3349: break;
3350: case 'T':
3351: PrintOut(priority, "normal, permissive");
3352: break;
3353: case 'o':
3354: case 'S':
3355: PrintOut(priority, "on, off");
3356: break;
3357: case 'l':
3358: PrintOut(priority, "error, selftest");
3359: break;
3360: case 'M':
3361: PrintOut(priority, "\"once\", \"daily\", \"diminishing\", \"test\", \"exec\"");
3362: break;
3363: case 'v':
3364: PrintOut(priority, "\n%s\n", create_vendor_attribute_arg_list().c_str());
3365: break;
3366: case 'P':
3367: PrintOut(priority, "use, ignore, show, showall");
3368: break;
3369: case 'F':
3370: PrintOut(priority, "none, samsung, samsung2, samsung3");
3371: break;
3372: }
3373: }
3374:
3375: // exits with an error message, or returns integer value of token
3376: static int GetInteger(const char *arg, const char *name, const char *token, int lineno, const char *cfgfile,
3377: int min, int max, char * suffix = 0)
3378: {
3379: // make sure argument is there
3380: if (!arg) {
3381: PrintOut(LOG_CRIT,"File %s line %d (drive %s): Directive: %s takes integer argument from %d to %d.\n",
3382: cfgfile, lineno, name, token, min, max);
3383: return -1;
3384: }
3385:
3386: // get argument value (base 10), check that it's integer, and in-range
3387: char *endptr;
3388: int val = strtol(arg,&endptr,10);
3389:
3390: // optional suffix present?
3391: if (suffix) {
3392: if (!strcmp(endptr, suffix))
3393: endptr += strlen(suffix);
3394: else
3395: *suffix = 0;
3396: }
3397:
3398: if (!(!*endptr && min <= val && val <= max)) {
3399: PrintOut(LOG_CRIT,"File %s line %d (drive %s): Directive: %s has argument: %s; needs integer from %d to %d.\n",
3400: cfgfile, lineno, name, token, arg, min, max);
3401: return -1;
3402: }
3403:
3404: // all is well; return value
3405: return val;
3406: }
3407:
3408:
3409: // Get 1-3 small integer(s) for '-W' directive
3410: static int Get3Integers(const char *arg, const char *name, const char *token, int lineno, const char *cfgfile,
3411: unsigned char *val1, unsigned char *val2, unsigned char *val3)
3412: {
3413: unsigned v1 = 0, v2 = 0, v3 = 0;
3414: int n1 = -1, n2 = -1, n3 = -1, len;
3415: if (!arg) {
3416: PrintOut(LOG_CRIT,"File %s line %d (drive %s): Directive: %s takes 1-3 integer argument(s) from 0 to 255.\n",
3417: cfgfile, lineno, name, token);
3418: return -1;
3419: }
3420:
3421: len = strlen(arg);
3422: if (!( sscanf(arg, "%u%n,%u%n,%u%n", &v1, &n1, &v2, &n2, &v3, &n3) >= 1
3423: && (n1 == len || n2 == len || n3 == len) && v1 <= 255 && v2 <= 255 && v3 <= 255)) {
3424: PrintOut(LOG_CRIT,"File %s line %d (drive %s): Directive: %s has argument: %s; needs 1-3 integer(s) from 0 to 255.\n",
3425: cfgfile, lineno, name, token, arg);
3426: return -1;
3427: }
3428: *val1 = (unsigned char)v1; *val2 = (unsigned char)v2; *val3 = (unsigned char)v3;
3429: return 0;
3430: }
3431:
3432:
3433: // This function returns 1 if it has correctly parsed one token (and
3434: // any arguments), else zero if no tokens remain. It returns -1 if an
3435: // error was encountered.
3436: static int ParseToken(char * token, dev_config & cfg)
3437: {
3438: char sym;
3439: const char * name = cfg.name.c_str();
3440: int lineno=cfg.lineno;
3441: const char *delim = " \n\t";
3442: int badarg = 0;
3443: int missingarg = 0;
3444: const char *arg = 0;
3445:
3446: // is the rest of the line a comment
3447: if (*token=='#')
3448: return 1;
3449:
3450: // is the token not recognized?
3451: if (*token!='-' || strlen(token)!=2) {
3452: PrintOut(LOG_CRIT,"File %s line %d (drive %s): unknown Directive: %s\n",
3453: configfile, lineno, name, token);
3454: PrintOut(LOG_CRIT, "Run smartd -D to print a list of valid Directives.\n");
3455: return -1;
3456: }
3457:
3458: // token we will be parsing:
3459: sym=token[1];
3460:
3461: // parse the token and swallow its argument
3462: int val;
3463: char plus[] = "+", excl[] = "!";
3464:
3465: switch (sym) {
3466: case 'C':
3467: // monitor current pending sector count (default 197)
3468: if ((val = GetInteger(arg=strtok(NULL,delim), name, token, lineno, configfile, 0, 255, plus)) < 0)
3469: return -1;
3470: cfg.curr_pending_id = (unsigned char)val;
3471: cfg.curr_pending_incr = (*plus == '+');
3472: cfg.curr_pending_set = true;
3473: break;
3474: case 'U':
3475: // monitor offline uncorrectable sectors (default 198)
3476: if ((val = GetInteger(arg=strtok(NULL,delim), name, token, lineno, configfile, 0, 255, plus)) < 0)
3477: return -1;
3478: cfg.offl_pending_id = (unsigned char)val;
3479: cfg.offl_pending_incr = (*plus == '+');
3480: cfg.offl_pending_set = true;
3481: break;
3482: case 'T':
3483: // Set tolerance level for SMART command failures
3484: if ((arg = strtok(NULL, delim)) == NULL) {
3485: missingarg = 1;
3486: } else if (!strcmp(arg, "normal")) {
3487: // Normal mode: exit on failure of a mandatory S.M.A.R.T. command, but
3488: // not on failure of an optional S.M.A.R.T. command.
3489: // This is the default so we don't need to actually do anything here.
3490: cfg.permissive = false;
3491: } else if (!strcmp(arg, "permissive")) {
3492: // Permissive mode; ignore errors from Mandatory SMART commands
3493: cfg.permissive = true;
3494: } else {
3495: badarg = 1;
3496: }
3497: break;
3498: case 'd':
3499: // specify the device type
3500: if ((arg = strtok(NULL, delim)) == NULL) {
3501: missingarg = 1;
3502: } else if (!strcmp(arg, "removable")) {
3503: cfg.removable = true;
3504: } else if (!strcmp(arg, "auto")) {
3505: cfg.dev_type = "";
3506: } else {
3507: cfg.dev_type = arg;
3508: }
3509: break;
3510: case 'F':
3511: // fix firmware bug
3512: if ((arg = strtok(NULL, delim)) == NULL) {
3513: missingarg = 1;
3514: } else if (!strcmp(arg, "none")) {
3515: cfg.fix_firmwarebug = FIX_NONE;
3516: } else if (!strcmp(arg, "samsung")) {
3517: cfg.fix_firmwarebug = FIX_SAMSUNG;
3518: } else if (!strcmp(arg, "samsung2")) {
3519: cfg.fix_firmwarebug = FIX_SAMSUNG2;
3520: } else if (!strcmp(arg, "samsung3")) {
3521: cfg.fix_firmwarebug = FIX_SAMSUNG3;
3522: } else {
3523: badarg = 1;
3524: }
3525: break;
3526: case 'H':
3527: // check SMART status
3528: cfg.smartcheck = true;
3529: break;
3530: case 'f':
3531: // check for failure of usage attributes
3532: cfg.usagefailed = true;
3533: break;
3534: case 't':
3535: // track changes in all vendor attributes
3536: cfg.prefail = true;
3537: cfg.usage = true;
3538: break;
3539: case 'p':
3540: // track changes in prefail vendor attributes
3541: cfg.prefail = true;
3542: break;
3543: case 'u':
3544: // track changes in usage vendor attributes
3545: cfg.usage = true;
3546: break;
3547: case 'l':
3548: // track changes in SMART logs
3549: if ((arg = strtok(NULL, delim)) == NULL) {
3550: missingarg = 1;
3551: } else if (!strcmp(arg, "selftest")) {
3552: // track changes in self-test log
3553: cfg.selftest = true;
3554: } else if (!strcmp(arg, "error")) {
3555: // track changes in ATA error log
3556: cfg.errorlog = true;
3557: } else if (!strcmp(arg, "xerror")) {
3558: // track changes in Extended Comprehensive SMART error log
3559: cfg.xerrorlog = true;
3560: } else if (!strcmp(arg, "offlinests")) {
3561: // track changes in offline data collection status
3562: cfg.offlinests = true;
3563: } else if (!strcmp(arg, "selfteststs")) {
3564: // track changes in self-test execution status
3565: cfg.selfteststs = true;
3566: } else if (!strncmp(arg, "scterc,", sizeof("scterc,")-1)) {
3567: // set SCT Error Recovery Control
3568: unsigned rt = ~0, wt = ~0; int nc = -1;
3569: sscanf(arg,"scterc,%u,%u%n", &rt, &wt, &nc);
3570: if (nc == (int)strlen(arg) && rt <= 999 && wt <= 999) {
3571: cfg.sct_erc_set = true;
3572: cfg.sct_erc_readtime = rt;
3573: cfg.sct_erc_writetime = wt;
3574: }
3575: else
3576: badarg = 1;
3577: } else {
3578: badarg = 1;
3579: }
3580: break;
3581: case 'a':
3582: // monitor everything
3583: cfg.smartcheck = true;
3584: cfg.prefail = true;
3585: cfg.usagefailed = true;
3586: cfg.usage = true;
3587: cfg.selftest = true;
3588: cfg.errorlog = true;
3589: cfg.selfteststs = true;
3590: break;
3591: case 'o':
3592: // automatic offline testing enable/disable
3593: if ((arg = strtok(NULL, delim)) == NULL) {
3594: missingarg = 1;
3595: } else if (!strcmp(arg, "on")) {
3596: cfg.autoofflinetest = 2;
3597: } else if (!strcmp(arg, "off")) {
3598: cfg.autoofflinetest = 1;
3599: } else {
3600: badarg = 1;
3601: }
3602: break;
3603: case 'n':
3604: // skip disk check if in idle or standby mode
3605: if (!(arg = strtok(NULL, delim)))
3606: missingarg = 1;
3607: else {
3608: char *endptr = NULL;
3609: char *next = strchr(const_cast<char*>(arg), ',');
3610:
3611: cfg.powerquiet = false;
3612: cfg.powerskipmax = 0;
3613:
3614: if (next!=NULL) *next='\0';
3615: if (!strcmp(arg, "never"))
3616: cfg.powermode = 0;
3617: else if (!strcmp(arg, "sleep"))
3618: cfg.powermode = 1;
3619: else if (!strcmp(arg, "standby"))
3620: cfg.powermode = 2;
3621: else if (!strcmp(arg, "idle"))
3622: cfg.powermode = 3;
3623: else
3624: badarg = 1;
3625:
3626: // if optional arguments are present
3627: if (!badarg && next!=NULL) {
3628: next++;
3629: cfg.powerskipmax = strtol(next, &endptr, 10);
3630: if (endptr == next)
3631: cfg.powerskipmax = 0;
3632: else {
3633: next = endptr + (*endptr != '\0');
3634: if (cfg.powerskipmax <= 0)
3635: badarg = 1;
3636: }
3637: if (*next != '\0') {
3638: if (!strcmp("q", next))
3639: cfg.powerquiet = true;
3640: else {
3641: badarg = 1;
3642: }
3643: }
3644: }
3645: }
3646: break;
3647: case 'S':
3648: // automatic attribute autosave enable/disable
3649: if ((arg = strtok(NULL, delim)) == NULL) {
3650: missingarg = 1;
3651: } else if (!strcmp(arg, "on")) {
3652: cfg.autosave = 2;
3653: } else if (!strcmp(arg, "off")) {
3654: cfg.autosave = 1;
3655: } else {
3656: badarg = 1;
3657: }
3658: break;
3659: case 's':
3660: // warn user, and delete any previously given -s REGEXP Directives
3661: if (!cfg.test_regex.empty()){
3662: PrintOut(LOG_INFO, "File %s line %d (drive %s): ignoring previous Test Directive -s %s\n",
3663: configfile, lineno, name, cfg.test_regex.get_pattern());
3664: cfg.test_regex = regular_expression();
3665: }
3666: // check for missing argument
3667: if (!(arg = strtok(NULL, delim))) {
3668: missingarg = 1;
3669: }
3670: // Compile regex
3671: else {
3672: if (!cfg.test_regex.compile(arg, REG_EXTENDED)) {
3673: // not a valid regular expression!
3674: PrintOut(LOG_CRIT, "File %s line %d (drive %s): -s argument \"%s\" is INVALID extended regular expression. %s.\n",
3675: configfile, lineno, name, arg, cfg.test_regex.get_errmsg());
3676: return -1;
3677: }
3678: }
3679: // Do a bit of sanity checking and warn user if we think that
3680: // their regexp is "strange". User probably confused about shell
3681: // glob(3) syntax versus regular expression syntax regexp(7).
3682: if (arg[(val = strspn(arg, "0123456789/.-+*|()?^$[]SLCOcnr"))])
3683: PrintOut(LOG_INFO, "File %s line %d (drive %s): warning, character %d (%c) looks odd in extended regular expression %s\n",
3684: configfile, lineno, name, val+1, arg[val], arg);
3685: break;
3686: case 'm':
3687: // send email to address that follows
3688: if (!(arg = strtok(NULL,delim)))
3689: missingarg = 1;
3690: else {
3691: if (!cfg.emailaddress.empty())
3692: PrintOut(LOG_INFO, "File %s line %d (drive %s): ignoring previous Address Directive -m %s\n",
3693: configfile, lineno, name, cfg.emailaddress.c_str());
3694: cfg.emailaddress = arg;
3695: }
3696: break;
3697: case 'M':
3698: // email warning options
3699: if (!(arg = strtok(NULL, delim)))
3700: missingarg = 1;
3701: else if (!strcmp(arg, "once"))
3702: cfg.emailfreq = 1;
3703: else if (!strcmp(arg, "daily"))
3704: cfg.emailfreq = 2;
3705: else if (!strcmp(arg, "diminishing"))
3706: cfg.emailfreq = 3;
3707: else if (!strcmp(arg, "test"))
3708: cfg.emailtest = 1;
3709: else if (!strcmp(arg, "exec")) {
3710: // Get the next argument (the command line)
3711: if (!(arg = strtok(NULL, delim))) {
3712: PrintOut(LOG_CRIT, "File %s line %d (drive %s): Directive %s 'exec' argument must be followed by executable path.\n",
3713: configfile, lineno, name, token);
3714: return -1;
3715: }
3716: // Free the last cmd line given if any, and copy new one
3717: if (!cfg.emailcmdline.empty())
3718: PrintOut(LOG_INFO, "File %s line %d (drive %s): ignoring previous mail Directive -M exec %s\n",
3719: configfile, lineno, name, cfg.emailcmdline.c_str());
3720: cfg.emailcmdline = arg;
3721: }
3722: else
3723: badarg = 1;
3724: break;
3725: case 'i':
3726: // ignore failure of usage attribute
3727: if ((val=GetInteger(arg=strtok(NULL,delim), name, token, lineno, configfile, 1, 255))<0)
3728: return -1;
3729: cfg.monitor_attr_flags.set(val, MONITOR_IGN_FAILUSE);
3730: break;
3731: case 'I':
3732: // ignore attribute for tracking purposes
3733: if ((val=GetInteger(arg=strtok(NULL,delim), name, token, lineno, configfile, 1, 255))<0)
3734: return -1;
3735: cfg.monitor_attr_flags.set(val, MONITOR_IGNORE);
3736: break;
3737: case 'r':
3738: // print raw value when tracking
3739: if ((val = GetInteger(arg=strtok(NULL,delim), name, token, lineno, configfile, 1, 255, excl)) < 0)
3740: return -1;
3741: cfg.monitor_attr_flags.set(val, MONITOR_RAW_PRINT);
3742: if (*excl == '!') // attribute change is critical
3743: cfg.monitor_attr_flags.set(val, MONITOR_AS_CRIT);
3744: break;
3745: case 'R':
3746: // track changes in raw value (forces printing of raw value)
3747: if ((val = GetInteger(arg=strtok(NULL,delim), name, token, lineno, configfile, 1, 255, excl)) < 0)
3748: return -1;
3749: cfg.monitor_attr_flags.set(val, MONITOR_RAW_PRINT|MONITOR_RAW);
3750: if (*excl == '!') // raw value change is critical
3751: cfg.monitor_attr_flags.set(val, MONITOR_RAW_AS_CRIT);
3752: break;
3753: case 'W':
3754: // track Temperature
3755: if ((val=Get3Integers(arg=strtok(NULL,delim), name, token, lineno, configfile,
3756: &cfg.tempdiff, &cfg.tempinfo, &cfg.tempcrit))<0)
3757: return -1;
3758: break;
3759: case 'v':
3760: // non-default vendor-specific attribute meaning
3761: if (!(arg=strtok(NULL,delim))) {
3762: missingarg = 1;
3763: } else if (!parse_attribute_def(arg, cfg.attribute_defs, PRIOR_USER)) {
3764: badarg = 1;
3765: }
3766: break;
3767: case 'P':
3768: // Define use of drive-specific presets.
3769: if (!(arg = strtok(NULL, delim))) {
3770: missingarg = 1;
3771: } else if (!strcmp(arg, "use")) {
3772: cfg.ignorepresets = false;
3773: } else if (!strcmp(arg, "ignore")) {
3774: cfg.ignorepresets = true;
3775: } else if (!strcmp(arg, "show")) {
3776: cfg.showpresets = true;
3777: } else if (!strcmp(arg, "showall")) {
3778: showallpresets();
3779: } else {
3780: badarg = 1;
3781: }
3782: break;
3783: default:
3784: // Directive not recognized
3785: PrintOut(LOG_CRIT,"File %s line %d (drive %s): unknown Directive: %s\n",
3786: configfile, lineno, name, token);
3787: Directives();
3788: return -1;
3789: }
3790: if (missingarg) {
3791: PrintOut(LOG_CRIT, "File %s line %d (drive %s): Missing argument to %s Directive\n",
3792: configfile, lineno, name, token);
3793: }
3794: if (badarg) {
3795: PrintOut(LOG_CRIT, "File %s line %d (drive %s): Invalid argument to %s Directive: %s\n",
3796: configfile, lineno, name, token, arg);
3797: }
3798: if (missingarg || badarg) {
3799: PrintOut(LOG_CRIT, "Valid arguments to %s Directive are: ", token);
3800: printoutvaliddirectiveargs(LOG_CRIT, sym);
3801: PrintOut(LOG_CRIT, "\n");
3802: return -1;
3803: }
3804:
3805: return 1;
3806: }
3807:
3808: // Scan directive for configuration file
3809: #define SCANDIRECTIVE "DEVICESCAN"
3810:
3811: // This is the routine that adds things to the conf_entries list.
3812: //
3813: // Return values are:
3814: // 1: parsed a normal line
3815: // 0: found comment or blank line
3816: // -1: found SCANDIRECTIVE line
3817: // -2: found an error
3818: //
3819: // Note: this routine modifies *line from the caller!
3820: static int ParseConfigLine(dev_config_vector & conf_entries, int /*entry*/, int lineno, /*const*/ char * line)
3821: {
3822: char *token=NULL;
3823: char *name=NULL;
3824: const char *delim = " \n\t";
3825: int devscan=0;
3826:
3827: // get first token: device name. If a comment, skip line
3828: if (!(name=strtok(line,delim)) || *name=='#') {
3829: return 0;
3830: }
3831:
3832: // Have we detected the SCANDIRECTIVE directive?
3833: if (!strcmp(SCANDIRECTIVE,name)){
3834: devscan=1;
3835: }
3836:
3837: // We've got a legit entry, make space to store it
3838: conf_entries.push_back( dev_config() );
3839: dev_config & cfg = conf_entries.back();
3840:
3841: cfg.name = name; // Later replaced by dev->get_info().info_name
3842: cfg.dev_name = name; // If DEVICESCAN later replaced by get->dev_info().dev_name
3843:
3844: // Store line number, and by default check for both device types.
3845: cfg.lineno=lineno;
3846:
3847: // parse tokens one at a time from the file.
3848: while ((token=strtok(NULL,delim))){
3849: int retval=ParseToken(token,cfg);
3850:
3851: if (retval==0)
3852: // No tokens left:
3853: break;
3854:
3855: if (retval>0) {
3856: // Parsed token
3857: #if (0)
3858: PrintOut(LOG_INFO,"Parsed token %s\n",token);
3859: #endif
3860: continue;
3861: }
3862:
3863: if (retval<0) {
3864: // error found on the line
3865: return -2;
3866: }
3867: }
3868:
3869: // If NO monitoring directives are set, then set all of them.
3870: if (!( cfg.smartcheck || cfg.selftest
3871: || cfg.errorlog || cfg.xerrorlog
3872: || cfg.offlinests || cfg.selfteststs
3873: || cfg.usagefailed || cfg.prefail || cfg.usage
3874: || cfg.tempdiff || cfg.tempinfo || cfg.tempcrit)) {
3875:
3876: PrintOut(LOG_INFO,"Drive: %s, implied '-a' Directive on line %d of file %s\n",
3877: cfg.name.c_str(), cfg.lineno, configfile);
3878:
3879: cfg.smartcheck = true;
3880: cfg.usagefailed = true;
3881: cfg.prefail = true;
3882: cfg.usage = true;
3883: cfg.selftest = true;
3884: cfg.errorlog = true;
3885: cfg.selfteststs = true;
3886: }
3887:
3888: // additional sanity check. Has user set -M options without -m?
3889: if (cfg.emailaddress.empty() && (!cfg.emailcmdline.empty() || cfg.emailfreq || cfg.emailtest)){
3890: PrintOut(LOG_CRIT,"Drive: %s, -M Directive(s) on line %d of file %s need -m ADDRESS Directive\n",
3891: cfg.name.c_str(), cfg.lineno, configfile);
3892: return -2;
3893: }
3894:
3895: // has the user has set <nomailer>?
3896: if (cfg.emailaddress == "<nomailer>") {
3897: // check that -M exec is also set
3898: if (cfg.emailcmdline.empty()){
3899: PrintOut(LOG_CRIT,"Drive: %s, -m <nomailer> Directive on line %d of file %s needs -M exec Directive\n",
3900: cfg.name.c_str(), cfg.lineno, configfile);
3901: return -2;
3902: }
3903: // From here on the sign of <nomailer> is address.empty() and !cfg.emailcmdline.empty()
3904: cfg.emailaddress.clear();
3905: }
3906:
3907: if (devscan)
3908: return -1;
3909: else
3910: return 1;
3911: }
3912:
3913: // Parses a configuration file. Return values are:
3914: // N=>0: found N entries
3915: // -1: syntax error in config file
3916: // -2: config file does not exist
3917: // -3: config file exists but cannot be read
3918: //
3919: // In the case where the return value is 0, there are three
3920: // possiblities:
3921: // Empty configuration file ==> conf_entries.empty()
3922: // No configuration file ==> conf_entries[0].lineno == 0
3923: // SCANDIRECTIVE found ==> conf_entries.back().lineno != 0 (size >= 1)
3924: static int ParseConfigFile(dev_config_vector & conf_entries)
3925: {
3926: // maximum line length in configuration file
3927: const int MAXLINELEN = 256;
3928: // maximum length of a continued line in configuration file
3929: const int MAXCONTLINE = 1023;
3930:
3931: stdio_file f;
3932: // Open config file, if it exists and is not <stdin>
3933: if (!(configfile == configfile_stdin)) { // pointer comparison ok here
3934: if (!f.open(configfile,"r") && (errno!=ENOENT || !configfile_alt.empty())) {
3935: // file exists but we can't read it or it should exist due to '-c' option
3936: int ret = (errno!=ENOENT ? -3 : -2);
3937: PrintOut(LOG_CRIT,"%s: Unable to open configuration file %s\n",
3938: strerror(errno),configfile);
3939: return ret;
3940: }
3941: }
3942: else // read from stdin ('-c -' option)
3943: f.open(stdin);
3944:
3945: // No configuration file found -- use fake one
3946: int entry = 0;
3947: if (!f) {
3948: char fakeconfig[] = SCANDIRECTIVE" -a"; // TODO: Remove this hack, build cfg_entry.
3949:
3950: if (ParseConfigLine(conf_entries, entry, 0, fakeconfig) != -1)
3951: throw std::logic_error("Internal error parsing "SCANDIRECTIVE);
3952: return 0;
3953: }
3954:
3955: #ifdef __CYGWIN__
3956: setmode(fileno(f), O_TEXT); // Allow files with \r\n
3957: #endif
3958:
3959: // configuration file exists
3960: PrintOut(LOG_INFO,"Opened configuration file %s\n",configfile);
3961:
3962: // parse config file line by line
3963: int lineno = 1, cont = 0, contlineno = 0;
3964: char line[MAXLINELEN+2];
3965: char fullline[MAXCONTLINE+1];
3966:
3967: for (;;) {
3968: int len=0,scandevice;
3969: char *lastslash;
3970: char *comment;
3971: char *code;
3972:
3973: // make debugging simpler
3974: memset(line,0,sizeof(line));
3975:
3976: // get a line
3977: code=fgets(line, MAXLINELEN+2, f);
3978:
3979: // are we at the end of the file?
3980: if (!code){
3981: if (cont) {
3982: scandevice = ParseConfigLine(conf_entries, entry, contlineno, fullline);
3983: // See if we found a SCANDIRECTIVE directive
3984: if (scandevice==-1)
3985: return 0;
3986: // did we find a syntax error
3987: if (scandevice==-2)
3988: return -1;
3989: // the final line is part of a continuation line
3990: cont=0;
3991: entry+=scandevice;
3992: }
3993: break;
3994: }
3995:
3996: // input file line number
3997: contlineno++;
3998:
3999: // See if line is too long
4000: len=strlen(line);
4001: if (len>MAXLINELEN){
4002: const char *warn;
4003: if (line[len-1]=='\n')
4004: warn="(including newline!) ";
4005: else
4006: warn="";
4007: PrintOut(LOG_CRIT,"Error: line %d of file %s %sis more than MAXLINELEN=%d characters.\n",
4008: (int)contlineno,configfile,warn,(int)MAXLINELEN);
4009: return -1;
4010: }
4011:
4012: // Ignore anything after comment symbol
4013: if ((comment=strchr(line,'#'))){
4014: *comment='\0';
4015: len=strlen(line);
4016: }
4017:
4018: // is the total line (made of all continuation lines) too long?
4019: if (cont+len>MAXCONTLINE){
4020: PrintOut(LOG_CRIT,"Error: continued line %d (actual line %d) of file %s is more than MAXCONTLINE=%d characters.\n",
4021: lineno, (int)contlineno, configfile, (int)MAXCONTLINE);
4022: return -1;
4023: }
4024:
4025: // copy string so far into fullline, and increment length
4026: strcpy(fullline+cont,line);
4027: cont+=len;
4028:
4029: // is this a continuation line. If so, replace \ by space and look at next line
4030: if ( (lastslash=strrchr(line,'\\')) && !strtok(lastslash+1," \n\t")){
4031: *(fullline+(cont-len)+(lastslash-line))=' ';
4032: continue;
4033: }
4034:
4035: // Not a continuation line. Parse it
4036: scandevice = ParseConfigLine(conf_entries, entry, contlineno, fullline);
4037:
4038: // did we find a scandevice directive?
4039: if (scandevice==-1)
4040: return 0;
4041: // did we find a syntax error
4042: if (scandevice==-2)
4043: return -1;
4044:
4045: entry+=scandevice;
4046: lineno++;
4047: cont=0;
4048: }
4049:
4050: // note -- may be zero if syntax of file OK, but no valid entries!
4051: return entry;
4052: }
4053:
4054: /* Prints the message "=======> VALID ARGUMENTS ARE: <LIST> <=======\n", where
4055: <LIST> is the list of valid arguments for option opt. */
4056: static void PrintValidArgs(char opt)
4057: {
4058: const char *s;
4059:
4060: PrintOut(LOG_CRIT, "=======> VALID ARGUMENTS ARE: ");
4061: if (!(s = GetValidArgList(opt)))
4062: PrintOut(LOG_CRIT, "Error constructing argument list for option %c", opt);
4063: else
4064: PrintOut(LOG_CRIT, "%s", (char *)s);
4065: PrintOut(LOG_CRIT, " <=======\n");
4066: }
4067:
4068: #ifndef _WIN32
4069: // Report error and exit if specified path is not absolute.
4070: static void check_abs_path(char option, const std::string & path)
4071: {
4072: if (path.empty() || path[0] == '/')
4073: return;
4074:
4075: debugmode = 1;
4076: PrintHead();
4077: PrintOut(LOG_CRIT, "=======> INVALID ARGUMENT TO -%c: %s <=======\n\n", option, path.c_str());
4078: PrintOut(LOG_CRIT, "Error: relative path names are not allowed\n\n");
4079: EXIT(EXIT_BADCMD);
4080: }
4081: #endif // !_WIN32
4082:
4083: // Parses input line, prints usage message and
4084: // version/license/copyright messages
4085: static void ParseOpts(int argc, char **argv)
4086: {
4087: // Init default configfile path
4088: #ifndef _WIN32
4089: configfile = SMARTMONTOOLS_SYSCONFDIR"/smartd.conf";
4090: #else
4091: static std::string configfile_str = get_exe_dir() + "/smartd.conf";
4092: configfile = configfile_str.c_str();
4093: #endif
4094:
4095: // Please update GetValidArgList() if you edit shortopts
4096: static const char shortopts[] = "c:l:q:dDni:p:r:s:A:B:Vh?"
4097: #ifdef HAVE_LIBCAP_NG
4098: "C"
4099: #endif
4100: ;
4101: // Please update GetValidArgList() if you edit longopts
4102: struct option longopts[] = {
4103: { "configfile", required_argument, 0, 'c' },
4104: { "logfacility", required_argument, 0, 'l' },
4105: { "quit", required_argument, 0, 'q' },
4106: { "debug", no_argument, 0, 'd' },
4107: { "showdirectives", no_argument, 0, 'D' },
4108: { "interval", required_argument, 0, 'i' },
4109: #ifndef _WIN32
4110: { "no-fork", no_argument, 0, 'n' },
4111: #else
4112: { "service", no_argument, 0, 'n' },
4113: #endif
4114: { "pidfile", required_argument, 0, 'p' },
4115: { "report", required_argument, 0, 'r' },
4116: { "savestates", required_argument, 0, 's' },
4117: { "attributelog", required_argument, 0, 'A' },
4118: { "drivedb", required_argument, 0, 'B' },
4119: { "version", no_argument, 0, 'V' },
4120: { "license", no_argument, 0, 'V' },
4121: { "copyright", no_argument, 0, 'V' },
4122: { "help", no_argument, 0, 'h' },
4123: { "usage", no_argument, 0, 'h' },
4124: #ifdef HAVE_LIBCAP_NG
4125: { "capabilities", no_argument, 0, 'C' },
4126: #endif
4127: { 0, 0, 0, 0 }
4128: };
4129:
4130: opterr=optopt=0;
4131: bool badarg = false;
4132: bool no_defaultdb = false; // set true on '-B FILE'
4133:
4134: // Parse input options.
4135: int optchar;
4136: while ((optchar = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1) {
4137: char *arg;
4138: char *tailptr;
4139: long lchecktime;
4140:
4141: switch(optchar) {
4142: case 'q':
4143: // when to quit
4144: if (!(strcmp(optarg,"nodev"))) {
4145: quit=0;
4146: } else if (!(strcmp(optarg,"nodevstartup"))) {
4147: quit=1;
4148: } else if (!(strcmp(optarg,"never"))) {
4149: quit=2;
4150: } else if (!(strcmp(optarg,"onecheck"))) {
4151: quit=3;
4152: debugmode=1;
4153: } else if (!(strcmp(optarg,"showtests"))) {
4154: quit=4;
4155: debugmode=1;
4156: } else if (!(strcmp(optarg,"errors"))) {
4157: quit=5;
4158: } else {
4159: badarg = true;
4160: }
4161: break;
4162: case 'l':
4163: // set the log facility level
4164: if (!strcmp(optarg, "daemon"))
4165: facility=LOG_DAEMON;
4166: else if (!strcmp(optarg, "local0"))
4167: facility=LOG_LOCAL0;
4168: else if (!strcmp(optarg, "local1"))
4169: facility=LOG_LOCAL1;
4170: else if (!strcmp(optarg, "local2"))
4171: facility=LOG_LOCAL2;
4172: else if (!strcmp(optarg, "local3"))
4173: facility=LOG_LOCAL3;
4174: else if (!strcmp(optarg, "local4"))
4175: facility=LOG_LOCAL4;
4176: else if (!strcmp(optarg, "local5"))
4177: facility=LOG_LOCAL5;
4178: else if (!strcmp(optarg, "local6"))
4179: facility=LOG_LOCAL6;
4180: else if (!strcmp(optarg, "local7"))
4181: facility=LOG_LOCAL7;
4182: else
4183: badarg = true;
4184: break;
4185: case 'd':
4186: // enable debug mode
4187: debugmode = 1;
4188: break;
4189: case 'n':
4190: // don't fork()
4191: #ifndef _WIN32 // On Windows, --service is already handled by daemon_main()
4192: do_fork = false;
4193: #endif
4194: break;
4195: case 'D':
4196: // print summary of all valid directives
4197: debugmode = 1;
4198: Directives();
4199: EXIT(0);
4200: break;
4201: case 'i':
4202: // Period (time interval) for checking
4203: // strtol will set errno in the event of overflow, so we'll check it.
4204: errno = 0;
4205: lchecktime = strtol(optarg, &tailptr, 10);
4206: if (*tailptr != '\0' || lchecktime < 10 || lchecktime > INT_MAX || errno) {
4207: debugmode=1;
4208: PrintHead();
4209: PrintOut(LOG_CRIT, "======> INVALID INTERVAL: %s <=======\n", optarg);
4210: PrintOut(LOG_CRIT, "======> INTERVAL MUST BE INTEGER BETWEEN %d AND %d <=======\n", 10, INT_MAX);
4211: PrintOut(LOG_CRIT, "\nUse smartd -h to get a usage summary\n\n");
4212: EXIT(EXIT_BADCMD);
4213: }
4214: checktime = (int)lchecktime;
4215: break;
4216: case 'r':
4217: // report IOCTL transactions
4218: {
4219: int i;
4220: char *s;
4221:
4222: // split_report_arg() may modify its first argument string, so use a
4223: // copy of optarg in case we want optarg for an error message.
4224: if (!(s = strdup(optarg))) {
4225: PrintOut(LOG_CRIT, "No memory to process -r option - exiting\n");
4226: EXIT(EXIT_NOMEM);
4227: }
4228: if (split_report_arg(s, &i)) {
4229: badarg = true;
4230: } else if (i<1 || i>3) {
4231: debugmode=1;
4232: PrintHead();
4233: PrintOut(LOG_CRIT, "======> INVALID REPORT LEVEL: %s <=======\n", optarg);
4234: PrintOut(LOG_CRIT, "======> LEVEL MUST BE INTEGER BETWEEN 1 AND 3<=======\n");
4235: EXIT(EXIT_BADCMD);
4236: } else if (!strcmp(s,"ioctl")) {
4237: ata_debugmode = scsi_debugmode = i;
4238: } else if (!strcmp(s,"ataioctl")) {
4239: ata_debugmode = i;
4240: } else if (!strcmp(s,"scsiioctl")) {
4241: scsi_debugmode = i;
4242: } else {
4243: badarg = true;
4244: }
4245: free(s); // TODO: use std::string
4246: }
4247: break;
4248: case 'c':
4249: // alternate configuration file
4250: if (strcmp(optarg,"-"))
4251: configfile = (configfile_alt = optarg).c_str();
4252: else // read from stdin
4253: configfile=configfile_stdin;
4254: break;
4255: case 'p':
4256: // output file with PID number
4257: pid_file = optarg;
4258: break;
4259: case 's':
4260: // path prefix of persistent state file
4261: state_path_prefix = optarg;
4262: break;
4263: case 'A':
4264: // path prefix of attribute log file
4265: attrlog_path_prefix = optarg;
4266: break;
4267: case 'B':
4268: {
4269: const char * path = optarg;
4270: if (*path == '+' && path[1])
4271: path++;
4272: else
4273: no_defaultdb = true;
4274: unsigned char savedebug = debugmode; debugmode = 1;
4275: if (!read_drive_database(path))
4276: EXIT(EXIT_BADCMD);
4277: debugmode = savedebug;
4278: }
4279: break;
4280: case 'V':
4281: // print version and CVS info
4282: debugmode = 1;
4283: PrintOut(LOG_INFO, "%s", format_version_info("smartd", true /*full*/).c_str());
4284: EXIT(0);
4285: break;
4286: #ifdef HAVE_LIBCAP_NG
4287: case 'C':
4288: // enable capabilities
4289: enable_capabilities = true;
4290: break;
4291: #endif
4292: case 'h':
4293: // help: print summary of command-line options
4294: debugmode=1;
4295: PrintHead();
4296: Usage();
4297: EXIT(0);
4298: break;
4299: case '?':
4300: default:
4301: // unrecognized option
4302: debugmode=1;
4303: PrintHead();
4304: // Point arg to the argument in which this option was found.
4305: arg = argv[optind-1];
4306: // Check whether the option is a long option that doesn't map to -h.
4307: if (arg[1] == '-' && optchar != 'h') {
4308: // Iff optopt holds a valid option then argument must be missing.
4309: if (optopt && (strchr(shortopts, optopt) != NULL)) {
4310: PrintOut(LOG_CRIT, "=======> ARGUMENT REQUIRED FOR OPTION: %s <=======\n",arg+2);
4311: PrintValidArgs(optopt);
4312: } else {
4313: PrintOut(LOG_CRIT, "=======> UNRECOGNIZED OPTION: %s <=======\n\n",arg+2);
4314: }
4315: PrintOut(LOG_CRIT, "\nUse smartd --help to get a usage summary\n\n");
4316: EXIT(EXIT_BADCMD);
4317: }
4318: if (optopt) {
4319: // Iff optopt holds a valid option then argument must be missing.
4320: if (strchr(shortopts, optopt) != NULL){
4321: PrintOut(LOG_CRIT, "=======> ARGUMENT REQUIRED FOR OPTION: %c <=======\n",optopt);
4322: PrintValidArgs(optopt);
4323: } else {
4324: PrintOut(LOG_CRIT, "=======> UNRECOGNIZED OPTION: %c <=======\n\n",optopt);
4325: }
4326: PrintOut(LOG_CRIT, "\nUse smartd -h to get a usage summary\n\n");
4327: EXIT(EXIT_BADCMD);
4328: }
4329: Usage();
4330: EXIT(0);
4331: }
4332:
4333: // Check to see if option had an unrecognized or incorrect argument.
4334: if (badarg) {
4335: debugmode=1;
4336: PrintHead();
4337: // It would be nice to print the actual option name given by the user
4338: // here, but we just print the short form. Please fix this if you know
4339: // a clean way to do it.
4340: PrintOut(LOG_CRIT, "=======> INVALID ARGUMENT TO -%c: %s <======= \n", optchar, optarg);
4341: PrintValidArgs(optchar);
4342: PrintOut(LOG_CRIT, "\nUse smartd -h to get a usage summary\n\n");
4343: EXIT(EXIT_BADCMD);
4344: }
4345: }
4346:
4347: // non-option arguments are not allowed
4348: if (argc > optind) {
4349: debugmode=1;
4350: PrintHead();
4351: PrintOut(LOG_CRIT, "=======> UNRECOGNIZED ARGUMENT: %s <=======\n\n", argv[optind]);
4352: PrintOut(LOG_CRIT, "\nUse smartd -h to get a usage summary\n\n");
4353: EXIT(EXIT_BADCMD);
4354: }
4355:
4356: // no pidfile in debug mode
4357: if (debugmode && !pid_file.empty()) {
4358: debugmode=1;
4359: PrintHead();
4360: PrintOut(LOG_CRIT, "=======> INVALID CHOICE OF OPTIONS: -d and -p <======= \n\n");
4361: PrintOut(LOG_CRIT, "Error: pid file %s not written in debug (-d) mode\n\n", pid_file.c_str());
4362: EXIT(EXIT_BADCMD);
4363: }
4364:
4365: #ifndef _WIN32
4366: if (!debugmode) {
4367: // absolute path names are required due to chdir('/') after fork().
4368: check_abs_path('p', pid_file);
4369: check_abs_path('s', state_path_prefix);
4370: check_abs_path('A', attrlog_path_prefix);
4371: }
4372: #endif
4373:
4374: // Read or init drive database
4375: if (!no_defaultdb) {
4376: unsigned char savedebug = debugmode; debugmode = 1;
4377: if (!read_default_drive_databases())
4378: EXIT(EXIT_BADCMD);
4379: debugmode = savedebug;
4380: }
4381:
4382: // print header
4383: PrintHead();
4384: }
4385:
4386: // Function we call if no configuration file was found or if the
4387: // SCANDIRECTIVE Directive was found. It makes entries for device
4388: // names returned by scan_smart_devices() in os_OSNAME.cpp
4389: static int MakeConfigEntries(const dev_config & base_cfg,
4390: dev_config_vector & conf_entries, smart_device_list & scanned_devs, const char * type)
4391: {
4392: // make list of devices
4393: smart_device_list devlist;
4394: if (!smi()->scan_smart_devices(devlist, (*type ? type : 0)))
4395: PrintOut(LOG_CRIT,"Problem creating device name scan list\n");
4396:
4397: // if no devices, or error constructing list, return
4398: if (devlist.size() <= 0)
4399: return 0;
4400:
4401: // add empty device slots for existing config entries
4402: while (scanned_devs.size() < conf_entries.size())
4403: scanned_devs.push_back((smart_device *)0);
4404:
4405: // loop over entries to create
4406: for (unsigned i = 0; i < devlist.size(); i++) {
4407: // Move device pointer
4408: smart_device * dev = devlist.release(i);
4409: scanned_devs.push_back(dev);
4410:
4411: // Copy configuration, update device and type name
4412: conf_entries.push_back(base_cfg);
4413: dev_config & cfg = conf_entries.back();
4414: cfg.name = dev->get_info().info_name;
4415: cfg.dev_name = dev->get_info().dev_name;
4416: cfg.dev_type = type;
4417: }
4418:
4419: return devlist.size();
4420: }
4421:
4422: static void CanNotRegister(const char *name, const char *type, int line, bool scandirective)
4423: {
4424: if (!debugmode && scandirective)
4425: return;
4426: if (line)
4427: PrintOut(scandirective?LOG_INFO:LOG_CRIT,
4428: "Unable to register %s device %s at line %d of file %s\n",
4429: type, name, line, configfile);
4430: else
4431: PrintOut(LOG_INFO,"Unable to register %s device %s\n",
4432: type, name);
4433: return;
4434: }
4435:
4436: // Returns negative value (see ParseConfigFile()) if config file
4437: // had errors, else number of entries which may be zero or positive.
4438: static int ReadOrMakeConfigEntries(dev_config_vector & conf_entries, smart_device_list & scanned_devs)
4439: {
4440: // parse configuration file configfile (normally /etc/smartd.conf)
4441: int entries = ParseConfigFile(conf_entries);
4442:
4443: if (entries < 0) {
4444: // There was an error reading the configuration file.
4445: conf_entries.clear();
4446: if (entries == -1)
4447: PrintOut(LOG_CRIT, "Configuration file %s has fatal syntax errors.\n", configfile);
4448: return entries;
4449: }
4450:
4451: // no error parsing config file.
4452: if (entries) {
4453: // we did not find a SCANDIRECTIVE and did find valid entries
4454: PrintOut(LOG_INFO, "Configuration file %s parsed.\n", configfile);
4455: }
4456: else if (!conf_entries.empty()) {
4457: // we found a SCANDIRECTIVE or there was no configuration file so
4458: // scan. Configuration file's last entry contains all options
4459: // that were set
4460: dev_config first = conf_entries.back();
4461: conf_entries.pop_back();
4462:
4463: if (first.lineno)
4464: PrintOut(LOG_INFO,"Configuration file %s was parsed, found %s, scanning devices\n", configfile, SCANDIRECTIVE);
4465: else
4466: PrintOut(LOG_INFO,"No configuration file %s found, scanning devices\n", configfile);
4467:
4468: // make config list of devices to search for
4469: MakeConfigEntries(first, conf_entries, scanned_devs, first.dev_type.c_str());
4470:
4471: // warn user if scan table found no devices
4472: if (conf_entries.empty())
4473: PrintOut(LOG_CRIT,"In the system's table of devices NO devices found to scan\n");
4474: }
4475: else
4476: PrintOut(LOG_CRIT,"Configuration file %s parsed but has no entries (like /dev/hda)\n",configfile);
4477:
4478: return conf_entries.size();
4479: }
4480:
4481:
4482: // This function tries devices from conf_entries. Each one that can be
4483: // registered is moved onto the [ata|scsi]devices lists and removed
4484: // from the conf_entries list.
4485: static void RegisterDevices(const dev_config_vector & conf_entries, smart_device_list & scanned_devs,
4486: dev_config_vector & configs, dev_state_vector & states, smart_device_list & devices)
4487: {
4488: // start by clearing lists/memory of ALL existing devices
4489: configs.clear();
4490: devices.clear();
4491: states.clear();
4492:
4493: // Register entries
4494: for (unsigned i = 0; i < conf_entries.size(); i++){
4495:
4496: dev_config cfg = conf_entries[i];
4497:
4498: // get device of appropriate type
4499: smart_device_auto_ptr dev;
4500: bool scanning = false;
4501:
4502: // Device may already be detected during devicescan
4503: if (i < scanned_devs.size()) {
4504: dev = scanned_devs.release(i);
4505: if (dev)
4506: scanning = true;
4507: }
4508:
4509: if (!dev) {
4510: dev = smi()->get_smart_device(cfg.name.c_str(), cfg.dev_type.c_str());
4511: if (!dev) {
4512: if (cfg.dev_type.empty())
4513: PrintOut(LOG_INFO,"Device: %s, unable to autodetect device type\n", cfg.name.c_str());
4514: else
4515: PrintOut(LOG_INFO,"Device: %s, unsupported device type '%s'\n", cfg.name.c_str(), cfg.dev_type.c_str());
4516: continue;
4517: }
4518: }
4519:
4520: // Save old info
4521: smart_device::device_info oldinfo = dev->get_info();
4522:
4523: // Open with autodetect support, may return 'better' device
4524: dev.replace( dev->autodetect_open() );
4525:
4526: // Report if type has changed
4527: if (oldinfo.dev_type != dev->get_dev_type())
4528: PrintOut(LOG_INFO,"Device: %s, type changed from '%s' to '%s'\n",
4529: cfg.name.c_str(), oldinfo.dev_type.c_str(), dev->get_dev_type());
4530:
4531: if (!dev->is_open()) {
4532: // For linux+devfs, a nonexistent device gives a strange error
4533: // message. This makes the error message a bit more sensible.
4534: // If no debug and scanning - don't print errors
4535: if (debugmode || !scanning)
4536: PrintOut(LOG_INFO, "Device: %s, open() failed: %s\n", dev->get_info_name(), dev->get_errmsg());
4537: continue;
4538: }
4539:
4540: // Update informal name
4541: cfg.name = dev->get_info().info_name;
4542: PrintOut(LOG_INFO, "Device: %s, opened\n", cfg.name.c_str());
4543:
4544: // Prepare initial state
4545: dev_state state;
4546:
4547: // register ATA devices
4548: if (dev->is_ata()){
4549: if (ATADeviceScan(cfg, state, dev->to_ata())) {
4550: CanNotRegister(cfg.name.c_str(), "ATA", cfg.lineno, scanning);
4551: dev.reset();
4552: }
4553: }
4554: // or register SCSI devices
4555: else if (dev->is_scsi()){
4556: if (SCSIDeviceScan(cfg, state, dev->to_scsi())) {
4557: CanNotRegister(cfg.name.c_str(), "SCSI", cfg.lineno, scanning);
4558: dev.reset();
4559: }
4560: }
4561: else {
4562: PrintOut(LOG_INFO, "Device: %s, neither ATA nor SCSI device\n", cfg.name.c_str());
4563: dev.reset();
4564: }
4565:
4566: if (dev) {
4567: // move onto the list of devices
4568: configs.push_back(cfg);
4569: states.push_back(state);
4570: devices.push_back(dev);
4571: }
4572: // if device is explictly listed and we can't register it, then
4573: // exit unless the user has specified that the device is removable
4574: else if (!scanning) {
4575: if (cfg.removable || quit==2)
4576: PrintOut(LOG_INFO, "Device %s not available\n", cfg.name.c_str());
4577: else {
4578: PrintOut(LOG_CRIT, "Unable to register device %s (no Directive -d removable). Exiting.\n", cfg.name.c_str());
4579: EXIT(EXIT_BADDEV);
4580: }
4581: }
4582: }
4583: }
4584:
4585:
4586: // Main program without exception handling
4587: static int main_worker(int argc, char **argv)
4588: {
4589: // Initialize interface
4590: smart_interface::init();
4591: if (!smi())
4592: return 1;
4593:
4594: // is it our first pass through?
4595: bool firstpass = true;
4596:
4597: // next time to wake up
4598: time_t wakeuptime = 0;
4599:
4600: // parse input and print header and usage info if needed
4601: ParseOpts(argc,argv);
4602:
4603: // Configuration for each device
4604: dev_config_vector configs;
4605: // Device states
4606: dev_state_vector states;
4607: // Devices to monitor
4608: smart_device_list devices;
4609:
4610: bool write_states_always = true;
4611:
4612: #ifdef HAVE_LIBCAP_NG
4613: // Drop capabilities
4614: if (enable_capabilities) {
4615: capng_clear(CAPNG_SELECT_BOTH);
4616: capng_updatev(CAPNG_ADD, (capng_type_t)(CAPNG_EFFECTIVE|CAPNG_PERMITTED),
4617: CAP_SYS_ADMIN, CAP_MKNOD, CAP_SYS_RAWIO, -1);
4618: capng_apply(CAPNG_SELECT_BOTH);
4619: }
4620: #endif
4621:
4622: // the main loop of the code
4623: for (;;) {
4624:
4625: // are we exiting from a signal?
4626: if (caughtsigEXIT) {
4627: // are we exiting with SIGTERM?
4628: int isterm=(caughtsigEXIT==SIGTERM);
4629: int isquit=(caughtsigEXIT==SIGQUIT);
4630: int isok=debugmode?isterm || isquit:isterm;
4631:
4632: PrintOut(isok?LOG_INFO:LOG_CRIT, "smartd received signal %d: %s\n",
4633: caughtsigEXIT, strsignal(caughtsigEXIT));
4634:
4635: if (!isok)
4636: return EXIT_SIGNAL;
4637:
4638: // Write state files
4639: if (!state_path_prefix.empty())
4640: write_all_dev_states(configs, states);
4641:
4642: return 0;
4643: }
4644:
4645: // Should we (re)read the config file?
4646: if (firstpass || caughtsigHUP){
4647: if (!firstpass) {
4648: #ifdef __CYGWIN__
4649: // Workaround for missing SIGQUIT via keyboard on Cygwin
4650: if (caughtsigHUP==2) {
4651: // Simulate SIGQUIT if another SIGINT arrives soon
4652: caughtsigHUP=0;
4653: sleep(1);
4654: if (caughtsigHUP==2) {
4655: caughtsigEXIT=SIGQUIT;
4656: continue;
4657: }
4658: caughtsigHUP=2;
4659: }
4660: #endif
4661: // Write state files
4662: if (!state_path_prefix.empty())
4663: write_all_dev_states(configs, states);
4664:
4665: PrintOut(LOG_INFO,
4666: caughtsigHUP==1?
4667: "Signal HUP - rereading configuration file %s\n":
4668: "\a\nSignal INT - rereading configuration file %s ("SIGQUIT_KEYNAME" quits)\n\n",
4669: configfile);
4670: }
4671:
4672: {
4673: dev_config_vector conf_entries; // Entries read from smartd.conf
4674: smart_device_list scanned_devs; // Devices found during scan
4675: // (re)reads config file, makes >=0 entries
4676: int entries = ReadOrMakeConfigEntries(conf_entries, scanned_devs);
4677:
4678: if (entries>=0) {
4679: // checks devices, then moves onto ata/scsi list or deallocates.
4680: RegisterDevices(conf_entries, scanned_devs, configs, states, devices);
4681: if (!(configs.size() == devices.size() && configs.size() == states.size()))
4682: throw std::logic_error("Invalid result from RegisterDevices");
4683: }
4684: else if (quit==2 || ((quit==0 || quit==1) && !firstpass)) {
4685: // user has asked to continue on error in configuration file
4686: if (!firstpass)
4687: PrintOut(LOG_INFO,"Reusing previous configuration\n");
4688: }
4689: else {
4690: // exit with configuration file error status
4691: return (entries==-3 ? EXIT_READCONF : entries==-2 ? EXIT_NOCONF : EXIT_BADCONF);
4692: }
4693: }
4694:
4695: // Log number of devices we are monitoring...
4696: if (devices.size() > 0 || quit==2 || (quit==1 && !firstpass)) {
4697: int numata = 0;
4698: for (unsigned i = 0; i < devices.size(); i++) {
4699: if (devices.at(i)->is_ata())
4700: numata++;
4701: }
4702: PrintOut(LOG_INFO,"Monitoring %d ATA and %d SCSI devices\n",
4703: numata, devices.size() - numata);
4704: }
4705: else {
4706: PrintOut(LOG_INFO,"Unable to monitor any SMART enabled devices. Try debug (-d) option. Exiting...\n");
4707: return EXIT_NODEV;
4708: }
4709:
4710: if (quit==4) {
4711: // user has asked to print test schedule
4712: PrintTestSchedule(configs, states, devices);
4713: return 0;
4714: }
4715:
4716: #ifdef HAVE_LIBCAP_NG
4717: if (enable_capabilities) {
4718: for (unsigned i = 0; i < configs.size(); i++) {
4719: if (!configs[i].emailaddress.empty() || !configs[i].emailcmdline.empty()) {
4720: PrintOut(LOG_WARNING, "Mail can't be enabled together with --capabilities. All mail will be suppressed.\n");
4721: break;
4722: }
4723: }
4724: }
4725: #endif
4726:
4727: // reset signal
4728: caughtsigHUP=0;
4729:
4730: // Always write state files after (re)configuration
4731: write_states_always = true;
4732: }
4733:
4734: // check all devices once,
4735: // self tests are not started in first pass unless '-q onecheck' is specified
4736: CheckDevicesOnce(configs, states, devices, firstpass, (!firstpass || quit==3));
4737:
4738: // Write state files
4739: if (!state_path_prefix.empty())
4740: write_all_dev_states(configs, states, write_states_always);
4741: write_states_always = false;
4742:
4743: // Write attribute logs
4744: if (!attrlog_path_prefix.empty())
4745: write_all_dev_attrlogs(configs, states);
4746:
4747: // user has asked us to exit after first check
4748: if (quit==3) {
4749: PrintOut(LOG_INFO,"Started with '-q onecheck' option. All devices sucessfully checked once.\n"
4750: "smartd is exiting (exit status 0)\n");
4751: return 0;
4752: }
4753:
4754: // fork into background if needed
4755: if (firstpass && !debugmode) {
4756: DaemonInit();
4757: }
4758:
4759: // set exit and signal handlers, write PID file, set wake-up time
4760: if (firstpass){
4761: Initialize(&wakeuptime);
4762: firstpass = false;
4763: }
4764:
4765: // sleep until next check time, or a signal arrives
4766: wakeuptime = dosleep(wakeuptime, write_states_always);
4767: }
4768: }
4769:
4770:
4771: #ifndef _WIN32
4772: // Main program
4773: int main(int argc, char **argv)
4774: #else
4775: // Windows: internal main function started direct or by service control manager
4776: static int smartd_main(int argc, char **argv)
4777: #endif
4778: {
4779: int status;
4780: try {
4781: // Do the real work ...
4782: status = main_worker(argc, argv);
4783: }
4784: catch (int ex) {
4785: // EXIT(status) arrives here
4786: status = ex;
4787: }
4788: catch (const std::bad_alloc & /*ex*/) {
4789: // Memory allocation failed (also thrown by std::operator new)
4790: PrintOut(LOG_CRIT, "Smartd: Out of memory\n");
4791: status = EXIT_NOMEM;
4792: }
4793: catch (const std::exception & ex) {
4794: // Other fatal errors
4795: PrintOut(LOG_CRIT, "Smartd: Exception: %s\n", ex.what());
4796: status = EXIT_BADCODE;
4797: }
4798:
4799: if (is_initialized)
4800: status = Goodbye(status);
4801:
4802: #ifdef _WIN32
4803: daemon_winsvc_exitcode = status;
4804: #endif
4805: return status;
4806: }
4807:
4808:
4809: #ifdef _WIN32
4810: // Main function for Windows
4811: int main(int argc, char **argv){
4812: // Options for smartd windows service
4813: static const daemon_winsvc_options svc_opts = {
4814: "--service", // cmd_opt
4815: "smartd", "SmartD Service", // servicename, displayname
4816: // description
4817: "Controls and monitors storage devices using the Self-Monitoring, "
4818: "Analysis and Reporting Technology System (S.M.A.R.T.) "
4819: "built into ATA and SCSI Hard Drives. "
4820: PACKAGE_HOMEPAGE
4821: };
4822: // daemon_main() handles daemon and service specific commands
4823: // and starts smartd_main() direct, from a new process,
4824: // or via service control manager
4825: return daemon_main("smartd", &svc_opts , smartd_main, argc, argv);
4826: }
4827: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to smartd.cpp CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / smartmontools