Ticket #677: query_device_open.patch

dev_interface.cpp

@@ -92 +92 @@
   return this;
 }
 
+bool smart_device::is_powered_down()
+{
+  return false;
+}
+
 bool smart_device::owns(const smart_device * /*dev*/) const
 {
   return false;

dev_interface.h

@@ -205 +205 @@
   virtual smart_device * autodetect_open();
 
   ///////////////////////////////////////////////
+  // Support for checking power mode reported by operating system
+
+  /// Early test if device is powered up or down.
+  /// Can be used without calling 'open()' first!
+  /// Return true when device is powered down, false when
+  /// powered up. If this function is not implemented or
+  /// the mode cannot be determined, return false.
+  /// Default implementation returns false.
+  virtual bool is_powered_down();
+
+  ///////////////////////////////////////////////
   // Support for tunnelled devices
 
   /// Return true if other device is owned by this device.

os_win32.cpp

@@ -1398 +1398 @@
 
   virtual bool open();
 
+  virtual bool is_powered_down();
+
   virtual bool ata_pass_through(const ata_cmd_in & in, ata_cmd_out & out);
 
   virtual bool ata_identify_is_cached() const;
 
 private:
-  bool open(int phydrive, int logdrive, const char * options, int port);
+  bool open(bool query_device);
 
+  bool open(int phydrive, int logdrive, const char * options, int port, bool query_device);
+
   std::string m_options;
   bool m_usr_options; // options set by user?
   bool m_admin; // open with admin access?
@@ -1444 +1448 @@
 
 bool win_ata_device::open()
 {
+  // Open device for r/w operations
+  return open(false);
+}
+
+bool win_ata_device::open(bool query_device)
+{
   const char * name = skipdev(get_dev_name()); int len = strlen(name);
   // [sh]d[a-z]([a-z])?(:[saicmfp]+)? => Physical drive 0-701, with options
   char drive[2+1] = "", options[8+1] = ""; int n1 = -1, n2 = -1;
   if (   sscanf(name, "%*[sh]d%2[a-z]%n:%6[saimfp]%n", drive, &n1, options, &n2) >= 1
       && ((n1 == len && !options[0]) || n2 == len)                                   ) {
-    return open(sdxy_to_phydrive(drive), -1, options, -1);
+    return open(sdxy_to_phydrive(drive), -1, options, -1, query_device);
   }
   // [sh]d[a-z],N(:[saicmfp3]+)? => Physical drive 0-701, RAID port N, with options
   drive[0] = 0; options[0] = 0; n1 = -1; n2 = -1;
@@ -1456 +1466 @@
   unsigned port = ~0;
   if (   sscanf(name, "%*[sh]d%2[a-z],%u%n:%7[saimfp3]%n", drive, &port, &n1, options, &n2) >= 2
       && port < 32 && ((n1 == len && !options[0]) || n2 == len)                                  ) {
-    return open(sdxy_to_phydrive(drive), -1, options, port);
+    return open(sdxy_to_phydrive(drive), -1, options, port, query_device);
   }
   // pd<m>,N => Physical drive <m>, RAID port N
   int phydrive = -1; port = ~0; n1 = -1; n2 = -1;
   if (   sscanf(name, "pd%d%n,%u%n", &phydrive, &n1, &port, &n2) >= 1
       && phydrive >= 0 && ((n1 == len && (int)port < 0) || (n2 == len && port < 32))) {
-    return open(phydrive, -1, "", (int)port);
+    return open(phydrive, -1, "", (int)port, query_device);
   }
   // [a-zA-Z]: => Physical drive behind logical drive 0-25
   int logdrive = drive_letter(name);
   if (logdrive >= 0) {
-    return open(-1, logdrive, "", -1);
+    return open(-1, logdrive, "", -1, query_device);
   }
 
   return set_err(EINVAL);
@@ -1474 +1484 @@
 }
 
 
-bool win_ata_device::open(int phydrive, int logdrive, const char * options, int port)
+bool win_ata_device::open(int phydrive, int logdrive, const char * options, int port, bool query_device)
 {
   m_phydrive = -1;
   char devpath[30];
@@ -1487 +1497 @@
 
   // Open device
   HANDLE h = INVALID_HANDLE_VALUE;
-  if (!(*options && !options[strspn(options, "fp")])) {
+  if (!(*options && !options[strspn(options, "fp")]) && !query_device) {
     // Open with admin rights
     m_admin = true;
     h = CreateFileA(devpath, GENERIC_READ|GENERIC_WRITE,
@@ -1514 +1524 @@
   set_fh(h);
 
   // Warn once if admin rights are missing
-  if (!m_admin) {
+  if (!m_admin && !query_device) {
     static bool noadmin_warning = false;
     if (!noadmin_warning) {
       pout("Warning: Limited functionality due to missing admin rights\n");
@@ -1595 +1605 @@
 
 /////////////////////////////////////////////////////////////////////////////
 
+// Query OS if device is powered up or down.
+bool win_ata_device::is_powered_down()
+{
+  // To check power mode, we open device for query operations only.
+  // Opening for SMART r/w operations can already spin up the disk.
+  bool self_open = !is_open();
+  if (self_open)
+    if (!open(true))
+      return false;
+  int rc = get_device_power_state(get_fh());
+  if (self_open)
+    close();
+  return !rc;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+
 // Interface to ATA devices
 bool win_ata_device::ata_pass_through(const ata_cmd_in & in, ata_cmd_out & out)
 {

smartctl.cpp

@@ -1304 +1304 @@
     pout("%s: Device of type '%s' [%s] detected\n",
          dev->get_info_name(), dev->get_dev_type(), get_protocol_info(dev.get()));
 
+  if (dev->is_ata() && ataopts.powermode>=2 && dev->is_powered_down()) {
+    pout( "%s: Device is in %s mode, exit(%d)\n", dev->get_info_name(), "STANDBY (OS)", FAILPOWER );
+    return FAILPOWER;
+  }
+
   // Open device
   {
     // Save old info

smartd.cpp

@@ -3135 +3135 @@
   if (cfg.emailtest)
     MailWarning(cfg, state, 0, "TEST EMAIL from smartd for device: %s", name);
 
+  // User may have requested (with the -n Directive) to leave the disk
+  // alone if it is in idle or standby mode.  In this case check the
+  // power mode first before opening the device for full access,
+  // and exit without check if disk is reported in standby.
+  if (cfg.powermode>=2 && !state.powermodefail) {
+    // Note that 'is_powered_down()' handles opening the device itself, and
+    // can be used before calling 'open()' (that's the whole point of 'is_powered_down()'!).
+    if (atadev->is_powered_down())
+    {
+      // skip at most powerskipmax checks
+      if (!cfg.powerskipmax || state.powerskipcnt<cfg.powerskipmax) {
+        // report first only except if state has changed, avoid waking up system disk
+        if ((!state.powerskipcnt || state.lastpowermodeskipped != -1) && !cfg.powerquiet) {
+          PrintOut(LOG_INFO, "Device: %s, is in %s mode, suspending checks\n", name, "STANDBY (OS)");
+          state.lastpowermodeskipped = -1;
+        }
+        state.powerskipcnt++;
+        return 0;
+      }
+    }
+  }
+
   // if we can't open device, fail gracefully rather than hard --
   // perhaps the next time around we'll be able to open it.  ATAPI
   // cd/dvd devices will hang awaiting media if O_NONBLOCK is not