blob: e038303c1e1aac42f46ba8849144bcdbfe41e7c7 [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
Yabin Cuid1104f72015-01-02 13:28:28 -080017#include <dirent.h>
San Mehatf1b736b2009-10-10 17:22:08 -070018#include <errno.h>
San Mehata2677e42009-12-13 10:40:18 -080019#include <fcntl.h>
Kenny Root344ca102012-04-03 17:23:01 -070020#include <fts.h>
Yabin Cuid1104f72015-01-02 13:28:28 -080021#include <mntent.h>
22#include <stdio.h>
23#include <stdlib.h>
24#include <string.h>
25#include <sys/ioctl.h>
26#include <sys/mount.h>
San Mehata19b2502010-01-06 10:33:53 -080027#include <sys/stat.h>
28#include <sys/types.h>
Jeff Sharkey66270a22015-06-24 11:49:24 -070029#include <sys/wait.h>
Yabin Cuid1104f72015-01-02 13:28:28 -080030#include <unistd.h>
San Mehata19b2502010-01-06 10:33:53 -080031
San Mehata2677e42009-12-13 10:40:18 -080032#include <linux/kdev_t.h>
San Mehatf1b736b2009-10-10 17:22:08 -070033
34#define LOG_TAG "Vold"
35
Kenny Root7b18a7b2010-03-15 13:13:41 -070036#include <openssl/md5.h>
37
Elliott Hughes7e128fb2015-12-04 15:50:53 -080038#include <android-base/logging.h>
39#include <android-base/stringprintf.h>
Jeff Sharkey71ebe152013-09-17 17:24:38 -070040#include <cutils/fs.h>
San Mehatf1b736b2009-10-10 17:22:08 -070041#include <cutils/log.h>
42
Robert Craigb9e3ba52014-02-04 10:53:00 -050043#include <selinux/android.h>
44
San Mehatfd7f5872009-10-12 11:32:47 -070045#include <sysutils/NetlinkEvent.h>
46
Kenny Root344ca102012-04-03 17:23:01 -070047#include <private/android_filesystem_config.h>
48
Jeff Sharkey5a6bfca2015-05-14 20:33:55 -070049#include "Benchmark.h"
Jeff Sharkey36801cc2015-03-13 16:09:20 -070050#include "EmulatedVolume.h"
San Mehatf1b736b2009-10-10 17:22:08 -070051#include "VolumeManager.h"
Jeff Sharkey36801cc2015-03-13 16:09:20 -070052#include "NetlinkManager.h"
San Mehata2677e42009-12-13 10:40:18 -080053#include "ResponseCode.h"
San Mehata19b2502010-01-06 10:33:53 -080054#include "Loop.h"
Jeff Sharkeyd0640f62015-05-21 22:35:42 -070055#include "fs/Ext4.h"
56#include "fs/Vfat.h"
Jeff Sharkey36801cc2015-03-13 16:09:20 -070057#include "Utils.h"
San Mehatb78a32c2010-01-10 13:02:12 -080058#include "Devmapper.h"
San Mehat586536c2010-02-16 17:12:00 -080059#include "Process.h"
San Mehatfcf24fe2010-03-03 12:37:32 -080060#include "Asec.h"
Hiroaki Miyazawa14eab552015-02-04 13:29:15 +090061#include "VoldUtil.h"
Ken Sumrall29d8da82011-05-18 17:20:07 -070062#include "cryptfs.h"
San Mehat23969932010-01-09 07:08:06 -080063
Mike Lockwood97f2fc12011-06-07 10:51:38 -070064#define MASS_STORAGE_FILE_PATH "/sys/class/android_usb/android0/f_mass_storage/lun/file"
65
Chih-Hung Hsiehcc5d5802016-05-11 15:05:05 -070066#define ROUND_UP_POWER_OF_2(number, po2) (((!!((number) & ((1U << (po2)) - 1))) << (po2))\
67 + ((number) & (~((1U << (po2)) - 1))))
Daniel Rosenberg6a74dca2014-05-23 13:47:00 -070068
Jeff Sharkey36801cc2015-03-13 16:09:20 -070069using android::base::StringPrintf;
70
Jeff Sharkey9f18fe72015-04-01 23:32:18 -070071/*
72 * Path to external storage where *only* root can access ASEC image files
73 */
74const char *VolumeManager::SEC_ASECDIR_EXT = "/mnt/secure/asec";
75
76/*
77 * Path to internal storage where *only* root can access ASEC image files
78 */
79const char *VolumeManager::SEC_ASECDIR_INT = "/data/app-asec";
80
81/*
82 * Path to where secure containers are mounted
83 */
84const char *VolumeManager::ASECDIR = "/mnt/asec";
85
86/*
87 * Path to where OBBs are mounted
88 */
89const char *VolumeManager::LOOPDIR = "/mnt/obb";
90
Jeff Sharkeyfa1c6772017-03-25 22:49:13 -060091static const char* kPathUserMount = "/mnt/user";
92static const char* kPathVirtualDisk = "/data/misc/vold/virtual_disk";
93
94static const char* kPropVirtualDisk = "persist.sys.virtual_disk";
95
96/* 512MiB is large enough for testing purposes */
97static const unsigned int kSizeVirtualDisk = 536870912;
Jeff Sharkey36801cc2015-03-13 16:09:20 -070098
Jeff Sharkey36801cc2015-03-13 16:09:20 -070099static const unsigned int kMajorBlockMmc = 179;
Yu Ning942d4e82016-01-08 17:36:47 +0800100static const unsigned int kMajorBlockExperimentalMin = 240;
101static const unsigned int kMajorBlockExperimentalMax = 254;
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700102
Daniel Rosenbergfcd34a02014-05-22 11:23:56 -0700103/* writes superblock at end of file or device given by name */
104static int writeSuperBlock(const char* name, struct asec_superblock *sb, unsigned int numImgSectors) {
Jeff Sharkeyce6a9132015-04-08 21:07:21 -0700105 int sbfd = open(name, O_RDWR | O_CLOEXEC);
Daniel Rosenbergfcd34a02014-05-22 11:23:56 -0700106 if (sbfd < 0) {
107 SLOGE("Failed to open %s for superblock write (%s)", name, strerror(errno));
108 return -1;
109 }
110
111 if (lseek(sbfd, (numImgSectors * 512), SEEK_SET) < 0) {
112 SLOGE("Failed to lseek for superblock (%s)", strerror(errno));
113 close(sbfd);
114 return -1;
115 }
116
117 if (write(sbfd, sb, sizeof(struct asec_superblock)) != sizeof(struct asec_superblock)) {
118 SLOGE("Failed to write superblock (%s)", strerror(errno));
119 close(sbfd);
120 return -1;
121 }
122 close(sbfd);
123 return 0;
124}
125
Mateusz Nowaka4f48d02015-08-03 18:06:39 +0200126static unsigned long adjustSectorNumExt4(unsigned long numSectors) {
Daniel Rosenberge9196fe2014-06-10 17:16:03 -0700127 // Ext4 started to reserve 2% or 4096 clusters, whichever is smaller for
128 // preventing costly operations or unexpected ENOSPC error.
129 // Ext4::format() uses default block size without clustering.
Mateusz Nowaka4f48d02015-08-03 18:06:39 +0200130 unsigned long clusterSectors = 4096 / 512;
131 unsigned long reservedSectors = (numSectors * 2)/100 + (numSectors % 50 > 0);
Daniel Rosenberge9196fe2014-06-10 17:16:03 -0700132 numSectors += reservedSectors > (4096 * clusterSectors) ? (4096 * clusterSectors) : reservedSectors;
Daniel Rosenbergfcd34a02014-05-22 11:23:56 -0700133 return ROUND_UP_POWER_OF_2(numSectors, 3);
134}
135
Mateusz Nowaka4f48d02015-08-03 18:06:39 +0200136static unsigned long adjustSectorNumFAT(unsigned long numSectors) {
Daniel Rosenbergfcd34a02014-05-22 11:23:56 -0700137 /*
138 * Add some headroom
139 */
Mateusz Nowaka4f48d02015-08-03 18:06:39 +0200140 unsigned long fatSize = (((numSectors * 4) / 512) + 1) * 2;
Daniel Rosenbergfcd34a02014-05-22 11:23:56 -0700141 numSectors += fatSize + 2;
142 /*
143 * FAT is aligned to 32 kb with 512b sectors.
144 */
145 return ROUND_UP_POWER_OF_2(numSectors, 6);
146}
147
148static int setupLoopDevice(char* buffer, size_t len, const char* asecFileName, const char* idHash, bool debug) {
149 if (Loop::lookupActive(idHash, buffer, len)) {
150 if (Loop::create(idHash, asecFileName, buffer, len)) {
151 SLOGE("ASEC loop device creation failed for %s (%s)", asecFileName, strerror(errno));
152 return -1;
153 }
154 if (debug) {
155 SLOGD("New loop device created at %s", buffer);
156 }
157 } else {
158 if (debug) {
159 SLOGD("Found active loopback for %s at %s", asecFileName, buffer);
160 }
161 }
162 return 0;
163}
164
Mateusz Nowaka4f48d02015-08-03 18:06:39 +0200165static int setupDevMapperDevice(char* buffer, size_t len, const char* loopDevice, const char* asecFileName, const char* key, const char* idHash , unsigned long numImgSectors, bool* createdDMDevice, bool debug) {
Daniel Rosenbergfcd34a02014-05-22 11:23:56 -0700166 if (strcmp(key, "none")) {
167 if (Devmapper::lookupActive(idHash, buffer, len)) {
168 if (Devmapper::create(idHash, loopDevice, key, numImgSectors,
169 buffer, len)) {
170 SLOGE("ASEC device mapping failed for %s (%s)", asecFileName, strerror(errno));
171 return -1;
172 }
173 if (debug) {
174 SLOGD("New devmapper instance created at %s", buffer);
175 }
176 } else {
177 if (debug) {
178 SLOGD("Found active devmapper for %s at %s", asecFileName, buffer);
179 }
180 }
181 *createdDMDevice = true;
182 } else {
Jeff Sharkey32ebb732017-03-27 16:18:50 -0600183 strlcpy(buffer, loopDevice, len);
Daniel Rosenbergfcd34a02014-05-22 11:23:56 -0700184 *createdDMDevice = false;
185 }
186 return 0;
187}
188
189static void waitForDevMapper(const char *dmDevice) {
190 /*
191 * Wait for the device mapper node to be created. Sometimes it takes a
192 * while. Wait for up to 1 second. We could also inspect incoming uevents,
193 * but that would take more effort.
194 */
195 int tries = 25;
196 while (tries--) {
197 if (!access(dmDevice, F_OK) || errno != ENOENT) {
198 break;
199 }
200 usleep(40 * 1000);
201 }
202}
203
San Mehatf1b736b2009-10-10 17:22:08 -0700204VolumeManager *VolumeManager::sInstance = NULL;
205
206VolumeManager *VolumeManager::Instance() {
207 if (!sInstance)
208 sInstance = new VolumeManager();
209 return sInstance;
210}
211
212VolumeManager::VolumeManager() {
San Mehatd9a4e352010-03-12 13:32:47 -0800213 mDebug = false;
San Mehat88705162010-01-15 09:26:28 -0800214 mActiveContainers = new AsecIdCollection();
San Mehatf1b736b2009-10-10 17:22:08 -0700215 mBroadcaster = NULL;
Mike Lockwooda28056b2010-10-28 15:21:24 -0400216 mUmsSharingCount = 0;
217 mSavedDirtyRatio = -1;
218 // set dirty ratio to 0 when UMS is active
219 mUmsDirtyRatio = 0;
San Mehatf1b736b2009-10-10 17:22:08 -0700220}
221
222VolumeManager::~VolumeManager() {
San Mehat88705162010-01-15 09:26:28 -0800223 delete mActiveContainers;
San Mehatf1b736b2009-10-10 17:22:08 -0700224}
225
Kenny Root7b18a7b2010-03-15 13:13:41 -0700226char *VolumeManager::asecHash(const char *id, char *buffer, size_t len) {
Kenny Rootacc9e7d2010-06-18 19:06:50 -0700227 static const char* digits = "0123456789abcdef";
228
Kenny Root7b18a7b2010-03-15 13:13:41 -0700229 unsigned char sig[MD5_DIGEST_LENGTH];
230
Kenny Rootacc9e7d2010-06-18 19:06:50 -0700231 if (buffer == NULL) {
232 SLOGE("Destination buffer is NULL");
233 errno = ESPIPE;
234 return NULL;
235 } else if (id == NULL) {
236 SLOGE("Source buffer is NULL");
237 errno = ESPIPE;
238 return NULL;
239 } else if (len < MD5_ASCII_LENGTH_PLUS_NULL) {
Colin Cross59846b62014-02-06 20:34:29 -0800240 SLOGE("Target hash buffer size < %d bytes (%zu)",
Kenny Rootacc9e7d2010-06-18 19:06:50 -0700241 MD5_ASCII_LENGTH_PLUS_NULL, len);
San Mehatd9a4e352010-03-12 13:32:47 -0800242 errno = ESPIPE;
243 return NULL;
244 }
Kenny Root7b18a7b2010-03-15 13:13:41 -0700245
246 MD5(reinterpret_cast<const unsigned char*>(id), strlen(id), sig);
San Mehatd9a4e352010-03-12 13:32:47 -0800247
Kenny Rootacc9e7d2010-06-18 19:06:50 -0700248 char *p = buffer;
Kenny Root7b18a7b2010-03-15 13:13:41 -0700249 for (int i = 0; i < MD5_DIGEST_LENGTH; i++) {
Kenny Rootacc9e7d2010-06-18 19:06:50 -0700250 *p++ = digits[sig[i] >> 4];
251 *p++ = digits[sig[i] & 0x0F];
San Mehatd9a4e352010-03-12 13:32:47 -0800252 }
Kenny Rootacc9e7d2010-06-18 19:06:50 -0700253 *p = '\0';
San Mehatd9a4e352010-03-12 13:32:47 -0800254
255 return buffer;
256}
257
Jeff Sharkeyfa1c6772017-03-25 22:49:13 -0600258int VolumeManager::updateVirtualDisk() {
259 if (property_get_bool(kPropVirtualDisk, false)) {
260 if (access(kPathVirtualDisk, F_OK) != 0) {
261 Loop::createImageFile(kPathVirtualDisk, kSizeVirtualDisk / 512);
262 }
263
264 if (mVirtualDisk == nullptr) {
265 if (Loop::create(kPathVirtualDisk, mVirtualDiskPath) != 0) {
266 LOG(ERROR) << "Failed to create virtual disk";
267 return -1;
268 }
269
270 struct stat buf;
271 if (stat(mVirtualDiskPath.c_str(), &buf) < 0) {
272 PLOG(ERROR) << "Failed to stat " << mVirtualDiskPath;
273 return -1;
274 }
275
276 auto disk = new android::vold::Disk("virtual", buf.st_rdev, "virtual",
277 android::vold::Disk::Flags::kAdoptable | android::vold::Disk::Flags::kSd);
278 disk->create();
279 mVirtualDisk = std::shared_ptr<android::vold::Disk>(disk);
280 mDisks.push_back(mVirtualDisk);
281 }
282 } else {
283 if (mVirtualDisk != nullptr) {
284 dev_t device = mVirtualDisk->getDevice();
285
286 auto i = mDisks.begin();
287 while (i != mDisks.end()) {
288 if ((*i)->getDevice() == device) {
289 (*i)->destroy();
290 i = mDisks.erase(i);
291 } else {
292 ++i;
293 }
294 }
295
296 Loop::destroyByDevice(mVirtualDiskPath.c_str());
297 mVirtualDisk = nullptr;
298 }
299
300 if (access(kPathVirtualDisk, F_OK) == 0) {
301 unlink(kPathVirtualDisk);
302 }
303 }
304 return 0;
305}
306
Jeff Sharkeyf1b996d2015-04-17 17:35:20 -0700307int VolumeManager::setDebug(bool enable) {
San Mehatd9a4e352010-03-12 13:32:47 -0800308 mDebug = enable;
Jeff Sharkeyf1b996d2015-04-17 17:35:20 -0700309 return 0;
San Mehatd9a4e352010-03-12 13:32:47 -0800310}
311
San Mehatf1b736b2009-10-10 17:22:08 -0700312int VolumeManager::start() {
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700313 // Always start from a clean slate by unmounting everything in
314 // directories that we own, in case we crashed.
Jeff Sharkey9c484982015-03-31 10:35:33 -0700315 unmountAll();
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700316
317 // Assume that we always have an emulated volume on internal
318 // storage; the framework will decide if it should be mounted.
Jeff Sharkeyc8e04c52015-04-21 12:14:17 -0700319 CHECK(mInternalEmulated == nullptr);
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700320 mInternalEmulated = std::shared_ptr<android::vold::VolumeBase>(
Jeff Sharkey3161fb32015-04-12 16:03:33 -0700321 new android::vold::EmulatedVolume("/data/media"));
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700322 mInternalEmulated->create();
323
Jeff Sharkeyfa1c6772017-03-25 22:49:13 -0600324 // Consider creating a virtual disk
325 updateVirtualDisk();
326
San Mehatf1b736b2009-10-10 17:22:08 -0700327 return 0;
328}
329
330int VolumeManager::stop() {
Jeff Sharkeyc8e04c52015-04-21 12:14:17 -0700331 CHECK(mInternalEmulated != nullptr);
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700332 mInternalEmulated->destroy();
333 mInternalEmulated = nullptr;
San Mehatf1b736b2009-10-10 17:22:08 -0700334 return 0;
335}
336
San Mehatfd7f5872009-10-12 11:32:47 -0700337void VolumeManager::handleBlockEvent(NetlinkEvent *evt) {
Jeff Sharkeyc8e04c52015-04-21 12:14:17 -0700338 std::lock_guard<std::mutex> lock(mLock);
339
Jeff Sharkeyf1b996d2015-04-17 17:35:20 -0700340 if (mDebug) {
341 LOG(VERBOSE) << "----------------";
342 LOG(VERBOSE) << "handleBlockEvent with action " << (int) evt->getAction();
343 evt->dump();
344 }
San Mehatf1b736b2009-10-10 17:22:08 -0700345
Mateusz Nowak64403792015-08-03 16:39:19 +0200346 std::string eventPath(evt->findParam("DEVPATH")?evt->findParam("DEVPATH"):"");
347 std::string devType(evt->findParam("DEVTYPE")?evt->findParam("DEVTYPE"):"");
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700348
349 if (devType != "disk") return;
350
351 int major = atoi(evt->findParam("MAJOR"));
352 int minor = atoi(evt->findParam("MINOR"));
353 dev_t device = makedev(major, minor);
354
355 switch (evt->getAction()) {
356 case NetlinkEvent::Action::kAdd: {
Chih-Hung Hsieh11a2ce82016-07-27 14:11:02 -0700357 for (const auto& source : mDiskSources) {
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700358 if (source->matches(eventPath)) {
Yu Ning942d4e82016-01-08 17:36:47 +0800359 // For now, assume that MMC and virtio-blk (the latter is
360 // emulator-specific; see Disk.cpp for details) devices are SD,
361 // and that everything else is USB
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700362 int flags = source->getFlags();
Yu Ning942d4e82016-01-08 17:36:47 +0800363 if (major == kMajorBlockMmc
364 || (android::vold::IsRunningInEmulator()
365 && major >= (int) kMajorBlockExperimentalMin
366 && major <= (int) kMajorBlockExperimentalMax)) {
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700367 flags |= android::vold::Disk::Flags::kSd;
368 } else {
369 flags |= android::vold::Disk::Flags::kUsb;
370 }
371
372 auto disk = new android::vold::Disk(eventPath, device,
373 source->getNickname(), flags);
374 disk->create();
375 mDisks.push_back(std::shared_ptr<android::vold::Disk>(disk));
376 break;
377 }
378 }
379 break;
380 }
381 case NetlinkEvent::Action::kChange: {
Jeff Sharkey7d9d0112015-04-14 23:14:23 -0700382 LOG(DEBUG) << "Disk at " << major << ":" << minor << " changed";
Chih-Hung Hsieh11a2ce82016-07-27 14:11:02 -0700383 for (const auto& disk : mDisks) {
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700384 if (disk->getDevice() == device) {
385 disk->readMetadata();
386 disk->readPartitions();
387 }
388 }
389 break;
390 }
391 case NetlinkEvent::Action::kRemove: {
392 auto i = mDisks.begin();
393 while (i != mDisks.end()) {
394 if ((*i)->getDevice() == device) {
395 (*i)->destroy();
396 i = mDisks.erase(i);
397 } else {
398 ++i;
399 }
400 }
401 break;
402 }
403 default: {
404 LOG(WARNING) << "Unexpected block event action " << (int) evt->getAction();
405 break;
406 }
407 }
408}
409
410void VolumeManager::addDiskSource(const std::shared_ptr<DiskSource>& diskSource) {
Wei Wang6b455c22017-01-20 11:52:33 -0800411 std::lock_guard<std::mutex> lock(mLock);
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700412 mDiskSources.push_back(diskSource);
413}
414
415std::shared_ptr<android::vold::Disk> VolumeManager::findDisk(const std::string& id) {
416 for (auto disk : mDisks) {
417 if (disk->getId() == id) {
418 return disk;
San Mehatf1b736b2009-10-10 17:22:08 -0700419 }
420 }
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700421 return nullptr;
422}
San Mehatf1b736b2009-10-10 17:22:08 -0700423
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700424std::shared_ptr<android::vold::VolumeBase> VolumeManager::findVolume(const std::string& id) {
425 if (mInternalEmulated->getId() == id) {
426 return mInternalEmulated;
San Mehatf1b736b2009-10-10 17:22:08 -0700427 }
Chih-Hung Hsieh11a2ce82016-07-27 14:11:02 -0700428 for (const auto& disk : mDisks) {
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700429 auto vol = disk->findVolume(id);
430 if (vol != nullptr) {
431 return vol;
432 }
433 }
434 return nullptr;
435}
436
Jeff Sharkeyc86ab6f2015-06-26 14:02:09 -0700437void VolumeManager::listVolumes(android::vold::VolumeBase::Type type,
438 std::list<std::string>& list) {
439 list.clear();
Chih-Hung Hsieh11a2ce82016-07-27 14:11:02 -0700440 for (const auto& disk : mDisks) {
Jeff Sharkeyc86ab6f2015-06-26 14:02:09 -0700441 disk->listVolumes(type, list);
442 }
443}
444
445nsecs_t VolumeManager::benchmarkPrivate(const std::string& id) {
Jeff Sharkey5a6bfca2015-05-14 20:33:55 -0700446 std::string path;
Jeff Sharkeyc86ab6f2015-06-26 14:02:09 -0700447 if (id == "private" || id == "null") {
Jeff Sharkey5a6bfca2015-05-14 20:33:55 -0700448 path = "/data";
Jeff Sharkeyc86ab6f2015-06-26 14:02:09 -0700449 } else {
450 auto vol = findVolume(id);
451 if (vol != nullptr && vol->getState() == android::vold::VolumeBase::State::kMounted) {
452 path = vol->getPath();
453 }
Jeff Sharkey5a6bfca2015-05-14 20:33:55 -0700454 }
455
456 if (path.empty()) {
457 LOG(WARNING) << "Failed to find volume for " << id;
458 return -1;
459 }
460
Jeff Sharkeyc86ab6f2015-06-26 14:02:09 -0700461 return android::vold::BenchmarkPrivate(path);
Jeff Sharkey5a6bfca2015-05-14 20:33:55 -0700462}
463
Jeff Sharkeybc40cc82015-06-18 14:25:08 -0700464int VolumeManager::forgetPartition(const std::string& partGuid) {
465 std::string normalizedGuid;
466 if (android::vold::NormalizeHex(partGuid, normalizedGuid)) {
467 LOG(WARNING) << "Invalid GUID " << partGuid;
468 return -1;
469 }
470
471 std::string keyPath = android::vold::BuildKeyPath(normalizedGuid);
472 if (unlink(keyPath.c_str()) != 0) {
473 LOG(ERROR) << "Failed to unlink " << keyPath;
474 return -1;
475 }
476
477 return 0;
478}
479
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700480int VolumeManager::linkPrimary(userid_t userId) {
481 std::string source(mPrimary->getPath());
482 if (mPrimary->getType() == android::vold::VolumeBase::Type::kEmulated) {
483 source = StringPrintf("%s/%d", source.c_str(), userId);
Jeff Sharkey32679a82015-07-21 14:22:01 -0700484 fs_prepare_dir(source.c_str(), 0755, AID_ROOT, AID_ROOT);
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700485 }
486
487 std::string target(StringPrintf("/mnt/user/%d/primary", userId));
488 if (TEMP_FAILURE_RETRY(unlink(target.c_str()))) {
489 if (errno != ENOENT) {
490 SLOGW("Failed to unlink %s: %s", target.c_str(), strerror(errno));
491 }
492 }
Jeff Sharkey1bfb3752015-04-29 15:22:23 -0700493 LOG(DEBUG) << "Linking " << source << " to " << target;
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700494 if (TEMP_FAILURE_RETRY(symlink(source.c_str(), target.c_str()))) {
495 SLOGW("Failed to link %s to %s: %s", source.c_str(), target.c_str(),
496 strerror(errno));
497 return -errno;
498 }
499 return 0;
500}
501
Jeff Sharkeybd3038d2015-06-10 09:42:01 -0700502int VolumeManager::onUserAdded(userid_t userId, int userSerialNumber) {
503 mAddedUsers[userId] = userSerialNumber;
504 return 0;
505}
506
507int VolumeManager::onUserRemoved(userid_t userId) {
508 mAddedUsers.erase(userId);
509 return 0;
510}
511
512int VolumeManager::onUserStarted(userid_t userId) {
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700513 // Note that sometimes the system will spin up processes from Zygote
514 // before actually starting the user, so we're okay if Zygote
515 // already created this directory.
Jeff Sharkeyfa1c6772017-03-25 22:49:13 -0600516 std::string path(StringPrintf("%s/%d", kPathUserMount, userId));
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700517 fs_prepare_dir(path.c_str(), 0755, AID_ROOT, AID_ROOT);
518
Jeff Sharkeybd3038d2015-06-10 09:42:01 -0700519 mStartedUsers.insert(userId);
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700520 if (mPrimary) {
521 linkPrimary(userId);
522 }
523 return 0;
524}
525
Jeff Sharkeybd3038d2015-06-10 09:42:01 -0700526int VolumeManager::onUserStopped(userid_t userId) {
527 mStartedUsers.erase(userId);
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700528 return 0;
529}
530
531int VolumeManager::setPrimary(const std::shared_ptr<android::vold::VolumeBase>& vol) {
532 mPrimary = vol;
Jeff Sharkeybd3038d2015-06-10 09:42:01 -0700533 for (userid_t userId : mStartedUsers) {
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700534 linkPrimary(userId);
535 }
536 return 0;
537}
538
Jeff Sharkeyc7b5b572015-06-30 15:54:17 -0700539static int unmount_tree(const char* path) {
540 size_t path_len = strlen(path);
541
542 FILE* fp = setmntent("/proc/mounts", "r");
543 if (fp == NULL) {
544 ALOGE("Error opening /proc/mounts: %s", strerror(errno));
545 return -errno;
546 }
547
548 // Some volumes can be stacked on each other, so force unmount in
549 // reverse order to give us the best chance of success.
550 std::list<std::string> toUnmount;
551 mntent* mentry;
552 while ((mentry = getmntent(fp)) != NULL) {
553 if (strncmp(mentry->mnt_dir, path, path_len) == 0) {
554 toUnmount.push_front(std::string(mentry->mnt_dir));
555 }
556 }
557 endmntent(fp);
558
Chih-Hung Hsieh11a2ce82016-07-27 14:11:02 -0700559 for (const auto& path : toUnmount) {
Jeff Sharkeyc7b5b572015-06-30 15:54:17 -0700560 if (umount2(path.c_str(), MNT_DETACH)) {
561 ALOGW("Failed to unmount %s: %s", path.c_str(), strerror(errno));
562 }
563 }
564 return 0;
565}
566
Jeff Sharkey66270a22015-06-24 11:49:24 -0700567int VolumeManager::remountUid(uid_t uid, const std::string& mode) {
568 LOG(DEBUG) << "Remounting " << uid << " as mode " << mode;
569
570 DIR* dir;
571 struct dirent* de;
572 char rootName[PATH_MAX];
573 char pidName[PATH_MAX];
574 int pidFd;
575 int nsFd;
576 struct stat sb;
577 pid_t child;
578
579 if (!(dir = opendir("/proc"))) {
580 PLOG(ERROR) << "Failed to opendir";
581 return -1;
582 }
583
584 // Figure out root namespace to compare against below
Daichi Hirono10d34882016-01-29 14:33:51 +0900585 if (android::vold::SaneReadLinkAt(dirfd(dir), "1/ns/mnt", rootName, PATH_MAX) == -1) {
Jeff Sharkey66270a22015-06-24 11:49:24 -0700586 PLOG(ERROR) << "Failed to readlink";
587 closedir(dir);
588 return -1;
589 }
590
591 // Poke through all running PIDs look for apps running as UID
592 while ((de = readdir(dir))) {
593 pidFd = -1;
594 nsFd = -1;
595
596 pidFd = openat(dirfd(dir), de->d_name, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
597 if (pidFd < 0) {
598 goto next;
599 }
600 if (fstat(pidFd, &sb) != 0) {
601 PLOG(WARNING) << "Failed to stat " << de->d_name;
602 goto next;
603 }
604 if (sb.st_uid != uid) {
605 goto next;
606 }
607
608 // Matches so far, but refuse to touch if in root namespace
609 LOG(DEBUG) << "Found matching PID " << de->d_name;
Daichi Hirono10d34882016-01-29 14:33:51 +0900610 if (android::vold::SaneReadLinkAt(pidFd, "ns/mnt", pidName, PATH_MAX) == -1) {
Jeff Sharkey66270a22015-06-24 11:49:24 -0700611 PLOG(WARNING) << "Failed to read namespace for " << de->d_name;
612 goto next;
613 }
614 if (!strcmp(rootName, pidName)) {
615 LOG(WARNING) << "Skipping due to root namespace";
616 goto next;
617 }
618
619 // We purposefully leave the namespace open across the fork
Jeff Sharkeyfd3dc3c2017-03-27 10:49:21 -0600620 nsFd = openat(pidFd, "ns/mnt", O_RDONLY); // not O_CLOEXEC
Jeff Sharkey66270a22015-06-24 11:49:24 -0700621 if (nsFd < 0) {
Jeff Sharkeyc7b5b572015-06-30 15:54:17 -0700622 PLOG(WARNING) << "Failed to open namespace for " << de->d_name;
Jeff Sharkey66270a22015-06-24 11:49:24 -0700623 goto next;
624 }
625
626 if (!(child = fork())) {
627 if (setns(nsFd, CLONE_NEWNS) != 0) {
Jeff Sharkeyc7b5b572015-06-30 15:54:17 -0700628 PLOG(ERROR) << "Failed to setns for " << de->d_name;
Jeff Sharkey66270a22015-06-24 11:49:24 -0700629 _exit(1);
630 }
631
Jeff Sharkeyc7b5b572015-06-30 15:54:17 -0700632 unmount_tree("/storage");
Jeff Sharkey66270a22015-06-24 11:49:24 -0700633
634 std::string storageSource;
635 if (mode == "default") {
Jeff Sharkey1bd078f2015-08-06 11:40:00 -0700636 storageSource = "/mnt/runtime/default";
Jeff Sharkey66270a22015-06-24 11:49:24 -0700637 } else if (mode == "read") {
Jeff Sharkey1bd078f2015-08-06 11:40:00 -0700638 storageSource = "/mnt/runtime/read";
Jeff Sharkey66270a22015-06-24 11:49:24 -0700639 } else if (mode == "write") {
Jeff Sharkey1bd078f2015-08-06 11:40:00 -0700640 storageSource = "/mnt/runtime/write";
Jeff Sharkey66270a22015-06-24 11:49:24 -0700641 } else {
642 // Sane default of no storage visible
643 _exit(0);
644 }
645 if (TEMP_FAILURE_RETRY(mount(storageSource.c_str(), "/storage",
Hidehiko Abe674bed12016-03-09 16:42:10 +0900646 NULL, MS_BIND | MS_REC, NULL)) == -1) {
Jeff Sharkeyc7b5b572015-06-30 15:54:17 -0700647 PLOG(ERROR) << "Failed to mount " << storageSource << " for "
648 << de->d_name;
649 _exit(1);
Jeff Sharkey66270a22015-06-24 11:49:24 -0700650 }
Hidehiko Abe674bed12016-03-09 16:42:10 +0900651 if (TEMP_FAILURE_RETRY(mount(NULL, "/storage", NULL,
652 MS_REC | MS_SLAVE, NULL)) == -1) {
653 PLOG(ERROR) << "Failed to set MS_SLAVE to /storage for "
654 << de->d_name;
655 _exit(1);
656 }
Jeff Sharkeyc7b5b572015-06-30 15:54:17 -0700657
658 // Mount user-specific symlink helper into place
659 userid_t user_id = multiuser_get_user_id(uid);
660 std::string userSource(StringPrintf("/mnt/user/%d", user_id));
661 if (TEMP_FAILURE_RETRY(mount(userSource.c_str(), "/storage/self",
662 NULL, MS_BIND, NULL)) == -1) {
663 PLOG(ERROR) << "Failed to mount " << userSource << " for "
664 << de->d_name;
665 _exit(1);
666 }
667
Jeff Sharkey66270a22015-06-24 11:49:24 -0700668 _exit(0);
669 }
670
671 if (child == -1) {
672 PLOG(ERROR) << "Failed to fork";
673 goto next;
674 } else {
675 TEMP_FAILURE_RETRY(waitpid(child, nullptr, 0));
676 }
677
678next:
679 close(nsFd);
680 close(pidFd);
681 }
682 closedir(dir);
683 return 0;
684}
685
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700686int VolumeManager::reset() {
687 // Tear down all existing disks/volumes and start from a blank slate so
688 // newly connected framework hears all events.
689 mInternalEmulated->destroy();
690 mInternalEmulated->create();
Chih-Hung Hsieh11a2ce82016-07-27 14:11:02 -0700691 for (const auto& disk : mDisks) {
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700692 disk->destroy();
693 disk->create();
694 }
Jeff Sharkeyfa1c6772017-03-25 22:49:13 -0600695 updateVirtualDisk();
Jeff Sharkeybd3038d2015-06-10 09:42:01 -0700696 mAddedUsers.clear();
697 mStartedUsers.clear();
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700698 return 0;
699}
700
Keun-young Parka5bbb5e2017-03-13 18:02:50 -0700701// Can be called twice (sequentially) during shutdown. should be safe for that.
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700702int VolumeManager::shutdown() {
Keun-young Parka5bbb5e2017-03-13 18:02:50 -0700703 if (mInternalEmulated == nullptr) {
704 return 0; // already shutdown
705 }
Jeff Sharkey9c484982015-03-31 10:35:33 -0700706 mInternalEmulated->destroy();
Keun-young Parka5bbb5e2017-03-13 18:02:50 -0700707 mInternalEmulated = nullptr;
Chih-Hung Hsieh11a2ce82016-07-27 14:11:02 -0700708 for (const auto& disk : mDisks) {
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700709 disk->destroy();
710 }
711 mDisks.clear();
712 return 0;
San Mehatf1b736b2009-10-10 17:22:08 -0700713}
714
Jeff Sharkey9c484982015-03-31 10:35:33 -0700715int VolumeManager::unmountAll() {
Jeff Sharkeyc8e04c52015-04-21 12:14:17 -0700716 std::lock_guard<std::mutex> lock(mLock);
717
Jeff Sharkey9c484982015-03-31 10:35:33 -0700718 // First, try gracefully unmounting all known devices
719 if (mInternalEmulated != nullptr) {
720 mInternalEmulated->unmount();
721 }
Chih-Hung Hsieh11a2ce82016-07-27 14:11:02 -0700722 for (const auto& disk : mDisks) {
Jeff Sharkey9c484982015-03-31 10:35:33 -0700723 disk->unmountAll();
724 }
725
726 // Worst case we might have some stale mounts lurking around, so
727 // force unmount those just to be safe.
728 FILE* fp = setmntent("/proc/mounts", "r");
729 if (fp == NULL) {
730 SLOGE("Error opening /proc/mounts: %s", strerror(errno));
731 return -errno;
732 }
733
734 // Some volumes can be stacked on each other, so force unmount in
735 // reverse order to give us the best chance of success.
736 std::list<std::string> toUnmount;
737 mntent* mentry;
738 while ((mentry = getmntent(fp)) != NULL) {
739 if (strncmp(mentry->mnt_dir, "/mnt/", 5) == 0
740 || strncmp(mentry->mnt_dir, "/storage/", 9) == 0) {
741 toUnmount.push_front(std::string(mentry->mnt_dir));
742 }
743 }
744 endmntent(fp);
745
Chih-Hung Hsieh11a2ce82016-07-27 14:11:02 -0700746 for (const auto& path : toUnmount) {
Jeff Sharkey9c484982015-03-31 10:35:33 -0700747 SLOGW("Tearing down stale mount %s", path.c_str());
748 android::vold::ForceUnmount(path);
749 }
750
751 return 0;
752}
753
Kenny Root508c0e12010-07-12 09:59:49 -0700754int VolumeManager::getObbMountPath(const char *sourceFile, char *mountPath, int mountPathLen) {
755 char idHash[33];
756 if (!asecHash(sourceFile, idHash, sizeof(idHash))) {
757 SLOGE("Hash of '%s' failed (%s)", sourceFile, strerror(errno));
758 return -1;
759 }
760
761 memset(mountPath, 0, mountPathLen);
Jeff Sharkey9f18fe72015-04-01 23:32:18 -0700762 int written = snprintf(mountPath, mountPathLen, "%s/%s", VolumeManager::LOOPDIR, idHash);
rpcraigd1c226f2012-10-09 06:58:16 -0400763 if ((written < 0) || (written >= mountPathLen)) {
764 errno = EINVAL;
765 return -1;
766 }
Kenny Root508c0e12010-07-12 09:59:49 -0700767
768 if (access(mountPath, F_OK)) {
769 errno = ENOENT;
770 return -1;
771 }
772
773 return 0;
774}
775
San Mehata19b2502010-01-06 10:33:53 -0800776int VolumeManager::getAsecMountPath(const char *id, char *buffer, int maxlen) {
San Mehat88ac2c02010-03-23 11:15:58 -0700777 char asecFileName[255];
Kenny Root344ca102012-04-03 17:23:01 -0700778
Nick Kralevich0de7c612014-01-27 14:58:06 -0800779 if (!isLegalAsecId(id)) {
780 SLOGE("getAsecMountPath: Invalid asec id \"%s\"", id);
781 errno = EINVAL;
782 return -1;
783 }
784
Kenny Root344ca102012-04-03 17:23:01 -0700785 if (findAsec(id, asecFileName, sizeof(asecFileName))) {
786 SLOGE("Couldn't find ASEC %s", id);
787 return -1;
788 }
San Mehat88ac2c02010-03-23 11:15:58 -0700789
790 memset(buffer, 0, maxlen);
791 if (access(asecFileName, F_OK)) {
792 errno = ENOENT;
793 return -1;
794 }
San Mehata19b2502010-01-06 10:33:53 -0800795
Jeff Sharkey9f18fe72015-04-01 23:32:18 -0700796 int written = snprintf(buffer, maxlen, "%s/%s", VolumeManager::ASECDIR, id);
rpcraigd1c226f2012-10-09 06:58:16 -0400797 if ((written < 0) || (written >= maxlen)) {
798 SLOGE("getAsecMountPath failed for %s: couldn't construct path in buffer", id);
799 errno = EINVAL;
800 return -1;
801 }
802
San Mehata19b2502010-01-06 10:33:53 -0800803 return 0;
804}
805
Dianne Hackborn736910c2011-06-27 13:37:07 -0700806int VolumeManager::getAsecFilesystemPath(const char *id, char *buffer, int maxlen) {
807 char asecFileName[255];
Kenny Root344ca102012-04-03 17:23:01 -0700808
Nick Kralevich0de7c612014-01-27 14:58:06 -0800809 if (!isLegalAsecId(id)) {
810 SLOGE("getAsecFilesystemPath: Invalid asec id \"%s\"", id);
811 errno = EINVAL;
812 return -1;
813 }
814
Kenny Root344ca102012-04-03 17:23:01 -0700815 if (findAsec(id, asecFileName, sizeof(asecFileName))) {
816 SLOGE("Couldn't find ASEC %s", id);
817 return -1;
818 }
Dianne Hackborn736910c2011-06-27 13:37:07 -0700819
820 memset(buffer, 0, maxlen);
821 if (access(asecFileName, F_OK)) {
822 errno = ENOENT;
823 return -1;
824 }
825
rpcraigd1c226f2012-10-09 06:58:16 -0400826 int written = snprintf(buffer, maxlen, "%s", asecFileName);
827 if ((written < 0) || (written >= maxlen)) {
828 errno = EINVAL;
829 return -1;
830 }
831
Dianne Hackborn736910c2011-06-27 13:37:07 -0700832 return 0;
833}
834
Mateusz Nowaka4f48d02015-08-03 18:06:39 +0200835int VolumeManager::createAsec(const char *id, unsigned long numSectors, const char *fstype,
Kenny Root344ca102012-04-03 17:23:01 -0700836 const char *key, const int ownerUid, bool isExternal) {
San Mehatfcf24fe2010-03-03 12:37:32 -0800837 struct asec_superblock sb;
838 memset(&sb, 0, sizeof(sb));
839
Nick Kralevich0de7c612014-01-27 14:58:06 -0800840 if (!isLegalAsecId(id)) {
841 SLOGE("createAsec: Invalid asec id \"%s\"", id);
842 errno = EINVAL;
843 return -1;
844 }
845
Kenny Root344ca102012-04-03 17:23:01 -0700846 const bool wantFilesystem = strcmp(fstype, "none");
847 bool usingExt4 = false;
848 if (wantFilesystem) {
849 usingExt4 = !strcmp(fstype, "ext4");
850 if (usingExt4) {
851 sb.c_opts |= ASEC_SB_C_OPTS_EXT4;
852 } else if (strcmp(fstype, "fat")) {
853 SLOGE("Invalid filesystem type %s", fstype);
854 errno = EINVAL;
855 return -1;
856 }
857 }
858
San Mehatfcf24fe2010-03-03 12:37:32 -0800859 sb.magic = ASEC_SB_MAGIC;
860 sb.ver = ASEC_SB_VER;
San Mehata19b2502010-01-06 10:33:53 -0800861
San Mehatd31e3802010-02-18 08:37:45 -0800862 if (numSectors < ((1024*1024)/512)) {
Mateusz Nowaka4f48d02015-08-03 18:06:39 +0200863 SLOGE("Invalid container size specified (%lu sectors)", numSectors);
San Mehatd31e3802010-02-18 08:37:45 -0800864 errno = EINVAL;
865 return -1;
866 }
867
San Mehata19b2502010-01-06 10:33:53 -0800868 char asecFileName[255];
Kenny Root344ca102012-04-03 17:23:01 -0700869
870 if (!findAsec(id, asecFileName, sizeof(asecFileName))) {
871 SLOGE("ASEC file '%s' currently exists - destroy it first! (%s)",
872 asecFileName, strerror(errno));
873 errno = EADDRINUSE;
874 return -1;
875 }
876
Jeff Sharkey9f18fe72015-04-01 23:32:18 -0700877 const char *asecDir = isExternal ? VolumeManager::SEC_ASECDIR_EXT : VolumeManager::SEC_ASECDIR_INT;
Kenny Root344ca102012-04-03 17:23:01 -0700878
rpcraigd1c226f2012-10-09 06:58:16 -0400879 int written = snprintf(asecFileName, sizeof(asecFileName), "%s/%s.asec", asecDir, id);
880 if ((written < 0) || (size_t(written) >= sizeof(asecFileName))) {
881 errno = EINVAL;
882 return -1;
883 }
San Mehata19b2502010-01-06 10:33:53 -0800884
885 if (!access(asecFileName, F_OK)) {
San Mehat97ac40e2010-03-24 10:24:19 -0700886 SLOGE("ASEC file '%s' currently exists - destroy it first! (%s)",
Kenny Root344ca102012-04-03 17:23:01 -0700887 asecFileName, strerror(errno));
San Mehata19b2502010-01-06 10:33:53 -0800888 errno = EADDRINUSE;
889 return -1;
890 }
891
Mateusz Nowaka4f48d02015-08-03 18:06:39 +0200892 unsigned long numImgSectors;
Daniel Rosenberg6a74dca2014-05-23 13:47:00 -0700893 if (usingExt4)
Daniel Rosenbergfcd34a02014-05-22 11:23:56 -0700894 numImgSectors = adjustSectorNumExt4(numSectors);
Daniel Rosenberg6a74dca2014-05-23 13:47:00 -0700895 else
Daniel Rosenbergfcd34a02014-05-22 11:23:56 -0700896 numImgSectors = adjustSectorNumFAT(numSectors);
San Mehatfcf24fe2010-03-03 12:37:32 -0800897
898 // Add +1 for our superblock which is at the end
899 if (Loop::createImageFile(asecFileName, numImgSectors + 1)) {
San Mehat97ac40e2010-03-24 10:24:19 -0700900 SLOGE("ASEC image file creation failed (%s)", strerror(errno));
San Mehata19b2502010-01-06 10:33:53 -0800901 return -1;
902 }
903
San Mehatd9a4e352010-03-12 13:32:47 -0800904 char idHash[33];
905 if (!asecHash(id, idHash, sizeof(idHash))) {
San Mehat97ac40e2010-03-24 10:24:19 -0700906 SLOGE("Hash of '%s' failed (%s)", id, strerror(errno));
San Mehatd9a4e352010-03-12 13:32:47 -0800907 unlink(asecFileName);
908 return -1;
909 }
910
San Mehata19b2502010-01-06 10:33:53 -0800911 char loopDevice[255];
San Mehatd9a4e352010-03-12 13:32:47 -0800912 if (Loop::create(idHash, asecFileName, loopDevice, sizeof(loopDevice))) {
San Mehat97ac40e2010-03-24 10:24:19 -0700913 SLOGE("ASEC loop device creation failed (%s)", strerror(errno));
San Mehata19b2502010-01-06 10:33:53 -0800914 unlink(asecFileName);
915 return -1;
916 }
917
San Mehatb78a32c2010-01-10 13:02:12 -0800918 char dmDevice[255];
919 bool cleanupDm = false;
San Mehata19b2502010-01-06 10:33:53 -0800920
San Mehatb78a32c2010-01-10 13:02:12 -0800921 if (strcmp(key, "none")) {
San Mehatfcf24fe2010-03-03 12:37:32 -0800922 // XXX: This is all we support for now
923 sb.c_cipher = ASEC_SB_C_CIPHER_TWOFISH;
San Mehatd9a4e352010-03-12 13:32:47 -0800924 if (Devmapper::create(idHash, loopDevice, key, numImgSectors, dmDevice,
San Mehatb78a32c2010-01-10 13:02:12 -0800925 sizeof(dmDevice))) {
San Mehat97ac40e2010-03-24 10:24:19 -0700926 SLOGE("ASEC device mapping failed (%s)", strerror(errno));
San Mehatb78a32c2010-01-10 13:02:12 -0800927 Loop::destroyByDevice(loopDevice);
928 unlink(asecFileName);
929 return -1;
930 }
931 cleanupDm = true;
932 } else {
San Mehatfcf24fe2010-03-03 12:37:32 -0800933 sb.c_cipher = ASEC_SB_C_CIPHER_NONE;
Jeff Sharkey32ebb732017-03-27 16:18:50 -0600934 strlcpy(dmDevice, loopDevice, sizeof(dmDevice));
San Mehatb78a32c2010-01-10 13:02:12 -0800935 }
936
San Mehatfcf24fe2010-03-03 12:37:32 -0800937 /*
938 * Drop down the superblock at the end of the file
939 */
Daniel Rosenbergfcd34a02014-05-22 11:23:56 -0700940 if (writeSuperBlock(loopDevice, &sb, numImgSectors)) {
San Mehatfcf24fe2010-03-03 12:37:32 -0800941 if (cleanupDm) {
San Mehatd9a4e352010-03-12 13:32:47 -0800942 Devmapper::destroy(idHash);
San Mehatfcf24fe2010-03-03 12:37:32 -0800943 }
944 Loop::destroyByDevice(loopDevice);
945 unlink(asecFileName);
946 return -1;
947 }
948
Kenny Root344ca102012-04-03 17:23:01 -0700949 if (wantFilesystem) {
950 int formatStatus;
rpcraiga54e13a2012-09-21 14:17:08 -0400951 char mountPoint[255];
952
Jeff Sharkey9f18fe72015-04-01 23:32:18 -0700953 int written = snprintf(mountPoint, sizeof(mountPoint), "%s/%s", VolumeManager::ASECDIR, id);
rpcraigd1c226f2012-10-09 06:58:16 -0400954 if ((written < 0) || (size_t(written) >= sizeof(mountPoint))) {
955 SLOGE("ASEC fs format failed: couldn't construct mountPoint");
956 if (cleanupDm) {
957 Devmapper::destroy(idHash);
958 }
959 Loop::destroyByDevice(loopDevice);
960 unlink(asecFileName);
961 return -1;
962 }
rpcraiga54e13a2012-09-21 14:17:08 -0400963
Kenny Root344ca102012-04-03 17:23:01 -0700964 if (usingExt4) {
Jeff Sharkeyd0640f62015-05-21 22:35:42 -0700965 formatStatus = android::vold::ext4::Format(dmDevice, numImgSectors, mountPoint);
Kenny Root344ca102012-04-03 17:23:01 -0700966 } else {
Jeff Sharkeyd0640f62015-05-21 22:35:42 -0700967 formatStatus = android::vold::vfat::Format(dmDevice, numImgSectors);
San Mehatb78a32c2010-01-10 13:02:12 -0800968 }
San Mehata19b2502010-01-06 10:33:53 -0800969
Kenny Root344ca102012-04-03 17:23:01 -0700970 if (formatStatus < 0) {
971 SLOGE("ASEC fs format failed (%s)", strerror(errno));
San Mehatb78a32c2010-01-10 13:02:12 -0800972 if (cleanupDm) {
San Mehatd9a4e352010-03-12 13:32:47 -0800973 Devmapper::destroy(idHash);
San Mehatb78a32c2010-01-10 13:02:12 -0800974 }
San Mehateb13a902010-01-07 12:12:50 -0800975 Loop::destroyByDevice(loopDevice);
976 unlink(asecFileName);
977 return -1;
978 }
Kenny Root344ca102012-04-03 17:23:01 -0700979
Kenny Root344ca102012-04-03 17:23:01 -0700980 if (mkdir(mountPoint, 0000)) {
San Mehata1091cb2010-02-28 20:17:20 -0800981 if (errno != EEXIST) {
San Mehat97ac40e2010-03-24 10:24:19 -0700982 SLOGE("Mountpoint creation failed (%s)", strerror(errno));
San Mehata1091cb2010-02-28 20:17:20 -0800983 if (cleanupDm) {
San Mehatd9a4e352010-03-12 13:32:47 -0800984 Devmapper::destroy(idHash);
San Mehata1091cb2010-02-28 20:17:20 -0800985 }
986 Loop::destroyByDevice(loopDevice);
987 unlink(asecFileName);
988 return -1;
989 }
San Mehatb78a32c2010-01-10 13:02:12 -0800990 }
San Mehata1091cb2010-02-28 20:17:20 -0800991
Kenny Root344ca102012-04-03 17:23:01 -0700992 int mountStatus;
993 if (usingExt4) {
Jeff Sharkeyd0640f62015-05-21 22:35:42 -0700994 mountStatus = android::vold::ext4::Mount(dmDevice, mountPoint,
995 false, false, false);
Kenny Root344ca102012-04-03 17:23:01 -0700996 } else {
Jeff Sharkeyd0640f62015-05-21 22:35:42 -0700997 mountStatus = android::vold::vfat::Mount(dmDevice, mountPoint,
998 false, false, false, ownerUid, 0, 0000, false);
Kenny Root344ca102012-04-03 17:23:01 -0700999 }
1000
1001 if (mountStatus) {
San Mehat97ac40e2010-03-24 10:24:19 -07001002 SLOGE("ASEC FAT mount failed (%s)", strerror(errno));
San Mehata1091cb2010-02-28 20:17:20 -08001003 if (cleanupDm) {
San Mehatd9a4e352010-03-12 13:32:47 -08001004 Devmapper::destroy(idHash);
San Mehata1091cb2010-02-28 20:17:20 -08001005 }
1006 Loop::destroyByDevice(loopDevice);
1007 unlink(asecFileName);
1008 return -1;
1009 }
Kenny Root344ca102012-04-03 17:23:01 -07001010
1011 if (usingExt4) {
Jeff Sharkeyce6a9132015-04-08 21:07:21 -07001012 int dirfd = open(mountPoint, O_DIRECTORY | O_CLOEXEC);
Kenny Root344ca102012-04-03 17:23:01 -07001013 if (dirfd >= 0) {
1014 if (fchown(dirfd, ownerUid, AID_SYSTEM)
1015 || fchmod(dirfd, S_IRUSR | S_IWUSR | S_IXUSR | S_ISGID | S_IRGRP | S_IXGRP)) {
1016 SLOGI("Cannot chown/chmod new ASEC mount point %s", mountPoint);
1017 }
1018 close(dirfd);
1019 }
1020 }
San Mehata1091cb2010-02-28 20:17:20 -08001021 } else {
San Mehat97ac40e2010-03-24 10:24:19 -07001022 SLOGI("Created raw secure container %s (no filesystem)", id);
San Mehata19b2502010-01-06 10:33:53 -08001023 }
San Mehat88705162010-01-15 09:26:28 -08001024
Kenny Rootcbacf782010-09-24 15:11:48 -07001025 mActiveContainers->push_back(new ContainerData(strdup(id), ASEC));
San Mehata19b2502010-01-06 10:33:53 -08001026 return 0;
1027}
1028
Mateusz Nowaka4f48d02015-08-03 18:06:39 +02001029int VolumeManager::resizeAsec(const char *id, unsigned long numSectors, const char *key) {
Daniel Rosenbergfcd34a02014-05-22 11:23:56 -07001030 char asecFileName[255];
1031 char mountPoint[255];
1032 bool cleanupDm = false;
1033
1034 if (!isLegalAsecId(id)) {
1035 SLOGE("resizeAsec: Invalid asec id \"%s\"", id);
1036 errno = EINVAL;
1037 return -1;
1038 }
1039
1040 if (findAsec(id, asecFileName, sizeof(asecFileName))) {
1041 SLOGE("Couldn't find ASEC %s", id);
1042 return -1;
1043 }
1044
Jeff Sharkey9f18fe72015-04-01 23:32:18 -07001045 int written = snprintf(mountPoint, sizeof(mountPoint), "%s/%s", VolumeManager::ASECDIR, id);
Daniel Rosenbergfcd34a02014-05-22 11:23:56 -07001046 if ((written < 0) || (size_t(written) >= sizeof(mountPoint))) {
1047 SLOGE("ASEC resize failed for %s: couldn't construct mountpoint", id);
1048 return -1;
1049 }
1050
1051 if (isMountpointMounted(mountPoint)) {
1052 SLOGE("ASEC %s mounted. Unmount before resizing", id);
1053 errno = EBUSY;
1054 return -1;
1055 }
1056
1057 struct asec_superblock sb;
1058 int fd;
Mateusz Nowaka4f48d02015-08-03 18:06:39 +02001059 unsigned long oldNumSec = 0;
Daniel Rosenbergfcd34a02014-05-22 11:23:56 -07001060
Jeff Sharkeyce6a9132015-04-08 21:07:21 -07001061 if ((fd = open(asecFileName, O_RDONLY | O_CLOEXEC)) < 0) {
Daniel Rosenbergfcd34a02014-05-22 11:23:56 -07001062 SLOGE("Failed to open ASEC file (%s)", strerror(errno));
1063 return -1;
1064 }
1065
1066 struct stat info;
1067 if (fstat(fd, &info) < 0) {
1068 SLOGE("Failed to get file size (%s)", strerror(errno));
1069 close(fd);
1070 return -1;
1071 }
1072
1073 oldNumSec = info.st_size / 512;
1074
Daniel Rosenbergfcd34a02014-05-22 11:23:56 -07001075 /*
1076 * Try to read superblock.
1077 */
1078 memset(&sb, 0, sizeof(struct asec_superblock));
1079 if (lseek(fd, ((oldNumSec - 1) * 512), SEEK_SET) < 0) {
1080 SLOGE("lseek failed (%s)", strerror(errno));
1081 close(fd);
1082 return -1;
1083 }
1084 if (read(fd, &sb, sizeof(struct asec_superblock)) != sizeof(struct asec_superblock)) {
1085 SLOGE("superblock read failed (%s)", strerror(errno));
1086 close(fd);
1087 return -1;
1088 }
1089 close(fd);
1090
1091 if (mDebug) {
1092 SLOGD("Container sb magic/ver (%.8x/%.2x)", sb.magic, sb.ver);
1093 }
1094 if (sb.magic != ASEC_SB_MAGIC || sb.ver != ASEC_SB_VER) {
1095 SLOGE("Bad container magic/version (%.8x/%.2x)", sb.magic, sb.ver);
1096 errno = EMEDIUMTYPE;
1097 return -1;
1098 }
1099
Daniel Rosenberge4c291a2016-04-20 14:07:32 -07001100 unsigned long numImgSectors;
Daniel Rosenbergfcd34a02014-05-22 11:23:56 -07001101 if (!(sb.c_opts & ASEC_SB_C_OPTS_EXT4)) {
1102 SLOGE("Only ext4 partitions are supported for resize");
1103 errno = EINVAL;
1104 return -1;
Daniel Rosenberge4c291a2016-04-20 14:07:32 -07001105 } else {
1106 numImgSectors = adjustSectorNumExt4(numSectors);
1107 }
1108
1109 /*
1110 * add one block for the superblock
1111 */
1112 SLOGD("Resizing from %lu sectors to %lu sectors", oldNumSec, numImgSectors + 1);
1113 if (oldNumSec == numImgSectors + 1) {
1114 SLOGW("Size unchanged; ignoring resize request");
1115 return 0;
1116 } else if (oldNumSec > numImgSectors + 1) {
1117 SLOGE("Only growing is currently supported.");
1118 close(fd);
1119 return -1;
Daniel Rosenbergfcd34a02014-05-22 11:23:56 -07001120 }
1121
1122 if (Loop::resizeImageFile(asecFileName, numImgSectors + 1)) {
1123 SLOGE("Resize of ASEC image file failed. Could not resize %s", id);
1124 return -1;
1125 }
1126
1127 /*
1128 * Drop down a copy of the superblock at the end of the file
1129 */
1130 if (writeSuperBlock(asecFileName, &sb, numImgSectors))
1131 goto fail;
1132
1133 char idHash[33];
1134 if (!asecHash(id, idHash, sizeof(idHash))) {
1135 SLOGE("Hash of '%s' failed (%s)", id, strerror(errno));
1136 goto fail;
1137 }
1138
1139 char loopDevice[255];
1140 if (setupLoopDevice(loopDevice, sizeof(loopDevice), asecFileName, idHash, mDebug))
1141 goto fail;
1142
1143 char dmDevice[255];
1144
1145 if (setupDevMapperDevice(dmDevice, sizeof(dmDevice), loopDevice, asecFileName, key, idHash, numImgSectors, &cleanupDm, mDebug)) {
1146 Loop::destroyByDevice(loopDevice);
1147 goto fail;
1148 }
1149
1150 /*
1151 * Wait for the device mapper node to be created.
1152 */
1153 waitForDevMapper(dmDevice);
1154
Jeff Sharkeyd0640f62015-05-21 22:35:42 -07001155 if (android::vold::ext4::Resize(dmDevice, numImgSectors)) {
Daniel Rosenbergfcd34a02014-05-22 11:23:56 -07001156 SLOGE("Unable to resize %s (%s)", id, strerror(errno));
1157 if (cleanupDm) {
1158 Devmapper::destroy(idHash);
1159 }
1160 Loop::destroyByDevice(loopDevice);
1161 goto fail;
1162 }
1163
1164 return 0;
1165fail:
1166 Loop::resizeImageFile(asecFileName, oldNumSec);
1167 return -1;
1168}
1169
San Mehata19b2502010-01-06 10:33:53 -08001170int VolumeManager::finalizeAsec(const char *id) {
1171 char asecFileName[255];
1172 char loopDevice[255];
1173 char mountPoint[255];
1174
Nick Kralevich0de7c612014-01-27 14:58:06 -08001175 if (!isLegalAsecId(id)) {
1176 SLOGE("finalizeAsec: Invalid asec id \"%s\"", id);
1177 errno = EINVAL;
1178 return -1;
1179 }
1180
Kenny Root344ca102012-04-03 17:23:01 -07001181 if (findAsec(id, asecFileName, sizeof(asecFileName))) {
1182 SLOGE("Couldn't find ASEC %s", id);
1183 return -1;
1184 }
San Mehata19b2502010-01-06 10:33:53 -08001185
San Mehatd9a4e352010-03-12 13:32:47 -08001186 char idHash[33];
1187 if (!asecHash(id, idHash, sizeof(idHash))) {
San Mehat97ac40e2010-03-24 10:24:19 -07001188 SLOGE("Hash of '%s' failed (%s)", id, strerror(errno));
San Mehatd9a4e352010-03-12 13:32:47 -08001189 return -1;
1190 }
1191
1192 if (Loop::lookupActive(idHash, loopDevice, sizeof(loopDevice))) {
San Mehat97ac40e2010-03-24 10:24:19 -07001193 SLOGE("Unable to finalize %s (%s)", id, strerror(errno));
San Mehata19b2502010-01-06 10:33:53 -08001194 return -1;
1195 }
1196
Hiroaki Miyazawa14eab552015-02-04 13:29:15 +09001197 unsigned long nr_sec = 0;
Kenny Root344ca102012-04-03 17:23:01 -07001198 struct asec_superblock sb;
1199
1200 if (Loop::lookupInfo(loopDevice, &sb, &nr_sec)) {
1201 return -1;
1202 }
1203
Jeff Sharkey9f18fe72015-04-01 23:32:18 -07001204 int written = snprintf(mountPoint, sizeof(mountPoint), "%s/%s", VolumeManager::ASECDIR, id);
rpcraigd1c226f2012-10-09 06:58:16 -04001205 if ((written < 0) || (size_t(written) >= sizeof(mountPoint))) {
1206 SLOGE("ASEC finalize failed: couldn't construct mountPoint");
1207 return -1;
1208 }
Kenny Root344ca102012-04-03 17:23:01 -07001209
1210 int result = 0;
1211 if (sb.c_opts & ASEC_SB_C_OPTS_EXT4) {
Jeff Sharkeyd0640f62015-05-21 22:35:42 -07001212 result = android::vold::ext4::Mount(loopDevice, mountPoint,
1213 true, true, true);
Kenny Root344ca102012-04-03 17:23:01 -07001214 } else {
Jeff Sharkeyd0640f62015-05-21 22:35:42 -07001215 result = android::vold::vfat::Mount(loopDevice, mountPoint,
1216 true, true, true, 0, 0, 0227, false);
Kenny Root344ca102012-04-03 17:23:01 -07001217 }
1218
1219 if (result) {
San Mehat97ac40e2010-03-24 10:24:19 -07001220 SLOGE("ASEC finalize mount failed (%s)", strerror(errno));
San Mehata19b2502010-01-06 10:33:53 -08001221 return -1;
1222 }
1223
San Mehatd9a4e352010-03-12 13:32:47 -08001224 if (mDebug) {
San Mehat97ac40e2010-03-24 10:24:19 -07001225 SLOGD("ASEC %s finalized", id);
San Mehatd9a4e352010-03-12 13:32:47 -08001226 }
San Mehata19b2502010-01-06 10:33:53 -08001227 return 0;
1228}
1229
Kenny Root344ca102012-04-03 17:23:01 -07001230int VolumeManager::fixupAsecPermissions(const char *id, gid_t gid, const char* filename) {
1231 char asecFileName[255];
1232 char loopDevice[255];
1233 char mountPoint[255];
1234
1235 if (gid < AID_APP) {
1236 SLOGE("Group ID is not in application range");
1237 return -1;
1238 }
1239
Nick Kralevich0de7c612014-01-27 14:58:06 -08001240 if (!isLegalAsecId(id)) {
1241 SLOGE("fixupAsecPermissions: Invalid asec id \"%s\"", id);
1242 errno = EINVAL;
1243 return -1;
1244 }
1245
Kenny Root344ca102012-04-03 17:23:01 -07001246 if (findAsec(id, asecFileName, sizeof(asecFileName))) {
1247 SLOGE("Couldn't find ASEC %s", id);
1248 return -1;
1249 }
1250
1251 char idHash[33];
1252 if (!asecHash(id, idHash, sizeof(idHash))) {
1253 SLOGE("Hash of '%s' failed (%s)", id, strerror(errno));
1254 return -1;
1255 }
1256
1257 if (Loop::lookupActive(idHash, loopDevice, sizeof(loopDevice))) {
1258 SLOGE("Unable fix permissions during lookup on %s (%s)", id, strerror(errno));
1259 return -1;
1260 }
1261
Hiroaki Miyazawa14eab552015-02-04 13:29:15 +09001262 unsigned long nr_sec = 0;
Kenny Root344ca102012-04-03 17:23:01 -07001263 struct asec_superblock sb;
1264
1265 if (Loop::lookupInfo(loopDevice, &sb, &nr_sec)) {
1266 return -1;
1267 }
1268
Jeff Sharkey9f18fe72015-04-01 23:32:18 -07001269 int written = snprintf(mountPoint, sizeof(mountPoint), "%s/%s", VolumeManager::ASECDIR, id);
rpcraigd1c226f2012-10-09 06:58:16 -04001270 if ((written < 0) || (size_t(written) >= sizeof(mountPoint))) {
1271 SLOGE("Unable remount to fix permissions for %s: couldn't construct mountpoint", id);
1272 return -1;
1273 }
Kenny Root344ca102012-04-03 17:23:01 -07001274
1275 int result = 0;
1276 if ((sb.c_opts & ASEC_SB_C_OPTS_EXT4) == 0) {
1277 return 0;
1278 }
1279
Jeff Sharkeyd0640f62015-05-21 22:35:42 -07001280 int ret = android::vold::ext4::Mount(loopDevice, mountPoint,
Kenny Root344ca102012-04-03 17:23:01 -07001281 false /* read-only */,
1282 true /* remount */,
1283 false /* executable */);
1284 if (ret) {
1285 SLOGE("Unable remount to fix permissions for %s (%s)", id, strerror(errno));
1286 return -1;
1287 }
1288
1289 char *paths[] = { mountPoint, NULL };
1290
1291 FTS *fts = fts_open(paths, FTS_PHYSICAL | FTS_NOCHDIR | FTS_XDEV, NULL);
1292 if (fts) {
1293 // Traverse the entire hierarchy and chown to system UID.
1294 for (FTSENT *ftsent = fts_read(fts); ftsent != NULL; ftsent = fts_read(fts)) {
1295 // We don't care about the lost+found directory.
1296 if (!strcmp(ftsent->fts_name, "lost+found")) {
1297 continue;
1298 }
1299
1300 /*
1301 * There can only be one file marked as private right now.
1302 * This should be more robust, but it satisfies the requirements
1303 * we have for right now.
1304 */
1305 const bool privateFile = !strcmp(ftsent->fts_name, filename);
1306
Jeff Sharkeyce6a9132015-04-08 21:07:21 -07001307 int fd = open(ftsent->fts_accpath, O_NOFOLLOW | O_CLOEXEC);
Kenny Root344ca102012-04-03 17:23:01 -07001308 if (fd < 0) {
1309 SLOGE("Couldn't open file %s: %s", ftsent->fts_accpath, strerror(errno));
1310 result = -1;
1311 continue;
1312 }
1313
1314 result |= fchown(fd, AID_SYSTEM, privateFile? gid : AID_SYSTEM);
1315
1316 if (ftsent->fts_info & FTS_D) {
Kenny Root1a673c82012-05-10 16:45:29 -07001317 result |= fchmod(fd, 0755);
Kenny Root348c8ab2012-05-10 15:39:53 -07001318 } else if (ftsent->fts_info & FTS_F) {
Kenny Root344ca102012-04-03 17:23:01 -07001319 result |= fchmod(fd, privateFile ? 0640 : 0644);
1320 }
Robert Craigb9e3ba52014-02-04 10:53:00 -05001321
Stephen Smalley5093e612014-02-12 09:43:08 -05001322 if (selinux_android_restorecon(ftsent->fts_path, 0) < 0) {
Robert Craigb9e3ba52014-02-04 10:53:00 -05001323 SLOGE("restorecon failed for %s: %s\n", ftsent->fts_path, strerror(errno));
1324 result |= -1;
1325 }
1326
Kenny Root344ca102012-04-03 17:23:01 -07001327 close(fd);
1328 }
1329 fts_close(fts);
1330
1331 // Finally make the directory readable by everyone.
Jeff Sharkeyce6a9132015-04-08 21:07:21 -07001332 int dirfd = open(mountPoint, O_DIRECTORY | O_CLOEXEC);
Kenny Root344ca102012-04-03 17:23:01 -07001333 if (dirfd < 0 || fchmod(dirfd, 0755)) {
1334 SLOGE("Couldn't change owner of existing directory %s: %s", mountPoint, strerror(errno));
1335 result |= -1;
1336 }
1337 close(dirfd);
1338 } else {
1339 result |= -1;
1340 }
1341
Jeff Sharkeyd0640f62015-05-21 22:35:42 -07001342 result |= android::vold::ext4::Mount(loopDevice, mountPoint,
Kenny Root344ca102012-04-03 17:23:01 -07001343 true /* read-only */,
1344 true /* remount */,
1345 true /* execute */);
1346
1347 if (result) {
1348 SLOGE("ASEC fix permissions failed (%s)", strerror(errno));
1349 return -1;
1350 }
1351
1352 if (mDebug) {
1353 SLOGD("ASEC %s permissions fixed", id);
1354 }
1355 return 0;
1356}
1357
San Mehat048b0802010-01-23 08:17:06 -08001358int VolumeManager::renameAsec(const char *id1, const char *id2) {
Kenny Root344ca102012-04-03 17:23:01 -07001359 char asecFilename1[255];
San Mehat048b0802010-01-23 08:17:06 -08001360 char *asecFilename2;
1361 char mountPoint[255];
1362
Kenny Root344ca102012-04-03 17:23:01 -07001363 const char *dir;
1364
Nick Kralevich0de7c612014-01-27 14:58:06 -08001365 if (!isLegalAsecId(id1)) {
1366 SLOGE("renameAsec: Invalid asec id1 \"%s\"", id1);
1367 errno = EINVAL;
1368 return -1;
1369 }
1370
1371 if (!isLegalAsecId(id2)) {
1372 SLOGE("renameAsec: Invalid asec id2 \"%s\"", id2);
1373 errno = EINVAL;
1374 return -1;
1375 }
1376
Kenny Root344ca102012-04-03 17:23:01 -07001377 if (findAsec(id1, asecFilename1, sizeof(asecFilename1), &dir)) {
1378 SLOGE("Couldn't find ASEC %s", id1);
1379 return -1;
1380 }
1381
1382 asprintf(&asecFilename2, "%s/%s.asec", dir, id2);
San Mehat048b0802010-01-23 08:17:06 -08001383
Jeff Sharkey9f18fe72015-04-01 23:32:18 -07001384 int written = snprintf(mountPoint, sizeof(mountPoint), "%s/%s", VolumeManager::ASECDIR, id1);
rpcraigd1c226f2012-10-09 06:58:16 -04001385 if ((written < 0) || (size_t(written) >= sizeof(mountPoint))) {
1386 SLOGE("Rename failed: couldn't construct mountpoint");
1387 goto out_err;
1388 }
1389
San Mehat048b0802010-01-23 08:17:06 -08001390 if (isMountpointMounted(mountPoint)) {
San Mehat97ac40e2010-03-24 10:24:19 -07001391 SLOGW("Rename attempt when src mounted");
San Mehat048b0802010-01-23 08:17:06 -08001392 errno = EBUSY;
1393 goto out_err;
1394 }
1395
Jeff Sharkey9f18fe72015-04-01 23:32:18 -07001396 written = snprintf(mountPoint, sizeof(mountPoint), "%s/%s", VolumeManager::ASECDIR, id2);
rpcraigd1c226f2012-10-09 06:58:16 -04001397 if ((written < 0) || (size_t(written) >= sizeof(mountPoint))) {
1398 SLOGE("Rename failed: couldn't construct mountpoint2");
1399 goto out_err;
1400 }
1401
San Mehat96956ed2010-02-24 08:42:51 -08001402 if (isMountpointMounted(mountPoint)) {
San Mehat97ac40e2010-03-24 10:24:19 -07001403 SLOGW("Rename attempt when dst mounted");
San Mehat96956ed2010-02-24 08:42:51 -08001404 errno = EBUSY;
1405 goto out_err;
1406 }
1407
San Mehat048b0802010-01-23 08:17:06 -08001408 if (!access(asecFilename2, F_OK)) {
San Mehat97ac40e2010-03-24 10:24:19 -07001409 SLOGE("Rename attempt when dst exists");
San Mehat048b0802010-01-23 08:17:06 -08001410 errno = EADDRINUSE;
1411 goto out_err;
1412 }
1413
1414 if (rename(asecFilename1, asecFilename2)) {
San Mehat97ac40e2010-03-24 10:24:19 -07001415 SLOGE("Rename of '%s' to '%s' failed (%s)", asecFilename1, asecFilename2, strerror(errno));
San Mehat048b0802010-01-23 08:17:06 -08001416 goto out_err;
1417 }
1418
San Mehat048b0802010-01-23 08:17:06 -08001419 free(asecFilename2);
1420 return 0;
1421
1422out_err:
San Mehat048b0802010-01-23 08:17:06 -08001423 free(asecFilename2);
1424 return -1;
1425}
1426
Kenny Rootfb7c4d52010-06-30 18:48:41 -07001427#define UNMOUNT_RETRIES 5
1428#define UNMOUNT_SLEEP_BETWEEN_RETRY_MS (1000 * 1000)
San Mehat4ba89482010-02-18 09:00:18 -08001429int VolumeManager::unmountAsec(const char *id, bool force) {
San Mehata19b2502010-01-06 10:33:53 -08001430 char asecFileName[255];
1431 char mountPoint[255];
1432
Nick Kralevich0de7c612014-01-27 14:58:06 -08001433 if (!isLegalAsecId(id)) {
1434 SLOGE("unmountAsec: Invalid asec id \"%s\"", id);
1435 errno = EINVAL;
1436 return -1;
1437 }
1438
Kenny Root344ca102012-04-03 17:23:01 -07001439 if (findAsec(id, asecFileName, sizeof(asecFileName))) {
1440 SLOGE("Couldn't find ASEC %s", id);
1441 return -1;
1442 }
1443
Jeff Sharkey9f18fe72015-04-01 23:32:18 -07001444 int written = snprintf(mountPoint, sizeof(mountPoint), "%s/%s", VolumeManager::ASECDIR, id);
rpcraigd1c226f2012-10-09 06:58:16 -04001445 if ((written < 0) || (size_t(written) >= sizeof(mountPoint))) {
1446 SLOGE("ASEC unmount failed for %s: couldn't construct mountpoint", id);
1447 return -1;
1448 }
San Mehata19b2502010-01-06 10:33:53 -08001449
San Mehatd9a4e352010-03-12 13:32:47 -08001450 char idHash[33];
1451 if (!asecHash(id, idHash, sizeof(idHash))) {
San Mehat97ac40e2010-03-24 10:24:19 -07001452 SLOGE("Hash of '%s' failed (%s)", id, strerror(errno));
San Mehatd9a4e352010-03-12 13:32:47 -08001453 return -1;
1454 }
1455
Kenny Rootfb7c4d52010-06-30 18:48:41 -07001456 return unmountLoopImage(id, idHash, asecFileName, mountPoint, force);
1457}
1458
Kenny Root508c0e12010-07-12 09:59:49 -07001459int VolumeManager::unmountObb(const char *fileName, bool force) {
Kenny Rootfb7c4d52010-06-30 18:48:41 -07001460 char mountPoint[255];
1461
1462 char idHash[33];
1463 if (!asecHash(fileName, idHash, sizeof(idHash))) {
1464 SLOGE("Hash of '%s' failed (%s)", fileName, strerror(errno));
1465 return -1;
1466 }
1467
Jeff Sharkey9f18fe72015-04-01 23:32:18 -07001468 int written = snprintf(mountPoint, sizeof(mountPoint), "%s/%s", VolumeManager::LOOPDIR, idHash);
rpcraigd1c226f2012-10-09 06:58:16 -04001469 if ((written < 0) || (size_t(written) >= sizeof(mountPoint))) {
1470 SLOGE("OBB unmount failed for %s: couldn't construct mountpoint", fileName);
1471 return -1;
1472 }
Kenny Rootfb7c4d52010-06-30 18:48:41 -07001473
1474 return unmountLoopImage(fileName, idHash, fileName, mountPoint, force);
1475}
1476
1477int VolumeManager::unmountLoopImage(const char *id, const char *idHash,
1478 const char *fileName, const char *mountPoint, bool force) {
San Mehat0586d542010-01-12 15:38:59 -08001479 if (!isMountpointMounted(mountPoint)) {
Kenny Rootfb7c4d52010-06-30 18:48:41 -07001480 SLOGE("Unmount request for %s when not mounted", id);
Kenny Root918e5f92010-09-30 18:00:52 -07001481 errno = ENOENT;
San Mehatb78a32c2010-01-10 13:02:12 -08001482 return -1;
1483 }
San Mehat23969932010-01-09 07:08:06 -08001484
San Mehatb78a32c2010-01-10 13:02:12 -08001485 int i, rc;
Kenny Rootfb7c4d52010-06-30 18:48:41 -07001486 for (i = 1; i <= UNMOUNT_RETRIES; i++) {
San Mehatb78a32c2010-01-10 13:02:12 -08001487 rc = umount(mountPoint);
1488 if (!rc) {
1489 break;
San Mehata19b2502010-01-06 10:33:53 -08001490 }
San Mehatb78a32c2010-01-10 13:02:12 -08001491 if (rc && (errno == EINVAL || errno == ENOENT)) {
Kenny Rootfb7c4d52010-06-30 18:48:41 -07001492 SLOGI("Container %s unmounted OK", id);
San Mehatb78a32c2010-01-10 13:02:12 -08001493 rc = 0;
1494 break;
San Mehata19b2502010-01-06 10:33:53 -08001495 }
Kenny Rootfb7c4d52010-06-30 18:48:41 -07001496 SLOGW("%s unmount attempt %d failed (%s)",
San Mehat8c940ef2010-02-13 14:19:53 -08001497 id, i, strerror(errno));
San Mehatb78a32c2010-01-10 13:02:12 -08001498
Jeff Sharkey36801cc2015-03-13 16:09:20 -07001499 int signal = 0; // default is to just complain
San Mehat4ba89482010-02-18 09:00:18 -08001500
1501 if (force) {
Kenny Rootfb7c4d52010-06-30 18:48:41 -07001502 if (i > (UNMOUNT_RETRIES - 2))
Jeff Sharkey36801cc2015-03-13 16:09:20 -07001503 signal = SIGKILL;
Kenny Rootfb7c4d52010-06-30 18:48:41 -07001504 else if (i > (UNMOUNT_RETRIES - 3))
Jeff Sharkey36801cc2015-03-13 16:09:20 -07001505 signal = SIGTERM;
San Mehat4ba89482010-02-18 09:00:18 -08001506 }
San Mehat8c940ef2010-02-13 14:19:53 -08001507
Jeff Sharkey36801cc2015-03-13 16:09:20 -07001508 Process::killProcessesWithOpenFiles(mountPoint, signal);
Kenny Rootfb7c4d52010-06-30 18:48:41 -07001509 usleep(UNMOUNT_SLEEP_BETWEEN_RETRY_MS);
San Mehatb78a32c2010-01-10 13:02:12 -08001510 }
1511
1512 if (rc) {
San Mehat4ba89482010-02-18 09:00:18 -08001513 errno = EBUSY;
San Mehat97ac40e2010-03-24 10:24:19 -07001514 SLOGE("Failed to unmount container %s (%s)", id, strerror(errno));
San Mehatb78a32c2010-01-10 13:02:12 -08001515 return -1;
1516 }
1517
San Mehat12f4b892010-02-24 11:43:22 -08001518 int retries = 10;
1519
1520 while(retries--) {
1521 if (!rmdir(mountPoint)) {
1522 break;
1523 }
1524
San Mehat97ac40e2010-03-24 10:24:19 -07001525 SLOGW("Failed to rmdir %s (%s)", mountPoint, strerror(errno));
Kenny Rootfb7c4d52010-06-30 18:48:41 -07001526 usleep(UNMOUNT_SLEEP_BETWEEN_RETRY_MS);
San Mehat12f4b892010-02-24 11:43:22 -08001527 }
1528
1529 if (!retries) {
San Mehat97ac40e2010-03-24 10:24:19 -07001530 SLOGE("Timed out trying to rmdir %s (%s)", mountPoint, strerror(errno));
San Mehatf5c61982010-02-03 11:04:46 -08001531 }
San Mehat88705162010-01-15 09:26:28 -08001532
Paul Lawrence60dec162014-09-02 10:52:15 -07001533 for (i=1; i <= UNMOUNT_RETRIES; i++) {
1534 if (Devmapper::destroy(idHash) && errno != ENXIO) {
1535 SLOGE("Failed to destroy devmapper instance (%s)", strerror(errno));
1536 usleep(UNMOUNT_SLEEP_BETWEEN_RETRY_MS);
1537 continue;
1538 } else {
1539 break;
1540 }
San Mehata19b2502010-01-06 10:33:53 -08001541 }
1542
1543 char loopDevice[255];
San Mehatd9a4e352010-03-12 13:32:47 -08001544 if (!Loop::lookupActive(idHash, loopDevice, sizeof(loopDevice))) {
San Mehata19b2502010-01-06 10:33:53 -08001545 Loop::destroyByDevice(loopDevice);
San Mehatd9a4e352010-03-12 13:32:47 -08001546 } else {
Kenny Rootfb7c4d52010-06-30 18:48:41 -07001547 SLOGW("Failed to find loop device for {%s} (%s)", fileName, strerror(errno));
San Mehata19b2502010-01-06 10:33:53 -08001548 }
San Mehat88705162010-01-15 09:26:28 -08001549
1550 AsecIdCollection::iterator it;
1551 for (it = mActiveContainers->begin(); it != mActiveContainers->end(); ++it) {
Kenny Rootcbacf782010-09-24 15:11:48 -07001552 ContainerData* cd = *it;
1553 if (!strcmp(cd->id, id)) {
San Mehat88705162010-01-15 09:26:28 -08001554 free(*it);
1555 mActiveContainers->erase(it);
1556 break;
1557 }
1558 }
1559 if (it == mActiveContainers->end()) {
San Mehat97ac40e2010-03-24 10:24:19 -07001560 SLOGW("mActiveContainers is inconsistent!");
San Mehat88705162010-01-15 09:26:28 -08001561 }
San Mehatb78a32c2010-01-10 13:02:12 -08001562 return 0;
1563}
1564
San Mehat4ba89482010-02-18 09:00:18 -08001565int VolumeManager::destroyAsec(const char *id, bool force) {
San Mehatb78a32c2010-01-10 13:02:12 -08001566 char asecFileName[255];
1567 char mountPoint[255];
1568
Nick Kralevich0de7c612014-01-27 14:58:06 -08001569 if (!isLegalAsecId(id)) {
1570 SLOGE("destroyAsec: Invalid asec id \"%s\"", id);
1571 errno = EINVAL;
1572 return -1;
1573 }
1574
Kenny Root344ca102012-04-03 17:23:01 -07001575 if (findAsec(id, asecFileName, sizeof(asecFileName))) {
1576 SLOGE("Couldn't find ASEC %s", id);
1577 return -1;
1578 }
1579
Jeff Sharkey9f18fe72015-04-01 23:32:18 -07001580 int written = snprintf(mountPoint, sizeof(mountPoint), "%s/%s", VolumeManager::ASECDIR, id);
rpcraigd1c226f2012-10-09 06:58:16 -04001581 if ((written < 0) || (size_t(written) >= sizeof(mountPoint))) {
1582 SLOGE("ASEC destroy failed for %s: couldn't construct mountpoint", id);
1583 return -1;
1584 }
San Mehatb78a32c2010-01-10 13:02:12 -08001585
San Mehat0586d542010-01-12 15:38:59 -08001586 if (isMountpointMounted(mountPoint)) {
San Mehatd9a4e352010-03-12 13:32:47 -08001587 if (mDebug) {
San Mehat97ac40e2010-03-24 10:24:19 -07001588 SLOGD("Unmounting container before destroy");
San Mehatd9a4e352010-03-12 13:32:47 -08001589 }
San Mehat4ba89482010-02-18 09:00:18 -08001590 if (unmountAsec(id, force)) {
San Mehat97ac40e2010-03-24 10:24:19 -07001591 SLOGE("Failed to unmount asec %s for destroy (%s)", id, strerror(errno));
San Mehat0586d542010-01-12 15:38:59 -08001592 return -1;
1593 }
1594 }
San Mehata19b2502010-01-06 10:33:53 -08001595
San Mehat0586d542010-01-12 15:38:59 -08001596 if (unlink(asecFileName)) {
San Mehat97ac40e2010-03-24 10:24:19 -07001597 SLOGE("Failed to unlink asec '%s' (%s)", asecFileName, strerror(errno));
San Mehat0586d542010-01-12 15:38:59 -08001598 return -1;
1599 }
San Mehata19b2502010-01-06 10:33:53 -08001600
San Mehatd9a4e352010-03-12 13:32:47 -08001601 if (mDebug) {
San Mehat97ac40e2010-03-24 10:24:19 -07001602 SLOGD("ASEC %s destroyed", id);
San Mehatd9a4e352010-03-12 13:32:47 -08001603 }
San Mehata19b2502010-01-06 10:33:53 -08001604 return 0;
1605}
1606
Nick Kralevich0de7c612014-01-27 14:58:06 -08001607/*
1608 * Legal ASEC ids consist of alphanumeric characters, '-',
1609 * '_', or '.'. ".." is not allowed. The first or last character
1610 * of the ASEC id cannot be '.' (dot).
1611 */
1612bool VolumeManager::isLegalAsecId(const char *id) const {
1613 size_t i;
1614 size_t len = strlen(id);
1615
1616 if (len == 0) {
1617 return false;
1618 }
1619 if ((id[0] == '.') || (id[len - 1] == '.')) {
1620 return false;
1621 }
1622
1623 for (i = 0; i < len; i++) {
1624 if (id[i] == '.') {
1625 // i=0 is guaranteed never to have a dot. See above.
1626 if (id[i-1] == '.') return false;
1627 continue;
1628 }
1629 if (id[i] == '_' || id[i] == '-') continue;
1630 if (id[i] >= 'a' && id[i] <= 'z') continue;
1631 if (id[i] >= 'A' && id[i] <= 'Z') continue;
1632 if (id[i] >= '0' && id[i] <= '9') continue;
1633 return false;
1634 }
1635
1636 return true;
1637}
1638
Kenny Root344ca102012-04-03 17:23:01 -07001639bool VolumeManager::isAsecInDirectory(const char *dir, const char *asecName) const {
Jeff Sharkeyce6a9132015-04-08 21:07:21 -07001640 int dirfd = open(dir, O_DIRECTORY | O_CLOEXEC);
Kenny Root344ca102012-04-03 17:23:01 -07001641 if (dirfd < 0) {
1642 SLOGE("Couldn't open internal ASEC dir (%s)", strerror(errno));
Nick Kralevich25e581a2015-02-06 08:55:08 -08001643 return false;
Kenny Root344ca102012-04-03 17:23:01 -07001644 }
1645
Nick Kralevich25e581a2015-02-06 08:55:08 -08001646 struct stat sb;
1647 bool ret = (fstatat(dirfd, asecName, &sb, AT_SYMLINK_NOFOLLOW) == 0)
1648 && S_ISREG(sb.st_mode);
Kenny Root344ca102012-04-03 17:23:01 -07001649
1650 close(dirfd);
1651
1652 return ret;
1653}
1654
1655int VolumeManager::findAsec(const char *id, char *asecPath, size_t asecPathLen,
1656 const char **directory) const {
Kenny Root344ca102012-04-03 17:23:01 -07001657 char *asecName;
1658
Nick Kralevich0de7c612014-01-27 14:58:06 -08001659 if (!isLegalAsecId(id)) {
1660 SLOGE("findAsec: Invalid asec id \"%s\"", id);
1661 errno = EINVAL;
1662 return -1;
1663 }
1664
Kenny Root344ca102012-04-03 17:23:01 -07001665 if (asprintf(&asecName, "%s.asec", id) < 0) {
1666 SLOGE("Couldn't allocate string to write ASEC name");
1667 return -1;
1668 }
1669
1670 const char *dir;
Jeff Sharkey9f18fe72015-04-01 23:32:18 -07001671 if (isAsecInDirectory(VolumeManager::SEC_ASECDIR_INT, asecName)) {
1672 dir = VolumeManager::SEC_ASECDIR_INT;
1673 } else if (isAsecInDirectory(VolumeManager::SEC_ASECDIR_EXT, asecName)) {
1674 dir = VolumeManager::SEC_ASECDIR_EXT;
Kenny Root344ca102012-04-03 17:23:01 -07001675 } else {
1676 free(asecName);
1677 return -1;
1678 }
1679
1680 if (directory != NULL) {
1681 *directory = dir;
1682 }
1683
1684 if (asecPath != NULL) {
1685 int written = snprintf(asecPath, asecPathLen, "%s/%s", dir, asecName);
rpcraigd1c226f2012-10-09 06:58:16 -04001686 if ((written < 0) || (size_t(written) >= asecPathLen)) {
1687 SLOGE("findAsec failed for %s: couldn't construct ASEC path", id);
Kenny Root344ca102012-04-03 17:23:01 -07001688 free(asecName);
1689 return -1;
1690 }
1691 }
1692
1693 free(asecName);
1694 return 0;
1695}
1696
Jeff Sharkey43ed1232014-08-22 12:29:05 -07001697int VolumeManager::mountAsec(const char *id, const char *key, int ownerUid, bool readOnly) {
San Mehata19b2502010-01-06 10:33:53 -08001698 char asecFileName[255];
1699 char mountPoint[255];
1700
Nick Kralevich0de7c612014-01-27 14:58:06 -08001701 if (!isLegalAsecId(id)) {
1702 SLOGE("mountAsec: Invalid asec id \"%s\"", id);
1703 errno = EINVAL;
1704 return -1;
1705 }
1706
Kenny Root344ca102012-04-03 17:23:01 -07001707 if (findAsec(id, asecFileName, sizeof(asecFileName))) {
1708 SLOGE("Couldn't find ASEC %s", id);
1709 return -1;
1710 }
1711
Jeff Sharkey9f18fe72015-04-01 23:32:18 -07001712 int written = snprintf(mountPoint, sizeof(mountPoint), "%s/%s", VolumeManager::ASECDIR, id);
rpcraigd1c226f2012-10-09 06:58:16 -04001713 if ((written < 0) || (size_t(written) >= sizeof(mountPoint))) {
Colin Cross59846b62014-02-06 20:34:29 -08001714 SLOGE("ASEC mount failed for %s: couldn't construct mountpoint", id);
rpcraigd1c226f2012-10-09 06:58:16 -04001715 return -1;
1716 }
San Mehata19b2502010-01-06 10:33:53 -08001717
1718 if (isMountpointMounted(mountPoint)) {
San Mehat97ac40e2010-03-24 10:24:19 -07001719 SLOGE("ASEC %s already mounted", id);
San Mehata19b2502010-01-06 10:33:53 -08001720 errno = EBUSY;
1721 return -1;
1722 }
1723
San Mehatd9a4e352010-03-12 13:32:47 -08001724 char idHash[33];
1725 if (!asecHash(id, idHash, sizeof(idHash))) {
San Mehat97ac40e2010-03-24 10:24:19 -07001726 SLOGE("Hash of '%s' failed (%s)", id, strerror(errno));
San Mehatd9a4e352010-03-12 13:32:47 -08001727 return -1;
1728 }
Kenny Root7b18a7b2010-03-15 13:13:41 -07001729
San Mehata19b2502010-01-06 10:33:53 -08001730 char loopDevice[255];
Daniel Rosenbergfcd34a02014-05-22 11:23:56 -07001731 if (setupLoopDevice(loopDevice, sizeof(loopDevice), asecFileName, idHash, mDebug))
1732 return -1;
San Mehatb78a32c2010-01-10 13:02:12 -08001733
1734 char dmDevice[255];
1735 bool cleanupDm = false;
Tim Murray8439dc92014-12-15 11:56:11 -08001736
Hiroaki Miyazawa14eab552015-02-04 13:29:15 +09001737 unsigned long nr_sec = 0;
San Mehatfcf24fe2010-03-03 12:37:32 -08001738 struct asec_superblock sb;
San Mehatfcf24fe2010-03-03 12:37:32 -08001739
Kenny Root344ca102012-04-03 17:23:01 -07001740 if (Loop::lookupInfo(loopDevice, &sb, &nr_sec)) {
1741 return -1;
1742 }
San Mehatfcf24fe2010-03-03 12:37:32 -08001743
San Mehatd9a4e352010-03-12 13:32:47 -08001744 if (mDebug) {
San Mehat97ac40e2010-03-24 10:24:19 -07001745 SLOGD("Container sb magic/ver (%.8x/%.2x)", sb.magic, sb.ver);
San Mehatd9a4e352010-03-12 13:32:47 -08001746 }
San Mehatfcf24fe2010-03-03 12:37:32 -08001747 if (sb.magic != ASEC_SB_MAGIC || sb.ver != ASEC_SB_VER) {
San Mehat97ac40e2010-03-24 10:24:19 -07001748 SLOGE("Bad container magic/version (%.8x/%.2x)", sb.magic, sb.ver);
San Mehatfcf24fe2010-03-03 12:37:32 -08001749 Loop::destroyByDevice(loopDevice);
1750 errno = EMEDIUMTYPE;
1751 return -1;
1752 }
1753 nr_sec--; // We don't want the devmapping to extend onto our superblock
1754
Daniel Rosenbergfcd34a02014-05-22 11:23:56 -07001755 if (setupDevMapperDevice(dmDevice, sizeof(dmDevice), loopDevice, asecFileName, key, idHash , nr_sec, &cleanupDm, mDebug)) {
1756 Loop::destroyByDevice(loopDevice);
1757 return -1;
San Mehata19b2502010-01-06 10:33:53 -08001758 }
1759
Kenny Root344ca102012-04-03 17:23:01 -07001760 if (mkdir(mountPoint, 0000)) {
San Mehatb78a32c2010-01-10 13:02:12 -08001761 if (errno != EEXIST) {
San Mehat97ac40e2010-03-24 10:24:19 -07001762 SLOGE("Mountpoint creation failed (%s)", strerror(errno));
San Mehatb78a32c2010-01-10 13:02:12 -08001763 if (cleanupDm) {
San Mehatd9a4e352010-03-12 13:32:47 -08001764 Devmapper::destroy(idHash);
San Mehatb78a32c2010-01-10 13:02:12 -08001765 }
1766 Loop::destroyByDevice(loopDevice);
1767 return -1;
1768 }
San Mehata19b2502010-01-06 10:33:53 -08001769 }
1770
Kenny Rootcdc2a1c2012-05-03 13:49:46 -07001771 /*
Daniel Rosenbergfcd34a02014-05-22 11:23:56 -07001772 * Wait for the device mapper node to be created.
Kenny Rootcdc2a1c2012-05-03 13:49:46 -07001773 */
Daniel Rosenbergfcd34a02014-05-22 11:23:56 -07001774 waitForDevMapper(dmDevice);
Kenny Rootcdc2a1c2012-05-03 13:49:46 -07001775
Kenny Root344ca102012-04-03 17:23:01 -07001776 int result;
1777 if (sb.c_opts & ASEC_SB_C_OPTS_EXT4) {
Jeff Sharkeyd0640f62015-05-21 22:35:42 -07001778 result = android::vold::ext4::Mount(dmDevice, mountPoint,
1779 readOnly, false, readOnly);
Kenny Root344ca102012-04-03 17:23:01 -07001780 } else {
Jeff Sharkeyd0640f62015-05-21 22:35:42 -07001781 result = android::vold::vfat::Mount(dmDevice, mountPoint,
1782 readOnly, false, readOnly, ownerUid, 0, 0222, false);
Kenny Root344ca102012-04-03 17:23:01 -07001783 }
1784
1785 if (result) {
San Mehat97ac40e2010-03-24 10:24:19 -07001786 SLOGE("ASEC mount failed (%s)", strerror(errno));
San Mehatb78a32c2010-01-10 13:02:12 -08001787 if (cleanupDm) {
San Mehatd9a4e352010-03-12 13:32:47 -08001788 Devmapper::destroy(idHash);
San Mehatb78a32c2010-01-10 13:02:12 -08001789 }
1790 Loop::destroyByDevice(loopDevice);
San Mehata19b2502010-01-06 10:33:53 -08001791 return -1;
1792 }
1793
Kenny Rootcbacf782010-09-24 15:11:48 -07001794 mActiveContainers->push_back(new ContainerData(strdup(id), ASEC));
San Mehatd9a4e352010-03-12 13:32:47 -08001795 if (mDebug) {
San Mehat97ac40e2010-03-24 10:24:19 -07001796 SLOGD("ASEC %s mounted", id);
San Mehatd9a4e352010-03-12 13:32:47 -08001797 }
San Mehata19b2502010-01-06 10:33:53 -08001798 return 0;
1799}
1800
Kenny Rootfb7c4d52010-06-30 18:48:41 -07001801/**
1802 * Mounts an image file <code>img</code>.
1803 */
Jeff Sharkey69479042012-09-25 16:14:57 -07001804int VolumeManager::mountObb(const char *img, const char *key, int ownerGid) {
Kenny Rootfb7c4d52010-06-30 18:48:41 -07001805 char mountPoint[255];
1806
Kenny Rootfb7c4d52010-06-30 18:48:41 -07001807 char idHash[33];
1808 if (!asecHash(img, idHash, sizeof(idHash))) {
1809 SLOGE("Hash of '%s' failed (%s)", img, strerror(errno));
1810 return -1;
1811 }
1812
Jeff Sharkey9f18fe72015-04-01 23:32:18 -07001813 int written = snprintf(mountPoint, sizeof(mountPoint), "%s/%s", VolumeManager::LOOPDIR, idHash);
rpcraigd1c226f2012-10-09 06:58:16 -04001814 if ((written < 0) || (size_t(written) >= sizeof(mountPoint))) {
Colin Cross59846b62014-02-06 20:34:29 -08001815 SLOGE("OBB mount failed for %s: couldn't construct mountpoint", img);
rpcraigd1c226f2012-10-09 06:58:16 -04001816 return -1;
1817 }
Kenny Rootfb7c4d52010-06-30 18:48:41 -07001818
1819 if (isMountpointMounted(mountPoint)) {
1820 SLOGE("Image %s already mounted", img);
1821 errno = EBUSY;
1822 return -1;
1823 }
1824
1825 char loopDevice[255];
Daniel Rosenbergfcd34a02014-05-22 11:23:56 -07001826 if (setupLoopDevice(loopDevice, sizeof(loopDevice), img, idHash, mDebug))
1827 return -1;
Kenny Rootfb7c4d52010-06-30 18:48:41 -07001828
1829 char dmDevice[255];
1830 bool cleanupDm = false;
1831 int fd;
Hiroaki Miyazawa14eab552015-02-04 13:29:15 +09001832 unsigned long nr_sec = 0;
Kenny Rootfb7c4d52010-06-30 18:48:41 -07001833
Jeff Sharkeyce6a9132015-04-08 21:07:21 -07001834 if ((fd = open(loopDevice, O_RDWR | O_CLOEXEC)) < 0) {
Kenny Rootfb7c4d52010-06-30 18:48:41 -07001835 SLOGE("Failed to open loopdevice (%s)", strerror(errno));
1836 Loop::destroyByDevice(loopDevice);
1837 return -1;
1838 }
1839
Hiroaki Miyazawa14eab552015-02-04 13:29:15 +09001840 get_blkdev_size(fd, &nr_sec);
1841 if (nr_sec == 0) {
Kenny Rootfb7c4d52010-06-30 18:48:41 -07001842 SLOGE("Failed to get loop size (%s)", strerror(errno));
1843 Loop::destroyByDevice(loopDevice);
1844 close(fd);
1845 return -1;
1846 }
1847
1848 close(fd);
1849
Hiroaki Miyazawa14eab552015-02-04 13:29:15 +09001850 if (setupDevMapperDevice(dmDevice, sizeof(loopDevice), loopDevice, img,key, idHash, nr_sec, &cleanupDm, mDebug)) {
Daniel Rosenbergfcd34a02014-05-22 11:23:56 -07001851 Loop::destroyByDevice(loopDevice);
1852 return -1;
Kenny Rootfb7c4d52010-06-30 18:48:41 -07001853 }
1854
1855 if (mkdir(mountPoint, 0755)) {
1856 if (errno != EEXIST) {
1857 SLOGE("Mountpoint creation failed (%s)", strerror(errno));
1858 if (cleanupDm) {
1859 Devmapper::destroy(idHash);
1860 }
1861 Loop::destroyByDevice(loopDevice);
1862 return -1;
1863 }
1864 }
1865
yoshiyuki hama476a6272015-01-28 16:37:23 +09001866 /*
1867 * Wait for the device mapper node to be created.
1868 */
1869 waitForDevMapper(dmDevice);
1870
Jeff Sharkeyd0640f62015-05-21 22:35:42 -07001871 if (android::vold::vfat::Mount(dmDevice, mountPoint,
1872 true, false, true, 0, ownerGid, 0227, false)) {
Kenny Rootfb7c4d52010-06-30 18:48:41 -07001873 SLOGE("Image mount failed (%s)", strerror(errno));
1874 if (cleanupDm) {
1875 Devmapper::destroy(idHash);
1876 }
1877 Loop::destroyByDevice(loopDevice);
1878 return -1;
1879 }
1880
Kenny Rootcbacf782010-09-24 15:11:48 -07001881 mActiveContainers->push_back(new ContainerData(strdup(img), OBB));
Kenny Rootfb7c4d52010-06-30 18:48:41 -07001882 if (mDebug) {
1883 SLOGD("Image %s mounted", img);
1884 }
1885 return 0;
1886}
1887
Kenny Root508c0e12010-07-12 09:59:49 -07001888int VolumeManager::listMountedObbs(SocketClient* cli) {
Yabin Cuid1104f72015-01-02 13:28:28 -08001889 FILE *fp = setmntent("/proc/mounts", "r");
1890 if (fp == NULL) {
Kenny Root508c0e12010-07-12 09:59:49 -07001891 SLOGE("Error opening /proc/mounts (%s)", strerror(errno));
1892 return -1;
1893 }
1894
1895 // Create a string to compare against that has a trailing slash
Jeff Sharkey9f18fe72015-04-01 23:32:18 -07001896 int loopDirLen = strlen(VolumeManager::LOOPDIR);
Kenny Root508c0e12010-07-12 09:59:49 -07001897 char loopDir[loopDirLen + 2];
Jeff Sharkey32ebb732017-03-27 16:18:50 -06001898 strlcpy(loopDir, VolumeManager::LOOPDIR, sizeof(loopDir));
Kenny Root508c0e12010-07-12 09:59:49 -07001899 loopDir[loopDirLen++] = '/';
1900 loopDir[loopDirLen] = '\0';
1901
Yabin Cuid1104f72015-01-02 13:28:28 -08001902 mntent* mentry;
1903 while ((mentry = getmntent(fp)) != NULL) {
1904 if (!strncmp(mentry->mnt_dir, loopDir, loopDirLen)) {
Jeff Sharkeyce6a9132015-04-08 21:07:21 -07001905 int fd = open(mentry->mnt_fsname, O_RDONLY | O_CLOEXEC);
Kenny Root508c0e12010-07-12 09:59:49 -07001906 if (fd >= 0) {
1907 struct loop_info64 li;
1908 if (ioctl(fd, LOOP_GET_STATUS64, &li) >= 0) {
1909 cli->sendMsg(ResponseCode::AsecListResult,
1910 (const char*) li.lo_file_name, false);
1911 }
1912 close(fd);
1913 }
1914 }
1915 }
Yabin Cuid1104f72015-01-02 13:28:28 -08001916 endmntent(fp);
Kenny Root508c0e12010-07-12 09:59:49 -07001917 return 0;
1918}
1919
Jeff Sharkey9c484982015-03-31 10:35:33 -07001920extern "C" int vold_unmountAll(void) {
Ken Sumrall425524d2012-06-14 20:55:28 -07001921 VolumeManager *vm = VolumeManager::Instance();
Jeff Sharkey9c484982015-03-31 10:35:33 -07001922 return vm->unmountAll();
Ken Sumrall425524d2012-06-14 20:55:28 -07001923}
1924
San Mehata19b2502010-01-06 10:33:53 -08001925bool VolumeManager::isMountpointMounted(const char *mp)
1926{
Yabin Cuid1104f72015-01-02 13:28:28 -08001927 FILE *fp = setmntent("/proc/mounts", "r");
1928 if (fp == NULL) {
San Mehat97ac40e2010-03-24 10:24:19 -07001929 SLOGE("Error opening /proc/mounts (%s)", strerror(errno));
San Mehata19b2502010-01-06 10:33:53 -08001930 return false;
1931 }
1932
Yabin Cuid1104f72015-01-02 13:28:28 -08001933 bool found_mp = false;
1934 mntent* mentry;
1935 while ((mentry = getmntent(fp)) != NULL) {
1936 if (strcmp(mentry->mnt_dir, mp) == 0) {
1937 found_mp = true;
1938 break;
San Mehata19b2502010-01-06 10:33:53 -08001939 }
San Mehata19b2502010-01-06 10:33:53 -08001940 }
Yabin Cuid1104f72015-01-02 13:28:28 -08001941 endmntent(fp);
1942 return found_mp;
San Mehata19b2502010-01-06 10:33:53 -08001943}
1944
Jeff Sharkey71ebe152013-09-17 17:24:38 -07001945int VolumeManager::mkdirs(char* path) {
Jeff Sharkey36801cc2015-03-13 16:09:20 -07001946 // Only offer to create directories for paths managed by vold
1947 if (strncmp(path, "/storage/", 9) == 0) {
1948 // fs_mkdirs() does symlink checking and relative path enforcement
1949 return fs_mkdirs(path, 0700);
Jeff Sharkey71ebe152013-09-17 17:24:38 -07001950 } else {
Cylen Yao27cfee32014-05-02 19:23:42 +08001951 SLOGE("Failed to find mounted volume for %s", path);
Jeff Sharkey71ebe152013-09-17 17:24:38 -07001952 return -EINVAL;
1953 }
Jeff Sharkey71ebe152013-09-17 17:24:38 -07001954}