blob: a54b05e74f6d516c665ea398900ef017f0c1df5d [file] [log] [blame]
Jeff Sharkey9c484982015-03-31 10:35:33 -07001/*
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
Jeff Sharkey9c484982015-03-31 10:35:33 -070017#include "PrivateVolume.h"
Jeff Sharkey3161fb32015-04-12 16:03:33 -070018#include "EmulatedVolume.h"
Jeff Sharkey9c484982015-03-31 10:35:33 -070019#include "Utils.h"
Paul Crowley886e5722020-02-07 12:51:56 -080020#include "VolumeEncryption.h"
Jeff Sharkey9c484982015-03-31 10:35:33 -070021#include "VolumeManager.h"
Paul Crowley14c8c072018-09-18 13:30:21 -070022#include "fs/Ext4.h"
23#include "fs/F2fs.h"
Jeff Sharkey9c484982015-03-31 10:35:33 -070024
Elliott Hughes7e128fb2015-12-04 15:50:53 -080025#include <android-base/logging.h>
Paul Crowley14c8c072018-09-18 13:30:21 -070026#include <android-base/stringprintf.h>
Jeff Sharkey9c484982015-03-31 10:35:33 -070027#include <cutils/fs.h>
Paul Crowley659b63f2020-02-07 12:15:56 -080028#include <libdm/dm.h>
Jeff Sharkey9c484982015-03-31 10:35:33 -070029#include <private/android_filesystem_config.h>
30
31#include <fcntl.h>
32#include <stdlib.h>
33#include <sys/mount.h>
Jeff Sharkey9c484982015-03-31 10:35:33 -070034#include <sys/param.h>
Paul Crowley14c8c072018-09-18 13:30:21 -070035#include <sys/stat.h>
36#include <sys/sysmacros.h>
37#include <sys/types.h>
38#include <sys/wait.h>
Ricky Wai9eb43672020-02-15 01:15:42 +000039#include <thread>
Jeff Sharkey9c484982015-03-31 10:35:33 -070040
41using android::base::StringPrintf;
42
43namespace android {
44namespace vold {
45
Jeff Sharkeyd0640f62015-05-21 22:35:42 -070046static const unsigned int kMajorBlockMmc = 179;
47
Paul Crowley3d98f5d2020-02-07 11:49:09 -080048PrivateVolume::PrivateVolume(dev_t device, const KeyBuffer& keyRaw)
Paul Crowley14c8c072018-09-18 13:30:21 -070049 : VolumeBase(Type::kPrivate), mRawDevice(device), mKeyRaw(keyRaw) {
Jeff Sharkey9c484982015-03-31 10:35:33 -070050 setId(StringPrintf("private:%u,%u", major(device), minor(device)));
51 mRawDevPath = StringPrintf("/dev/block/vold/%s", getId().c_str());
Jeff Sharkey9c484982015-03-31 10:35:33 -070052}
53
Paul Crowley14c8c072018-09-18 13:30:21 -070054PrivateVolume::~PrivateVolume() {}
Jeff Sharkey9c484982015-03-31 10:35:33 -070055
56status_t PrivateVolume::readMetadata() {
Jeff Sharkey3472e522017-10-06 18:02:53 -060057 status_t res = ReadMetadata(mDmDevPath, &mFsType, &mFsUuid, &mFsLabel);
Jeff Sharkeycbe69fc2017-09-15 16:50:28 -060058
Jeff Sharkey814e9d32017-09-13 11:49:44 -060059 auto listener = getListener();
60 if (listener) listener->onVolumeMetadataChanged(getId(), mFsType, mFsUuid, mFsLabel);
Jeff Sharkeycbe69fc2017-09-15 16:50:28 -060061
Jeff Sharkey9c484982015-03-31 10:35:33 -070062 return res;
63}
64
65status_t PrivateVolume::doCreate() {
66 if (CreateDeviceNode(mRawDevPath, mRawDevice)) {
67 return -EIO;
68 }
69
70 // Recover from stale vold by tearing down any old mappings
Paul Crowley659b63f2020-02-07 12:15:56 -080071 auto& dm = dm::DeviceMapper::Instance();
Ricky Wai9eb43672020-02-15 01:15:42 +000072 // TODO(b/149396179) there appears to be a race somewhere in the system where trying
73 // to delete the device fails with EBUSY; for now, work around this by retrying.
74 bool ret;
75 int tries = 10;
76 while (tries-- > 0) {
77 ret = dm.DeleteDeviceIfExists(getId());
78 if (ret || errno != EBUSY) {
79 break;
80 }
Paul Crowley659b63f2020-02-07 12:15:56 -080081 PLOG(ERROR) << "Cannot remove dm device " << getId();
Ricky Wai9eb43672020-02-15 01:15:42 +000082 std::this_thread::sleep_for(std::chrono::milliseconds(100));
83 }
84 if (!ret) {
Paul Crowley659b63f2020-02-07 12:15:56 -080085 return -EIO;
86 }
Jeff Sharkey9c484982015-03-31 10:35:33 -070087
88 // TODO: figure out better SELinux labels for private volumes
89
Paul Crowley886e5722020-02-07 12:51:56 -080090 if (!setup_ext_volume(getId(), mRawDevPath, mKeyRaw, &mDmDevPath)) {
91 LOG(ERROR) << getId() << " failed to setup metadata encryption";
Jeff Sharkey9c484982015-03-31 10:35:33 -070092 return -EIO;
93 }
94
95 return OK;
96}
97
98status_t PrivateVolume::doDestroy() {
Paul Crowley659b63f2020-02-07 12:15:56 -080099 auto& dm = dm::DeviceMapper::Instance();
Ricky Wai9eb43672020-02-15 01:15:42 +0000100 // TODO(b/149396179) there appears to be a race somewhere in the system where trying
101 // to delete the device fails with EBUSY; for now, work around this by retrying.
102 bool ret;
103 int tries = 10;
104 while (tries-- > 0) {
105 ret = dm.DeleteDevice(getId());
106 if (ret || errno != EBUSY) {
107 break;
108 }
Paul Crowley659b63f2020-02-07 12:15:56 -0800109 PLOG(ERROR) << "Cannot remove dm device " << getId();
Ricky Wai9eb43672020-02-15 01:15:42 +0000110 std::this_thread::sleep_for(std::chrono::milliseconds(100));
111 }
112 if (!ret) {
Paul Crowley659b63f2020-02-07 12:15:56 -0800113 return -EIO;
Jeff Sharkey9c484982015-03-31 10:35:33 -0700114 }
115 return DestroyDeviceNode(mRawDevPath);
116}
117
118status_t PrivateVolume::doMount() {
119 if (readMetadata()) {
120 LOG(ERROR) << getId() << " failed to read metadata";
121 return -EIO;
122 }
123
Jeff Sharkeyf0121c52015-04-06 14:08:45 -0700124 mPath = StringPrintf("/mnt/expand/%s", mFsUuid.c_str());
125 setPath(mPath);
126
127 if (PrepareDir(mPath, 0700, AID_ROOT, AID_ROOT)) {
128 PLOG(ERROR) << getId() << " failed to create mount point " << mPath;
129 return -EIO;
130 }
131
Jeff Sharkeyd0640f62015-05-21 22:35:42 -0700132 if (mFsType == "ext4") {
133 int res = ext4::Check(mDmDevPath, mPath);
134 if (res == 0 || res == 1) {
135 LOG(DEBUG) << getId() << " passed filesystem check";
136 } else {
137 PLOG(ERROR) << getId() << " failed filesystem check";
138 return -EIO;
139 }
Jeff Sharkey9c484982015-03-31 10:35:33 -0700140
Jeff Sharkeyd0640f62015-05-21 22:35:42 -0700141 if (ext4::Mount(mDmDevPath, mPath, false, false, true)) {
142 PLOG(ERROR) << getId() << " failed to mount";
143 return -EIO;
144 }
145
146 } else if (mFsType == "f2fs") {
147 int res = f2fs::Check(mDmDevPath);
148 if (res == 0) {
149 LOG(DEBUG) << getId() << " passed filesystem check";
150 } else {
151 PLOG(ERROR) << getId() << " failed filesystem check";
152 return -EIO;
153 }
154
155 if (f2fs::Mount(mDmDevPath, mPath)) {
156 PLOG(ERROR) << getId() << " failed to mount";
157 return -EIO;
158 }
159
160 } else {
161 LOG(ERROR) << getId() << " unsupported filesystem " << mFsType;
Jeff Sharkey9c484982015-03-31 10:35:33 -0700162 return -EIO;
163 }
164
Jeff Sharkeyd24aeda2016-07-15 16:20:22 -0600165 RestoreconRecursive(mPath);
Jeff Sharkey34824122015-06-09 10:59:17 -0700166
Jeff Sharkeyf0121c52015-04-06 14:08:45 -0700167 // Verify that common directories are ready to roll
168 if (PrepareDir(mPath + "/app", 0771, AID_SYSTEM, AID_SYSTEM) ||
Paul Crowley14c8c072018-09-18 13:30:21 -0700169 PrepareDir(mPath + "/user", 0711, AID_SYSTEM, AID_SYSTEM) ||
170 PrepareDir(mPath + "/user_de", 0711, AID_SYSTEM, AID_SYSTEM) ||
171 PrepareDir(mPath + "/media", 0770, AID_MEDIA_RW, AID_MEDIA_RW) ||
172 PrepareDir(mPath + "/media/0", 0770, AID_MEDIA_RW, AID_MEDIA_RW) ||
173 PrepareDir(mPath + "/local", 0751, AID_ROOT, AID_ROOT) ||
174 PrepareDir(mPath + "/local/tmp", 0771, AID_SHELL, AID_SHELL)) {
Jeff Sharkeyf0121c52015-04-06 14:08:45 -0700175 PLOG(ERROR) << getId() << " failed to prepare";
176 return -EIO;
177 }
178
Zima438b242019-09-25 14:37:38 +0100179 auto vol_manager = VolumeManager::Instance();
Jeff Sharkey3161fb32015-04-12 16:03:33 -0700180 std::string mediaPath(mPath + "/media");
Zima438b242019-09-25 14:37:38 +0100181
182 // Create a new emulated volume stacked above us for all added users, they will automatically
183 // be destroyed during unmount
184 for (userid_t user : vol_manager->getStartedUsers()) {
185 auto vol = std::shared_ptr<VolumeBase>(
186 new EmulatedVolume(mediaPath, mRawDevice, mFsUuid, user));
187 vol->setMountUserId(user);
188 addVolume(vol);
189 vol->create();
190 }
Jeff Sharkey3161fb32015-04-12 16:03:33 -0700191
Jeff Sharkey9c484982015-03-31 10:35:33 -0700192 return OK;
193}
194
195status_t PrivateVolume::doUnmount() {
196 ForceUnmount(mPath);
197
198 if (TEMP_FAILURE_RETRY(rmdir(mPath.c_str()))) {
199 PLOG(ERROR) << getId() << " failed to rmdir mount point " << mPath;
200 }
201
202 return OK;
203}
204
Jeff Sharkeyd0640f62015-05-21 22:35:42 -0700205status_t PrivateVolume::doFormat(const std::string& fsType) {
206 std::string resolvedFsType = fsType;
207 if (fsType == "auto") {
208 // For now, assume that all MMC devices are flash-based SD cards, and
209 // give everyone else ext4 because sysfs rotational isn't reliable.
210 if ((major(mRawDevice) == kMajorBlockMmc) && f2fs::IsSupported()) {
211 resolvedFsType = "f2fs";
212 } else {
213 resolvedFsType = "ext4";
214 }
215 LOG(DEBUG) << "Resolved auto to " << resolvedFsType;
216 }
217
218 if (resolvedFsType == "ext4") {
219 // TODO: change reported mountpoint once we have better selinux support
220 if (ext4::Format(mDmDevPath, 0, "/data")) {
221 PLOG(ERROR) << getId() << " failed to format";
222 return -EIO;
223 }
224 } else if (resolvedFsType == "f2fs") {
225 if (f2fs::Format(mDmDevPath)) {
226 PLOG(ERROR) << getId() << " failed to format";
227 return -EIO;
228 }
229 } else {
230 LOG(ERROR) << getId() << " unsupported filesystem " << fsType;
231 return -EINVAL;
Jeff Sharkey9c484982015-03-31 10:35:33 -0700232 }
233
234 return OK;
235}
236
237} // namespace vold
238} // namespace android