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 
getId()77     const std::string& getId() { return mId; }
getDiskId()78     const std::string& getDiskId() { return mDiskId; }
getPartGuid()79     const std::string& getPartGuid() { return mPartGuid; }
getType()80     Type getType() { return mType; }
getMountFlags()81     int getMountFlags() { return mMountFlags; }
getMountUserId()82     userid_t getMountUserId() { return mMountUserId; }
getState()83     State getState() { return mState; }
getPath()84     const std::string& getPath() { return mPath; }
getInternalPath()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