path: root/VolumeBase.h (plain)
blob: 28a2cfe1ea6f0eae247598e03256dc4ecde44102

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 droidvold {
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& getSysPath() { return mSysPath; }
86	const std::string& getInternalPath() { return mInternalPath; }
87	int getDiskFlags() { return mDiskFlags; }
88	int getPartNo() { return mPartNo; }
89
90	status_t setDiskId(const std::string& diskId);
91	status_t setPartGuid(const std::string& partGuid);
92	status_t setMountFlags(int mountFlags);
93	status_t setMountUserId(userid_t mountUserId);
94	status_t setSilent(bool silent);
95	void setSysPath(const std::string& sysPath) { mSysPath = sysPath; }
96	status_t setDiskFlags(int diskFlags);
97	status_t setPartNo(int part);
98
99	void addVolume(const std::shared_ptr<VolumeBase>& volume);
100	void removeVolume(const std::shared_ptr<VolumeBase>& volume);
101
102	std::shared_ptr<VolumeBase> findVolume(const std::string& id);
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	virtual bool isSrdiskMounted() = 0;
110
111	protected:
112	explicit VolumeBase(Type type);
113
114	virtual status_t doCreate();
115	virtual status_t doDestroy();
116	virtual status_t doMount() = 0;
117	virtual status_t doUnmount() = 0;
118	virtual status_t doFormat(const std::string& fsType);
119
120	status_t setId(const std::string& id);
121	status_t setPath(const std::string& path);
122	status_t setInternalPath(const std::string& internalPath);
123	void notifyEvent(int msg);
124	void notifyEvent(int msg, const std::string& value);
125
126	private:
127	/* ID that uniquely references volume while alive */
128	std::string mId;
129	/* ID that uniquely references parent disk while alive */
130	std::string mDiskId;
131	/* Partition GUID of this volume */
132	std::string mPartGuid;
133	/* Volume type */
134	Type mType;
135	/* Flags used when mounting this volume */
136	int mMountFlags;
137	/* User that owns this volume, otherwise -1 */
138	userid_t mMountUserId;
139	/* Flag indicating object is created */
140	bool mCreated;
141	/* Current state of volume */
142	State mState;
143	/* Path to mounted volume */
144	std::string mPath;
145	/* Device path under sysfs */
146	std::string mSysPath;
147	/* Path to internal backing storage */
148	std::string mInternalPath;
149	/* Flag indicating that volume should emit no events */
150	bool mSilent;
151	int mDiskFlags;
152	int mPartNo;
153
154	/* Volumes stacked on top of this volume */
155	std::list<std::shared_ptr<VolumeBase>> mVolumes;
156
157	void setState(State state);
158
159	DISALLOW_COPY_AND_ASSIGN(VolumeBase);
160	};
161
162	} // namespace vold
163	} // namespace android
164
165	#endif
166