Home | History | Annotate | Download | only in vold 
      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
    156