Home | History | Annotate | Download | only in model 
      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 "android/os/IVoldListener.h"
     21 #include "Utils.h"
     22 
     23 #include <cutils/multiuser.h>
     24 #include <utils/Errors.h>
     25 
     26 #include <sys/types.h>
     27 #include <list>
     28 #include <string>
     29 
     30 namespace android {
     31 namespace vold {
     32 
     33 /*
     34  * Representation of a mounted volume ready for presentation.
     35  *
     36  * Various subclasses handle the different mounting prerequisites, such as
     37  * encryption details, etc.  Volumes can also be "stacked" above other
     38  * volumes to help communicate dependencies.  For example, an ASEC volume
     39  * can be stacked on a vfat volume.
     40  *
     41  * Mounted volumes can be asked to manage bind mounts to present themselves
     42  * to specific users on the device.
     43  *
     44  * When an unmount is requested, the volume recursively unmounts any stacked
     45  * volumes and removes any bind mounts before finally unmounting itself.
     46  */
     47 class VolumeBase {
     48 public:
     49     virtual ~VolumeBase();
     50 
     51     enum class Type {
     52         kPublic = 0,
     53         kPrivate,
     54         kEmulated,
     55         kAsec,
     56         kObb,
     57     };
     58 
     59     enum MountFlags {
     60         /* Flag that volume is primary external storage */
     61         kPrimary = 1 << 0,
     62         /* Flag that volume is visible to normal apps */
     63         kVisible = 1 << 1,
     64     };
     65 
     66     enum class State {
     67         kUnmounted = 0,
     68         kChecking,
     69         kMounted,
     70         kMountedReadOnly,
     71         kFormatting,
     72         kEjecting,
     73         kUnmountable,
     74         kRemoved,
     75         kBadRemoval,
     76     };
     77 
     78     const std::string& getId() { return mId; }
     79     const std::string& getDiskId() { return mDiskId; }
     80     const std::string& getPartGuid() { return mPartGuid; }
     81     Type getType() { return mType; }
     82     int getMountFlags() { return mMountFlags; }
     83     userid_t getMountUserId() { return mMountUserId; }
     84     State getState() { return mState; }
     85     const std::string& getPath() { return mPath; }
     86     const std::string& getInternalPath() { return mInternalPath; }
     87 
     88     status_t setDiskId(const std::string& diskId);
     89     status_t setPartGuid(const std::string& partGuid);
     90     status_t setMountFlags(int mountFlags);
     91     status_t setMountUserId(userid_t mountUserId);
     92     status_t setSilent(bool silent);
     93 
     94     void addVolume(const std::shared_ptr<VolumeBase>& volume);
     95     void removeVolume(const std::shared_ptr<VolumeBase>& volume);
     96 
     97     std::shared_ptr<VolumeBase> findVolume(const std::string& id);
     98 
     99     status_t create();
    100     status_t destroy();
    101     status_t mount();
    102     status_t unmount();
    103     status_t format(const std::string& fsType);
    104 
    105 protected:
    106     explicit VolumeBase(Type type);
    107 
    108     virtual status_t doCreate();
    109     virtual status_t doDestroy();
    110     virtual status_t doMount() = 0;
    111     virtual status_t doUnmount() = 0;
    112     virtual status_t doFormat(const std::string& fsType);
    113 
    114     status_t setId(const std::string& id);
    115     status_t setPath(const std::string& path);
    116     status_t setInternalPath(const std::string& internalPath);
    117 
    118     android::sp<android::os::IVoldListener> getListener();
    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
    156