blob: 02025b74353aa3710835ab5dcb0fcf60b108e469 [file] [log] [blame]
San Mehatf1b736b2009-10-10 17:22:08 -07001/*
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
Jeff Sharkey67b8c492017-09-21 17:08:43 -060017#define ATRACE_TAG ATRACE_TAG_PACKAGE_MANAGER
18
Yabin Cuid1104f72015-01-02 13:28:28 -080019#include <dirent.h>
San Mehatf1b736b2009-10-10 17:22:08 -070020#include <errno.h>
San Mehata2677e42009-12-13 10:40:18 -080021#include <fcntl.h>
Ricky Waie96b34f2020-05-07 16:01:33 +010022#include <limits.h>
Yabin Cuid1104f72015-01-02 13:28:28 -080023#include <mntent.h>
24#include <stdio.h>
25#include <stdlib.h>
26#include <string.h>
27#include <sys/ioctl.h>
28#include <sys/mount.h>
San Mehata19b2502010-01-06 10:33:53 -080029#include <sys/stat.h>
Elliott Hughes0e08e842017-05-18 09:08:24 -070030#include <sys/sysmacros.h>
Paul Crowleyedf7a4e2018-09-18 15:14:18 -070031#include <sys/types.h>
Jeff Sharkey66270a22015-06-24 11:49:24 -070032#include <sys/wait.h>
Yabin Cuid1104f72015-01-02 13:28:28 -080033#include <unistd.h>
Sudheer Shanka40ab6742018-09-18 13:07:45 -070034#include <array>
San Mehata19b2502010-01-06 10:33:53 -080035
San Mehata2677e42009-12-13 10:40:18 -080036#include <linux/kdev_t.h>
San Mehatf1b736b2009-10-10 17:22:08 -070037
Jiyong Park8d21c922019-01-04 13:35:25 +090038#include <ApexProperties.sysprop.h>
Elliott Hughes7e128fb2015-12-04 15:50:53 -080039#include <android-base/logging.h>
Jeff Vander Stoep58890832017-10-23 17:12:31 -070040#include <android-base/parseint.h>
Jeff Sharkey3472e522017-10-06 18:02:53 -060041#include <android-base/properties.h>
Elliott Hughes7e128fb2015-12-04 15:50:53 -080042#include <android-base/stringprintf.h>
Jeff Vander Stoep58890832017-10-23 17:12:31 -070043#include <android-base/strings.h>
Narayan Kamath02efdf52019-11-27 10:53:51 +000044#include <async_safe/log.h>
Jeff Vander Stoep58890832017-10-23 17:12:31 -070045
Jeff Sharkey71ebe152013-09-17 17:24:38 -070046#include <cutils/fs.h>
Jeff Sharkey67b8c492017-09-21 17:08:43 -060047#include <utils/Trace.h>
San Mehatf1b736b2009-10-10 17:22:08 -070048
Robert Craigb9e3ba52014-02-04 10:53:00 -050049#include <selinux/android.h>
50
San Mehatfd7f5872009-10-12 11:32:47 -070051#include <sysutils/NetlinkEvent.h>
52
Kenny Root344ca102012-04-03 17:23:01 -070053#include <private/android_filesystem_config.h>
54
Eric Biggersa701c452018-10-23 13:06:55 -070055#include <fscrypt/fscrypt.h>
Paul Crowleyc6433a22017-10-24 14:54:43 -070056
Risanac02a482018-10-31 21:59:47 -060057#include "AppFuseUtil.h"
Paul Crowleyc6433a22017-10-24 14:54:43 -070058#include "Devmapper.h"
Eric Biggersa701c452018-10-23 13:06:55 -070059#include "FsCrypt.h"
San Mehata19b2502010-01-06 10:33:53 -080060#include "Loop.h"
Paul Crowleyc6433a22017-10-24 14:54:43 -070061#include "NetlinkManager.h"
62#include "Process.h"
63#include "Utils.h"
Sudheer Shanka40ab6742018-09-18 13:07:45 -070064#include "VoldNativeService.h"
Paul Crowleyc6433a22017-10-24 14:54:43 -070065#include "VoldUtil.h"
66#include "VolumeManager.h"
Jeff Sharkeyd0640f62015-05-21 22:35:42 -070067#include "fs/Ext4.h"
68#include "fs/Vfat.h"
Paul Crowleyc6433a22017-10-24 14:54:43 -070069#include "model/EmulatedVolume.h"
70#include "model/ObbVolume.h"
Zima438b242019-09-25 14:37:38 +010071#include "model/PrivateVolume.h"
Risan8c9f3322018-10-29 08:52:56 +090072#include "model/StubVolume.h"
San Mehat23969932010-01-09 07:08:06 -080073
Sudheer Shankaf9b38a52019-02-14 19:09:51 +000074using android::OK;
Sudheer Shanka53947a32018-08-01 10:24:13 -070075using android::base::GetBoolProperty;
Mark Salyzyn86e81e72018-09-20 10:09:27 -070076using android::base::StartsWith;
Sudheer Shanka53947a32018-08-01 10:24:13 -070077using android::base::StringAppendF;
Jeff Sharkey36801cc2015-03-13 16:09:20 -070078using android::base::StringPrintf;
Jeff Sharkey11c2d382017-09-11 10:32:01 -060079using android::base::unique_fd;
Sudheer Shanka023b5392019-02-06 12:39:19 -080080using android::vold::BindMount;
Sudheer Shankaf9b38a52019-02-14 19:09:51 +000081using android::vold::CreateDir;
Sudheer Shanka30df1c62019-02-22 17:03:02 -080082using android::vold::DeleteDirContents;
Sudheer Shanka023b5392019-02-06 12:39:19 -080083using android::vold::DeleteDirContentsAndDir;
Ricky Wai07e64a42020-02-11 14:31:24 +000084using android::vold::EnsureDirExists;
Martijn Coenen62a4b272020-01-31 15:23:09 +010085using android::vold::IsFilesystemSupported;
Daniel Rosenbergf36bddd2020-05-11 22:58:42 -070086using android::vold::IsSdcardfsUsed;
Alistair Delvaff1fc9b2020-05-14 16:35:03 -070087using android::vold::IsVirtioBlkDevice;
Martijn Coenen62a4b272020-01-31 15:23:09 +010088using android::vold::PrepareAndroidDirs;
Martijn Coenen04bb17f2020-02-10 23:48:11 +010089using android::vold::PrepareAppDirFromRoot;
Zima438b242019-09-25 14:37:38 +010090using android::vold::PrivateVolume;
Sudheer Shanka023b5392019-02-06 12:39:19 -080091using android::vold::Symlink;
92using android::vold::Unlink;
93using android::vold::UnmountTree;
Sudheer Shanka03992e32018-12-12 12:43:38 -080094using android::vold::VoldNativeService;
Zima438b242019-09-25 14:37:38 +010095using android::vold::VolumeBase;
Jeff Sharkey36801cc2015-03-13 16:09:20 -070096
Jeff Sharkeyfa1c6772017-03-25 22:49:13 -060097static const char* kPathUserMount = "/mnt/user";
98static const char* kPathVirtualDisk = "/data/misc/vold/virtual_disk";
99
100static const char* kPropVirtualDisk = "persist.sys.virtual_disk";
101
Sudheer Shanka53947a32018-08-01 10:24:13 -0700102static const std::string kEmptyString("");
103
Jeff Sharkeyfa1c6772017-03-25 22:49:13 -0600104/* 512MiB is large enough for testing purposes */
105static const unsigned int kSizeVirtualDisk = 536870912;
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700106
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700107static const unsigned int kMajorBlockMmc = 179;
108
Ricky Wai07e64a42020-02-11 14:31:24 +0000109using ScanProcCallback = bool(*)(uid_t uid, pid_t pid, int nsFd, const char* name, void* params);
110
Paul Crowleyedf7a4e2018-09-18 15:14:18 -0700111VolumeManager* VolumeManager::sInstance = NULL;
San Mehatf1b736b2009-10-10 17:22:08 -0700112
Paul Crowleyedf7a4e2018-09-18 15:14:18 -0700113VolumeManager* VolumeManager::Instance() {
114 if (!sInstance) sInstance = new VolumeManager();
San Mehatf1b736b2009-10-10 17:22:08 -0700115 return sInstance;
116}
117
118VolumeManager::VolumeManager() {
San Mehatd9a4e352010-03-12 13:32:47 -0800119 mDebug = false;
Jeff Sharkey11c2d382017-09-11 10:32:01 -0600120 mNextObbId = 0;
Risan82e90de2020-02-04 16:07:21 +0900121 mNextStubId = 0;
Jeff Sharkey401b2602017-12-14 22:15:20 -0700122 // For security reasons, assume that a secure keyguard is
123 // showing until we hear otherwise
124 mSecureKeyguardShowing = true;
San Mehatf1b736b2009-10-10 17:22:08 -0700125}
126
Paul Crowleyedf7a4e2018-09-18 15:14:18 -0700127VolumeManager::~VolumeManager() {}
San Mehatd9a4e352010-03-12 13:32:47 -0800128
Jeff Sharkeyfa1c6772017-03-25 22:49:13 -0600129int VolumeManager::updateVirtualDisk() {
Jeff Sharkey67b8c492017-09-21 17:08:43 -0600130 ATRACE_NAME("VolumeManager::updateVirtualDisk");
Mark Salyzyn86e81e72018-09-20 10:09:27 -0700131 if (GetBoolProperty(kPropVirtualDisk, false)) {
Jeff Sharkeyfa1c6772017-03-25 22:49:13 -0600132 if (access(kPathVirtualDisk, F_OK) != 0) {
133 Loop::createImageFile(kPathVirtualDisk, kSizeVirtualDisk / 512);
134 }
135
136 if (mVirtualDisk == nullptr) {
137 if (Loop::create(kPathVirtualDisk, mVirtualDiskPath) != 0) {
138 LOG(ERROR) << "Failed to create virtual disk";
139 return -1;
140 }
141
142 struct stat buf;
143 if (stat(mVirtualDiskPath.c_str(), &buf) < 0) {
144 PLOG(ERROR) << "Failed to stat " << mVirtualDiskPath;
145 return -1;
146 }
147
Paul Crowleyedf7a4e2018-09-18 15:14:18 -0700148 auto disk = new android::vold::Disk(
149 "virtual", buf.st_rdev, "virtual",
150 android::vold::Disk::Flags::kAdoptable | android::vold::Disk::Flags::kSd);
Jeff Sharkeyfa1c6772017-03-25 22:49:13 -0600151 mVirtualDisk = std::shared_ptr<android::vold::Disk>(disk);
Jeff Sharkey401b2602017-12-14 22:15:20 -0700152 handleDiskAdded(mVirtualDisk);
Jeff Sharkeyfa1c6772017-03-25 22:49:13 -0600153 }
154 } else {
155 if (mVirtualDisk != nullptr) {
156 dev_t device = mVirtualDisk->getDevice();
Jeff Sharkey401b2602017-12-14 22:15:20 -0700157 handleDiskRemoved(device);
Jeff Sharkeyfa1c6772017-03-25 22:49:13 -0600158
159 Loop::destroyByDevice(mVirtualDiskPath.c_str());
160 mVirtualDisk = nullptr;
161 }
162
163 if (access(kPathVirtualDisk, F_OK) == 0) {
164 unlink(kPathVirtualDisk);
165 }
166 }
167 return 0;
168}
169
Jeff Sharkeyf1b996d2015-04-17 17:35:20 -0700170int VolumeManager::setDebug(bool enable) {
San Mehatd9a4e352010-03-12 13:32:47 -0800171 mDebug = enable;
Jeff Sharkeyf1b996d2015-04-17 17:35:20 -0700172 return 0;
San Mehatd9a4e352010-03-12 13:32:47 -0800173}
174
San Mehatf1b736b2009-10-10 17:22:08 -0700175int VolumeManager::start() {
Jeff Sharkey67b8c492017-09-21 17:08:43 -0600176 ATRACE_NAME("VolumeManager::start");
177
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700178 // Always start from a clean slate by unmounting everything in
179 // directories that we own, in case we crashed.
Jeff Sharkey9c484982015-03-31 10:35:33 -0700180 unmountAll();
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700181
Jeff Sharkey11c2d382017-09-11 10:32:01 -0600182 Devmapper::destroyAll();
183 Loop::destroyAll();
184
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700185 // Assume that we always have an emulated volume on internal
186 // storage; the framework will decide if it should be mounted.
Zima438b242019-09-25 14:37:38 +0100187 CHECK(mInternalEmulatedVolumes.empty());
188
189 auto vol = std::shared_ptr<android::vold::VolumeBase>(
190 new android::vold::EmulatedVolume("/data/media", 0));
191 vol->setMountUserId(0);
192 vol->create();
193 mInternalEmulatedVolumes.push_back(vol);
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700194
Jeff Sharkeyfa1c6772017-03-25 22:49:13 -0600195 // Consider creating a virtual disk
196 updateVirtualDisk();
197
San Mehatf1b736b2009-10-10 17:22:08 -0700198 return 0;
199}
200
Paul Crowleyedf7a4e2018-09-18 15:14:18 -0700201void VolumeManager::handleBlockEvent(NetlinkEvent* evt) {
Jeff Sharkeyc8e04c52015-04-21 12:14:17 -0700202 std::lock_guard<std::mutex> lock(mLock);
203
Jeff Sharkeyf1b996d2015-04-17 17:35:20 -0700204 if (mDebug) {
Sudheer Shanka4b6ca4e2018-09-21 10:54:54 -0700205 LOG(DEBUG) << "----------------";
206 LOG(DEBUG) << "handleBlockEvent with action " << (int)evt->getAction();
Jeff Sharkeyf1b996d2015-04-17 17:35:20 -0700207 evt->dump();
208 }
San Mehatf1b736b2009-10-10 17:22:08 -0700209
Paul Crowleyedf7a4e2018-09-18 15:14:18 -0700210 std::string eventPath(evt->findParam("DEVPATH") ? evt->findParam("DEVPATH") : "");
211 std::string devType(evt->findParam("DEVTYPE") ? evt->findParam("DEVTYPE") : "");
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700212
213 if (devType != "disk") return;
214
Jeff Sharkey95440eb2017-09-18 18:19:28 -0600215 int major = std::stoi(evt->findParam("MAJOR"));
216 int minor = std::stoi(evt->findParam("MINOR"));
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700217 dev_t device = makedev(major, minor);
218
219 switch (evt->getAction()) {
Paul Crowleyedf7a4e2018-09-18 15:14:18 -0700220 case NetlinkEvent::Action::kAdd: {
221 for (const auto& source : mDiskSources) {
222 if (source->matches(eventPath)) {
223 // For now, assume that MMC and virtio-blk (the latter is
Alistair Delvaff1fc9b2020-05-14 16:35:03 -0700224 // specific to virtual platforms; see Utils.cpp for details)
225 // devices are SD, and that everything else is USB
Paul Crowleyedf7a4e2018-09-18 15:14:18 -0700226 int flags = source->getFlags();
Alistair Delvaff1fc9b2020-05-14 16:35:03 -0700227 if (major == kMajorBlockMmc || IsVirtioBlkDevice(major)) {
Paul Crowleyedf7a4e2018-09-18 15:14:18 -0700228 flags |= android::vold::Disk::Flags::kSd;
229 } else {
230 flags |= android::vold::Disk::Flags::kUsb;
231 }
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700232
Paul Crowleyedf7a4e2018-09-18 15:14:18 -0700233 auto disk =
234 new android::vold::Disk(eventPath, device, source->getNickname(), flags);
235 handleDiskAdded(std::shared_ptr<android::vold::Disk>(disk));
236 break;
237 }
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700238 }
Paul Crowleyedf7a4e2018-09-18 15:14:18 -0700239 break;
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700240 }
Paul Crowleyedf7a4e2018-09-18 15:14:18 -0700241 case NetlinkEvent::Action::kChange: {
Nikita Ioffeb881fc42021-07-28 02:58:57 +0100242 LOG(VERBOSE) << "Disk at " << major << ":" << minor << " changed";
Paul Crowleyedf7a4e2018-09-18 15:14:18 -0700243 handleDiskChanged(device);
244 break;
245 }
246 case NetlinkEvent::Action::kRemove: {
247 handleDiskRemoved(device);
248 break;
249 }
250 default: {
251 LOG(WARNING) << "Unexpected block event action " << (int)evt->getAction();
252 break;
253 }
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700254 }
255}
256
Jeff Sharkey401b2602017-12-14 22:15:20 -0700257void VolumeManager::handleDiskAdded(const std::shared_ptr<android::vold::Disk>& disk) {
258 // For security reasons, if secure keyguard is showing, wait
259 // until the user unlocks the device to actually touch it
Martijn Coenencf5916f2020-01-03 14:36:45 +0100260 // Additionally, wait until user 0 is actually started, since we need
261 // the user to be up before we can mount a FUSE daemon to handle the disk.
262 bool userZeroStarted = mStartedUsers.find(0) != mStartedUsers.end();
Jeff Sharkey401b2602017-12-14 22:15:20 -0700263 if (mSecureKeyguardShowing) {
264 LOG(INFO) << "Found disk at " << disk->getEventPath()
Paul Crowleyedf7a4e2018-09-18 15:14:18 -0700265 << " but delaying scan due to secure keyguard";
Jeff Sharkey401b2602017-12-14 22:15:20 -0700266 mPendingDisks.push_back(disk);
Martijn Coenencf5916f2020-01-03 14:36:45 +0100267 } else if (!userZeroStarted) {
268 LOG(INFO) << "Found disk at " << disk->getEventPath()
269 << " but delaying scan due to user zero not having started";
270 mPendingDisks.push_back(disk);
Jeff Sharkey401b2602017-12-14 22:15:20 -0700271 } else {
272 disk->create();
273 mDisks.push_back(disk);
274 }
275}
276
277void VolumeManager::handleDiskChanged(dev_t device) {
278 for (const auto& disk : mDisks) {
279 if (disk->getDevice() == device) {
280 disk->readMetadata();
281 disk->readPartitions();
282 }
283 }
284
285 // For security reasons, we ignore all pending disks, since
286 // we'll scan them once the device is unlocked
287}
288
289void VolumeManager::handleDiskRemoved(dev_t device) {
290 auto i = mDisks.begin();
291 while (i != mDisks.end()) {
292 if ((*i)->getDevice() == device) {
293 (*i)->destroy();
294 i = mDisks.erase(i);
295 } else {
296 ++i;
297 }
298 }
299 auto j = mPendingDisks.begin();
300 while (j != mPendingDisks.end()) {
301 if ((*j)->getDevice() == device) {
302 j = mPendingDisks.erase(j);
303 } else {
304 ++j;
305 }
306 }
307}
308
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700309void VolumeManager::addDiskSource(const std::shared_ptr<DiskSource>& diskSource) {
Wei Wang6b455c22017-01-20 11:52:33 -0800310 std::lock_guard<std::mutex> lock(mLock);
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700311 mDiskSources.push_back(diskSource);
312}
313
314std::shared_ptr<android::vold::Disk> VolumeManager::findDisk(const std::string& id) {
315 for (auto disk : mDisks) {
316 if (disk->getId() == id) {
317 return disk;
San Mehatf1b736b2009-10-10 17:22:08 -0700318 }
319 }
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700320 return nullptr;
321}
San Mehatf1b736b2009-10-10 17:22:08 -0700322
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700323std::shared_ptr<android::vold::VolumeBase> VolumeManager::findVolume(const std::string& id) {
Zima438b242019-09-25 14:37:38 +0100324 for (const auto& vol : mInternalEmulatedVolumes) {
325 if (vol->getId() == id) {
326 return vol;
327 }
San Mehatf1b736b2009-10-10 17:22:08 -0700328 }
Chih-Hung Hsieh11a2ce82016-07-27 14:11:02 -0700329 for (const auto& disk : mDisks) {
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700330 auto vol = disk->findVolume(id);
331 if (vol != nullptr) {
332 return vol;
333 }
334 }
Jeff Sharkey11c2d382017-09-11 10:32:01 -0600335 for (const auto& vol : mObbVolumes) {
336 if (vol->getId() == id) {
337 return vol;
338 }
339 }
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700340 return nullptr;
341}
342
Greg Kaiser2bc201e2018-12-18 08:42:08 -0800343void VolumeManager::listVolumes(android::vold::VolumeBase::Type type,
344 std::list<std::string>& list) const {
Jeff Sharkeyc86ab6f2015-06-26 14:02:09 -0700345 list.clear();
Chih-Hung Hsieh11a2ce82016-07-27 14:11:02 -0700346 for (const auto& disk : mDisks) {
Jeff Sharkeyc86ab6f2015-06-26 14:02:09 -0700347 disk->listVolumes(type, list);
348 }
349}
350
Jeff Sharkey3ce18252017-10-24 11:08:45 -0600351int VolumeManager::forgetPartition(const std::string& partGuid, const std::string& fsUuid) {
Jeff Sharkeybc40cc82015-06-18 14:25:08 -0700352 std::string normalizedGuid;
353 if (android::vold::NormalizeHex(partGuid, normalizedGuid)) {
354 LOG(WARNING) << "Invalid GUID " << partGuid;
355 return -1;
356 }
357
Paul Crowleyc6433a22017-10-24 14:54:43 -0700358 bool success = true;
Jeff Sharkeybc40cc82015-06-18 14:25:08 -0700359 std::string keyPath = android::vold::BuildKeyPath(normalizedGuid);
360 if (unlink(keyPath.c_str()) != 0) {
361 LOG(ERROR) << "Failed to unlink " << keyPath;
Paul Crowleyc6433a22017-10-24 14:54:43 -0700362 success = false;
Jeff Sharkeybc40cc82015-06-18 14:25:08 -0700363 }
Eric Biggersa701c452018-10-23 13:06:55 -0700364 if (fscrypt_is_native()) {
365 if (!fscrypt_destroy_volume_keys(fsUuid)) {
Paul Crowleyc6433a22017-10-24 14:54:43 -0700366 success = false;
367 }
368 }
369 return success ? 0 : -1;
Jeff Sharkeybc40cc82015-06-18 14:25:08 -0700370}
371
Zima438b242019-09-25 14:37:38 +0100372void VolumeManager::destroyEmulatedVolumesForUser(userid_t userId) {
373 // Destroy and remove all unstacked EmulatedVolumes for the user
374 auto i = mInternalEmulatedVolumes.begin();
375 while (i != mInternalEmulatedVolumes.end()) {
376 auto vol = *i;
377 if (vol->getMountUserId() == userId) {
378 vol->destroy();
379 i = mInternalEmulatedVolumes.erase(i);
380 } else {
381 i++;
382 }
383 }
384
385 // Destroy and remove all stacked EmulatedVolumes for the user on each mounted private volume
386 std::list<std::string> private_vols;
387 listVolumes(VolumeBase::Type::kPrivate, private_vols);
388 for (const std::string& id : private_vols) {
389 PrivateVolume* pvol = static_cast<PrivateVolume*>(findVolume(id).get());
390 std::list<std::shared_ptr<VolumeBase>> vols_to_remove;
391 if (pvol->getState() == VolumeBase::State::kMounted) {
392 for (const auto& vol : pvol->getVolumes()) {
393 if (vol->getMountUserId() == userId) {
394 vols_to_remove.push_back(vol);
395 }
396 }
397 for (const auto& vol : vols_to_remove) {
398 vol->destroy();
399 pvol->removeVolume(vol);
400 }
401 } // else EmulatedVolumes will be destroyed on VolumeBase#unmount
402 }
403}
404
405void VolumeManager::createEmulatedVolumesForUser(userid_t userId) {
406 // Create unstacked EmulatedVolumes for the user
407 auto vol = std::shared_ptr<android::vold::VolumeBase>(
408 new android::vold::EmulatedVolume("/data/media", userId));
409 vol->setMountUserId(userId);
410 mInternalEmulatedVolumes.push_back(vol);
411 vol->create();
412
413 // Create stacked EmulatedVolumes for the user on each PrivateVolume
414 std::list<std::string> private_vols;
415 listVolumes(VolumeBase::Type::kPrivate, private_vols);
416 for (const std::string& id : private_vols) {
417 PrivateVolume* pvol = static_cast<PrivateVolume*>(findVolume(id).get());
418 if (pvol->getState() == VolumeBase::State::kMounted) {
419 auto evol =
420 std::shared_ptr<android::vold::VolumeBase>(new android::vold::EmulatedVolume(
421 pvol->getPath() + "/media", pvol->getRawDevice(), pvol->getFsUuid(),
422 userId));
423 evol->setMountUserId(userId);
424 pvol->addVolume(evol);
425 evol->create();
426 } // else EmulatedVolumes will be created per user when on PrivateVolume#doMount
427 }
428}
429
Jeff Sharkeybd3038d2015-06-10 09:42:01 -0700430int VolumeManager::onUserAdded(userid_t userId, int userSerialNumber) {
Zima438b242019-09-25 14:37:38 +0100431 LOG(INFO) << "onUserAdded: " << userId;
432
Jeff Sharkeybd3038d2015-06-10 09:42:01 -0700433 mAddedUsers[userId] = userSerialNumber;
434 return 0;
435}
436
437int VolumeManager::onUserRemoved(userid_t userId) {
Zima438b242019-09-25 14:37:38 +0100438 LOG(INFO) << "onUserRemoved: " << userId;
439
Zim2d45d9b2019-11-14 16:19:05 +0000440 onUserStopped(userId);
Jeff Sharkeybd3038d2015-06-10 09:42:01 -0700441 mAddedUsers.erase(userId);
442 return 0;
443}
444
Sudheer Shankaebce4cc2019-04-29 10:46:35 -0700445int VolumeManager::onUserStarted(userid_t userId) {
Zima438b242019-09-25 14:37:38 +0100446 LOG(INFO) << "onUserStarted: " << userId;
447
Zim2d45d9b2019-11-14 16:19:05 +0000448 if (mStartedUsers.find(userId) == mStartedUsers.end()) {
449 createEmulatedVolumesForUser(userId);
450 }
451
Jeff Sharkeybd3038d2015-06-10 09:42:01 -0700452 mStartedUsers.insert(userId);
Martijn Coenencf5916f2020-01-03 14:36:45 +0100453
454 createPendingDisksIfNeeded();
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700455 return 0;
456}
457
Jeff Sharkeybd3038d2015-06-10 09:42:01 -0700458int VolumeManager::onUserStopped(userid_t userId) {
Sudheer Shanka40ab6742018-09-18 13:07:45 -0700459 LOG(VERBOSE) << "onUserStopped: " << userId;
Zima438b242019-09-25 14:37:38 +0100460
Zim2d45d9b2019-11-14 16:19:05 +0000461 if (mStartedUsers.find(userId) != mStartedUsers.end()) {
Zima438b242019-09-25 14:37:38 +0100462 destroyEmulatedVolumesForUser(userId);
463 }
464
Jeff Sharkeybd3038d2015-06-10 09:42:01 -0700465 mStartedUsers.erase(userId);
Sudheer Shankafa6a1742018-10-04 16:26:22 -0700466 return 0;
467}
468
Martijn Coenencf5916f2020-01-03 14:36:45 +0100469void VolumeManager::createPendingDisksIfNeeded() {
470 bool userZeroStarted = mStartedUsers.find(0) != mStartedUsers.end();
471 if (!mSecureKeyguardShowing && userZeroStarted) {
472 // Now that secure keyguard has been dismissed and user 0 has
473 // started, process any pending disks
Jeff Sharkey401b2602017-12-14 22:15:20 -0700474 for (const auto& disk : mPendingDisks) {
475 disk->create();
476 mDisks.push_back(disk);
477 }
478 mPendingDisks.clear();
479 }
Martijn Coenencf5916f2020-01-03 14:36:45 +0100480}
481
482int VolumeManager::onSecureKeyguardStateChanged(bool isShowing) {
483 mSecureKeyguardShowing = isShowing;
484 createPendingDisksIfNeeded();
Jeff Sharkey401b2602017-12-14 22:15:20 -0700485 return 0;
486}
487
Narayan Kamath02efdf52019-11-27 10:53:51 +0000488// This code is executed after a fork so it's very important that the set of
489// methods we call here is strictly limited.
490//
491// TODO: Get rid of this guesswork altogether and instead exec a process
492// immediately after fork to do our bindding for us.
493static bool childProcess(const char* storageSource, const char* userSource, int nsFd,
Ricky Wai07e64a42020-02-11 14:31:24 +0000494 const char* name) {
Narayan Kamath02efdf52019-11-27 10:53:51 +0000495 if (setns(nsFd, CLONE_NEWNS) != 0) {
Ricky Wai07e64a42020-02-11 14:31:24 +0000496 async_safe_format_log(ANDROID_LOG_ERROR, "vold", "Failed to setns for %s :%s", name,
Narayan Kamath02efdf52019-11-27 10:53:51 +0000497 strerror(errno));
498 return false;
499 }
500
501 // NOTE: Inlined from vold::UnmountTree here to avoid using PLOG methods and
502 // to also protect against future changes that may cause issues across a
503 // fork.
504 if (TEMP_FAILURE_RETRY(umount2("/storage/", MNT_DETACH)) < 0 && errno != EINVAL &&
505 errno != ENOENT) {
506 async_safe_format_log(ANDROID_LOG_ERROR, "vold", "Failed to unmount /storage/ :%s",
507 strerror(errno));
508 return false;
509 }
510
511 if (TEMP_FAILURE_RETRY(mount(storageSource, "/storage", NULL, MS_BIND | MS_REC, NULL)) == -1) {
512 async_safe_format_log(ANDROID_LOG_ERROR, "vold", "Failed to mount %s for %s :%s",
Ricky Wai07e64a42020-02-11 14:31:24 +0000513 storageSource, name, strerror(errno));
Narayan Kamath02efdf52019-11-27 10:53:51 +0000514 return false;
515 }
516
517 if (TEMP_FAILURE_RETRY(mount(NULL, "/storage", NULL, MS_REC | MS_SLAVE, NULL)) == -1) {
518 async_safe_format_log(ANDROID_LOG_ERROR, "vold",
Ricky Wai07e64a42020-02-11 14:31:24 +0000519 "Failed to set MS_SLAVE to /storage for %s :%s", name,
Narayan Kamath02efdf52019-11-27 10:53:51 +0000520 strerror(errno));
521 return false;
522 }
523
524 if (TEMP_FAILURE_RETRY(mount(userSource, "/storage/self", NULL, MS_BIND, NULL)) == -1) {
525 async_safe_format_log(ANDROID_LOG_ERROR, "vold", "Failed to mount %s for %s :%s",
Ricky Wai07e64a42020-02-11 14:31:24 +0000526 userSource, name, strerror(errno));
Narayan Kamath02efdf52019-11-27 10:53:51 +0000527 return false;
528 }
529
530 return true;
531}
532
Ricky Wai07e64a42020-02-11 14:31:24 +0000533// Fork the process and remount storage
534bool forkAndRemountChild(uid_t uid, pid_t pid, int nsFd, const char* name, void* params) {
535 int32_t mountMode = *static_cast<int32_t*>(params);
536 std::string userSource;
537 std::string storageSource;
538 pid_t child;
539 // Need to fix these paths to account for when sdcardfs is gone
Sudheer Shanka817b9112018-12-13 17:40:28 -0800540 switch (mountMode) {
541 case VoldNativeService::REMOUNT_MODE_NONE:
Ricky Wai07e64a42020-02-11 14:31:24 +0000542 return true;
Sudheer Shanka817b9112018-12-13 17:40:28 -0800543 case VoldNativeService::REMOUNT_MODE_DEFAULT:
Ricky Wai07e64a42020-02-11 14:31:24 +0000544 storageSource = "/mnt/runtime/default";
Sudheer Shanka817b9112018-12-13 17:40:28 -0800545 break;
Abhijeet Kaure715ec12021-02-24 12:33:25 +0000546 case VoldNativeService::REMOUNT_MODE_ANDROID_WRITABLE:
Sudheer Shankaa05ea742019-04-12 13:55:28 -0700547 case VoldNativeService::REMOUNT_MODE_INSTALLER:
Ricky Wai07e64a42020-02-11 14:31:24 +0000548 storageSource = "/mnt/runtime/write";
Sudheer Shanka817b9112018-12-13 17:40:28 -0800549 break;
Zim981222f2019-09-09 10:24:44 +0100550 case VoldNativeService::REMOUNT_MODE_PASS_THROUGH:
Ricky Wai07e64a42020-02-11 14:31:24 +0000551 return true;
Sudheer Shanka817b9112018-12-13 17:40:28 -0800552 default:
553 PLOG(ERROR) << "Unknown mode " << std::to_string(mountMode);
Ricky Wai07e64a42020-02-11 14:31:24 +0000554 return false;
Sudheer Shanka817b9112018-12-13 17:40:28 -0800555 }
Ricky Wai07e64a42020-02-11 14:31:24 +0000556 LOG(DEBUG) << "Remounting " << uid << " as " << storageSource;
Jeff Sharkey66270a22015-06-24 11:49:24 -0700557
Ricky Wai07e64a42020-02-11 14:31:24 +0000558 // Fork a child to mount user-specific symlink helper into place
559 userSource = StringPrintf("/mnt/user/%d", multiuser_get_user_id(uid));
560 if (!(child = fork())) {
561 if (childProcess(storageSource.c_str(), userSource.c_str(), nsFd, name)) {
562 _exit(0);
563 } else {
564 _exit(1);
565 }
566 }
567
568 if (child == -1) {
569 PLOG(ERROR) << "Failed to fork";
570 return false;
571 } else {
572 TEMP_FAILURE_RETRY(waitpid(child, nullptr, 0));
573 }
574 return true;
575}
576
577// Helper function to scan all processes in /proc and call the callback if:
578// 1). pid belongs to an app process
579// 2). If input uid is 0 or it matches the process uid
580// 3). If userId is not -1 or userId matches the process userId
581bool scanProcProcesses(uid_t uid, userid_t userId, ScanProcCallback callback, void* params) {
Jeff Sharkey66270a22015-06-24 11:49:24 -0700582 DIR* dir;
583 struct dirent* de;
Jeff Sharkey3472e522017-10-06 18:02:53 -0600584 std::string rootName;
585 std::string pidName;
Jeff Sharkey66270a22015-06-24 11:49:24 -0700586 int pidFd;
587 int nsFd;
588 struct stat sb;
Jeff Sharkey66270a22015-06-24 11:49:24 -0700589
Jiyong Park8d21c922019-01-04 13:35:25 +0900590 static bool apexUpdatable = android::sysprop::ApexProperties::updatable().value_or(false);
591
Jeff Sharkey66270a22015-06-24 11:49:24 -0700592 if (!(dir = opendir("/proc"))) {
Ricky Wai07e64a42020-02-11 14:31:24 +0000593 async_safe_format_log(ANDROID_LOG_ERROR, "vold", "Failed to opendir");
594 return false;
Jeff Sharkey66270a22015-06-24 11:49:24 -0700595 }
596
597 // Figure out root namespace to compare against below
Jeff Sharkey3472e522017-10-06 18:02:53 -0600598 if (!android::vold::Readlinkat(dirfd(dir), "1/ns/mnt", &rootName)) {
Ricky Wai07e64a42020-02-11 14:31:24 +0000599 async_safe_format_log(ANDROID_LOG_ERROR, "vold", "Failed to read root namespace");
Jeff Sharkey66270a22015-06-24 11:49:24 -0700600 closedir(dir);
Ricky Wai07e64a42020-02-11 14:31:24 +0000601 return false;
Jeff Sharkey66270a22015-06-24 11:49:24 -0700602 }
603
Ricky Wai07e64a42020-02-11 14:31:24 +0000604 async_safe_format_log(ANDROID_LOG_INFO, "vold", "Start scanning all processes");
Jeff Sharkey66270a22015-06-24 11:49:24 -0700605 // Poke through all running PIDs look for apps running as UID
606 while ((de = readdir(dir))) {
Jeff Vander Stoep58890832017-10-23 17:12:31 -0700607 pid_t pid;
608 if (de->d_type != DT_DIR) continue;
609 if (!android::base::ParseInt(de->d_name, &pid)) continue;
610
Jeff Sharkey66270a22015-06-24 11:49:24 -0700611 pidFd = -1;
612 nsFd = -1;
613
614 pidFd = openat(dirfd(dir), de->d_name, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
615 if (pidFd < 0) {
616 goto next;
617 }
618 if (fstat(pidFd, &sb) != 0) {
Ricky Wai07e64a42020-02-11 14:31:24 +0000619 async_safe_format_log(ANDROID_LOG_ERROR, "vold", "Failed to stat %s", de->d_name);
Jeff Sharkey66270a22015-06-24 11:49:24 -0700620 goto next;
621 }
Ricky Wai07e64a42020-02-11 14:31:24 +0000622 if (uid != 0 && sb.st_uid != uid) {
623 goto next;
624 }
625 if (userId != static_cast<userid_t>(-1) && multiuser_get_user_id(sb.st_uid) != userId) {
Jeff Sharkey66270a22015-06-24 11:49:24 -0700626 goto next;
627 }
628
629 // Matches so far, but refuse to touch if in root namespace
Jeff Sharkey3472e522017-10-06 18:02:53 -0600630 if (!android::vold::Readlinkat(pidFd, "ns/mnt", &pidName)) {
Ricky Wai07e64a42020-02-11 14:31:24 +0000631 async_safe_format_log(ANDROID_LOG_ERROR, "vold",
632 "Failed to read namespacefor %s", de->d_name);
Jeff Sharkey66270a22015-06-24 11:49:24 -0700633 goto next;
634 }
Jeff Sharkey3472e522017-10-06 18:02:53 -0600635 if (rootName == pidName) {
Jeff Sharkey66270a22015-06-24 11:49:24 -0700636 goto next;
637 }
638
Jiyong Park8d21c922019-01-04 13:35:25 +0900639 if (apexUpdatable) {
640 std::string exeName;
641 // When ro.apex.bionic_updatable is set to true,
642 // some early native processes have mount namespaces that are different
643 // from that of the init. Therefore, above check can't filter them out.
644 // Since the propagation type of / is 'shared', unmounting /storage
645 // for the early native processes affects other processes including
646 // init. Filter out such processes by skipping if a process is a
647 // non-Java process whose UID is < AID_APP_START. (The UID condition
648 // is required to not filter out child processes spawned by apps.)
649 if (!android::vold::Readlinkat(pidFd, "exe", &exeName)) {
Jiyong Park8d21c922019-01-04 13:35:25 +0900650 goto next;
651 }
652 if (!StartsWith(exeName, "/system/bin/app_process") && sb.st_uid < AID_APP_START) {
Jiyong Park8d21c922019-01-04 13:35:25 +0900653 goto next;
654 }
655 }
656
Jeff Sharkey66270a22015-06-24 11:49:24 -0700657 // We purposefully leave the namespace open across the fork
Nick Kraleviche7e89ac2019-03-29 16:03:51 -0700658 // NOLINTNEXTLINE(android-cloexec-open): Deliberately not O_CLOEXEC
659 nsFd = openat(pidFd, "ns/mnt", O_RDONLY);
Jeff Sharkey66270a22015-06-24 11:49:24 -0700660 if (nsFd < 0) {
Ricky Wai07e64a42020-02-11 14:31:24 +0000661 async_safe_format_log(ANDROID_LOG_ERROR, "vold",
662 "Failed to open namespace for %s", de->d_name);
Jeff Sharkey66270a22015-06-24 11:49:24 -0700663 goto next;
664 }
665
Ricky Wai07e64a42020-02-11 14:31:24 +0000666 if (!callback(sb.st_uid, pid, nsFd, de->d_name, params)) {
667 async_safe_format_log(ANDROID_LOG_ERROR, "vold", "Failed in callback");
Jeff Sharkey66270a22015-06-24 11:49:24 -0700668 }
669
Paul Crowleyedf7a4e2018-09-18 15:14:18 -0700670 next:
Jeff Sharkey66270a22015-06-24 11:49:24 -0700671 close(nsFd);
672 close(pidFd);
673 }
674 closedir(dir);
Ricky Wai07e64a42020-02-11 14:31:24 +0000675 async_safe_format_log(ANDROID_LOG_INFO, "vold", "Finished scanning all processes");
676 return true;
677}
678
Ricky Waia2ca11e2021-01-15 14:03:23 +0000679// In each app's namespace, unmount obb and data dirs
680static bool umountStorageDirs(int nsFd, const char* android_data_dir, const char* android_obb_dir,
681 int uid, const char* targets[], int size) {
682 // This code is executed after a fork so it's very important that the set of
683 // methods we call here is strictly limited.
684 if (setns(nsFd, CLONE_NEWNS) != 0) {
685 async_safe_format_log(ANDROID_LOG_ERROR, "vold", "Failed to setns %s", strerror(errno));
686 return false;
687 }
688
689 // Unmount of Android/data/foo needs to be done before Android/data below.
690 bool result = true;
691 for (int i = 0; i < size; i++) {
692 if (TEMP_FAILURE_RETRY(umount2(targets[i], MNT_DETACH)) < 0 && errno != EINVAL &&
693 errno != ENOENT) {
694 async_safe_format_log(ANDROID_LOG_ERROR, "vold", "Failed to umount %s: %s",
695 targets[i], strerror(errno));
696 result = false;
697 }
698 }
699
700 // Mount tmpfs on Android/data and Android/obb
701 if (TEMP_FAILURE_RETRY(umount2(android_data_dir, MNT_DETACH)) < 0 && errno != EINVAL &&
702 errno != ENOENT) {
703 async_safe_format_log(ANDROID_LOG_ERROR, "vold", "Failed to umount %s :%s",
704 android_data_dir, strerror(errno));
705 result = false;
706 }
707 if (TEMP_FAILURE_RETRY(umount2(android_obb_dir, MNT_DETACH)) < 0 && errno != EINVAL &&
708 errno != ENOENT) {
709 async_safe_format_log(ANDROID_LOG_ERROR, "vold", "Failed to umount %s :%s",
710 android_obb_dir, strerror(errno));
711 result = false;
712 }
713 return result;
714}
715
Ricky Waie96b34f2020-05-07 16:01:33 +0100716// In each app's namespace, mount tmpfs on obb and data dir, and bind mount obb and data
717// package dirs.
718static bool remountStorageDirs(int nsFd, const char* android_data_dir, const char* android_obb_dir,
719 int uid, const char* sources[], const char* targets[], int size) {
Ricky Wai6b122572020-02-28 16:30:47 +0000720 // This code is executed after a fork so it's very important that the set of
721 // methods we call here is strictly limited.
Ricky Wai07e64a42020-02-11 14:31:24 +0000722 if (setns(nsFd, CLONE_NEWNS) != 0) {
723 async_safe_format_log(ANDROID_LOG_ERROR, "vold", "Failed to setns %s", strerror(errno));
724 return false;
725 }
726
Ricky Waie96b34f2020-05-07 16:01:33 +0100727 // Mount tmpfs on Android/data and Android/obb
728 if (TEMP_FAILURE_RETRY(mount("tmpfs", android_data_dir, "tmpfs",
729 MS_NOSUID | MS_NODEV | MS_NOEXEC, "uid=0,gid=0,mode=0751")) == -1) {
730 async_safe_format_log(ANDROID_LOG_ERROR, "vold", "Failed to mount tmpfs to %s :%s",
731 android_data_dir, strerror(errno));
732 return false;
733 }
734 if (TEMP_FAILURE_RETRY(mount("tmpfs", android_obb_dir, "tmpfs",
735 MS_NOSUID | MS_NODEV | MS_NOEXEC, "uid=0,gid=0,mode=0751")) == -1) {
736 async_safe_format_log(ANDROID_LOG_ERROR, "vold", "Failed to mount tmpfs to %s :%s",
737 android_obb_dir, strerror(errno));
738 return false;
739 }
740
Ricky Wai6b122572020-02-28 16:30:47 +0000741 for (int i = 0; i < size; i++) {
Ricky Waie96b34f2020-05-07 16:01:33 +0100742 // Create package dir and bind mount it to the actual one.
743 if (TEMP_FAILURE_RETRY(mkdir(targets[i], 0700)) == -1) {
744 async_safe_format_log(ANDROID_LOG_ERROR, "vold", "Failed to mkdir %s %s",
745 targets[i], strerror(errno));
746 return false;
747 }
Ricky Wai6b122572020-02-28 16:30:47 +0000748 if (TEMP_FAILURE_RETRY(mount(sources[i], targets[i], NULL, MS_BIND | MS_REC, NULL)) == -1) {
749 async_safe_format_log(ANDROID_LOG_ERROR, "vold", "Failed to mount %s to %s :%s",
750 sources[i], targets[i], strerror(errno));
Ricky Wai07e64a42020-02-11 14:31:24 +0000751 return false;
752 }
Ricky Wai07e64a42020-02-11 14:31:24 +0000753 }
754 return true;
755}
756
Ricky Wai6b122572020-02-28 16:30:47 +0000757static std::string getStorageDirSrc(userid_t userId, const std::string& dirName,
758 const std::string& packageName) {
Daniel Rosenbergf36bddd2020-05-11 22:58:42 -0700759 if (IsSdcardfsUsed()) {
Ricky Wai6b122572020-02-28 16:30:47 +0000760 return StringPrintf("/mnt/runtime/default/emulated/%d/%s/%s",
761 userId, dirName.c_str(), packageName.c_str());
762 } else {
763 return StringPrintf("/mnt/pass_through/%d/emulated/%d/%s/%s",
764 userId, userId, dirName.c_str(), packageName.c_str());
Ricky Wai07e64a42020-02-11 14:31:24 +0000765 }
Ricky Wai6b122572020-02-28 16:30:47 +0000766}
767
768static std::string getStorageDirTarget(userid_t userId, std::string dirName,
769 std::string packageName) {
770 return StringPrintf("/storage/emulated/%d/%s/%s",
771 userId, dirName.c_str(), packageName.c_str());
772}
773
Ricky Waia2ca11e2021-01-15 14:03:23 +0000774// Fork the process and remount / unmount app data and obb dirs
775bool VolumeManager::forkAndRemountStorage(int uid, int pid, bool doUnmount,
Linus Tufvesson75973cb2020-03-23 11:59:43 +0000776 const std::vector<std::string>& packageNames) {
Ricky Wai6b122572020-02-28 16:30:47 +0000777 userid_t userId = multiuser_get_user_id(uid);
778 std::string mnt_path = StringPrintf("/proc/%d/ns/mnt", pid);
779 android::base::unique_fd nsFd(
780 TEMP_FAILURE_RETRY(open(mnt_path.c_str(), O_RDONLY | O_CLOEXEC)));
781 if (nsFd == -1) {
782 PLOG(ERROR) << "Unable to open " << mnt_path.c_str();
783 return false;
784 }
785 // Storing both Android/obb and Android/data paths.
786 int size = packageNames.size() * 2;
787
788 std::unique_ptr<std::string[]> sources(new std::string[size]);
789 std::unique_ptr<std::string[]> targets(new std::string[size]);
790 std::unique_ptr<const char*[]> sources_uptr(new const char*[size]);
791 std::unique_ptr<const char*[]> targets_uptr(new const char*[size]);
792 const char** sources_cstr = sources_uptr.get();
793 const char** targets_cstr = targets_uptr.get();
794
795 for (int i = 0; i < size; i += 2) {
796 std::string const& packageName = packageNames[i/2];
797 sources[i] = getStorageDirSrc(userId, "Android/data", packageName);
798 targets[i] = getStorageDirTarget(userId, "Android/data", packageName);
799 sources[i+1] = getStorageDirSrc(userId, "Android/obb", packageName);
800 targets[i+1] = getStorageDirTarget(userId, "Android/obb", packageName);
801
802 sources_cstr[i] = sources[i].c_str();
803 targets_cstr[i] = targets[i].c_str();
804 sources_cstr[i+1] = sources[i+1].c_str();
805 targets_cstr[i+1] = targets[i+1].c_str();
806 }
807
808 for (int i = 0; i < size; i++) {
Linus Tufvesson75973cb2020-03-23 11:59:43 +0000809 // Make sure /storage/emulated/... paths are setup correctly
Ricky Waif6da79c2021-01-19 11:27:36 +0000810 // This needs to be done before EnsureDirExists to ensure Android/ is created.
811 auto status = setupAppDir(targets_cstr[i], uid, false /* fixupExistingOnly */);
Ricky Wai6b122572020-02-28 16:30:47 +0000812 if (status != OK) {
813 PLOG(ERROR) << "Failed to create dir: " << targets_cstr[i];
814 return false;
815 }
Ricky Waif6da79c2021-01-19 11:27:36 +0000816 status = EnsureDirExists(sources_cstr[i], 0771, AID_MEDIA_RW, AID_MEDIA_RW);
817 if (status != OK) {
818 PLOG(ERROR) << "Failed to create dir: " << sources_cstr[i];
819 return false;
820 }
Ricky Wai6b122572020-02-28 16:30:47 +0000821 }
822
Ricky Waie96b34f2020-05-07 16:01:33 +0100823 char android_data_dir[PATH_MAX];
824 char android_obb_dir[PATH_MAX];
825 snprintf(android_data_dir, PATH_MAX, "/storage/emulated/%d/Android/data", userId);
826 snprintf(android_obb_dir, PATH_MAX, "/storage/emulated/%d/Android/obb", userId);
827
Ricky Wai6b122572020-02-28 16:30:47 +0000828 pid_t child;
829 // Fork a child to mount Android/obb android Android/data dirs, as we don't want it to affect
830 // original vold process mount namespace.
831 if (!(child = fork())) {
Ricky Waia2ca11e2021-01-15 14:03:23 +0000832 if (doUnmount) {
833 if (umountStorageDirs(nsFd, android_data_dir, android_obb_dir, uid,
834 targets_cstr, size)) {
835 _exit(0);
836 } else {
837 _exit(1);
838 }
Ricky Wai07e64a42020-02-11 14:31:24 +0000839 } else {
Ricky Waia2ca11e2021-01-15 14:03:23 +0000840 if (remountStorageDirs(nsFd, android_data_dir, android_obb_dir, uid,
841 sources_cstr, targets_cstr, size)) {
842 _exit(0);
843 } else {
844 _exit(1);
845 }
Ricky Wai07e64a42020-02-11 14:31:24 +0000846 }
847 }
Ricky Wai6b122572020-02-28 16:30:47 +0000848
Ricky Wai07e64a42020-02-11 14:31:24 +0000849 if (child == -1) {
850 PLOG(ERROR) << "Failed to fork";
Ricky Wai6b122572020-02-28 16:30:47 +0000851 return false;
852 } else {
853 int status;
854 if (TEMP_FAILURE_RETRY(waitpid(child, &status, 0)) == -1) {
855 PLOG(ERROR) << "Failed to waitpid: " << child;
856 return false;
857 }
858 if (!WIFEXITED(status)) {
859 PLOG(ERROR) << "Process did not exit normally, status: " << status;
860 return false;
861 }
862 if (WEXITSTATUS(status)) {
863 PLOG(ERROR) << "Process exited with code: " << WEXITSTATUS(status);
864 return false;
Ricky Wai07e64a42020-02-11 14:31:24 +0000865 }
866 }
Ricky Wai6b122572020-02-28 16:30:47 +0000867 return true;
868}
869
Ricky Waia2ca11e2021-01-15 14:03:23 +0000870int VolumeManager::handleAppStorageDirs(int uid, int pid,
871 bool doUnmount, const std::vector<std::string>& packageNames) {
Ricky Wai6b122572020-02-28 16:30:47 +0000872 // Only run the remount if fuse is mounted for that user.
873 userid_t userId = multiuser_get_user_id(uid);
874 bool fuseMounted = false;
875 for (auto& vol : mInternalEmulatedVolumes) {
876 if (vol->getMountUserId() == userId && vol->getState() == VolumeBase::State::kMounted) {
877 auto* emulatedVol = static_cast<android::vold::EmulatedVolume*>(vol.get());
878 if (emulatedVol) {
879 fuseMounted = emulatedVol->isFuseMounted();
880 }
881 break;
882 }
883 }
884 if (fuseMounted) {
Ricky Waia2ca11e2021-01-15 14:03:23 +0000885 forkAndRemountStorage(uid, pid, doUnmount, packageNames);
Ricky Wai6b122572020-02-28 16:30:47 +0000886 }
Jeff Sharkey66270a22015-06-24 11:49:24 -0700887 return 0;
888}
889
Martijn Coenen23c04452020-04-29 07:49:41 +0200890int VolumeManager::abortFuse() {
891 return android::vold::AbortFuseConnections();
892}
893
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700894int VolumeManager::reset() {
895 // Tear down all existing disks/volumes and start from a blank slate so
896 // newly connected framework hears all events.
Zima438b242019-09-25 14:37:38 +0100897 for (const auto& vol : mInternalEmulatedVolumes) {
898 vol->destroy();
Gao Xiangd263da82017-08-14 11:32:13 +0800899 }
Zima438b242019-09-25 14:37:38 +0100900 mInternalEmulatedVolumes.clear();
Zima438b242019-09-25 14:37:38 +0100901
Chih-Hung Hsieh11a2ce82016-07-27 14:11:02 -0700902 for (const auto& disk : mDisks) {
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700903 disk->destroy();
904 disk->create();
905 }
Jeff Sharkeyfa1c6772017-03-25 22:49:13 -0600906 updateVirtualDisk();
Jeff Sharkeybd3038d2015-06-10 09:42:01 -0700907 mAddedUsers.clear();
Sudheer Shanka023b5392019-02-06 12:39:19 -0800908 mStartedUsers.clear();
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700909 return 0;
910}
911
Keun-young Parka5bbb5e2017-03-13 18:02:50 -0700912// Can be called twice (sequentially) during shutdown. should be safe for that.
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700913int VolumeManager::shutdown() {
Zima438b242019-09-25 14:37:38 +0100914 if (mInternalEmulatedVolumes.empty()) {
Paul Crowleyedf7a4e2018-09-18 15:14:18 -0700915 return 0; // already shutdown
Keun-young Parka5bbb5e2017-03-13 18:02:50 -0700916 }
Paul Crowley56292ef2017-10-20 08:07:53 -0700917 android::vold::sSleepOnUnmount = false;
Zima438b242019-09-25 14:37:38 +0100918 for (const auto& vol : mInternalEmulatedVolumes) {
919 vol->destroy();
920 }
Chih-Hung Hsieh11a2ce82016-07-27 14:11:02 -0700921 for (const auto& disk : mDisks) {
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700922 disk->destroy();
923 }
Zima438b242019-09-25 14:37:38 +0100924
925 mInternalEmulatedVolumes.clear();
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700926 mDisks.clear();
Jeff Sharkey401b2602017-12-14 22:15:20 -0700927 mPendingDisks.clear();
Paul Crowley56292ef2017-10-20 08:07:53 -0700928 android::vold::sSleepOnUnmount = true;
Martijn Coenen23c04452020-04-29 07:49:41 +0200929
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700930 return 0;
San Mehatf1b736b2009-10-10 17:22:08 -0700931}
932
Jeff Sharkey9c484982015-03-31 10:35:33 -0700933int VolumeManager::unmountAll() {
Jeff Sharkeyc8e04c52015-04-21 12:14:17 -0700934 std::lock_guard<std::mutex> lock(mLock);
Jeff Sharkey67b8c492017-09-21 17:08:43 -0600935 ATRACE_NAME("VolumeManager::unmountAll()");
Jeff Sharkeyc8e04c52015-04-21 12:14:17 -0700936
Jeff Sharkey9c484982015-03-31 10:35:33 -0700937 // First, try gracefully unmounting all known devices
Zima438b242019-09-25 14:37:38 +0100938 for (const auto& vol : mInternalEmulatedVolumes) {
939 vol->unmount();
Jeff Sharkey9c484982015-03-31 10:35:33 -0700940 }
Chih-Hung Hsieh11a2ce82016-07-27 14:11:02 -0700941 for (const auto& disk : mDisks) {
Jeff Sharkey9c484982015-03-31 10:35:33 -0700942 disk->unmountAll();
943 }
944
945 // Worst case we might have some stale mounts lurking around, so
946 // force unmount those just to be safe.
LongPing.WEI4f046062018-11-23 19:27:35 +0800947 FILE* fp = setmntent("/proc/mounts", "re");
Jeff Sharkey9c484982015-03-31 10:35:33 -0700948 if (fp == NULL) {
Jeff Sharkey3472e522017-10-06 18:02:53 -0600949 PLOG(ERROR) << "Failed to open /proc/mounts";
Jeff Sharkey9c484982015-03-31 10:35:33 -0700950 return -errno;
951 }
952
953 // Some volumes can be stacked on each other, so force unmount in
954 // reverse order to give us the best chance of success.
955 std::list<std::string> toUnmount;
956 mntent* mentry;
957 while ((mentry = getmntent(fp)) != NULL) {
Jeff Sharkey3472e522017-10-06 18:02:53 -0600958 auto test = std::string(mentry->mnt_dir);
Mark Salyzyn86e81e72018-09-20 10:09:27 -0700959 if ((StartsWith(test, "/mnt/") &&
960#ifdef __ANDROID_DEBUGGABLE__
961 !StartsWith(test, "/mnt/scratch") &&
962#endif
Martijn Coenenb0e977a2020-01-11 19:24:26 +0100963 !StartsWith(test, "/mnt/vendor") && !StartsWith(test, "/mnt/product") &&
Ricky Waief639212020-04-07 13:43:20 +0100964 !StartsWith(test, "/mnt/installer") && !StartsWith(test, "/mnt/androidwritable")) ||
Mark Salyzyn86e81e72018-09-20 10:09:27 -0700965 StartsWith(test, "/storage/")) {
Jeff Sharkey3472e522017-10-06 18:02:53 -0600966 toUnmount.push_front(test);
Jeff Sharkey9c484982015-03-31 10:35:33 -0700967 }
968 }
969 endmntent(fp);
970
Chih-Hung Hsieh11a2ce82016-07-27 14:11:02 -0700971 for (const auto& path : toUnmount) {
Jeff Sharkey11c2d382017-09-11 10:32:01 -0600972 LOG(DEBUG) << "Tearing down stale mount " << path;
Jeff Sharkey9c484982015-03-31 10:35:33 -0700973 android::vold::ForceUnmount(path);
974 }
975
976 return 0;
977}
978
Ricky Waibbfb6ea2020-12-03 15:32:52 +0000979int VolumeManager::ensureAppDirsCreated(const std::vector<std::string>& paths, int32_t appUid) {
Ricky Waibbfb6ea2020-12-03 15:32:52 +0000980 int size = paths.size();
981 for (int i = 0; i < size; i++) {
982 int result = setupAppDir(paths[i], appUid, false /* fixupExistingOnly */,
983 true /* skipIfDirExists */);
984 if (result != OK) {
985 return result;
986 }
987 }
988 return OK;
989}
990
991int VolumeManager::setupAppDir(const std::string& path, int32_t appUid, bool fixupExistingOnly,
992 bool skipIfDirExists) {
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700993 // Only offer to create directories for paths managed by vold
Martijn Coenen13ff6682019-12-24 12:57:16 +0100994 if (!StartsWith(path, "/storage/")) {
Jeff Sharkey3472e522017-10-06 18:02:53 -0600995 LOG(ERROR) << "Failed to find mounted volume for " << path;
Jeff Sharkey71ebe152013-09-17 17:24:38 -0700996 return -EINVAL;
997 }
Martijn Coenen13ff6682019-12-24 12:57:16 +0100998
Martijn Coenen0a7e9922020-01-24 16:17:32 +0100999 // Find the volume it belongs to
1000 auto filter_fn = [&](const VolumeBase& vol) {
1001 if (vol.getState() != VolumeBase::State::kMounted) {
1002 // The volume must be mounted
1003 return false;
1004 }
Youkichi Hosoi2991cbe2021-11-11 11:23:01 +09001005 if (!vol.isVisibleForWrite()) {
1006 // App dirs should only be created for writable volumes.
Martijn Coenen0a7e9922020-01-24 16:17:32 +01001007 return false;
1008 }
1009 if (vol.getInternalPath().empty()) {
1010 return false;
1011 }
1012 if (vol.getMountUserId() != USER_UNKNOWN &&
1013 vol.getMountUserId() != multiuser_get_user_id(appUid)) {
1014 // The app dir must be created on a volume with the same user-id
1015 return false;
1016 }
1017 if (!path.empty() && StartsWith(path, vol.getPath())) {
1018 return true;
1019 }
1020
1021 return false;
1022 };
1023 auto volume = findVolumeWithFilter(filter_fn);
1024 if (volume == nullptr) {
1025 LOG(ERROR) << "Failed to find mounted volume for " << path;
1026 return -EINVAL;
1027 }
Zimc59d7742020-01-06 21:48:16 +00001028 // Convert paths to lower filesystem paths to avoid making FUSE requests for these reasons:
1029 // 1. A FUSE request from vold puts vold at risk of hanging if the FUSE daemon is down
1030 // 2. The FUSE daemon prevents requests on /mnt/user/0/emulated/<userid != 0> and a request
1031 // on /storage/emulated/10 means /mnt/user/0/emulated/10
Martijn Coenen0a7e9922020-01-24 16:17:32 +01001032 const std::string lowerPath =
1033 volume->getInternalPath() + path.substr(volume->getPath().length());
Zimc59d7742020-01-06 21:48:16 +00001034
Martijn Coenen62a4b272020-01-31 15:23:09 +01001035 const std::string volumeRoot = volume->getRootPath(); // eg /data/media/0
1036
Ricky Waibbfb6ea2020-12-03 15:32:52 +00001037 const int access_result = access(lowerPath.c_str(), F_OK);
1038 if (fixupExistingOnly && access_result != 0) {
Martijn Coenen816f4d92020-02-18 15:06:37 +01001039 // Nothing to fixup
1040 return OK;
1041 }
1042
Ricky Waibbfb6ea2020-12-03 15:32:52 +00001043 if (skipIfDirExists && access_result == 0) {
1044 // It's safe to assume it's ok as it will be used for zygote to bind mount dir only,
1045 // which the dir doesn't need to have correct permission for now yet.
1046 return OK;
1047 }
1048
Martijn Coenenbf205ab2020-04-20 15:14:48 +02001049 if (volume->getType() == VolumeBase::Type::kPublic) {
1050 // On public volumes, we don't need to setup permissions, as everything goes through
1051 // FUSE; just create the dirs and be done with it.
1052 return fs_mkdirs(lowerPath.c_str(), 0700);
1053 }
1054
Martijn Coenenb5a31c92020-02-13 23:30:38 +01001055 // Create the app paths we need from the root
Martijn Coenen816f4d92020-02-18 15:06:37 +01001056 return PrepareAppDirFromRoot(lowerPath, volumeRoot, appUid, fixupExistingOnly);
1057}
1058
1059int VolumeManager::fixupAppDir(const std::string& path, int32_t appUid) {
Daniel Rosenbergf36bddd2020-05-11 22:58:42 -07001060 if (IsSdcardfsUsed()) {
Martijn Coenen816f4d92020-02-18 15:06:37 +01001061 //sdcardfs magically does this for us
1062 return OK;
1063 }
1064 return setupAppDir(path, appUid, true /* fixupExistingOnly */);
Jeff Sharkey71ebe152013-09-17 17:24:38 -07001065}
Jeff Sharkey11c2d382017-09-11 10:32:01 -06001066
Jeff Sharkey11c2d382017-09-11 10:32:01 -06001067int VolumeManager::createObb(const std::string& sourcePath, const std::string& sourceKey,
Paul Crowleyedf7a4e2018-09-18 15:14:18 -07001068 int32_t ownerGid, std::string* outVolId) {
Jeff Sharkey11c2d382017-09-11 10:32:01 -06001069 int id = mNextObbId++;
1070
Martijn Coenend6a612a2020-11-19 10:49:45 +01001071 std::string lowerSourcePath;
1072
1073 // Convert to lower filesystem path
1074 if (StartsWith(sourcePath, "/storage/")) {
1075 auto filter_fn = [&](const VolumeBase& vol) {
1076 if (vol.getState() != VolumeBase::State::kMounted) {
1077 // The volume must be mounted
1078 return false;
1079 }
Youkichi Hosoi2991cbe2021-11-11 11:23:01 +09001080 if (!vol.isVisibleForWrite()) {
1081 // Obb volume should only be created for writable volumes.
Martijn Coenend6a612a2020-11-19 10:49:45 +01001082 return false;
1083 }
1084 if (vol.getInternalPath().empty()) {
1085 return false;
1086 }
1087 if (!sourcePath.empty() && StartsWith(sourcePath, vol.getPath())) {
1088 return true;
1089 }
1090
1091 return false;
1092 };
1093 auto volume = findVolumeWithFilter(filter_fn);
1094 if (volume == nullptr) {
1095 LOG(ERROR) << "Failed to find mounted volume for " << sourcePath;
1096 return -EINVAL;
1097 } else {
1098 lowerSourcePath =
1099 volume->getInternalPath() + sourcePath.substr(volume->getPath().length());
1100 }
1101 } else {
1102 lowerSourcePath = sourcePath;
1103 }
1104
Jeff Sharkey11c2d382017-09-11 10:32:01 -06001105 auto vol = std::shared_ptr<android::vold::VolumeBase>(
Martijn Coenend6a612a2020-11-19 10:49:45 +01001106 new android::vold::ObbVolume(id, lowerSourcePath, sourceKey, ownerGid));
Jeff Sharkey11c2d382017-09-11 10:32:01 -06001107 vol->create();
1108
1109 mObbVolumes.push_back(vol);
1110 *outVolId = vol->getId();
1111 return android::OK;
1112}
1113
1114int VolumeManager::destroyObb(const std::string& volId) {
1115 auto i = mObbVolumes.begin();
1116 while (i != mObbVolumes.end()) {
1117 if ((*i)->getId() == volId) {
1118 (*i)->destroy();
1119 i = mObbVolumes.erase(i);
1120 } else {
1121 ++i;
1122 }
1123 }
1124 return android::OK;
1125}
1126
Risan8c9f3322018-10-29 08:52:56 +09001127int VolumeManager::createStubVolume(const std::string& sourcePath, const std::string& mountPath,
1128 const std::string& fsType, const std::string& fsUuid,
Risan73a7a852020-02-07 18:03:44 +09001129 const std::string& fsLabel, int32_t flags,
Risan82e90de2020-02-04 16:07:21 +09001130 std::string* outVolId) {
1131 dev_t stubId = --mNextStubId;
1132 auto vol = std::shared_ptr<android::vold::StubVolume>(
1133 new android::vold::StubVolume(stubId, sourcePath, mountPath, fsType, fsUuid, fsLabel));
Risan8c9f3322018-10-29 08:52:56 +09001134
Youkichi Hosoidefc0452020-07-08 06:08:48 +09001135 int32_t passedFlags = 0;
Risan73a7a852020-02-07 18:03:44 +09001136 passedFlags |= (flags & android::vold::Disk::Flags::kUsb);
1137 passedFlags |= (flags & android::vold::Disk::Flags::kSd);
Youkichi Hosoidefc0452020-07-08 06:08:48 +09001138 if (flags & android::vold::Disk::Flags::kStubVisible) {
1139 passedFlags |= (flags & android::vold::Disk::Flags::kStubVisible);
1140 } else {
1141 passedFlags |= (flags & android::vold::Disk::Flags::kStubInvisible);
1142 }
Risan82e90de2020-02-04 16:07:21 +09001143 // StubDisk doesn't have device node corresponds to it. So, a fake device
Risan73a7a852020-02-07 18:03:44 +09001144 // number is used.
Risan82e90de2020-02-04 16:07:21 +09001145 auto disk = std::shared_ptr<android::vold::Disk>(
Risan73a7a852020-02-07 18:03:44 +09001146 new android::vold::Disk("stub", stubId, "stub", passedFlags));
Risan82e90de2020-02-04 16:07:21 +09001147 disk->initializePartition(vol);
1148 handleDiskAdded(disk);
Risan8c9f3322018-10-29 08:52:56 +09001149 *outVolId = vol->getId();
1150 return android::OK;
1151}
1152
1153int VolumeManager::destroyStubVolume(const std::string& volId) {
Risan82e90de2020-02-04 16:07:21 +09001154 auto tokens = android::base::Split(volId, ":");
1155 CHECK(tokens.size() == 2);
1156 dev_t stubId;
1157 CHECK(android::base::ParseUint(tokens[1], &stubId));
1158 handleDiskRemoved(stubId);
Risan8c9f3322018-10-29 08:52:56 +09001159 return android::OK;
1160}
1161
Risan8f6198d2018-10-26 20:56:45 -06001162int VolumeManager::mountAppFuse(uid_t uid, int mountId, unique_fd* device_fd) {
Risanac02a482018-10-31 21:59:47 -06001163 return android::vold::MountAppFuse(uid, mountId, device_fd);
Jeff Sharkey11c2d382017-09-11 10:32:01 -06001164}
1165
Risan8f6198d2018-10-26 20:56:45 -06001166int VolumeManager::unmountAppFuse(uid_t uid, int mountId) {
Risanac02a482018-10-31 21:59:47 -06001167 return android::vold::UnmountAppFuse(uid, mountId);
Risan8f6198d2018-10-26 20:56:45 -06001168}
1169
1170int VolumeManager::openAppFuseFile(uid_t uid, int mountId, int fileId, int flags) {
Risanac02a482018-10-31 21:59:47 -06001171 return android::vold::OpenAppFuseFile(uid, mountId, fileId, flags);
Jeff Sharkey11c2d382017-09-11 10:32:01 -06001172}