VolumeBase.h revision 36801cccf27152c9eca5aab6ba3527221525110f 
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 Flags {
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        kMounting,
68        kMounted,
69        kFormatting,
70        kUnmounting,
71    };
72
73    const std::string& getId() { return mId; }
74    Type getType() { return mType; }
75    int getFlags() { return mFlags; }
76    userid_t getUser() { return mUser; }
77    State getState() { return mState; }
78    const std::string& getPath() { return mPath; }
79
80    status_t setFlags(int flags);
81    status_t setUser(userid_t user);
82
83    void addVolume(const std::shared_ptr<VolumeBase>& volume);
84    void removeVolume(const std::shared_ptr<VolumeBase>& volume);
85
86    std::shared_ptr<VolumeBase> findVolume(const std::string& id);
87
88    status_t create();
89    status_t destroy();
90
91    status_t mount();
92    status_t unmount();
93    status_t format();
94
95protected:
96    explicit VolumeBase(Type type);
97
98    virtual status_t doMount() = 0;
99    virtual status_t doUnmount() = 0;
100    virtual status_t doFormat();
101
102    status_t setId(const std::string& id);
103    status_t setPath(const std::string& path);
104
105private:
106    /* ID that uniquely references volume while alive */
107    std::string mId;
108    /* Volume type */
109    Type mType;
110    /* Flags applicable to volume */
111    int mFlags;
112    /* User that owns this volume, otherwise -1 */
113    userid_t mUser;
114    /* Flag indicating object is created */
115    bool mCreated;
116    /* Current state of volume */
117    State mState;
118    /* Path to mounted volume */
119    std::string mPath;
120
121    /* Volumes stacked on top of this volume */
122    std::list<std::shared_ptr<VolumeBase>> mVolumes;
123
124    void setState(State state);
125
126    DISALLOW_COPY_AND_ASSIGN(VolumeBase);
127};
128
129}  // namespace vold
130}  // namespace android
131
132#endif
133