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