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