VolumeBase.h revision 1d6fbcc389ecb9f418076e8ab5f4c93a5d911de9 
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
29namespace android {
30namespace 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 */
46class VolumeBase {
47public:
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    Type getType() { return mType; }
80    int getMountFlags() { return mMountFlags; }
81    userid_t getMountUserId() { return mMountUserId; }
82    State getState() { return mState; }
83    const std::string& getPath() { return mPath; }
84    const std::string& getInternalPath() { return mInternalPath; }
85
86    status_t setDiskId(const std::string& diskId);
87    status_t setMountFlags(int mountFlags);
88    status_t setMountUserId(userid_t mountUserId);
89    status_t setSilent(bool silent);
90
91    void addVolume(const std::shared_ptr<VolumeBase>& volume);
92    void removeVolume(const std::shared_ptr<VolumeBase>& volume);
93
94    std::shared_ptr<VolumeBase> findVolume(const std::string& id);
95
96    status_t create();
97    status_t destroy();
98    status_t mount();
99    status_t unmount();
100    status_t format();
101
102protected:
103    explicit VolumeBase(Type type);
104
105    virtual status_t doCreate();
106    virtual status_t doDestroy();
107    virtual status_t doMount() = 0;
108    virtual status_t doUnmount() = 0;
109    virtual status_t doFormat();
110
111    status_t setId(const std::string& id);
112    status_t setPath(const std::string& path);
113    status_t setInternalPath(const std::string& internalPath);
114
115    void notifyEvent(int msg);
116    void notifyEvent(int msg, const std::string& value);
117
118private:
119    /* ID that uniquely references volume while alive */
120    std::string mId;
121    /* ID that uniquely references parent disk while alive */
122    std::string mDiskId;
123    /* Volume type */
124    Type mType;
125    /* Flags used when mounting this volume */
126    int mMountFlags;
127    /* User that owns this volume, otherwise -1 */
128    userid_t mMountUserId;
129    /* Flag indicating object is created */
130    bool mCreated;
131    /* Current state of volume */
132    State mState;
133    /* Path to mounted volume */
134    std::string mPath;
135    /* Path to internal backing storage */
136    std::string mInternalPath;
137    /* Flag indicating that volume should emit no events */
138    bool mSilent;
139
140    /* Volumes stacked on top of this volume */
141    std::list<std::shared_ptr<VolumeBase>> mVolumes;
142
143    void setState(State state);
144
145    DISALLOW_COPY_AND_ASSIGN(VolumeBase);
146};
147
148}  // namespace vold
149}  // namespace android
150
151#endif
152