Home | History | Annotate | Download | only in vold 
      1 /*
      2  * Copyright (C) 2015 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #include "fs/Ext4.h"
     18 #include "fs/F2fs.h"
     19 #include "PrivateVolume.h"
     20 #include "EmulatedVolume.h"
     21 #include "Utils.h"
     22 #include "VolumeManager.h"
     23 #include "ResponseCode.h"
     24 #include "cryptfs.h"
     25 
     26 #include <android-base/stringprintf.h>
     27 #include <android-base/logging.h>
     28 #include <cutils/fs.h>
     29 #include <private/android_filesystem_config.h>
     30 
     31 #include <fcntl.h>
     32 #include <stdlib.h>
     33 #include <sys/mount.h>
     34 #include <sys/stat.h>
     35 #include <sys/types.h>
     36 #include <sys/wait.h>
     37 #include <sys/param.h>
     38 
     39 using android::base::StringPrintf;
     40 
     41 namespace android {
     42 namespace vold {
     43 
     44 static const unsigned int kMajorBlockMmc = 179;
     45 
     46 PrivateVolume::PrivateVolume(dev_t device, const std::string& keyRaw) :
     47         VolumeBase(Type::kPrivate), mRawDevice(device), mKeyRaw(keyRaw) {
     48     setId(StringPrintf("private:%u,%u", major(device), minor(device)));
     49     mRawDevPath = StringPrintf("/dev/block/vold/%s", getId().c_str());
     50 }
     51 
     52 PrivateVolume::~PrivateVolume() {
     53 }
     54 
     55 status_t PrivateVolume::readMetadata() {
     56     status_t res = ReadMetadata(mDmDevPath, mFsType, mFsUuid, mFsLabel);
     57     notifyEvent(ResponseCode::VolumeFsTypeChanged, mFsType);
     58     notifyEvent(ResponseCode::VolumeFsUuidChanged, mFsUuid);
     59     notifyEvent(ResponseCode::VolumeFsLabelChanged, mFsLabel);
     60     return res;
     61 }
     62 
     63 status_t PrivateVolume::doCreate() {
     64     if (CreateDeviceNode(mRawDevPath, mRawDevice)) {
     65         return -EIO;
     66     }
     67 
     68     // Recover from stale vold by tearing down any old mappings
     69     cryptfs_revert_ext_volume(getId().c_str());
     70 
     71     // TODO: figure out better SELinux labels for private volumes
     72 
     73     unsigned char* key = (unsigned char*) mKeyRaw.data();
     74     char crypto_blkdev[MAXPATHLEN];
     75     int res = cryptfs_setup_ext_volume(getId().c_str(), mRawDevPath.c_str(),
     76             key, mKeyRaw.size(), crypto_blkdev);
     77     mDmDevPath = crypto_blkdev;
     78     if (res != 0) {
     79         PLOG(ERROR) << getId() << " failed to setup cryptfs";
     80         return -EIO;
     81     }
     82 
     83     return OK;
     84 }
     85 
     86 status_t PrivateVolume::doDestroy() {
     87     if (cryptfs_revert_ext_volume(getId().c_str())) {
     88         LOG(ERROR) << getId() << " failed to revert cryptfs";
     89     }
     90     return DestroyDeviceNode(mRawDevPath);
     91 }
     92 
     93 status_t PrivateVolume::doMount() {
     94     if (readMetadata()) {
     95         LOG(ERROR) << getId() << " failed to read metadata";
     96         return -EIO;
     97     }
     98 
     99     mPath = StringPrintf("/mnt/expand/%s", mFsUuid.c_str());
    100     setPath(mPath);
    101 
    102     if (PrepareDir(mPath, 0700, AID_ROOT, AID_ROOT)) {
    103         PLOG(ERROR) << getId() << " failed to create mount point " << mPath;
    104         return -EIO;
    105     }
    106 
    107     if (mFsType == "ext4") {
    108         int res = ext4::Check(mDmDevPath, mPath);
    109         if (res == 0 || res == 1) {
    110             LOG(DEBUG) << getId() << " passed filesystem check";
    111         } else {
    112             PLOG(ERROR) << getId() << " failed filesystem check";
    113             return -EIO;
    114         }
    115 
    116         if (ext4::Mount(mDmDevPath, mPath, false, false, true)) {
    117             PLOG(ERROR) << getId() << " failed to mount";
    118             return -EIO;
    119         }
    120 
    121     } else if (mFsType == "f2fs") {
    122         int res = f2fs::Check(mDmDevPath);
    123         if (res == 0) {
    124             LOG(DEBUG) << getId() << " passed filesystem check";
    125         } else {
    126             PLOG(ERROR) << getId() << " failed filesystem check";
    127             return -EIO;
    128         }
    129 
    130         if (f2fs::Mount(mDmDevPath, mPath)) {
    131             PLOG(ERROR) << getId() << " failed to mount";
    132             return -EIO;
    133         }
    134 
    135     } else {
    136         LOG(ERROR) << getId() << " unsupported filesystem " << mFsType;
    137         return -EIO;
    138     }
    139 
    140     RestoreconRecursive(mPath);
    141 
    142     // Verify that common directories are ready to roll
    143     if (PrepareDir(mPath + "/app", 0771, AID_SYSTEM, AID_SYSTEM) ||
    144             PrepareDir(mPath + "/user", 0711, AID_SYSTEM, AID_SYSTEM) ||
    145             PrepareDir(mPath + "/user_de", 0711, AID_SYSTEM, AID_SYSTEM) ||
    146             PrepareDir(mPath + "/media", 0770, AID_MEDIA_RW, AID_MEDIA_RW) ||
    147             PrepareDir(mPath + "/media/0", 0770, AID_MEDIA_RW, AID_MEDIA_RW) ||
    148             PrepareDir(mPath + "/local", 0751, AID_ROOT, AID_ROOT) ||
    149             PrepareDir(mPath + "/local/tmp", 0771, AID_SHELL, AID_SHELL)) {
    150         PLOG(ERROR) << getId() << " failed to prepare";
    151         return -EIO;
    152     }
    153 
    154     // Create a new emulated volume stacked above us, it will automatically
    155     // be destroyed during unmount
    156     std::string mediaPath(mPath + "/media");
    157     auto vol = std::shared_ptr<VolumeBase>(
    158             new EmulatedVolume(mediaPath, mRawDevice, mFsUuid));
    159     addVolume(vol);
    160     vol->create();
    161 
    162     return OK;
    163 }
    164 
    165 status_t PrivateVolume::doUnmount() {
    166     ForceUnmount(mPath);
    167 
    168     if (TEMP_FAILURE_RETRY(rmdir(mPath.c_str()))) {
    169         PLOG(ERROR) << getId() << " failed to rmdir mount point " << mPath;
    170     }
    171 
    172     return OK;
    173 }
    174 
    175 status_t PrivateVolume::doFormat(const std::string& fsType) {
    176     std::string resolvedFsType = fsType;
    177     if (fsType == "auto") {
    178         // For now, assume that all MMC devices are flash-based SD cards, and
    179         // give everyone else ext4 because sysfs rotational isn't reliable.
    180         if ((major(mRawDevice) == kMajorBlockMmc) && f2fs::IsSupported()) {
    181             resolvedFsType = "f2fs";
    182         } else {
    183             resolvedFsType = "ext4";
    184         }
    185         LOG(DEBUG) << "Resolved auto to " << resolvedFsType;
    186     }
    187 
    188     if (resolvedFsType == "ext4") {
    189         // TODO: change reported mountpoint once we have better selinux support
    190         if (ext4::Format(mDmDevPath, 0, "/data")) {
    191             PLOG(ERROR) << getId() << " failed to format";
    192             return -EIO;
    193         }
    194     } else if (resolvedFsType == "f2fs") {
    195         if (f2fs::Format(mDmDevPath)) {
    196             PLOG(ERROR) << getId() << " failed to format";
    197             return -EIO;
    198         }
    199     } else {
    200         LOG(ERROR) << getId() << " unsupported filesystem " << fsType;
    201         return -EINVAL;
    202     }
    203 
    204     return OK;
    205 }
    206 
    207 }  // namespace vold
    208 }  // namespace android
    209