chromeos/disks/disk_mount_manager.cc

// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chromeos/disks/disk_mount_manager.h"

#include <map>
#include <set>

#include "base/bind.h"
#include "base/memory/weak_ptr.h"
#include "base/observer_list.h"
#include "base/string_util.h"
#include "chromeos/dbus/dbus_thread_manager.h"

namespace chromeos {
namespace disks {

namespace {

const char kDeviceNotFound[] = "Device could not be found";

DiskMountManager* g_disk_mount_manager = NULL;

// The DiskMountManager implementation.
class DiskMountManagerImpl : public DiskMountManager {
 public:
  DiskMountManagerImpl() : weak_ptr_factory_(this) {
    DBusThreadManager* dbus_thread_manager = DBusThreadManager::Get();
    DCHECK(dbus_thread_manager);
    cros_disks_client_ = dbus_thread_manager->GetCrosDisksClient();
    DCHECK(cros_disks_client_);

    cros_disks_client_->SetUpConnections(
        base::Bind(&DiskMountManagerImpl::OnMountEvent,
                   weak_ptr_factory_.GetWeakPtr()),
        base::Bind(&DiskMountManagerImpl::OnMountCompleted,
                   weak_ptr_factory_.GetWeakPtr()));
  }

  virtual ~DiskMountManagerImpl() {
  }

  // DiskMountManager override.
  virtual void AddObserver(Observer* observer) OVERRIDE {
    observers_.AddObserver(observer);
  }

  // DiskMountManager override.
  virtual void RemoveObserver(Observer* observer) OVERRIDE {
    observers_.RemoveObserver(observer);
  }

  // DiskMountManager override.
  virtual void MountPath(const std::string& source_path,
                         const std::string& source_format,
                         const std::string& mount_label,
                         MountType type) OVERRIDE {
    // Hidden and non-existent devices should not be mounted.
    if (type == MOUNT_TYPE_DEVICE) {
      DiskMap::const_iterator it = disks_.find(source_path);
      if (it == disks_.end() || it->second->is_hidden()) {
        OnMountCompleted(MOUNT_ERROR_INTERNAL, source_path, type, "");
        return;
      }
    }
    cros_disks_client_->Mount(
        source_path,
        source_format,
        mount_label,
        type,
        // When succeeds, OnMountCompleted will be called by
        // "MountCompleted" signal instead.
        base::Bind(&base::DoNothing),
        base::Bind(&DiskMountManagerImpl::OnMountCompleted,
                   weak_ptr_factory_.GetWeakPtr(),
                   MOUNT_ERROR_INTERNAL,
                   source_path,
                   type,
                   ""));
  }

  // DiskMountManager override.
  virtual void UnmountPath(const std::string& mount_path) OVERRIDE {
    cros_disks_client_->Unmount(mount_path,
                                base::Bind(&DiskMountManagerImpl::OnUnmountPath,
                                           weak_ptr_factory_.GetWeakPtr()),
                                base::Bind(&base::DoNothing));
  }

  // DiskMountManager override.
  virtual void FormatUnmountedDevice(const std::string& file_path) OVERRIDE {
    for (DiskMountManager::DiskMap::iterator it = disks_.begin();
         it != disks_.end(); ++it) {
      if (it->second->file_path() == file_path &&
          !it->second->mount_path().empty()) {
        LOG(ERROR) << "Device is still mounted: " << file_path;
        OnFormatDevice(file_path, false);
        return;
      }
    }
    const char kFormatVFAT[] = "vfat";
    cros_disks_client_->FormatDevice(
        file_path,
        kFormatVFAT,
        base::Bind(&DiskMountManagerImpl::OnFormatDevice,
                   weak_ptr_factory_.GetWeakPtr()),
        base::Bind(&DiskMountManagerImpl::OnFormatDevice,
                   weak_ptr_factory_.GetWeakPtr(),
                   file_path,
                   false));
  }

  // DiskMountManager override.
  virtual void FormatMountedDevice(const std::string& mount_path) OVERRIDE {
    Disk* disk = NULL;
    for (DiskMountManager::DiskMap::iterator it = disks_.begin();
         it != disks_.end(); ++it) {
      if (it->second->mount_path() == mount_path) {
        disk = it->second;
        break;
      }
    }
    if (!disk) {
      LOG(ERROR) << "Device with this mount path not found: " << mount_path;
      OnFormatDevice(mount_path, false);
      return;
    }
    if (formatting_pending_.find(disk->device_path()) !=
        formatting_pending_.end()) {
      LOG(ERROR) << "Formatting is already pending: " << mount_path;
      OnFormatDevice(mount_path, false);
      return;
    }
    // Formatting process continues, after unmounting.
    formatting_pending_[disk->device_path()] = disk->file_path();
    UnmountPath(disk->mount_path());
  }

  // DiskMountManager override.
  virtual void UnmountDeviceRecursive(
      const std::string& device_path,
      UnmountDeviceRecursiveCallbackType callback,
      void* user_data) OVERRIDE {
    bool success = true;
    std::string error_message;
    std::vector<std::string> devices_to_unmount;

    // Get list of all devices to unmount.
    int device_path_len = device_path.length();
    for (DiskMap::iterator it = disks_.begin(); it != disks_.end(); ++it) {
      if (!it->second->mount_path().empty() &&
          strncmp(device_path.c_str(), it->second->device_path().c_str(),
                  device_path_len) == 0) {
        devices_to_unmount.push_back(it->second->mount_path());
      }
    }
    // We should detect at least original device.
    if (devices_to_unmount.empty()) {
      if (disks_.find(device_path) == disks_.end()) {
        success = false;
        error_message = kDeviceNotFound;
      } else {
        // Nothing to unmount.
        callback(user_data, true);
        return;
      }
    }
    if (success) {
      // We will send the same callback data object to all Unmount calls and use
      // it to syncronize callbacks.
      UnmountDeviceRecursiveCallbackData* cb_data =
          new UnmountDeviceRecursiveCallbackData(user_data, callback,
                                                 devices_to_unmount.size());
      for (size_t i = 0; i < devices_to_unmount.size(); ++i) {
        cros_disks_client_->Unmount(
            devices_to_unmount[i],
            base::Bind(&DiskMountManagerImpl::OnUnmountDeviceRecursive,
                       weak_ptr_factory_.GetWeakPtr(), cb_data, true),
            base::Bind(&DiskMountManagerImpl::OnUnmountDeviceRecursive,
                       weak_ptr_factory_.GetWeakPtr(),
                       cb_data,
                       false,
                       devices_to_unmount[i]));
      }
    } else {
      LOG(WARNING) << "Unmount recursive request failed for device "
                   << device_path << ", with error: " << error_message;
      callback(user_data, false);
    }
  }

  // DiskMountManager override.
  virtual void RequestMountInfoRefresh() OVERRIDE {
    cros_disks_client_->EnumerateAutoMountableDevices(
        base::Bind(&DiskMountManagerImpl::OnRequestMountInfo,
                   weak_ptr_factory_.GetWeakPtr()),
        base::Bind(&base::DoNothing));
  }

  // DiskMountManager override.
  virtual const DiskMap& disks() const OVERRIDE { return disks_; }

  // DiskMountManager override.
  virtual const Disk* FindDiskBySourcePath(const std::string& source_path)
      const OVERRIDE {
    DiskMap::const_iterator disk_it = disks_.find(source_path);
    return disk_it == disks_.end() ? NULL : disk_it->second;
  }

  // DiskMountManager override.
  virtual const MountPointMap& mount_points() const OVERRIDE {
    return mount_points_;
  }

 private:
  struct UnmountDeviceRecursiveCallbackData {
    void* user_data;
    UnmountDeviceRecursiveCallbackType callback;
    size_t pending_callbacks_count;

    UnmountDeviceRecursiveCallbackData(void* ud,
                                       UnmountDeviceRecursiveCallbackType cb,
                                       int count)
        : user_data(ud),
          callback(cb),
          pending_callbacks_count(count) {
    }
  };

  // Callback for UnmountDeviceRecursive.
  void OnUnmountDeviceRecursive(UnmountDeviceRecursiveCallbackData* cb_data,
                                bool success,
                                const std::string& mount_path) {
    if (success) {
      // Do standard processing for Unmount event.
      OnUnmountPath(mount_path);
      LOG(INFO) << mount_path <<  " unmounted.";
    }
    // This is safe as long as all callbacks are called on the same thread as
    // UnmountDeviceRecursive.
    cb_data->pending_callbacks_count--;

    if (cb_data->pending_callbacks_count == 0) {
      cb_data->callback(cb_data->user_data, success);
      delete cb_data;
    }
  }

  // Callback to handle MountCompleted signal and Mount method call failure.
  void OnMountCompleted(MountError error_code,
                        const std::string& source_path,
                        MountType mount_type,
                        const std::string& mount_path) {
    MountCondition mount_condition = MOUNT_CONDITION_NONE;
    if (mount_type == MOUNT_TYPE_DEVICE) {
      if (error_code == MOUNT_ERROR_UNKNOWN_FILESYSTEM) {
        mount_condition = MOUNT_CONDITION_UNKNOWN_FILESYSTEM;
      }
      if (error_code == MOUNT_ERROR_UNSUPPORTED_FILESYSTEM) {
        mount_condition = MOUNT_CONDITION_UNSUPPORTED_FILESYSTEM;
      }
    }
    const MountPointInfo mount_info(source_path, mount_path, mount_type,
                                    mount_condition);

    NotifyMountCompleted(MOUNTING, error_code, mount_info);

    // If the device is corrupted but it's still possible to format it, it will
    // be fake mounted.
    if ((error_code == MOUNT_ERROR_NONE || mount_info.mount_condition) &&
        mount_points_.find(mount_info.mount_path) == mount_points_.end()) {
      mount_points_.insert(MountPointMap::value_type(mount_info.mount_path,
                                                     mount_info));
    }
    if ((error_code == MOUNT_ERROR_NONE || mount_info.mount_condition) &&
        mount_info.mount_type == MOUNT_TYPE_DEVICE &&
        !mount_info.source_path.empty() &&
        !mount_info.mount_path.empty()) {
      DiskMap::iterator iter = disks_.find(mount_info.source_path);
      if (iter == disks_.end()) {
        // disk might have been removed by now?
        return;
      }
      Disk* disk = iter->second;
      DCHECK(disk);
      disk->set_mount_path(mount_info.mount_path);
      NotifyDiskStatusUpdate(MOUNT_DISK_MOUNTED, disk);
    }
  }

  // Callback for UnmountPath.
  void OnUnmountPath(const std::string& mount_path) {
    MountPointMap::iterator mount_points_it = mount_points_.find(mount_path);
    if (mount_points_it == mount_points_.end())
      return;
    // TODO(tbarzic): Add separate, PathUnmounted event to Observer.
    NotifyMountCompleted(
        UNMOUNTING, MOUNT_ERROR_NONE,
        MountPointInfo(mount_points_it->second.source_path,
                       mount_points_it->second.mount_path,
                       mount_points_it->second.mount_type,
                       mount_points_it->second.mount_condition));
    std::string path(mount_points_it->second.source_path);
    mount_points_.erase(mount_points_it);
    DiskMap::iterator iter = disks_.find(path);
    if (iter == disks_.end()) {
      // disk might have been removed by now.
      return;
    }
    Disk* disk = iter->second;
    DCHECK(disk);
    disk->clear_mount_path();
    // Check if there is a formatting scheduled.
    PathMap::iterator it = formatting_pending_.find(disk->device_path());
    if (it != formatting_pending_.end()) {
      // Copy the string before it gets erased.
      const std::string file_path = it->second;
      formatting_pending_.erase(it);
      FormatUnmountedDevice(file_path);
    }
  }

  // Callback for FormatDevice.
  void OnFormatDevice(const std::string& device_path, bool success) {
    if (success) {
      NotifyDeviceStatusUpdate(MOUNT_FORMATTING_STARTED, device_path);
    } else {
      NotifyDeviceStatusUpdate(MOUNT_FORMATTING_STARTED,
                             std::string("!") + device_path);
      LOG(WARNING) << "Format request failed for device " << device_path;
    }
  }

  // Callbcak for GetDeviceProperties.
  void OnGetDeviceProperties(const DiskInfo& disk_info) {
    // TODO(zelidrag): Find a better way to filter these out before we
    // fetch the properties:
    // Ignore disks coming from the device we booted the system from.
    if (disk_info.on_boot_device())
      return;

    LOG(WARNING) << "Found disk " << disk_info.device_path();
    // Delete previous disk info for this path:
    bool is_new = true;
    DiskMap::iterator iter = disks_.find(disk_info.device_path());
    if (iter != disks_.end()) {
      delete iter->second;
      disks_.erase(iter);
      is_new = false;
    }
    Disk* disk = new Disk(disk_info.device_path(),
                          disk_info.mount_path(),
                          disk_info.system_path(),
                          disk_info.file_path(),
                          disk_info.label(),
                          disk_info.drive_label(),
                          disk_info.vendor_id(),
                          disk_info.vendor_name(),
                          disk_info.product_id(),
                          disk_info.product_name(),
                          disk_info.uuid(),
                          FindSystemPathPrefix(disk_info.system_path()),
                          disk_info.device_type(),
                          disk_info.total_size_in_bytes(),
                          disk_info.is_drive(),
                          disk_info.is_read_only(),
                          disk_info.has_media(),
                          disk_info.on_boot_device(),
                          disk_info.is_hidden());
    disks_.insert(std::make_pair(disk_info.device_path(), disk));
    NotifyDiskStatusUpdate(is_new ? MOUNT_DISK_ADDED : MOUNT_DISK_CHANGED,
                           disk);
  }

  // Callbcak for RequestMountInfo.
  void OnRequestMountInfo(const std::vector<std::string>& devices) {
    std::set<std::string> current_device_set;
    if (!devices.empty()) {
      // Initiate properties fetch for all removable disks,
      for (size_t i = 0; i < devices.size(); i++) {
        current_device_set.insert(devices[i]);
        // Initiate disk property retrieval for each relevant device path.
        cros_disks_client_->GetDeviceProperties(
            devices[i],
            base::Bind(&DiskMountManagerImpl::OnGetDeviceProperties,
                       weak_ptr_factory_.GetWeakPtr()),
            base::Bind(&base::DoNothing));
      }
    }
    // Search and remove disks that are no longer present.
    for (DiskMap::iterator iter = disks_.begin(); iter != disks_.end(); ) {
      if (current_device_set.find(iter->first) == current_device_set.end()) {
        Disk* disk = iter->second;
        NotifyDiskStatusUpdate(MOUNT_DISK_REMOVED, disk);
        delete iter->second;
        disks_.erase(iter++);
      } else {
        ++iter;
      }
    }
  }

  // Callback to handle mount event signals.
  void OnMountEvent(MountEventType event, const std::string& device_path_arg) {
    // Take a copy of the argument so we can modify it below.
    std::string device_path = device_path_arg;
    DiskMountManagerEventType type = MOUNT_DEVICE_ADDED;
    switch (event) {
      case DISK_ADDED: {
        cros_disks_client_->GetDeviceProperties(
            device_path,
            base::Bind(&DiskMountManagerImpl::OnGetDeviceProperties,
                       weak_ptr_factory_.GetWeakPtr()),
            base::Bind(&base::DoNothing));
        return;
      }
      case DISK_REMOVED: {
        // Search and remove disks that are no longer present.
        DiskMountManager::DiskMap::iterator iter = disks_.find(device_path);
        if (iter != disks_.end()) {
          Disk* disk = iter->second;
          NotifyDiskStatusUpdate(MOUNT_DISK_REMOVED, disk);
          delete iter->second;
          disks_.erase(iter);
        }
        return;
      }
      case DEVICE_ADDED: {
        type = MOUNT_DEVICE_ADDED;
        system_path_prefixes_.insert(device_path);
        break;
      }
      case DEVICE_REMOVED: {
        type = MOUNT_DEVICE_REMOVED;
        system_path_prefixes_.erase(device_path);
        break;
      }
      case DEVICE_SCANNED: {
        type = MOUNT_DEVICE_SCANNED;
        break;
      }
      case FORMATTING_FINISHED: {
        // FORMATTING_FINISHED actually returns file path instead of device
        // path.
        device_path = FilePathToDevicePath(device_path);
        if (device_path.empty()) {
          LOG(ERROR) << "Error while handling disks metadata. Cannot find "
                     << "device that is being formatted.";
          return;
        }
        type = MOUNT_FORMATTING_FINISHED;
        break;
      }
      default: {
        LOG(ERROR) << "Unknown event: " << event;
        return;
      }
    }
    NotifyDeviceStatusUpdate(type, device_path);
  }

  // Notifies all observers about disk status update.
  void NotifyDiskStatusUpdate(DiskMountManagerEventType event,
                              const Disk* disk) {
    FOR_EACH_OBSERVER(Observer, observers_, DiskChanged(event, disk));
  }

  // Notifies all observers about device status update.
  void NotifyDeviceStatusUpdate(DiskMountManagerEventType event,
                                const std::string& device_path) {
    FOR_EACH_OBSERVER(Observer, observers_, DeviceChanged(event, device_path));
  }

  // Notifies all observers about mount completion.
  void NotifyMountCompleted(MountEvent event_type,
                            MountError error_code,
                            const MountPointInfo& mount_info) {
    FOR_EACH_OBSERVER(Observer, observers_,
                      MountCompleted(event_type, error_code, mount_info));
  }

  // Converts file path to device path.
  std::string FilePathToDevicePath(const std::string& file_path) {
    // TODO(hashimoto): Refactor error handling code like here.
    // Appending "!" is not the best way to indicate error.  This kind of trick
    // also makes it difficult to simplify the code paths.  crosbug.com/22972
    const int failed = StartsWithASCII(file_path, "!", true);
    for (DiskMountManager::DiskMap::iterator it = disks_.begin();
         it != disks_.end(); ++it) {
      // Skip the leading '!' on the failure case.
      if (it->second->file_path() == file_path.substr(failed)) {
        if (failed)
          return std::string("!") + it->second->device_path();
        else
          return it->second->device_path();
      }
    }
    return "";
  }

  // Finds system path prefix from |system_path|.
  const std::string& FindSystemPathPrefix(const std::string& system_path) {
    if (system_path.empty())
      return EmptyString();
    for (SystemPathPrefixSet::const_iterator it = system_path_prefixes_.begin();
         it != system_path_prefixes_.end();
         ++it) {
      const std::string& prefix = *it;
      if (StartsWithASCII(system_path, prefix, true))
        return prefix;
    }
    return EmptyString();
  }

  // Mount event change observers.
  ObserverList<Observer> observers_;

  CrosDisksClient* cros_disks_client_;

  // The list of disks found.
  DiskMountManager::DiskMap disks_;

  DiskMountManager::MountPointMap mount_points_;

  typedef std::set<std::string> SystemPathPrefixSet;
  SystemPathPrefixSet system_path_prefixes_;

  // A map from device path (e.g. /sys/devices/pci0000:00/.../sdb/sdb1)) to file
  // path (e.g. /dev/sdb).
  // Devices in this map are supposed to be formatted, but are currently waiting
  // to be unmounted. When device is in this map, the formatting process HAVEN'T
  // started yet.
  typedef std::map<std::string, std::string> PathMap;
  PathMap formatting_pending_;

  base::WeakPtrFactory<DiskMountManagerImpl> weak_ptr_factory_;

  DISALLOW_COPY_AND_ASSIGN(DiskMountManagerImpl);
};

}  // namespace

DiskMountManager::Disk::Disk(const std::string& device_path,
                             const std::string& mount_path,
                             const std::string& system_path,
                             const std::string& file_path,
                             const std::string& device_label,
                             const std::string& drive_label,
                             const std::string& vendor_id,
                             const std::string& vendor_name,
                             const std::string& product_id,
                             const std::string& product_name,
                             const std::string& fs_uuid,
                             const std::string& system_path_prefix,
                             DeviceType device_type,
                             uint64 total_size_in_bytes,
                             bool is_parent,
                             bool is_read_only,
                             bool has_media,
                             bool on_boot_device,
                             bool is_hidden)
    : device_path_(device_path),
      mount_path_(mount_path),
      system_path_(system_path),
      file_path_(file_path),
      device_label_(device_label),
      drive_label_(drive_label),
      vendor_id_(vendor_id),
      vendor_name_(vendor_name),
      product_id_(product_id),
      product_name_(product_name),
      fs_uuid_(fs_uuid),
      system_path_prefix_(system_path_prefix),
      device_type_(device_type),
      total_size_in_bytes_(total_size_in_bytes),
      is_parent_(is_parent),
      is_read_only_(is_read_only),
      has_media_(has_media),
      on_boot_device_(on_boot_device),
      is_hidden_(is_hidden) {
}

DiskMountManager::Disk::~Disk() {}

// static
std::string DiskMountManager::MountTypeToString(MountType type) {
  switch (type) {
    case MOUNT_TYPE_DEVICE:
      return "device";
    case MOUNT_TYPE_ARCHIVE:
      return "file";
    case MOUNT_TYPE_NETWORK_STORAGE:
      return "network";
    case MOUNT_TYPE_GDATA:
      return "gdata";
    case MOUNT_TYPE_INVALID:
      return "invalid";
    default:
      NOTREACHED();
  }
  return "";
}

// static
std::string DiskMountManager::MountConditionToString(MountCondition condition) {
  switch (condition) {
    case MOUNT_CONDITION_NONE:
      return "";
    case MOUNT_CONDITION_UNKNOWN_FILESYSTEM:
      return "unknown_filesystem";
    case MOUNT_CONDITION_UNSUPPORTED_FILESYSTEM:
      return "unsupported_filesystem";
    default:
      NOTREACHED();
  }
  return "";
}

// static
MountType DiskMountManager::MountTypeFromString(const std::string& type_str) {
  if (type_str == "device")
    return MOUNT_TYPE_DEVICE;
  else if (type_str == "network")
    return MOUNT_TYPE_NETWORK_STORAGE;
  else if (type_str == "file")
    return MOUNT_TYPE_ARCHIVE;
  else if (type_str == "gdata")
    return MOUNT_TYPE_GDATA;
  else
    return MOUNT_TYPE_INVALID;
}

// static
std::string DiskMountManager::DeviceTypeToString(DeviceType type) {
  switch (type) {
    case DEVICE_TYPE_USB:
      return "usb";
    case DEVICE_TYPE_SD:
      return "sd";
    case DEVICE_TYPE_OPTICAL_DISC:
      return "optical";
    case DEVICE_TYPE_MOBILE:
      return "mobile";
    default:
      return "unknown";
  }
}

// static
void DiskMountManager::Initialize() {
  if (g_disk_mount_manager) {
    LOG(WARNING) << "DiskMountManager was already initialized";
    return;
  }
  g_disk_mount_manager = new DiskMountManagerImpl();
  VLOG(1) << "DiskMountManager initialized";
}

// static
void DiskMountManager::InitializeForTesting(
    DiskMountManager* disk_mount_manager) {
  if (g_disk_mount_manager) {
    LOG(WARNING) << "DiskMountManager was already initialized";
    return;
  }
  g_disk_mount_manager = disk_mount_manager;
  VLOG(1) << "DiskMountManager initialized";
}

// static
void DiskMountManager::Shutdown() {
  if (!g_disk_mount_manager) {
    LOG(WARNING) << "DiskMountManager::Shutdown() called with NULL manager";
    return;
  }
  delete g_disk_mount_manager;
  g_disk_mount_manager = NULL;
  VLOG(1) << "DiskMountManager Shutdown completed";
}

// static
DiskMountManager* DiskMountManager::GetInstance() {
  return g_disk_mount_manager;
}

}  // namespace disks
}  // namespace chromeos