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