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