1 /*
2  * Copyright (C) 2015 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 #include "fs/Ext4.h"
18 #include "fs/F2fs.h"
19 #include "PrivateVolume.h"
20 #include "EmulatedVolume.h"
21 #include "Utils.h"
22 #include "VolumeManager.h"
23 #include "ResponseCode.h"
24 #include "cryptfs.h"
25 
26 #include <android-base/stringprintf.h>
27 #include <android-base/logging.h>
28 #include <cutils/fs.h>
29 #include <private/android_filesystem_config.h>
30 
31 #include <fcntl.h>
32 #include <stdlib.h>
33 #include <sys/mount.h>
34 #include <sys/stat.h>
35 #include <sys/types.h>
36 #include <sys/wait.h>
37 #include <sys/param.h>
38 
39 using android::base::StringPrintf;
40 
41 namespace android {
42 namespace vold {
43 
44 static const unsigned int kMajorBlockMmc = 179;
45 
PrivateVolume(dev_t device,const std::string & keyRaw)46 PrivateVolume::PrivateVolume(dev_t device, const std::string& keyRaw) :
47         VolumeBase(Type::kPrivate), mRawDevice(device), mKeyRaw(keyRaw) {
48     setId(StringPrintf("private:%u,%u", major(device), minor(device)));
49     mRawDevPath = StringPrintf("/dev/block/vold/%s", getId().c_str());
50 }
51 
~PrivateVolume()52 PrivateVolume::~PrivateVolume() {
53 }
54 
readMetadata()55 status_t PrivateVolume::readMetadata() {
56     status_t res = ReadMetadata(mDmDevPath, mFsType, mFsUuid, mFsLabel);
57     notifyEvent(ResponseCode::VolumeFsTypeChanged, mFsType);
58     notifyEvent(ResponseCode::VolumeFsUuidChanged, mFsUuid);
59     notifyEvent(ResponseCode::VolumeFsLabelChanged, mFsLabel);
60     return res;
61 }
62 
doCreate()63 status_t PrivateVolume::doCreate() {
64     if (CreateDeviceNode(mRawDevPath, mRawDevice)) {
65         return -EIO;
66     }
67 
68     // Recover from stale vold by tearing down any old mappings
69     cryptfs_revert_ext_volume(getId().c_str());
70 
71     // TODO: figure out better SELinux labels for private volumes
72 
73     unsigned char* key = (unsigned char*) mKeyRaw.data();
74     char crypto_blkdev[MAXPATHLEN];
75     int res = cryptfs_setup_ext_volume(getId().c_str(), mRawDevPath.c_str(),
76             key, mKeyRaw.size(), crypto_blkdev);
77     mDmDevPath = crypto_blkdev;
78     if (res != 0) {
79         PLOG(ERROR) << getId() << " failed to setup cryptfs";
80         return -EIO;
81     }
82 
83     return OK;
84 }
85 
doDestroy()86 status_t PrivateVolume::doDestroy() {
87     if (cryptfs_revert_ext_volume(getId().c_str())) {
88         LOG(ERROR) << getId() << " failed to revert cryptfs";
89     }
90     return DestroyDeviceNode(mRawDevPath);
91 }
92 
doMount()93 status_t PrivateVolume::doMount() {
94     if (readMetadata()) {
95         LOG(ERROR) << getId() << " failed to read metadata";
96         return -EIO;
97     }
98 
99     mPath = StringPrintf("/mnt/expand/%s", mFsUuid.c_str());
100     setPath(mPath);
101 
102     if (PrepareDir(mPath, 0700, AID_ROOT, AID_ROOT)) {
103         PLOG(ERROR) << getId() << " failed to create mount point " << mPath;
104         return -EIO;
105     }
106 
107     if (mFsType == "ext4") {
108         int res = ext4::Check(mDmDevPath, mPath);
109         if (res == 0 || res == 1) {
110             LOG(DEBUG) << getId() << " passed filesystem check";
111         } else {
112             PLOG(ERROR) << getId() << " failed filesystem check";
113             return -EIO;
114         }
115 
116         if (ext4::Mount(mDmDevPath, mPath, false, false, true)) {
117             PLOG(ERROR) << getId() << " failed to mount";
118             return -EIO;
119         }
120 
121     } else if (mFsType == "f2fs") {
122         int res = f2fs::Check(mDmDevPath);
123         if (res == 0) {
124             LOG(DEBUG) << getId() << " passed filesystem check";
125         } else {
126             PLOG(ERROR) << getId() << " failed filesystem check";
127             return -EIO;
128         }
129 
130         if (f2fs::Mount(mDmDevPath, mPath)) {
131             PLOG(ERROR) << getId() << " failed to mount";
132             return -EIO;
133         }
134 
135     } else {
136         LOG(ERROR) << getId() << " unsupported filesystem " << mFsType;
137         return -EIO;
138     }
139 
140     LOG(VERBOSE) << "Starting restorecon of " << mPath;
141 
142     // TODO: find a cleaner way of waiting for restorecon to finish
143     property_set("selinux.restorecon_recursive", "");
144     property_set("selinux.restorecon_recursive", mPath.c_str());
145 
146     char value[PROPERTY_VALUE_MAX];
147     while (true) {
148         property_get("selinux.restorecon_recursive", value, "");
149         if (strcmp(mPath.c_str(), value) == 0) {
150             break;
151         }
152         sleep(1);
153         LOG(VERBOSE) << "Waiting for restorecon...";
154     }
155 
156     LOG(VERBOSE) << "Finished restorecon of " << mPath;
157 
158     // Verify that common directories are ready to roll
159     if (PrepareDir(mPath + "/app", 0771, AID_SYSTEM, AID_SYSTEM) ||
160             PrepareDir(mPath + "/user", 0711, AID_SYSTEM, AID_SYSTEM) ||
161             PrepareDir(mPath + "/user_de", 0711, AID_SYSTEM, AID_SYSTEM) ||
162             PrepareDir(mPath + "/media", 0770, AID_MEDIA_RW, AID_MEDIA_RW) ||
163             PrepareDir(mPath + "/media/0", 0770, AID_MEDIA_RW, AID_MEDIA_RW) ||
164             PrepareDir(mPath + "/local", 0751, AID_ROOT, AID_ROOT) ||
165             PrepareDir(mPath + "/local/tmp", 0771, AID_SHELL, AID_SHELL)) {
166         PLOG(ERROR) << getId() << " failed to prepare";
167         return -EIO;
168     }
169 
170     // Create a new emulated volume stacked above us, it will automatically
171     // be destroyed during unmount
172     std::string mediaPath(mPath + "/media");
173     auto vol = std::shared_ptr<VolumeBase>(
174             new EmulatedVolume(mediaPath, mRawDevice, mFsUuid));
175     addVolume(vol);
176     vol->create();
177 
178     return OK;
179 }
180 
doUnmount()181 status_t PrivateVolume::doUnmount() {
182     ForceUnmount(mPath);
183 
184     if (TEMP_FAILURE_RETRY(rmdir(mPath.c_str()))) {
185         PLOG(ERROR) << getId() << " failed to rmdir mount point " << mPath;
186     }
187 
188     return OK;
189 }
190 
doFormat(const std::string & fsType)191 status_t PrivateVolume::doFormat(const std::string& fsType) {
192     std::string resolvedFsType = fsType;
193     if (fsType == "auto") {
194         // For now, assume that all MMC devices are flash-based SD cards, and
195         // give everyone else ext4 because sysfs rotational isn't reliable.
196         if ((major(mRawDevice) == kMajorBlockMmc) && f2fs::IsSupported()) {
197             resolvedFsType = "f2fs";
198         } else {
199             resolvedFsType = "ext4";
200         }
201         LOG(DEBUG) << "Resolved auto to " << resolvedFsType;
202     }
203 
204     if (resolvedFsType == "ext4") {
205         // TODO: change reported mountpoint once we have better selinux support
206         if (ext4::Format(mDmDevPath, 0, "/data")) {
207             PLOG(ERROR) << getId() << " failed to format";
208             return -EIO;
209         }
210     } else if (resolvedFsType == "f2fs") {
211         if (f2fs::Format(mDmDevPath)) {
212             PLOG(ERROR) << getId() << " failed to format";
213             return -EIO;
214         }
215     } else {
216         LOG(ERROR) << getId() << " unsupported filesystem " << fsType;
217         return -EINVAL;
218     }
219 
220     return OK;
221 }
222 
223 }  // namespace vold
224 }  // namespace android
225