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 #include "android/os/IVoldListener.h"
22 #include "android/os/IVoldMountCallback.h"
23 
24 #include <cutils/multiuser.h>
25 #include <utils/Errors.h>
26 
27 #include <sys/types.h>
28 #include <list>
29 #include <string>
30 
31 static constexpr userid_t USER_UNKNOWN = ((userid_t)-1);
32 
33 namespace android {
34 namespace vold {
35 
36 /*
37  * Representation of a mounted volume ready for presentation.
38  *
39  * Various subclasses handle the different mounting prerequisites, such as
40  * encryption details, etc.  Volumes can also be "stacked" above other
41  * volumes to help communicate dependencies.  For example, an ASEC volume
42  * can be stacked on a vfat volume.
43  *
44  * Mounted volumes can be asked to manage bind mounts to present themselves
45  * to specific users on the device.
46  *
47  * When an unmount is requested, the volume recursively unmounts any stacked
48  * volumes and removes any bind mounts before finally unmounting itself.
49  */
50 class VolumeBase {
51   public:
52     virtual ~VolumeBase();
53 
54     enum class Type {
55         kPublic = 0,
56         kPrivate,
57         kEmulated,
58         kAsec,
59         kObb,
60         kStub,
61     };
62 
63     enum MountFlags {
64         /* Flag that volume is primary external storage */
65         kPrimary = 1 << 0,
66         /* Flag that volume is visible to normal apps */
67         kVisible = 1 << 1,
68     };
69 
70     enum class State {
71         kUnmounted = 0,
72         kChecking,
73         kMounted,
74         kMountedReadOnly,
75         kFormatting,
76         kEjecting,
77         kUnmountable,
78         kRemoved,
79         kBadRemoval,
80     };
81 
getId()82     const std::string& getId() const { return mId; }
getDiskId()83     const std::string& getDiskId() const { return mDiskId; }
getPartGuid()84     const std::string& getPartGuid() const { return mPartGuid; }
getType()85     Type getType() const { return mType; }
getMountFlags()86     int getMountFlags() const { return mMountFlags; }
getMountUserId()87     userid_t getMountUserId() const { return mMountUserId; }
getState()88     State getState() const { return mState; }
getPath()89     const std::string& getPath() const { return mPath; }
getInternalPath()90     const std::string& getInternalPath() const { return mInternalPath; }
getVolumes()91     const std::list<std::shared_ptr<VolumeBase>>& getVolumes() const { return mVolumes; }
92 
93     status_t setDiskId(const std::string& diskId);
94     status_t setPartGuid(const std::string& partGuid);
95     status_t setMountFlags(int mountFlags);
96     status_t setMountUserId(userid_t mountUserId);
97     status_t setMountCallback(const android::sp<android::os::IVoldMountCallback>& callback);
98     status_t setSilent(bool silent);
99 
100     void addVolume(const std::shared_ptr<VolumeBase>& volume);
101     void removeVolume(const std::shared_ptr<VolumeBase>& volume);
102 
103     std::shared_ptr<VolumeBase> findVolume(const std::string& id);
104 
isEmulated()105     bool isEmulated() { return mType == Type::kEmulated; }
106 
107     status_t create();
108     status_t destroy();
109     status_t mount();
110     status_t unmount();
111     status_t format(const std::string& fsType);
112 
113     virtual std::string getRootPath() const;
114 
115     std::ostream& operator<<(std::ostream& stream) const;
116 
117   protected:
118     explicit VolumeBase(Type type);
119 
120     virtual status_t doCreate();
121     virtual status_t doDestroy();
122     virtual status_t doMount() = 0;
123     virtual void doPostMount();
124     virtual status_t doUnmount() = 0;
125     virtual status_t doFormat(const std::string& fsType);
126 
127     status_t setId(const std::string& id);
128     status_t setPath(const std::string& path);
129     status_t setInternalPath(const std::string& internalPath);
130 
131     android::sp<android::os::IVoldListener> getListener() const;
132     android::sp<android::os::IVoldMountCallback> getMountCallback() const;
133 
134   private:
135     /* ID that uniquely references volume while alive */
136     std::string mId;
137     /* ID that uniquely references parent disk while alive */
138     std::string mDiskId;
139     /* Partition GUID of this volume */
140     std::string mPartGuid;
141     /* Volume type */
142     Type mType;
143     /* Flags used when mounting this volume */
144     int mMountFlags;
145     /* User that owns this volume, otherwise -1 */
146     userid_t mMountUserId;
147     /* Flag indicating object is created */
148     bool mCreated;
149     /* Current state of volume */
150     State mState;
151     /* Path to mounted volume */
152     std::string mPath;
153     /* Path to internal backing storage */
154     std::string mInternalPath;
155     /* Flag indicating that volume should emit no events */
156     bool mSilent;
157     android::sp<android::os::IVoldMountCallback> mMountCallback;
158 
159     /* Volumes stacked on top of this volume */
160     std::list<std::shared_ptr<VolumeBase>> mVolumes;
161 
162     void setState(State state);
163 
164     DISALLOW_COPY_AND_ASSIGN(VolumeBase);
165 };
166 
167 }  // namespace vold
168 }  // namespace android
169 
170 #endif
171