VolumeBase.h

   1 /*
   2  * Copyright (C) 2008 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #ifndef ANDROID_VOLD_VOLUME_BASE_H
  18 #define ANDROID_VOLD_VOLUME_BASE_H
  19
  20 #include "Utils.h"
  21
  22 #include <cutils/multiuser.h>
  23 #include <utils/Errors.h>
  24
  25 #include <sys/types.h>
  26 #include <list>
  27 #include <string>
  28
  29 namespace android {
  30 namespace vold {
  31
  32 /*
  33  * Representation of a mounted volume ready for presentation.
  34  *
  35  * Various subclasses handle the different mounting prerequisites, such as
  36  * encryption details, etc.  Volumes can also be "stacked" above other
  37  * volumes to help communicate dependencies.  For example, an ASEC volume
  38  * can be stacked on a vfat volume.
  39  *
  40  * Mounted volumes can be asked to manage bind mounts to present themselves
  41  * to specific users on the device.
  42  *
  43  * When an unmount is requested, the volume recursively unmounts any stacked
  44  * volumes and removes any bind mounts before finally unmounting itself.
  45  */
  46 class VolumeBase {
  47 public:
  48     virtual ~VolumeBase();
  49
  50     enum class Type {
  51         kPublic = 0,
  52         kPrivate,
  53         kEmulated,
  54         kAsec,
  55         kObb,
  56     };
  57
  58     enum MountFlags {
  59         /* Flag that volume is primary external storage */
  60         kPrimary = 1 << 0,
  61         /* Flag that volume is visible to normal apps */
  62         kVisible = 1 << 1,
  63     };
  64
  65     enum class State {
  66         kUnmounted = 0,
  67         kChecking,
  68         kMounted,
  69         kMountedReadOnly,
  70         kFormatting,
  71         kEjecting,
  72         kUnmountable,
  73         kRemoved,
  74         kBadRemoval,
  75     };
  76
  77     const std::string& getId() { return mId; }
  78     const std::string& getDiskId() { return mDiskId; }
  79     const std::string& getPartGuid() { return mPartGuid; }
  80     Type getType() { return mType; }
  81     int getMountFlags() { return mMountFlags; }
  82     userid_t getMountUserId() { return mMountUserId; }
  83     State getState() { return mState; }
  84     const std::string& getPath() { return mPath; }
  85     const std::string& getInternalPath() { return mInternalPath; }
  86
  87     status_t setDiskId(const std::string& diskId);
  88     status_t setPartGuid(const std::string& partGuid);
  89     status_t setMountFlags(int mountFlags);
  90     status_t setMountUserId(userid_t mountUserId);
  91     status_t setSilent(bool silent);
  92
  93     void addVolume(const std::shared_ptr<VolumeBase>& volume);
  94     void removeVolume(const std::shared_ptr<VolumeBase>& volume);
  95
  96     std::shared_ptr<VolumeBase> findVolume(const std::string& id);
  97
  98     status_t create();
  99     status_t destroy();
 100     status_t mount();
 101     status_t unmount();
 102     status_t format(const std::string& fsType);
 103
 104 protected:
 105     explicit VolumeBase(Type type);
 106
 107     virtual status_t doCreate();
 108     virtual status_t doDestroy();
 109     virtual status_t doMount() = 0;
 110     virtual status_t doUnmount() = 0;
 111     virtual status_t doFormat(const std::string& fsType);
 112
 113     status_t setId(const std::string& id);
 114     status_t setPath(const std::string& path);
 115     status_t setInternalPath(const std::string& internalPath);
 116
 117     void notifyEvent(int msg);
 118     void notifyEvent(int msg, const std::string& value);
 119
 120 private:
 121     /* ID that uniquely references volume while alive */
 122     std::string mId;
 123     /* ID that uniquely references parent disk while alive */
 124     std::string mDiskId;
 125     /* Partition GUID of this volume */
 126     std::string mPartGuid;
 127     /* Volume type */
 128     Type mType;
 129     /* Flags used when mounting this volume */
 130     int mMountFlags;
 131     /* User that owns this volume, otherwise -1 */
 132     userid_t mMountUserId;
 133     /* Flag indicating object is created */
 134     bool mCreated;
 135     /* Current state of volume */
 136     State mState;
 137     /* Path to mounted volume */
 138     std::string mPath;
 139     /* Path to internal backing storage */
 140     std::string mInternalPath;
 141     /* Flag indicating that volume should emit no events */
 142     bool mSilent;
 143
 144     /* Volumes stacked on top of this volume */
 145     std::list<std::shared_ptr<VolumeBase>> mVolumes;
 146
 147     void setState(State state);
 148
 149     DISALLOW_COPY_AND_ASSIGN(VolumeBase);
 150 };
 151
 152 }  // namespace vold
 153 }  // namespace android
 154
 155 #endif