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