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/Vfat.h"
18 #include "PublicVolume.h"
19 #include "Utils.h"
20 #include "VolumeManager.h"
21 #include "ResponseCode.h"
22 
23 #include <base/stringprintf.h>
24 #include <base/logging.h>
25 #include <cutils/fs.h>
26 #include <private/android_filesystem_config.h>
27 
28 #include <fcntl.h>
29 #include <stdlib.h>
30 #include <sys/mount.h>
31 #include <sys/stat.h>
32 #include <sys/types.h>
33 #include <sys/wait.h>
34 
35 using android::base::StringPrintf;
36 
37 namespace android {
38 namespace vold {
39 
40 static const char* kFusePath = "/system/bin/sdcard";
41 
42 static const char* kAsecPath = "/mnt/secure/asec";
43 
PublicVolume(dev_t device)44 PublicVolume::PublicVolume(dev_t device) :
45         VolumeBase(Type::kPublic), mDevice(device), mFusePid(0) {
46     setId(StringPrintf("public:%u,%u", major(device), minor(device)));
47     mDevPath = StringPrintf("/dev/block/vold/%s", getId().c_str());
48 }
49 
~PublicVolume()50 PublicVolume::~PublicVolume() {
51 }
52 
readMetadata()53 status_t PublicVolume::readMetadata() {
54     status_t res = ReadMetadataUntrusted(mDevPath, mFsType, mFsUuid, mFsLabel);
55     notifyEvent(ResponseCode::VolumeFsTypeChanged, mFsType);
56     notifyEvent(ResponseCode::VolumeFsUuidChanged, mFsUuid);
57     notifyEvent(ResponseCode::VolumeFsLabelChanged, mFsLabel);
58     return res;
59 }
60 
initAsecStage()61 status_t PublicVolume::initAsecStage() {
62     std::string legacyPath(mRawPath + "/android_secure");
63     std::string securePath(mRawPath + "/.android_secure");
64 
65     // Recover legacy secure path
66     if (!access(legacyPath.c_str(), R_OK | X_OK)
67             && access(securePath.c_str(), R_OK | X_OK)) {
68         if (rename(legacyPath.c_str(), securePath.c_str())) {
69             PLOG(WARNING) << getId() << " failed to rename legacy ASEC dir";
70         }
71     }
72 
73     if (TEMP_FAILURE_RETRY(mkdir(securePath.c_str(), 0700))) {
74         if (errno != EEXIST) {
75             PLOG(WARNING) << getId() << " creating ASEC stage failed";
76             return -errno;
77         }
78     }
79 
80     BindMount(securePath, kAsecPath);
81 
82     return OK;
83 }
84 
doCreate()85 status_t PublicVolume::doCreate() {
86     return CreateDeviceNode(mDevPath, mDevice);
87 }
88 
doDestroy()89 status_t PublicVolume::doDestroy() {
90     return DestroyDeviceNode(mDevPath);
91 }
92 
doMount()93 status_t PublicVolume::doMount() {
94     // TODO: expand to support mounting other filesystems
95     readMetadata();
96 
97     if (mFsType != "vfat") {
98         LOG(ERROR) << getId() << " unsupported filesystem " << mFsType;
99         return -EIO;
100     }
101 
102     if (vfat::Check(mDevPath)) {
103         LOG(ERROR) << getId() << " failed filesystem check";
104         return -EIO;
105     }
106 
107     // Use UUID as stable name, if available
108     std::string stableName = getId();
109     if (!mFsUuid.empty()) {
110         stableName = mFsUuid;
111     }
112 
113     mRawPath = StringPrintf("/mnt/media_rw/%s", stableName.c_str());
114 
115     mFuseDefault = StringPrintf("/mnt/runtime/default/%s", stableName.c_str());
116     mFuseRead = StringPrintf("/mnt/runtime/read/%s", stableName.c_str());
117     mFuseWrite = StringPrintf("/mnt/runtime/write/%s", stableName.c_str());
118 
119     setInternalPath(mRawPath);
120     if (getMountFlags() & MountFlags::kVisible) {
121         setPath(StringPrintf("/storage/%s", stableName.c_str()));
122     } else {
123         setPath(mRawPath);
124     }
125 
126     if (fs_prepare_dir(mRawPath.c_str(), 0700, AID_ROOT, AID_ROOT) ||
127             fs_prepare_dir(mFuseDefault.c_str(), 0700, AID_ROOT, AID_ROOT) ||
128             fs_prepare_dir(mFuseRead.c_str(), 0700, AID_ROOT, AID_ROOT) ||
129             fs_prepare_dir(mFuseWrite.c_str(), 0700, AID_ROOT, AID_ROOT)) {
130         PLOG(ERROR) << getId() << " failed to create mount points";
131         return -errno;
132     }
133 
134     if (vfat::Mount(mDevPath, mRawPath, false, false, false,
135             AID_MEDIA_RW, AID_MEDIA_RW, 0007, true)) {
136         PLOG(ERROR) << getId() << " failed to mount " << mDevPath;
137         return -EIO;
138     }
139 
140     if (getMountFlags() & MountFlags::kPrimary) {
141         initAsecStage();
142     }
143 
144     if (!(getMountFlags() & MountFlags::kVisible)) {
145         // Not visible to apps, so no need to spin up FUSE
146         return OK;
147     }
148 
149     dev_t before = GetDevice(mFuseWrite);
150 
151     if (!(mFusePid = fork())) {
152         if (getMountFlags() & MountFlags::kPrimary) {
153             if (execl(kFusePath, kFusePath,
154                     "-u", "1023", // AID_MEDIA_RW
155                     "-g", "1023", // AID_MEDIA_RW
156                     "-U", std::to_string(getMountUserId()).c_str(),
157                     "-w",
158                     mRawPath.c_str(),
159                     stableName.c_str(),
160                     NULL)) {
161                 PLOG(ERROR) << "Failed to exec";
162             }
163         } else {
164             if (execl(kFusePath, kFusePath,
165                     "-u", "1023", // AID_MEDIA_RW
166                     "-g", "1023", // AID_MEDIA_RW
167                     "-U", std::to_string(getMountUserId()).c_str(),
168                     mRawPath.c_str(),
169                     stableName.c_str(),
170                     NULL)) {
171                 PLOG(ERROR) << "Failed to exec";
172             }
173         }
174 
175         LOG(ERROR) << "FUSE exiting";
176         _exit(1);
177     }
178 
179     if (mFusePid == -1) {
180         PLOG(ERROR) << getId() << " failed to fork";
181         return -errno;
182     }
183 
184     while (before == GetDevice(mFuseWrite)) {
185         LOG(VERBOSE) << "Waiting for FUSE to spin up...";
186         usleep(50000); // 50ms
187     }
188 
189     return OK;
190 }
191 
doUnmount()192 status_t PublicVolume::doUnmount() {
193     if (mFusePid > 0) {
194         kill(mFusePid, SIGTERM);
195         TEMP_FAILURE_RETRY(waitpid(mFusePid, nullptr, 0));
196         mFusePid = 0;
197     }
198 
199     ForceUnmount(kAsecPath);
200 
201     ForceUnmount(mFuseDefault);
202     ForceUnmount(mFuseRead);
203     ForceUnmount(mFuseWrite);
204     ForceUnmount(mRawPath);
205 
206     rmdir(mFuseDefault.c_str());
207     rmdir(mFuseRead.c_str());
208     rmdir(mFuseWrite.c_str());
209     rmdir(mRawPath.c_str());
210 
211     mFuseDefault.clear();
212     mFuseRead.clear();
213     mFuseWrite.clear();
214     mRawPath.clear();
215 
216     return OK;
217 }
218 
doFormat(const std::string & fsType)219 status_t PublicVolume::doFormat(const std::string& fsType) {
220     if (fsType == "vfat" || fsType == "auto") {
221         if (WipeBlockDevice(mDevPath) != OK) {
222             LOG(WARNING) << getId() << " failed to wipe";
223         }
224         if (vfat::Format(mDevPath, 0)) {
225             LOG(ERROR) << getId() << " failed to format";
226             return -errno;
227         }
228     } else {
229         LOG(ERROR) << "Unsupported filesystem " << fsType;
230         return -EINVAL;
231     }
232 
233     return OK;
234 }
235 
236 }  // namespace vold
237 }  // namespace android
238