blob: 66e642f2bc84563544796de9eee4cdb4d966ae5e [file] [log] [blame]
Jeff Sharkeydeb24052015-03-02 21:01:40 -08001/*
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
Jeff Sharkeydeb24052015-03-02 21:01:40 -080017#include "Utils.h"
Paul Crowley56292ef2017-10-20 08:07:53 -070018
Jeff Sharkeydeb24052015-03-02 21:01:40 -080019#include "Process.h"
Paul Crowley56292ef2017-10-20 08:07:53 -070020#include "sehandle.h"
Jeff Sharkeydeb24052015-03-02 21:01:40 -080021
Paul Crowley298fa322018-10-30 15:59:24 -070022#include <android-base/chrono_utils.h>
Elliott Hughes7e128fb2015-12-04 15:50:53 -080023#include <android-base/file.h>
24#include <android-base/logging.h>
Tom Cherryd6127ef2017-06-15 17:13:56 -070025#include <android-base/properties.h>
Elliott Hughes7e128fb2015-12-04 15:50:53 -080026#include <android-base/stringprintf.h>
Paul Crowley14c8c072018-09-18 13:30:21 -070027#include <android-base/strings.h>
Sudheer Shanka40ab6742018-09-18 13:07:45 -070028#include <android-base/unique_fd.h>
Jeff Sharkeydeb24052015-03-02 21:01:40 -080029#include <cutils/fs.h>
Jeff Sharkey9c484982015-03-31 10:35:33 -070030#include <logwrap/logwrap.h>
Tom Cherryd6127ef2017-06-15 17:13:56 -070031#include <private/android_filesystem_config.h>
Martijn Coenenaee40512020-02-18 16:29:25 +010032#include <private/android_projectid_config.h>
Jeff Sharkeydeb24052015-03-02 21:01:40 -080033
Jeff Sharkey1d6fbcc2015-04-24 16:00:03 -070034#include <dirent.h>
Jeff Sharkeydeb24052015-03-02 21:01:40 -080035#include <fcntl.h>
36#include <linux/fs.h>
Martijn Coenen879fa802020-02-11 12:37:25 +010037#include <linux/posix_acl.h>
38#include <linux/posix_acl_xattr.h>
Sudheer Shanka89ddf992018-09-25 14:22:07 -070039#include <mntent.h>
40#include <stdio.h>
Jeff Sharkeydeb24052015-03-02 21:01:40 -080041#include <stdlib.h>
42#include <sys/mount.h>
Jeff Sharkeydeb24052015-03-02 21:01:40 -080043#include <sys/stat.h>
Jeff Sharkey1d6fbcc2015-04-24 16:00:03 -070044#include <sys/statvfs.h>
Paul Crowley14c8c072018-09-18 13:30:21 -070045#include <sys/sysmacros.h>
46#include <sys/types.h>
47#include <sys/wait.h>
Martijn Coenen879fa802020-02-11 12:37:25 +010048#include <sys/xattr.h>
Paul Crowley747b4212019-04-05 04:09:57 -070049#include <unistd.h>
Paul Crowley298fa322018-10-30 15:59:24 -070050
Martijn Coenen816f4d92020-02-18 15:06:37 +010051#include <filesystem>
Sudheer Shanka89ddf992018-09-25 14:22:07 -070052#include <list>
Paul Crowley14c8c072018-09-18 13:30:21 -070053#include <mutex>
Martijn Coenen04bb17f2020-02-10 23:48:11 +010054#include <regex>
Paul Crowley298fa322018-10-30 15:59:24 -070055#include <thread>
Jeff Sharkeydeb24052015-03-02 21:01:40 -080056
57#ifndef UMOUNT_NOFOLLOW
Paul Crowley14c8c072018-09-18 13:30:21 -070058#define UMOUNT_NOFOLLOW 0x00000008 /* Don't follow symlink on umount */
Jeff Sharkeydeb24052015-03-02 21:01:40 -080059#endif
60
Paul Crowley298fa322018-10-30 15:59:24 -070061using namespace std::chrono_literals;
Martijn Coenenba9868b2020-01-31 15:49:24 +010062using android::base::EndsWith;
Jeff Sharkeyd0640f62015-05-21 22:35:42 -070063using android::base::ReadFileToString;
Martijn Coenen13ff6682019-12-24 12:57:16 +010064using android::base::StartsWith;
Jeff Sharkey9c484982015-03-31 10:35:33 -070065using android::base::StringPrintf;
Nikita Ioffedcee5c12020-06-12 12:59:45 +010066using android::base::unique_fd;
Jeff Sharkey9c484982015-03-31 10:35:33 -070067
Jeff Sharkeydeb24052015-03-02 21:01:40 -080068namespace android {
69namespace vold {
70
ThiƩbaud Weksteenae8550f2021-09-10 10:51:08 +020071char* sBlkidContext = nullptr;
72char* sBlkidUntrustedContext = nullptr;
73char* sFsckContext = nullptr;
74char* sFsckUntrustedContext = nullptr;
Jeff Sharkey95c87cc2015-04-01 11:54:32 -070075
Paul Crowley56292ef2017-10-20 08:07:53 -070076bool sSleepOnUnmount = true;
77
Jeff Sharkey9c484982015-03-31 10:35:33 -070078static const char* kBlkidPath = "/system/bin/blkid";
Jeff Sharkeybc40cc82015-06-18 14:25:08 -070079static const char* kKeyPath = "/data/misc/vold";
Jeff Sharkey9c484982015-03-31 10:35:33 -070080
Alistair Delvaff1fc9b2020-05-14 16:35:03 -070081static const char* kProcDevices = "/proc/devices";
Jeff Sharkeyd0640f62015-05-21 22:35:42 -070082static const char* kProcFilesystems = "/proc/filesystems";
83
Martijn Coenen04bb17f2020-02-10 23:48:11 +010084static const char* kAndroidDir = "/Android/";
85static const char* kAppDataDir = "/Android/data/";
86static const char* kAppMediaDir = "/Android/media/";
87static const char* kAppObbDir = "/Android/obb/";
88
Ricky Wai07e64a42020-02-11 14:31:24 +000089static const char* kMediaProviderCtx = "u:r:mediaprovider:";
90static const char* kMediaProviderAppCtx = "u:r:mediaprovider_app:";
91
Jeff Sharkeyae4f85d2017-10-18 17:02:21 -060092// Lock used to protect process-level SELinux changes from racing with each
93// other between multiple threads.
94static std::mutex kSecurityLock;
95
Nikita Ioffedcee5c12020-06-12 12:59:45 +010096std::string GetFuseMountPathForUser(userid_t user_id, const std::string& relative_upper_path) {
97 return StringPrintf("/mnt/user/%d/%s", user_id, relative_upper_path.c_str());
98}
99
Jeff Sharkeydeb24052015-03-02 21:01:40 -0800100status_t CreateDeviceNode(const std::string& path, dev_t dev) {
Jeff Sharkeyae4f85d2017-10-18 17:02:21 -0600101 std::lock_guard<std::mutex> lock(kSecurityLock);
Jeff Sharkeydeb24052015-03-02 21:01:40 -0800102 const char* cpath = path.c_str();
103 status_t res = 0;
104
105 char* secontext = nullptr;
106 if (sehandle) {
107 if (!selabel_lookup(sehandle, &secontext, cpath, S_IFBLK)) {
108 setfscreatecon(secontext);
109 }
110 }
111
112 mode_t mode = 0660 | S_IFBLK;
113 if (mknod(cpath, mode, dev) < 0) {
114 if (errno != EEXIST) {
Paul Crowley14c8c072018-09-18 13:30:21 -0700115 PLOG(ERROR) << "Failed to create device node for " << major(dev) << ":" << minor(dev)
116 << " at " << path;
Jeff Sharkeydeb24052015-03-02 21:01:40 -0800117 res = -errno;
118 }
119 }
120
121 if (secontext) {
122 setfscreatecon(nullptr);
123 freecon(secontext);
124 }
125
126 return res;
127}
128
129status_t DestroyDeviceNode(const std::string& path) {
130 const char* cpath = path.c_str();
131 if (TEMP_FAILURE_RETRY(unlink(cpath))) {
132 return -errno;
133 } else {
134 return OK;
135 }
136}
137
Martijn Coenen442bb832020-02-18 13:44:59 +0100138// Sets a default ACL on the directory.
Martijn Coenen5adf92a2021-02-01 07:57:02 +0000139status_t SetDefaultAcl(const std::string& path, mode_t mode, uid_t uid, gid_t gid,
140 std::vector<gid_t> additionalGids) {
Daniel Rosenbergf36bddd2020-05-11 22:58:42 -0700141 if (IsSdcardfsUsed()) {
Martijn Coenen879fa802020-02-11 12:37:25 +0100142 // sdcardfs magically takes care of this
143 return OK;
144 }
145
Martijn Coenen1129b812020-06-16 14:58:52 +0200146 size_t num_entries = 3 + (additionalGids.size() > 0 ? additionalGids.size() + 1 : 0);
147 size_t size = sizeof(posix_acl_xattr_header) + num_entries * sizeof(posix_acl_xattr_entry);
Martijn Coenen879fa802020-02-11 12:37:25 +0100148 auto buf = std::make_unique<uint8_t[]>(size);
149
150 posix_acl_xattr_header* acl_header = reinterpret_cast<posix_acl_xattr_header*>(buf.get());
151 acl_header->a_version = POSIX_ACL_XATTR_VERSION;
152
153 posix_acl_xattr_entry* entry =
154 reinterpret_cast<posix_acl_xattr_entry*>(buf.get() + sizeof(posix_acl_xattr_header));
155
Martijn Coenen1129b812020-06-16 14:58:52 +0200156 int tag_index = 0;
157
158 entry[tag_index].e_tag = ACL_USER_OBJ;
Martijn Coenen442bb832020-02-18 13:44:59 +0100159 // The existing mode_t mask has the ACL in the lower 9 bits:
160 // the lowest 3 for "other", the next 3 the group, the next 3 for the owner
161 // Use the mode_t masks to get these bits out, and shift them to get the
162 // correct value per entity.
163 //
164 // Eg if mode_t = 0700, rwx for the owner, then & S_IRWXU >> 6 results in 7
Martijn Coenen1129b812020-06-16 14:58:52 +0200165 entry[tag_index].e_perm = (mode & S_IRWXU) >> 6;
166 entry[tag_index].e_id = uid;
167 tag_index++;
Martijn Coenen879fa802020-02-11 12:37:25 +0100168
Martijn Coenen1129b812020-06-16 14:58:52 +0200169 entry[tag_index].e_tag = ACL_GROUP_OBJ;
170 entry[tag_index].e_perm = (mode & S_IRWXG) >> 3;
171 entry[tag_index].e_id = gid;
172 tag_index++;
Martijn Coenen879fa802020-02-11 12:37:25 +0100173
Martijn Coenen1129b812020-06-16 14:58:52 +0200174 if (additionalGids.size() > 0) {
175 for (gid_t additional_gid : additionalGids) {
176 entry[tag_index].e_tag = ACL_GROUP;
177 entry[tag_index].e_perm = (mode & S_IRWXG) >> 3;
178 entry[tag_index].e_id = additional_gid;
179 tag_index++;
180 }
181
182 entry[tag_index].e_tag = ACL_MASK;
183 entry[tag_index].e_perm = (mode & S_IRWXG) >> 3;
184 entry[tag_index].e_id = 0;
185 tag_index++;
186 }
187
188 entry[tag_index].e_tag = ACL_OTHER;
189 entry[tag_index].e_perm = mode & S_IRWXO;
190 entry[tag_index].e_id = 0;
Martijn Coenen879fa802020-02-11 12:37:25 +0100191
192 int ret = setxattr(path.c_str(), XATTR_NAME_POSIX_ACL_DEFAULT, acl_header, size, 0);
193
194 if (ret != 0) {
195 PLOG(ERROR) << "Failed to set default ACL on " << path;
196 }
197
198 return ret;
199}
200
Martijn Coenen5fe1b162020-02-06 18:57:47 +0100201int SetQuotaInherit(const std::string& path) {
Eric Biggersf9d9ac22020-10-23 16:32:58 -0700202 unsigned int flags;
Martijn Coenen5fe1b162020-02-06 18:57:47 +0100203
204 android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(path.c_str(), O_RDONLY | O_CLOEXEC)));
205 if (fd == -1) {
206 PLOG(ERROR) << "Failed to open " << path << " to set project id inheritance.";
207 return -1;
208 }
209
210 int ret = ioctl(fd, FS_IOC_GETFLAGS, &flags);
211 if (ret == -1) {
212 PLOG(ERROR) << "Failed to get flags for " << path << " to set project id inheritance.";
213 return ret;
214 }
215
216 flags |= FS_PROJINHERIT_FL;
217
218 ret = ioctl(fd, FS_IOC_SETFLAGS, &flags);
219 if (ret == -1) {
220 PLOG(ERROR) << "Failed to set flags for " << path << " to set project id inheritance.";
221 return ret;
222 }
223
224 return 0;
225}
226
227int SetQuotaProjectId(const std::string& path, long projectId) {
Martijn Coenenfb42bc42020-01-16 01:25:27 +0100228 struct fsxattr fsx;
229
230 android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(path.c_str(), O_RDONLY | O_CLOEXEC)));
231 if (fd == -1) {
232 PLOG(ERROR) << "Failed to open " << path << " to set project id.";
233 return -1;
234 }
235
236 int ret = ioctl(fd, FS_IOC_FSGETXATTR, &fsx);
237 if (ret == -1) {
238 PLOG(ERROR) << "Failed to get extended attributes for " << path << " to get project id.";
239 return ret;
240 }
241
242 fsx.fsx_projid = projectId;
Eric Biggers39aa9582021-05-03 12:29:40 -0700243 ret = ioctl(fd, FS_IOC_FSSETXATTR, &fsx);
244 if (ret == -1) {
245 PLOG(ERROR) << "Failed to set project id on " << path;
246 return ret;
247 }
248 return 0;
Martijn Coenenfb42bc42020-01-16 01:25:27 +0100249}
250
Martijn Coenen04bb17f2020-02-10 23:48:11 +0100251int PrepareDirWithProjectId(const std::string& path, mode_t mode, uid_t uid, gid_t gid,
252 long projectId) {
253 int ret = fs_prepare_dir(path.c_str(), mode, uid, gid);
254
255 if (ret != 0) {
256 return ret;
Martijn Coenen13ff6682019-12-24 12:57:16 +0100257 }
Martijn Coenenba9868b2020-01-31 15:49:24 +0100258
Daniel Rosenbergf36bddd2020-05-11 22:58:42 -0700259 if (!IsSdcardfsUsed()) {
Martijn Coenen04bb17f2020-02-10 23:48:11 +0100260 ret = SetQuotaProjectId(path, projectId);
Martijn Coenen13ff6682019-12-24 12:57:16 +0100261 }
262
263 return ret;
264}
265
Martijn Coenen816f4d92020-02-18 15:06:37 +0100266static int FixupAppDir(const std::string& path, mode_t mode, uid_t uid, gid_t gid, long projectId) {
267 namespace fs = std::filesystem;
268
269 // Setup the directory itself correctly
270 int ret = PrepareDirWithProjectId(path, mode, uid, gid, projectId);
271 if (ret != OK) {
272 return ret;
273 }
274
275 // Fixup all of its file entries
276 for (const auto& itEntry : fs::directory_iterator(path)) {
277 ret = lchown(itEntry.path().c_str(), uid, gid);
278 if (ret != 0) {
279 return ret;
280 }
281
282 ret = chmod(itEntry.path().c_str(), mode);
283 if (ret != 0) {
284 return ret;
285 }
286
Daniel Rosenbergf36bddd2020-05-11 22:58:42 -0700287 if (!IsSdcardfsUsed()) {
Martijn Coenen816f4d92020-02-18 15:06:37 +0100288 ret = SetQuotaProjectId(itEntry.path(), projectId);
289 if (ret != 0) {
290 return ret;
291 }
292 }
293 }
294
295 return OK;
296}
297
298int PrepareAppDirFromRoot(const std::string& path, const std::string& root, int appUid,
299 bool fixupExisting) {
Martijn Coenenb5a31c92020-02-13 23:30:38 +0100300 long projectId;
301 size_t pos;
302 int ret = 0;
Daniel Rosenbergf36bddd2020-05-11 22:58:42 -0700303 bool sdcardfsSupport = IsSdcardfsUsed();
Martijn Coenenb5a31c92020-02-13 23:30:38 +0100304
305 // Make sure the Android/ directories exist and are setup correctly
306 ret = PrepareAndroidDirs(root);
307 if (ret != 0) {
308 LOG(ERROR) << "Failed to prepare Android/ directories.";
309 return ret;
Martijn Coenen04bb17f2020-02-10 23:48:11 +0100310 }
311
Martijn Coenenb5a31c92020-02-13 23:30:38 +0100312 // Now create the application-specific subdir(s)
313 // path is something like /data/media/0/Android/data/com.foo/files
314 // First, chop off the volume root, eg /data/media/0
315 std::string pathFromRoot = path.substr(root.length());
Martijn Coenen04bb17f2020-02-10 23:48:11 +0100316
Martijn Coenenb5a31c92020-02-13 23:30:38 +0100317 uid_t uid = appUid;
318 gid_t gid = AID_MEDIA_RW;
Martijn Coenen1129b812020-06-16 14:58:52 +0200319 std::vector<gid_t> additionalGids;
Martijn Coenenb5a31c92020-02-13 23:30:38 +0100320 std::string appDir;
Martijn Coenen04bb17f2020-02-10 23:48:11 +0100321
Martijn Coenenb5a31c92020-02-13 23:30:38 +0100322 // Check that the next part matches one of the allowed Android/ dirs
323 if (StartsWith(pathFromRoot, kAppDataDir)) {
324 appDir = kAppDataDir;
Daniel Rosenbergf36bddd2020-05-11 22:58:42 -0700325 if (!sdcardfsSupport) {
Martijn Coenenb5a31c92020-02-13 23:30:38 +0100326 gid = AID_EXT_DATA_RW;
Martijn Coenen1129b812020-06-16 14:58:52 +0200327 // Also add the app's own UID as a group; since apps belong to a group
328 // that matches their UID, this ensures that they will always have access to
329 // the files created in these dirs, even if they are created by other processes
330 additionalGids.push_back(uid);
Martijn Coenenb5a31c92020-02-13 23:30:38 +0100331 }
332 } else if (StartsWith(pathFromRoot, kAppMediaDir)) {
333 appDir = kAppMediaDir;
Daniel Rosenbergf36bddd2020-05-11 22:58:42 -0700334 if (!sdcardfsSupport) {
Martijn Coenenb5a31c92020-02-13 23:30:38 +0100335 gid = AID_MEDIA_RW;
336 }
Ricky Waie50ddb72020-02-17 18:57:01 +0000337 } else if (StartsWith(pathFromRoot, kAppObbDir)) {
Martijn Coenenb5a31c92020-02-13 23:30:38 +0100338 appDir = kAppObbDir;
Daniel Rosenbergf36bddd2020-05-11 22:58:42 -0700339 if (!sdcardfsSupport) {
Martijn Coenenb5a31c92020-02-13 23:30:38 +0100340 gid = AID_EXT_OBB_RW;
Martijn Coenen1129b812020-06-16 14:58:52 +0200341 // See comments for kAppDataDir above
342 additionalGids.push_back(uid);
Martijn Coenenb5a31c92020-02-13 23:30:38 +0100343 }
344 } else {
Martijn Coenen04bb17f2020-02-10 23:48:11 +0100345 LOG(ERROR) << "Invalid application directory: " << path;
346 return -EINVAL;
347 }
348
Martijn Coenen04bb17f2020-02-10 23:48:11 +0100349 // mode = 770, plus sticky bit on directory to inherit GID when apps
350 // create subdirs
351 mode_t mode = S_IRWXU | S_IRWXG | S_ISGID;
Martijn Coenenb5a31c92020-02-13 23:30:38 +0100352 // the project ID for application-specific directories is directly
353 // derived from their uid
Martijn Coenen04bb17f2020-02-10 23:48:11 +0100354
Martijn Coenenb5a31c92020-02-13 23:30:38 +0100355 // Chop off the generic application-specific part, eg /Android/data/
356 // this leaves us with something like com.foo/files/
357 std::string leftToCreate = pathFromRoot.substr(appDir.length());
358 if (!EndsWith(leftToCreate, "/")) {
359 leftToCreate += "/";
360 }
361 std::string pathToCreate = root + appDir;
362 int depth = 0;
Martijn Coenenaee40512020-02-18 16:29:25 +0100363 // Derive initial project ID
364 if (appDir == kAppDataDir || appDir == kAppMediaDir) {
365 projectId = uid - AID_APP_START + PROJECT_ID_EXT_DATA_START;
366 } else if (appDir == kAppObbDir) {
367 projectId = uid - AID_APP_START + PROJECT_ID_EXT_OBB_START;
368 }
369
Martijn Coenenb5a31c92020-02-13 23:30:38 +0100370 while ((pos = leftToCreate.find('/')) != std::string::npos) {
371 std::string component = leftToCreate.substr(0, pos + 1);
372 leftToCreate = leftToCreate.erase(0, pos + 1);
373 pathToCreate = pathToCreate + component;
374
375 if (appDir == kAppDataDir && depth == 1 && component == "cache/") {
376 // All dirs use the "app" project ID, except for the cache dirs in
377 // Android/data, eg Android/data/com.foo/cache
378 // Note that this "sticks" - eg subdirs of this dir need the same
379 // project ID.
Martijn Coenenaee40512020-02-18 16:29:25 +0100380 projectId = uid - AID_APP_START + PROJECT_ID_EXT_CACHE_START;
Martijn Coenenb5a31c92020-02-13 23:30:38 +0100381 }
Martijn Coenen816f4d92020-02-18 15:06:37 +0100382
383 if (fixupExisting && access(pathToCreate.c_str(), F_OK) == 0) {
384 // Fixup all files in this existing directory with the correct UID/GID
385 // and project ID.
386 ret = FixupAppDir(pathToCreate, mode, uid, gid, projectId);
387 } else {
388 ret = PrepareDirWithProjectId(pathToCreate, mode, uid, gid, projectId);
389 }
390
Martijn Coenenb5a31c92020-02-13 23:30:38 +0100391 if (ret != 0) {
392 return ret;
393 }
394
395 if (depth == 0) {
396 // Set the default ACL on the top-level application-specific directories,
397 // to ensure that even if applications run with a umask of 0077,
398 // new directories within these directories will allow the GID
399 // specified here to write; this is necessary for apps like
400 // installers and MTP, that require access here.
401 //
402 // See man (5) acl for more details.
Martijn Coenen1129b812020-06-16 14:58:52 +0200403 ret = SetDefaultAcl(pathToCreate, mode, uid, gid, additionalGids);
Martijn Coenenb5a31c92020-02-13 23:30:38 +0100404 if (ret != 0) {
405 return ret;
406 }
Martijn Coenen9171fcc2020-03-11 11:51:45 +0100407
Daniel Rosenbergf36bddd2020-05-11 22:58:42 -0700408 if (!sdcardfsSupport) {
Martijn Coenen9171fcc2020-03-11 11:51:45 +0100409 // Set project ID inheritance, so that future subdirectories inherit the
410 // same project ID
411 ret = SetQuotaInherit(pathToCreate);
412 if (ret != 0) {
413 return ret;
414 }
415 }
Martijn Coenenb5a31c92020-02-13 23:30:38 +0100416 }
417
418 depth++;
Martijn Coenen04bb17f2020-02-10 23:48:11 +0100419 }
420
Martijn Coenenb5a31c92020-02-13 23:30:38 +0100421 return OK;
Martijn Coenen04bb17f2020-02-10 23:48:11 +0100422}
423
Daniel Rosenbergcc874802020-08-12 18:31:43 -0700424int SetAttrs(const std::string& path, unsigned int attrs) {
Eric Biggersf9d9ac22020-10-23 16:32:58 -0700425 unsigned int flags;
Daniel Rosenbergcc874802020-08-12 18:31:43 -0700426 android::base::unique_fd fd(
427 TEMP_FAILURE_RETRY(open(path.c_str(), O_RDONLY | O_NONBLOCK | O_CLOEXEC)));
428
429 if (fd == -1) {
430 PLOG(ERROR) << "Failed to open " << path;
431 return -1;
432 }
433
Eric Biggersf9d9ac22020-10-23 16:32:58 -0700434 if (ioctl(fd, FS_IOC_GETFLAGS, &flags)) {
Daniel Rosenbergcc874802020-08-12 18:31:43 -0700435 PLOG(ERROR) << "Failed to get flags for " << path;
436 return -1;
437 }
438
439 if ((flags & attrs) == attrs) return 0;
440 flags |= attrs;
Eric Biggersf9d9ac22020-10-23 16:32:58 -0700441 if (ioctl(fd, FS_IOC_SETFLAGS, &flags)) {
Daniel Rosenbergcc874802020-08-12 18:31:43 -0700442 PLOG(ERROR) << "Failed to set flags for " << path << "(0x" << std::hex << attrs << ")";
443 return -1;
444 }
445 return 0;
446}
447
448status_t PrepareDir(const std::string& path, mode_t mode, uid_t uid, gid_t gid,
449 unsigned int attrs) {
Jeff Sharkeyae4f85d2017-10-18 17:02:21 -0600450 std::lock_guard<std::mutex> lock(kSecurityLock);
Jeff Sharkeyf0121c52015-04-06 14:08:45 -0700451 const char* cpath = path.c_str();
452
453 char* secontext = nullptr;
454 if (sehandle) {
455 if (!selabel_lookup(sehandle, &secontext, cpath, S_IFDIR)) {
456 setfscreatecon(secontext);
457 }
458 }
459
460 int res = fs_prepare_dir(cpath, mode, uid, gid);
461
462 if (secontext) {
463 setfscreatecon(nullptr);
464 freecon(secontext);
465 }
466
Daniel Rosenbergcc874802020-08-12 18:31:43 -0700467 if (res) return -errno;
468 if (attrs) res = SetAttrs(path, attrs);
469
Jeff Sharkeyf0121c52015-04-06 14:08:45 -0700470 if (res == 0) {
471 return OK;
472 } else {
473 return -errno;
474 }
475}
476
Jeff Sharkeydeb24052015-03-02 21:01:40 -0800477status_t ForceUnmount(const std::string& path) {
478 const char* cpath = path.c_str();
479 if (!umount2(cpath, UMOUNT_NOFOLLOW) || errno == EINVAL || errno == ENOENT) {
480 return OK;
481 }
Jeff Sharkey89f74fb2015-10-21 12:16:12 -0700482 // Apps might still be handling eject request, so wait before
483 // we start sending signals
Paul Crowley56292ef2017-10-20 08:07:53 -0700484 if (sSleepOnUnmount) sleep(5);
Jeff Sharkey89f74fb2015-10-21 12:16:12 -0700485
Jeff Sharkey3472e522017-10-06 18:02:53 -0600486 KillProcessesWithOpenFiles(path, SIGINT);
Paul Crowley56292ef2017-10-20 08:07:53 -0700487 if (sSleepOnUnmount) sleep(5);
Jeff Sharkeyce6a9132015-04-08 21:07:21 -0700488 if (!umount2(cpath, UMOUNT_NOFOLLOW) || errno == EINVAL || errno == ENOENT) {
489 return OK;
490 }
Jeff Sharkeyce6a9132015-04-08 21:07:21 -0700491
Jeff Sharkey3472e522017-10-06 18:02:53 -0600492 KillProcessesWithOpenFiles(path, SIGTERM);
Paul Crowley56292ef2017-10-20 08:07:53 -0700493 if (sSleepOnUnmount) sleep(5);
Jeff Sharkeydeb24052015-03-02 21:01:40 -0800494 if (!umount2(cpath, UMOUNT_NOFOLLOW) || errno == EINVAL || errno == ENOENT) {
495 return OK;
496 }
Jeff Sharkey89f74fb2015-10-21 12:16:12 -0700497
Jeff Sharkey3472e522017-10-06 18:02:53 -0600498 KillProcessesWithOpenFiles(path, SIGKILL);
Paul Crowley56292ef2017-10-20 08:07:53 -0700499 if (sSleepOnUnmount) sleep(5);
Jeff Sharkey89f74fb2015-10-21 12:16:12 -0700500 if (!umount2(cpath, UMOUNT_NOFOLLOW) || errno == EINVAL || errno == ENOENT) {
501 return OK;
502 }
Zim3623a212019-07-19 16:46:53 +0100503 PLOG(INFO) << "ForceUnmount failed";
Jeff Sharkeydeb24052015-03-02 21:01:40 -0800504 return -errno;
505}
506
Ricky Wai23356372021-04-30 09:53:07 +0100507status_t KillProcessesWithTmpfsMountPrefix(const std::string& path) {
508 if (KillProcessesWithTmpfsMounts(path, SIGINT) == 0) {
Ricky Wai07e64a42020-02-11 14:31:24 +0000509 return OK;
510 }
511 if (sSleepOnUnmount) sleep(5);
512
Ricky Wai23356372021-04-30 09:53:07 +0100513 if (KillProcessesWithTmpfsMounts(path, SIGTERM) == 0) {
Ricky Wai07e64a42020-02-11 14:31:24 +0000514 return OK;
515 }
516 if (sSleepOnUnmount) sleep(5);
517
Ricky Wai23356372021-04-30 09:53:07 +0100518 if (KillProcessesWithTmpfsMounts(path, SIGKILL) == 0) {
Ricky Wai07e64a42020-02-11 14:31:24 +0000519 return OK;
520 }
521 if (sSleepOnUnmount) sleep(5);
522
523 // Send SIGKILL a second time to determine if we've
524 // actually killed everyone mount
Ricky Wai23356372021-04-30 09:53:07 +0100525 if (KillProcessesWithTmpfsMounts(path, SIGKILL) == 0) {
Ricky Wai07e64a42020-02-11 14:31:24 +0000526 return OK;
527 }
528 PLOG(ERROR) << "Failed to kill processes using " << path;
529 return -EBUSY;
530}
531
Jeff Sharkey89f74fb2015-10-21 12:16:12 -0700532status_t KillProcessesUsingPath(const std::string& path) {
Zim75273002021-03-04 12:21:24 +0000533 if (KillProcessesWithOpenFiles(path, SIGINT, false /* killFuseDaemon */) == 0) {
Jeff Sharkey89f74fb2015-10-21 12:16:12 -0700534 return OK;
535 }
Paul Crowley56292ef2017-10-20 08:07:53 -0700536 if (sSleepOnUnmount) sleep(5);
Jeff Sharkey89f74fb2015-10-21 12:16:12 -0700537
Zim75273002021-03-04 12:21:24 +0000538 if (KillProcessesWithOpenFiles(path, SIGTERM, false /* killFuseDaemon */) == 0) {
Jeff Sharkey89f74fb2015-10-21 12:16:12 -0700539 return OK;
540 }
Paul Crowley56292ef2017-10-20 08:07:53 -0700541 if (sSleepOnUnmount) sleep(5);
Jeff Sharkey89f74fb2015-10-21 12:16:12 -0700542
Zim75273002021-03-04 12:21:24 +0000543 if (KillProcessesWithOpenFiles(path, SIGKILL, false /* killFuseDaemon */) == 0) {
Jeff Sharkey89f74fb2015-10-21 12:16:12 -0700544 return OK;
545 }
Paul Crowley56292ef2017-10-20 08:07:53 -0700546 if (sSleepOnUnmount) sleep(5);
Jeff Sharkey89f74fb2015-10-21 12:16:12 -0700547
548 // Send SIGKILL a second time to determine if we've
549 // actually killed everyone with open files
Zim75273002021-03-04 12:21:24 +0000550 // This time, we also kill the FUSE daemon if found
551 if (KillProcessesWithOpenFiles(path, SIGKILL, true /* killFuseDaemon */) == 0) {
Jeff Sharkey89f74fb2015-10-21 12:16:12 -0700552 return OK;
553 }
554 PLOG(ERROR) << "Failed to kill processes using " << path;
555 return -EBUSY;
556}
557
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700558status_t BindMount(const std::string& source, const std::string& target) {
Sudheer Shanka023b5392019-02-06 12:39:19 -0800559 if (UnmountTree(target) < 0) {
560 return -errno;
561 }
562 if (TEMP_FAILURE_RETRY(mount(source.c_str(), target.c_str(), nullptr, MS_BIND, nullptr)) < 0) {
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700563 PLOG(ERROR) << "Failed to bind mount " << source << " to " << target;
564 return -errno;
565 }
566 return OK;
567}
568
Sudheer Shanka023b5392019-02-06 12:39:19 -0800569status_t Symlink(const std::string& target, const std::string& linkpath) {
570 if (Unlink(linkpath) < 0) {
571 return -errno;
572 }
573 if (TEMP_FAILURE_RETRY(symlink(target.c_str(), linkpath.c_str())) < 0) {
574 PLOG(ERROR) << "Failed to create symlink " << linkpath << " to " << target;
575 return -errno;
576 }
577 return OK;
578}
579
580status_t Unlink(const std::string& linkpath) {
581 if (TEMP_FAILURE_RETRY(unlink(linkpath.c_str())) < 0 && errno != EINVAL && errno != ENOENT) {
582 PLOG(ERROR) << "Failed to unlink " << linkpath;
583 return -errno;
584 }
585 return OK;
586}
587
Sudheer Shankaf9b38a52019-02-14 19:09:51 +0000588status_t CreateDir(const std::string& dir, mode_t mode) {
589 struct stat sb;
590 if (TEMP_FAILURE_RETRY(stat(dir.c_str(), &sb)) == 0) {
591 if (S_ISDIR(sb.st_mode)) {
592 return OK;
593 } else if (TEMP_FAILURE_RETRY(unlink(dir.c_str())) == -1) {
594 PLOG(ERROR) << "Failed to unlink " << dir;
595 return -errno;
596 }
597 } else if (errno != ENOENT) {
598 PLOG(ERROR) << "Failed to stat " << dir;
599 return -errno;
600 }
Sudheer Shanka6d285ce2019-02-19 14:12:20 -0800601 if (TEMP_FAILURE_RETRY(mkdir(dir.c_str(), mode)) == -1 && errno != EEXIST) {
Sudheer Shankaf9b38a52019-02-14 19:09:51 +0000602 PLOG(ERROR) << "Failed to mkdir " << dir;
603 return -errno;
604 }
605 return OK;
606}
607
Jeff Sharkey3472e522017-10-06 18:02:53 -0600608bool FindValue(const std::string& raw, const std::string& key, std::string* value) {
609 auto qual = key + "=\"";
Paul Crowley95abfa02019-02-05 15:33:34 -0800610 size_t start = 0;
611 while (true) {
612 start = raw.find(qual, start);
613 if (start == std::string::npos) return false;
614 if (start == 0 || raw[start - 1] == ' ') {
615 break;
616 }
617 start += 1;
Jeff Sharkey3472e522017-10-06 18:02:53 -0600618 }
Jeff Sharkey3472e522017-10-06 18:02:53 -0600619 start += qual.length();
620
621 auto end = raw.find("\"", start);
622 if (end == std::string::npos) return false;
623
624 *value = raw.substr(start, end - start);
625 return true;
626}
627
Paul Crowley14c8c072018-09-18 13:30:21 -0700628static status_t readMetadata(const std::string& path, std::string* fsType, std::string* fsUuid,
629 std::string* fsLabel, bool untrusted) {
Jeff Sharkey3472e522017-10-06 18:02:53 -0600630 fsType->clear();
631 fsUuid->clear();
632 fsLabel->clear();
Jeff Sharkey9c484982015-03-31 10:35:33 -0700633
Jeff Sharkeyce6a9132015-04-08 21:07:21 -0700634 std::vector<std::string> cmd;
635 cmd.push_back(kBlkidPath);
636 cmd.push_back("-c");
637 cmd.push_back("/dev/null");
Jeff Sharkeyeddf9bd2015-08-12 16:04:35 -0700638 cmd.push_back("-s");
639 cmd.push_back("TYPE");
640 cmd.push_back("-s");
641 cmd.push_back("UUID");
642 cmd.push_back("-s");
643 cmd.push_back("LABEL");
Jeff Sharkeyce6a9132015-04-08 21:07:21 -0700644 cmd.push_back(path);
645
646 std::vector<std::string> output;
Paul Crowleyde2d6202018-11-30 11:43:47 -0800647 status_t res = ForkExecvp(cmd, &output, untrusted ? sBlkidUntrustedContext : sBlkidContext);
Jeff Sharkeyce6a9132015-04-08 21:07:21 -0700648 if (res != OK) {
649 LOG(WARNING) << "blkid failed to identify " << path;
650 return res;
Jeff Sharkey9c484982015-03-31 10:35:33 -0700651 }
652
Chih-Hung Hsieh11a2ce82016-07-27 14:11:02 -0700653 for (const auto& line : output) {
Jeff Sharkey9c484982015-03-31 10:35:33 -0700654 // Extract values from blkid output, if defined
Jeff Sharkey3472e522017-10-06 18:02:53 -0600655 FindValue(line, "TYPE", fsType);
656 FindValue(line, "UUID", fsUuid);
657 FindValue(line, "LABEL", fsLabel);
Jeff Sharkey9c484982015-03-31 10:35:33 -0700658 }
659
Jeff Sharkeyce6a9132015-04-08 21:07:21 -0700660 return OK;
Jeff Sharkey9c484982015-03-31 10:35:33 -0700661}
662
Paul Crowley14c8c072018-09-18 13:30:21 -0700663status_t ReadMetadata(const std::string& path, std::string* fsType, std::string* fsUuid,
664 std::string* fsLabel) {
Jeff Sharkey95c87cc2015-04-01 11:54:32 -0700665 return readMetadata(path, fsType, fsUuid, fsLabel, false);
666}
667
Paul Crowley14c8c072018-09-18 13:30:21 -0700668status_t ReadMetadataUntrusted(const std::string& path, std::string* fsType, std::string* fsUuid,
669 std::string* fsLabel) {
Jeff Sharkey95c87cc2015-04-01 11:54:32 -0700670 return readMetadata(path, fsType, fsUuid, fsLabel, true);
671}
672
Paul Crowleyde2d6202018-11-30 11:43:47 -0800673static std::vector<const char*> ConvertToArgv(const std::vector<std::string>& args) {
674 std::vector<const char*> argv;
675 argv.reserve(args.size() + 1);
676 for (const auto& arg : args) {
677 if (argv.empty()) {
678 LOG(DEBUG) << arg;
Jeff Sharkey9c484982015-03-31 10:35:33 -0700679 } else {
Paul Crowleyde2d6202018-11-30 11:43:47 -0800680 LOG(DEBUG) << " " << arg;
Jeff Sharkey9c484982015-03-31 10:35:33 -0700681 }
Paul Crowleyde2d6202018-11-30 11:43:47 -0800682 argv.emplace_back(arg.data());
Jeff Sharkey9c484982015-03-31 10:35:33 -0700683 }
Paul Crowleyde2d6202018-11-30 11:43:47 -0800684 argv.emplace_back(nullptr);
685 return argv;
Jeff Sharkey9c484982015-03-31 10:35:33 -0700686}
687
Paul Crowleyde2d6202018-11-30 11:43:47 -0800688static status_t ReadLinesFromFdAndLog(std::vector<std::string>* output,
689 android::base::unique_fd ufd) {
690 std::unique_ptr<FILE, int (*)(FILE*)> fp(android::base::Fdopen(std::move(ufd), "r"), fclose);
Jeff Sharkeyce6a9132015-04-08 21:07:21 -0700691 if (!fp) {
Paul Crowleyde2d6202018-11-30 11:43:47 -0800692 PLOG(ERROR) << "fdopen in ReadLinesFromFdAndLog";
Jeff Sharkeyce6a9132015-04-08 21:07:21 -0700693 return -errno;
694 }
Paul Crowleyde2d6202018-11-30 11:43:47 -0800695 if (output) output->clear();
Jeff Sharkeyce6a9132015-04-08 21:07:21 -0700696 char line[1024];
Paul Crowleyde2d6202018-11-30 11:43:47 -0800697 while (fgets(line, sizeof(line), fp.get()) != nullptr) {
Sudheer Shanka4b6ca4e2018-09-21 10:54:54 -0700698 LOG(DEBUG) << line;
Paul Crowleyde2d6202018-11-30 11:43:47 -0800699 if (output) output->emplace_back(line);
Jeff Sharkeyce6a9132015-04-08 21:07:21 -0700700 }
Paul Crowleyde2d6202018-11-30 11:43:47 -0800701 return OK;
702}
703
704status_t ForkExecvp(const std::vector<std::string>& args, std::vector<std::string>* output,
ThiƩbaud Weksteenae8550f2021-09-10 10:51:08 +0200705 char* context) {
Paul Crowleyde2d6202018-11-30 11:43:47 -0800706 auto argv = ConvertToArgv(args);
707
Paul Crowleye6d76632018-11-30 11:43:47 -0800708 android::base::unique_fd pipe_read, pipe_write;
709 if (!android::base::Pipe(&pipe_read, &pipe_write)) {
710 PLOG(ERROR) << "Pipe in ForkExecvp";
Paul Crowleyde2d6202018-11-30 11:43:47 -0800711 return -errno;
712 }
Paul Crowleyde2d6202018-11-30 11:43:47 -0800713
714 pid_t pid = fork();
715 if (pid == 0) {
716 if (context) {
717 if (setexeccon(context)) {
Paul Crowleye6d76632018-11-30 11:43:47 -0800718 LOG(ERROR) << "Failed to setexeccon in ForkExecvp";
Paul Crowleyde2d6202018-11-30 11:43:47 -0800719 abort();
720 }
721 }
722 pipe_read.reset();
Paul Crowleybe857bf2018-12-07 12:23:25 -0800723 if (dup2(pipe_write.get(), STDOUT_FILENO) == -1) {
724 PLOG(ERROR) << "dup2 in ForkExecvp";
725 _exit(EXIT_FAILURE);
726 }
Paul Crowleye6d76632018-11-30 11:43:47 -0800727 pipe_write.reset();
Paul Crowleyde2d6202018-11-30 11:43:47 -0800728 execvp(argv[0], const_cast<char**>(argv.data()));
Paul Crowleye6d76632018-11-30 11:43:47 -0800729 PLOG(ERROR) << "exec in ForkExecvp";
Paul Crowleyde2d6202018-11-30 11:43:47 -0800730 _exit(EXIT_FAILURE);
731 }
732 if (pid == -1) {
733 PLOG(ERROR) << "fork in ForkExecvp";
Jeff Sharkeyce6a9132015-04-08 21:07:21 -0700734 return -errno;
735 }
736
Paul Crowleyde2d6202018-11-30 11:43:47 -0800737 pipe_write.reset();
738 auto st = ReadLinesFromFdAndLog(output, std::move(pipe_read));
739 if (st != 0) return st;
740
741 int status;
742 if (waitpid(pid, &status, 0) == -1) {
743 PLOG(ERROR) << "waitpid in ForkExecvp";
744 return -errno;
745 }
746 if (!WIFEXITED(status)) {
747 LOG(ERROR) << "Process did not exit normally, status: " << status;
748 return -ECHILD;
749 }
750 if (WEXITSTATUS(status)) {
751 LOG(ERROR) << "Process exited with code: " << WEXITSTATUS(status);
752 return WEXITSTATUS(status);
753 }
Jeff Sharkeyce6a9132015-04-08 21:07:21 -0700754 return OK;
755}
756
Daniel Rosenbergd9261b12021-09-14 17:32:06 -0700757status_t ForkExecvpTimeout(const std::vector<std::string>& args, std::chrono::seconds timeout,
758 char* context) {
759 int status;
760
761 pid_t wait_timeout_pid = fork();
762 if (wait_timeout_pid == 0) {
763 pid_t pid = ForkExecvpAsync(args, context);
764 if (pid == -1) {
765 _exit(EXIT_FAILURE);
766 }
767 pid_t timer_pid = fork();
768 if (timer_pid == 0) {
769 sleep(timeout.count());
770 _exit(ETIMEDOUT);
771 }
772 if (timer_pid == -1) {
773 PLOG(ERROR) << "fork in ForkExecvpAsync_timeout";
774 kill(pid, SIGTERM);
775 _exit(EXIT_FAILURE);
776 }
777 pid_t finished = wait(&status);
778 if (finished == pid) {
779 kill(timer_pid, SIGTERM);
780 } else {
781 kill(pid, SIGTERM);
782 }
783 if (!WIFEXITED(status)) {
784 _exit(ECHILD);
785 }
786 _exit(WEXITSTATUS(status));
787 }
788 if (waitpid(wait_timeout_pid, &status, 0) == -1) {
789 PLOG(ERROR) << "waitpid in ForkExecvpAsync_timeout";
790 return -errno;
791 }
792 if (!WIFEXITED(status)) {
793 LOG(ERROR) << "Process did not exit normally, status: " << status;
794 return -ECHILD;
795 }
796 if (WEXITSTATUS(status)) {
797 LOG(ERROR) << "Process exited with code: " << WEXITSTATUS(status);
798 return WEXITSTATUS(status);
799 }
800 return OK;
801}
802
803pid_t ForkExecvpAsync(const std::vector<std::string>& args, char* context) {
Paul Crowleyde2d6202018-11-30 11:43:47 -0800804 auto argv = ConvertToArgv(args);
Jeff Sharkey1d6fbcc2015-04-24 16:00:03 -0700805
806 pid_t pid = fork();
807 if (pid == 0) {
808 close(STDIN_FILENO);
809 close(STDOUT_FILENO);
810 close(STDERR_FILENO);
Daniel Rosenbergd9261b12021-09-14 17:32:06 -0700811 if (context) {
812 if (setexeccon(context)) {
813 LOG(ERROR) << "Failed to setexeccon in ForkExecvpAsync";
814 abort();
815 }
816 }
Jeff Sharkey1d6fbcc2015-04-24 16:00:03 -0700817
Paul Crowleyde2d6202018-11-30 11:43:47 -0800818 execvp(argv[0], const_cast<char**>(argv.data()));
819 PLOG(ERROR) << "exec in ForkExecvpAsync";
820 _exit(EXIT_FAILURE);
Jeff Sharkey1d6fbcc2015-04-24 16:00:03 -0700821 }
Jeff Sharkey1d6fbcc2015-04-24 16:00:03 -0700822 if (pid == -1) {
Paul Crowleyde2d6202018-11-30 11:43:47 -0800823 PLOG(ERROR) << "fork in ForkExecvpAsync";
824 return -1;
Jeff Sharkey1d6fbcc2015-04-24 16:00:03 -0700825 }
Jeff Sharkey1d6fbcc2015-04-24 16:00:03 -0700826 return pid;
827}
828
Jeff Sharkey9c484982015-03-31 10:35:33 -0700829status_t ReadRandomBytes(size_t bytes, std::string& out) {
Pavel Grafove2e2d302017-08-01 17:15:53 +0100830 out.resize(bytes);
831 return ReadRandomBytes(bytes, &out[0]);
832}
Jeff Sharkey9c484982015-03-31 10:35:33 -0700833
Pavel Grafove2e2d302017-08-01 17:15:53 +0100834status_t ReadRandomBytes(size_t bytes, char* buf) {
Jeff Sharkey9c484982015-03-31 10:35:33 -0700835 int fd = TEMP_FAILURE_RETRY(open("/dev/urandom", O_RDONLY | O_CLOEXEC | O_NOFOLLOW));
836 if (fd == -1) {
837 return -errno;
838 }
839
Eric Biggers0ef7bfd2019-01-16 13:05:34 -0800840 ssize_t n;
Pavel Grafove2e2d302017-08-01 17:15:53 +0100841 while ((n = TEMP_FAILURE_RETRY(read(fd, &buf[0], bytes))) > 0) {
Jeff Sharkey9c484982015-03-31 10:35:33 -0700842 bytes -= n;
Pavel Grafove2e2d302017-08-01 17:15:53 +0100843 buf += n;
Jeff Sharkey9c484982015-03-31 10:35:33 -0700844 }
Elliott Hughesa6231082015-05-15 18:34:24 -0700845 close(fd);
Jeff Sharkey9c484982015-03-31 10:35:33 -0700846
847 if (bytes == 0) {
848 return OK;
849 } else {
850 return -EIO;
851 }
852}
853
Jeff Sharkey46bb69f2017-06-21 13:52:23 -0600854status_t GenerateRandomUuid(std::string& out) {
855 status_t res = ReadRandomBytes(16, out);
856 if (res == OK) {
Paul Crowley14c8c072018-09-18 13:30:21 -0700857 out[6] &= 0x0f; /* clear version */
858 out[6] |= 0x40; /* set to version 4 */
859 out[8] &= 0x3f; /* clear variant */
860 out[8] |= 0x80; /* set to IETF variant */
Jeff Sharkey46bb69f2017-06-21 13:52:23 -0600861 }
862 return res;
863}
864
Jeff Sharkey9c484982015-03-31 10:35:33 -0700865status_t HexToStr(const std::string& hex, std::string& str) {
866 str.clear();
867 bool even = true;
868 char cur = 0;
869 for (size_t i = 0; i < hex.size(); i++) {
870 int val = 0;
871 switch (hex[i]) {
Paul Crowley14c8c072018-09-18 13:30:21 -0700872 // clang-format off
873 case ' ': case '-': case ':': continue;
874 case 'f': case 'F': val = 15; break;
875 case 'e': case 'E': val = 14; break;
876 case 'd': case 'D': val = 13; break;
877 case 'c': case 'C': val = 12; break;
878 case 'b': case 'B': val = 11; break;
879 case 'a': case 'A': val = 10; break;
880 case '9': val = 9; break;
881 case '8': val = 8; break;
882 case '7': val = 7; break;
883 case '6': val = 6; break;
884 case '5': val = 5; break;
885 case '4': val = 4; break;
886 case '3': val = 3; break;
887 case '2': val = 2; break;
888 case '1': val = 1; break;
889 case '0': val = 0; break;
890 default: return -EINVAL;
891 // clang-format on
Jeff Sharkey9c484982015-03-31 10:35:33 -0700892 }
893
894 if (even) {
895 cur = val << 4;
896 } else {
897 cur += val;
898 str.push_back(cur);
899 cur = 0;
900 }
901 even = !even;
902 }
903 return even ? OK : -EINVAL;
904}
905
906static const char* kLookup = "0123456789abcdef";
907
908status_t StrToHex(const std::string& str, std::string& hex) {
909 hex.clear();
910 for (size_t i = 0; i < str.size(); i++) {
Jeff Sharkeyef369752015-04-29 15:57:48 -0700911 hex.push_back(kLookup[(str[i] & 0xF0) >> 4]);
Jeff Sharkey9c484982015-03-31 10:35:33 -0700912 hex.push_back(kLookup[str[i] & 0x0F]);
913 }
914 return OK;
915}
916
Pavel Grafove2e2d302017-08-01 17:15:53 +0100917status_t StrToHex(const KeyBuffer& str, KeyBuffer& hex) {
918 hex.clear();
919 for (size_t i = 0; i < str.size(); i++) {
920 hex.push_back(kLookup[(str.data()[i] & 0xF0) >> 4]);
921 hex.push_back(kLookup[str.data()[i] & 0x0F]);
922 }
923 return OK;
924}
925
Jeff Sharkeybc40cc82015-06-18 14:25:08 -0700926status_t NormalizeHex(const std::string& in, std::string& out) {
927 std::string tmp;
928 if (HexToStr(in, tmp)) {
929 return -EINVAL;
930 }
931 return StrToHex(tmp, out);
932}
933
Oleksiy Avramchenko625dc782018-05-23 10:50:46 +0200934status_t GetBlockDevSize(int fd, uint64_t* size) {
935 if (ioctl(fd, BLKGETSIZE64, size)) {
936 return -errno;
937 }
938
939 return OK;
940}
941
942status_t GetBlockDevSize(const std::string& path, uint64_t* size) {
943 int fd = open(path.c_str(), O_RDONLY | O_CLOEXEC);
944 status_t res = OK;
945
946 if (fd < 0) {
947 return -errno;
948 }
949
950 res = GetBlockDevSize(fd, size);
951
952 close(fd);
953
954 return res;
955}
956
957status_t GetBlockDev512Sectors(const std::string& path, uint64_t* nr_sec) {
958 uint64_t size;
959 status_t res = GetBlockDevSize(path, &size);
960
961 if (res != OK) {
962 return res;
963 }
964
965 *nr_sec = size / 512;
966
967 return OK;
968}
969
Jeff Sharkey1d6fbcc2015-04-24 16:00:03 -0700970uint64_t GetFreeBytes(const std::string& path) {
971 struct statvfs sb;
972 if (statvfs(path.c_str(), &sb) == 0) {
Paul Crowley14c8c072018-09-18 13:30:21 -0700973 return (uint64_t)sb.f_bavail * sb.f_frsize;
Jeff Sharkey1d6fbcc2015-04-24 16:00:03 -0700974 } else {
975 return -1;
976 }
977}
978
979// TODO: borrowed from frameworks/native/libs/diskusage/ which should
980// eventually be migrated into system/
Paul Crowley14c8c072018-09-18 13:30:21 -0700981static int64_t stat_size(struct stat* s) {
Jeff Sharkey1d6fbcc2015-04-24 16:00:03 -0700982 int64_t blksize = s->st_blksize;
983 // count actual blocks used instead of nominal file size
984 int64_t size = s->st_blocks * 512;
985
986 if (blksize) {
987 /* round up to filesystem block size */
988 size = (size + blksize - 1) & (~(blksize - 1));
989 }
990
991 return size;
992}
993
994// TODO: borrowed from frameworks/native/libs/diskusage/ which should
995// eventually be migrated into system/
996int64_t calculate_dir_size(int dfd) {
997 int64_t size = 0;
998 struct stat s;
Paul Crowley14c8c072018-09-18 13:30:21 -0700999 DIR* d;
1000 struct dirent* de;
Jeff Sharkey1d6fbcc2015-04-24 16:00:03 -07001001
1002 d = fdopendir(dfd);
1003 if (d == NULL) {
1004 close(dfd);
1005 return 0;
1006 }
1007
1008 while ((de = readdir(d))) {
Paul Crowley14c8c072018-09-18 13:30:21 -07001009 const char* name = de->d_name;
Jeff Sharkey1d6fbcc2015-04-24 16:00:03 -07001010 if (fstatat(dfd, name, &s, AT_SYMLINK_NOFOLLOW) == 0) {
1011 size += stat_size(&s);
1012 }
1013 if (de->d_type == DT_DIR) {
1014 int subfd;
1015
1016 /* always skip "." and ".." */
Eric Biggers7bcf4272020-11-02 15:31:56 -08001017 if (IsDotOrDotDot(*de)) continue;
Jeff Sharkey1d6fbcc2015-04-24 16:00:03 -07001018
Jeff Sharkeyfd3dc3c2017-03-27 10:49:21 -06001019 subfd = openat(dfd, name, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
Jeff Sharkey1d6fbcc2015-04-24 16:00:03 -07001020 if (subfd >= 0) {
1021 size += calculate_dir_size(subfd);
1022 }
1023 }
1024 }
1025 closedir(d);
1026 return size;
1027}
1028
1029uint64_t GetTreeBytes(const std::string& path) {
Jeff Sharkeyfd3dc3c2017-03-27 10:49:21 -06001030 int dirfd = open(path.c_str(), O_RDONLY | O_DIRECTORY | O_CLOEXEC);
Jeff Sharkey1d6fbcc2015-04-24 16:00:03 -07001031 if (dirfd < 0) {
1032 PLOG(WARNING) << "Failed to open " << path;
1033 return -1;
1034 } else {
Josh Gao72fb1a62018-05-29 19:05:16 -07001035 return calculate_dir_size(dirfd);
Jeff Sharkey1d6fbcc2015-04-24 16:00:03 -07001036 }
1037}
1038
Ricky Wai07e64a42020-02-11 14:31:24 +00001039// TODO: Use a better way to determine if it's media provider app.
1040bool IsFuseDaemon(const pid_t pid) {
1041 auto path = StringPrintf("/proc/%d/mounts", pid);
1042 char* tmp;
1043 if (lgetfilecon(path.c_str(), &tmp) < 0) {
1044 return false;
1045 }
1046 bool result = android::base::StartsWith(tmp, kMediaProviderAppCtx)
1047 || android::base::StartsWith(tmp, kMediaProviderCtx);
1048 freecon(tmp);
1049 return result;
1050}
1051
Jeff Sharkeyd0640f62015-05-21 22:35:42 -07001052bool IsFilesystemSupported(const std::string& fsType) {
1053 std::string supported;
1054 if (!ReadFileToString(kProcFilesystems, &supported)) {
1055 PLOG(ERROR) << "Failed to read supported filesystems";
1056 return false;
1057 }
1058 return supported.find(fsType + "\n") != std::string::npos;
1059}
1060
Daniel Rosenbergf36bddd2020-05-11 22:58:42 -07001061bool IsSdcardfsUsed() {
1062 return IsFilesystemSupported("sdcardfs") &&
1063 base::GetBoolProperty(kExternalStorageSdcardfs, true);
1064}
1065
Jeff Sharkeyd0640f62015-05-21 22:35:42 -07001066status_t WipeBlockDevice(const std::string& path) {
1067 status_t res = -1;
1068 const char* c_path = path.c_str();
Oleksiy Avramchenko625dc782018-05-23 10:50:46 +02001069 uint64_t range[2] = {0, 0};
Jeff Sharkeyd0640f62015-05-21 22:35:42 -07001070
1071 int fd = TEMP_FAILURE_RETRY(open(c_path, O_RDWR | O_CLOEXEC));
1072 if (fd == -1) {
1073 PLOG(ERROR) << "Failed to open " << path;
1074 goto done;
1075 }
1076
Oleksiy Avramchenko625dc782018-05-23 10:50:46 +02001077 if (GetBlockDevSize(fd, &range[1]) != OK) {
Jeff Sharkeyd0640f62015-05-21 22:35:42 -07001078 PLOG(ERROR) << "Failed to determine size of " << path;
1079 goto done;
1080 }
1081
Jeff Sharkeyd0640f62015-05-21 22:35:42 -07001082 LOG(INFO) << "About to discard " << range[1] << " on " << path;
1083 if (ioctl(fd, BLKDISCARD, &range) == 0) {
1084 LOG(INFO) << "Discard success on " << path;
1085 res = 0;
1086 } else {
1087 PLOG(ERROR) << "Discard failure on " << path;
1088 }
1089
1090done:
1091 close(fd);
1092 return res;
1093}
1094
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -08001095static bool isValidFilename(const std::string& name) {
Paul Crowley14c8c072018-09-18 13:30:21 -07001096 if (name.empty() || (name == ".") || (name == "..") || (name.find('/') != std::string::npos)) {
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -08001097 return false;
1098 } else {
1099 return true;
1100 }
1101}
1102
Jeff Sharkeybc40cc82015-06-18 14:25:08 -07001103std::string BuildKeyPath(const std::string& partGuid) {
1104 return StringPrintf("%s/expand_%s.key", kKeyPath, partGuid.c_str());
1105}
1106
Jeff Sharkeybe70c9a2016-04-14 20:45:16 -06001107std::string BuildDataSystemLegacyPath(userid_t userId) {
Paul Crowley3b71fc52017-10-09 10:55:21 -07001108 return StringPrintf("%s/system/users/%u", BuildDataPath("").c_str(), userId);
Jeff Sharkeybe70c9a2016-04-14 20:45:16 -06001109}
1110
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -08001111std::string BuildDataSystemCePath(userid_t userId) {
Paul Crowley3b71fc52017-10-09 10:55:21 -07001112 return StringPrintf("%s/system_ce/%u", BuildDataPath("").c_str(), userId);
Jeff Sharkey47695b22016-02-01 17:02:29 -07001113}
1114
1115std::string BuildDataSystemDePath(userid_t userId) {
Paul Crowley3b71fc52017-10-09 10:55:21 -07001116 return StringPrintf("%s/system_de/%u", BuildDataPath("").c_str(), userId);
Jeff Sharkey47695b22016-02-01 17:02:29 -07001117}
1118
Jeff Sharkeybe70c9a2016-04-14 20:45:16 -06001119std::string BuildDataMiscLegacyPath(userid_t userId) {
Paul Crowley3b71fc52017-10-09 10:55:21 -07001120 return StringPrintf("%s/misc/user/%u", BuildDataPath("").c_str(), userId);
Jeff Sharkeybe70c9a2016-04-14 20:45:16 -06001121}
1122
Jeff Sharkey47695b22016-02-01 17:02:29 -07001123std::string BuildDataMiscCePath(userid_t userId) {
Paul Crowley3b71fc52017-10-09 10:55:21 -07001124 return StringPrintf("%s/misc_ce/%u", BuildDataPath("").c_str(), userId);
Jeff Sharkey47695b22016-02-01 17:02:29 -07001125}
1126
1127std::string BuildDataMiscDePath(userid_t userId) {
Paul Crowley3b71fc52017-10-09 10:55:21 -07001128 return StringPrintf("%s/misc_de/%u", BuildDataPath("").c_str(), userId);
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -08001129}
1130
Calin Juravle79f55a42016-02-17 20:14:46 +00001131// Keep in sync with installd (frameworks/native/cmds/installd/utils.h)
1132std::string BuildDataProfilesDePath(userid_t userId) {
Paul Crowley3b71fc52017-10-09 10:55:21 -07001133 return StringPrintf("%s/misc/profiles/cur/%u", BuildDataPath("").c_str(), userId);
Calin Juravle79f55a42016-02-17 20:14:46 +00001134}
1135
Andreas Huber71cd43f2018-01-22 11:25:29 -08001136std::string BuildDataVendorCePath(userid_t userId) {
1137 return StringPrintf("%s/vendor_ce/%u", BuildDataPath("").c_str(), userId);
1138}
1139
1140std::string BuildDataVendorDePath(userid_t userId) {
1141 return StringPrintf("%s/vendor_de/%u", BuildDataPath("").c_str(), userId);
1142}
1143
Paul Crowley3b71fc52017-10-09 10:55:21 -07001144std::string BuildDataPath(const std::string& volumeUuid) {
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -08001145 // TODO: unify with installd path generation logic
Paul Crowley3b71fc52017-10-09 10:55:21 -07001146 if (volumeUuid.empty()) {
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -08001147 return "/data";
1148 } else {
1149 CHECK(isValidFilename(volumeUuid));
Paul Crowley3b71fc52017-10-09 10:55:21 -07001150 return StringPrintf("/mnt/expand/%s", volumeUuid.c_str());
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -08001151 }
1152}
1153
Paul Crowley3b71fc52017-10-09 10:55:21 -07001154std::string BuildDataMediaCePath(const std::string& volumeUuid, userid_t userId) {
Jeff Sharkeyfc505c32015-12-07 17:27:01 -07001155 // TODO: unify with installd path generation logic
1156 std::string data(BuildDataPath(volumeUuid));
1157 return StringPrintf("%s/media/%u", data.c_str(), userId);
1158}
1159
Paul Crowley3b71fc52017-10-09 10:55:21 -07001160std::string BuildDataUserCePath(const std::string& volumeUuid, userid_t userId) {
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -08001161 // TODO: unify with installd path generation logic
1162 std::string data(BuildDataPath(volumeUuid));
Paul Crowley3b71fc52017-10-09 10:55:21 -07001163 if (volumeUuid.empty() && userId == 0) {
cjbaoeb501142017-04-12 00:09:00 +08001164 std::string legacy = StringPrintf("%s/data", data.c_str());
1165 struct stat sb;
1166 if (lstat(legacy.c_str(), &sb) == 0 && S_ISDIR(sb.st_mode)) {
1167 /* /data/data is dir, return /data/data for legacy system */
1168 return legacy;
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -08001169 }
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -08001170 }
cjbaoeb501142017-04-12 00:09:00 +08001171 return StringPrintf("%s/user/%u", data.c_str(), userId);
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -08001172}
1173
Paul Crowley3b71fc52017-10-09 10:55:21 -07001174std::string BuildDataUserDePath(const std::string& volumeUuid, userid_t userId) {
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -08001175 // TODO: unify with installd path generation logic
1176 std::string data(BuildDataPath(volumeUuid));
1177 return StringPrintf("%s/user_de/%u", data.c_str(), userId);
1178}
1179
Jeff Sharkey66270a22015-06-24 11:49:24 -07001180dev_t GetDevice(const std::string& path) {
1181 struct stat sb;
1182 if (stat(path.c_str(), &sb)) {
1183 PLOG(WARNING) << "Failed to stat " << path;
1184 return 0;
1185 } else {
1186 return sb.st_dev;
1187 }
1188}
1189
Eric Biggersf74373b2020-11-05 19:58:26 -08001190// Returns true if |path1| names the same existing file or directory as |path2|.
1191bool IsSameFile(const std::string& path1, const std::string& path2) {
1192 struct stat stbuf1, stbuf2;
1193 if (stat(path1.c_str(), &stbuf1) != 0 || stat(path2.c_str(), &stbuf2) != 0) return false;
1194 return stbuf1.st_ino == stbuf2.st_ino && stbuf1.st_dev == stbuf2.st_dev;
1195}
1196
Jeff Sharkeyd24aeda2016-07-15 16:20:22 -06001197status_t RestoreconRecursive(const std::string& path) {
Sudheer Shanka4b6ca4e2018-09-21 10:54:54 -07001198 LOG(DEBUG) << "Starting restorecon of " << path;
Jeff Sharkeyd24aeda2016-07-15 16:20:22 -06001199
Tom Cherryd6127ef2017-06-15 17:13:56 -07001200 static constexpr const char* kRestoreconString = "selinux.restorecon_recursive";
Jeff Sharkeyd24aeda2016-07-15 16:20:22 -06001201
Tom Cherryd6127ef2017-06-15 17:13:56 -07001202 android::base::SetProperty(kRestoreconString, "");
1203 android::base::SetProperty(kRestoreconString, path);
1204
1205 android::base::WaitForProperty(kRestoreconString, path);
Jeff Sharkeyd24aeda2016-07-15 16:20:22 -06001206
Sudheer Shanka4b6ca4e2018-09-21 10:54:54 -07001207 LOG(DEBUG) << "Finished restorecon of " << path;
Jeff Sharkeyd24aeda2016-07-15 16:20:22 -06001208 return OK;
1209}
1210
Jeff Sharkey3472e522017-10-06 18:02:53 -06001211bool Readlinkat(int dirfd, const std::string& path, std::string* result) {
1212 // Shamelessly borrowed from android::base::Readlink()
1213 result->clear();
1214
1215 // Most Linux file systems (ext2 and ext4, say) limit symbolic links to
1216 // 4095 bytes. Since we'll copy out into the string anyway, it doesn't
1217 // waste memory to just start there. We add 1 so that we can recognize
1218 // whether it actually fit (rather than being truncated to 4095).
1219 std::vector<char> buf(4095 + 1);
1220 while (true) {
1221 ssize_t size = readlinkat(dirfd, path.c_str(), &buf[0], buf.size());
1222 // Unrecoverable error?
Paul Crowley14c8c072018-09-18 13:30:21 -07001223 if (size == -1) return false;
Jeff Sharkey3472e522017-10-06 18:02:53 -06001224 // It fit! (If size == buf.size(), it may have been truncated.)
1225 if (static_cast<size_t>(size) < buf.size()) {
1226 result->assign(&buf[0], size);
1227 return true;
1228 }
1229 // Double our buffer and try again.
1230 buf.resize(buf.size() * 2);
Daichi Hirono10d34882016-01-29 14:33:51 +09001231 }
1232}
1233
Alistair Delvaff1fc9b2020-05-14 16:35:03 -07001234static unsigned int GetMajorBlockVirtioBlk() {
1235 std::string devices;
1236 if (!ReadFileToString(kProcDevices, &devices)) {
1237 PLOG(ERROR) << "Unable to open /proc/devices";
1238 return 0;
1239 }
1240
1241 bool blockSection = false;
1242 for (auto line : android::base::Split(devices, "\n")) {
1243 if (line == "Block devices:") {
1244 blockSection = true;
1245 } else if (line == "Character devices:") {
1246 blockSection = false;
1247 } else if (blockSection) {
1248 auto tokens = android::base::Split(line, " ");
1249 if (tokens.size() == 2 && tokens[1] == "virtblk") {
1250 return std::stoul(tokens[0]);
1251 }
1252 }
1253 }
1254
1255 return 0;
1256}
1257
1258bool IsVirtioBlkDevice(unsigned int major) {
1259 // Most virtualized platforms expose block devices with the virtio-blk
1260 // block device driver. Unfortunately, this driver does not use a fixed
1261 // major number, but relies on the kernel to assign one from a specific
1262 // range of block majors, which are allocated for "LOCAL/EXPERIMENAL USE"
1263 // per Documentation/devices.txt. This is true even for the latest Linux
1264 // kernel (4.4; see init() in drivers/block/virtio_blk.c).
1265 static unsigned int kMajorBlockVirtioBlk = GetMajorBlockVirtioBlk();
1266 return kMajorBlockVirtioBlk && major == kMajorBlockVirtioBlk;
Yu Ning942d4e82016-01-08 17:36:47 +08001267}
1268
Sudheer Shanka295fb242019-01-16 23:04:07 -08001269status_t UnmountTree(const std::string& mountPoint) {
Sudheer Shanka023b5392019-02-06 12:39:19 -08001270 if (TEMP_FAILURE_RETRY(umount2(mountPoint.c_str(), MNT_DETACH)) < 0 && errno != EINVAL &&
1271 errno != ENOENT) {
Sudheer Shanka295fb242019-01-16 23:04:07 -08001272 PLOG(ERROR) << "Failed to unmount " << mountPoint;
Sudheer Shanka89ddf992018-09-25 14:22:07 -07001273 return -errno;
1274 }
Sudheer Shanka89ddf992018-09-25 14:22:07 -07001275 return OK;
1276}
1277
Eric Biggers7bcf4272020-11-02 15:31:56 -08001278bool IsDotOrDotDot(const struct dirent& ent) {
1279 return strcmp(ent.d_name, ".") == 0 || strcmp(ent.d_name, "..") == 0;
1280}
1281
Sudheer Shanka40ab6742018-09-18 13:07:45 -07001282static status_t delete_dir_contents(DIR* dir) {
1283 // Shamelessly borrowed from android::installd
1284 int dfd = dirfd(dir);
1285 if (dfd < 0) {
1286 return -errno;
1287 }
1288
Sudheer Shanka6bf14802019-01-17 13:38:10 -08001289 status_t result = OK;
Sudheer Shanka40ab6742018-09-18 13:07:45 -07001290 struct dirent* de;
1291 while ((de = readdir(dir))) {
1292 const char* name = de->d_name;
1293 if (de->d_type == DT_DIR) {
1294 /* always skip "." and ".." */
Eric Biggers7bcf4272020-11-02 15:31:56 -08001295 if (IsDotOrDotDot(*de)) continue;
Sudheer Shanka40ab6742018-09-18 13:07:45 -07001296
1297 android::base::unique_fd subfd(
1298 openat(dfd, name, O_RDONLY | O_DIRECTORY | O_NOFOLLOW | O_CLOEXEC));
1299 if (subfd.get() == -1) {
1300 PLOG(ERROR) << "Couldn't openat " << name;
1301 result = -errno;
1302 continue;
1303 }
Josh Gaoe3c32e02018-11-05 13:47:28 -08001304 std::unique_ptr<DIR, decltype(&closedir)> subdirp(
1305 android::base::Fdopendir(std::move(subfd)), closedir);
Sudheer Shanka40ab6742018-09-18 13:07:45 -07001306 if (!subdirp) {
1307 PLOG(ERROR) << "Couldn't fdopendir " << name;
1308 result = -errno;
1309 continue;
1310 }
1311 result = delete_dir_contents(subdirp.get());
1312 if (unlinkat(dfd, name, AT_REMOVEDIR) < 0) {
1313 PLOG(ERROR) << "Couldn't unlinkat " << name;
1314 result = -errno;
1315 }
1316 } else {
1317 if (unlinkat(dfd, name, 0) < 0) {
1318 PLOG(ERROR) << "Couldn't unlinkat " << name;
1319 result = -errno;
1320 }
1321 }
1322 }
1323 return result;
1324}
1325
1326status_t DeleteDirContentsAndDir(const std::string& pathname) {
Sudheer Shanka30df1c62019-02-22 17:03:02 -08001327 status_t res = DeleteDirContents(pathname);
1328 if (res < 0) {
1329 return res;
1330 }
Sudheer Shanka8255a2b2019-02-25 12:21:23 -08001331 if (TEMP_FAILURE_RETRY(rmdir(pathname.c_str())) < 0 && errno != ENOENT) {
Sudheer Shanka30df1c62019-02-22 17:03:02 -08001332 PLOG(ERROR) << "rmdir failed on " << pathname;
1333 return -errno;
1334 }
1335 LOG(VERBOSE) << "Success: rmdir on " << pathname;
1336 return OK;
1337}
1338
1339status_t DeleteDirContents(const std::string& pathname) {
Sudheer Shanka40ab6742018-09-18 13:07:45 -07001340 // Shamelessly borrowed from android::installd
1341 std::unique_ptr<DIR, decltype(&closedir)> dirp(opendir(pathname.c_str()), closedir);
1342 if (!dirp) {
1343 if (errno == ENOENT) {
1344 return OK;
1345 }
1346 PLOG(ERROR) << "Failed to opendir " << pathname;
1347 return -errno;
1348 }
Sudheer Shanka30df1c62019-02-22 17:03:02 -08001349 return delete_dir_contents(dirp.get());
Sudheer Shanka40ab6742018-09-18 13:07:45 -07001350}
1351
Paul Crowley298fa322018-10-30 15:59:24 -07001352// TODO(118708649): fix duplication with init/util.h
1353status_t WaitForFile(const char* filename, std::chrono::nanoseconds timeout) {
1354 android::base::Timer t;
1355 while (t.duration() < timeout) {
1356 struct stat sb;
1357 if (stat(filename, &sb) != -1) {
1358 LOG(INFO) << "wait for '" << filename << "' took " << t;
1359 return 0;
1360 }
1361 std::this_thread::sleep_for(10ms);
1362 }
1363 LOG(WARNING) << "wait for '" << filename << "' timed out and took " << t;
1364 return -1;
1365}
1366
Eric Biggersbd138dd2021-02-16 15:59:17 -08001367bool pathExists(const std::string& path) {
1368 return access(path.c_str(), F_OK) == 0;
1369}
1370
Paul Crowley621d9b92018-12-07 15:36:09 -08001371bool FsyncDirectory(const std::string& dirname) {
1372 android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(dirname.c_str(), O_RDONLY | O_CLOEXEC)));
1373 if (fd == -1) {
1374 PLOG(ERROR) << "Failed to open " << dirname;
1375 return false;
1376 }
1377 if (fsync(fd) == -1) {
1378 if (errno == EROFS || errno == EINVAL) {
1379 PLOG(WARNING) << "Skip fsync " << dirname
1380 << " on a file system does not support synchronization";
1381 } else {
1382 PLOG(ERROR) << "Failed to fsync " << dirname;
1383 return false;
1384 }
1385 }
1386 return true;
1387}
1388
Eric Biggers3345a2a2021-02-16 15:59:17 -08001389bool FsyncParentDirectory(const std::string& path) {
1390 return FsyncDirectory(android::base::Dirname(path));
1391}
1392
Eric Biggersfec0c0e2021-02-16 15:59:17 -08001393// Creates all parent directories of |path| that don't already exist. Assigns
1394// the specified |mode| to any new directories, and also fsync()s their parent
1395// directories so that the new directories get written to disk right away.
1396bool MkdirsSync(const std::string& path, mode_t mode) {
1397 if (path[0] != '/') {
1398 LOG(ERROR) << "MkdirsSync() needs an absolute path, but got " << path;
1399 return false;
1400 }
1401 std::vector<std::string> components = android::base::Split(android::base::Dirname(path), "/");
1402
1403 std::string current_dir = "/";
1404 for (const std::string& component : components) {
1405 if (component.empty()) continue;
1406
1407 std::string parent_dir = current_dir;
1408 if (current_dir != "/") current_dir += "/";
1409 current_dir += component;
1410
1411 if (!pathExists(current_dir)) {
1412 if (mkdir(current_dir.c_str(), mode) != 0) {
1413 PLOG(ERROR) << "Failed to create " << current_dir;
1414 return false;
1415 }
1416 if (!FsyncDirectory(parent_dir)) return false;
1417 LOG(DEBUG) << "Created directory " << current_dir;
1418 }
1419 }
1420 return true;
1421}
1422
Tommy Chiu0bd2d112019-03-26 17:18:09 +08001423bool writeStringToFile(const std::string& payload, const std::string& filename) {
1424 android::base::unique_fd fd(TEMP_FAILURE_RETRY(
1425 open(filename.c_str(), O_WRONLY | O_CREAT | O_NOFOLLOW | O_TRUNC | O_CLOEXEC, 0666)));
1426 if (fd == -1) {
1427 PLOG(ERROR) << "Failed to open " << filename;
1428 return false;
1429 }
1430 if (!android::base::WriteStringToFd(payload, fd)) {
1431 PLOG(ERROR) << "Failed to write to " << filename;
1432 unlink(filename.c_str());
1433 return false;
1434 }
1435 // fsync as close won't guarantee flush data
1436 // see close(2), fsync(2) and b/68901441
1437 if (fsync(fd) == -1) {
1438 if (errno == EROFS || errno == EINVAL) {
1439 PLOG(WARNING) << "Skip fsync " << filename
1440 << " on a file system does not support synchronization";
1441 } else {
1442 PLOG(ERROR) << "Failed to fsync " << filename;
1443 unlink(filename.c_str());
1444 return false;
1445 }
1446 }
1447 return true;
1448}
1449
Martijn Coenen23c04452020-04-29 07:49:41 +02001450status_t AbortFuseConnections() {
1451 namespace fs = std::filesystem;
1452
1453 for (const auto& itEntry : fs::directory_iterator("/sys/fs/fuse/connections")) {
Tao Wu3d989622020-08-06 19:31:21 -07001454 std::string fsPath = itEntry.path().string() + "/filesystem";
1455 std::string fs;
1456
1457 // Virtiofs is on top of fuse and there isn't any user space daemon.
1458 // Android user space doesn't manage it.
1459 if (android::base::ReadFileToString(fsPath, &fs, false) &&
1460 android::base::Trim(fs) == "virtiofs") {
1461 LOG(INFO) << "Ignore virtiofs connection entry " << itEntry.path().string();
1462 continue;
1463 }
1464
Martijn Coenen23c04452020-04-29 07:49:41 +02001465 std::string abortPath = itEntry.path().string() + "/abort";
1466 LOG(DEBUG) << "Aborting fuse connection entry " << abortPath;
1467 bool ret = writeStringToFile("1", abortPath);
1468 if (!ret) {
1469 LOG(WARNING) << "Failed to write to " << abortPath;
1470 }
1471 }
1472
1473 return OK;
1474}
1475
Ricky Wai07e64a42020-02-11 14:31:24 +00001476status_t EnsureDirExists(const std::string& path, mode_t mode, uid_t uid, gid_t gid) {
1477 if (access(path.c_str(), F_OK) != 0) {
1478 PLOG(WARNING) << "Dir does not exist: " << path;
1479 if (fs_prepare_dir(path.c_str(), mode, uid, gid) != 0) {
1480 return -errno;
1481 }
1482 }
1483 return OK;
1484}
1485
Martijn Coenena4850062020-06-29 11:53:34 +02001486// Gets the sysfs path for parameters of the backing device info (bdi)
1487static std::string getBdiPathForMount(const std::string& mount) {
1488 // First figure out MAJOR:MINOR of mount. Simplest way is to stat the path.
1489 struct stat info;
1490 if (stat(mount.c_str(), &info) != 0) {
1491 PLOG(ERROR) << "Failed to stat " << mount;
1492 return "";
1493 }
1494 unsigned int maj = major(info.st_dev);
1495 unsigned int min = minor(info.st_dev);
1496
1497 return StringPrintf("/sys/class/bdi/%u:%u", maj, min);
1498}
1499
1500// Configures max_ratio for the FUSE filesystem.
1501void ConfigureMaxDirtyRatioForFuse(const std::string& fuse_mount, unsigned int max_ratio) {
1502 LOG(INFO) << "Configuring max_ratio of " << fuse_mount << " fuse filesystem to " << max_ratio;
1503 if (max_ratio > 100) {
1504 LOG(ERROR) << "Invalid max_ratio: " << max_ratio;
1505 return;
1506 }
1507 std::string fuseBdiPath = getBdiPathForMount(fuse_mount);
1508 if (fuseBdiPath == "") {
1509 return;
1510 }
1511 std::string max_ratio_file = StringPrintf("%s/max_ratio", fuseBdiPath.c_str());
1512 unique_fd fd(TEMP_FAILURE_RETRY(open(max_ratio_file.c_str(), O_WRONLY | O_CLOEXEC)));
1513 if (fd.get() == -1) {
1514 PLOG(ERROR) << "Failed to open " << max_ratio_file;
1515 return;
1516 }
1517 LOG(INFO) << "Writing " << max_ratio << " to " << max_ratio_file;
1518 if (!WriteStringToFd(std::to_string(max_ratio), fd)) {
1519 PLOG(ERROR) << "Failed to write to " << max_ratio_file;
1520 }
1521}
1522
Nikita Ioffedcee5c12020-06-12 12:59:45 +01001523// Configures read ahead property of the fuse filesystem with the mount point |fuse_mount| by
1524// writing |read_ahead_kb| to the /sys/class/bdi/MAJOR:MINOR/read_ahead_kb.
1525void ConfigureReadAheadForFuse(const std::string& fuse_mount, size_t read_ahead_kb) {
1526 LOG(INFO) << "Configuring read_ahead of " << fuse_mount << " fuse filesystem to "
1527 << read_ahead_kb << "kb";
Martijn Coenena4850062020-06-29 11:53:34 +02001528 std::string fuseBdiPath = getBdiPathForMount(fuse_mount);
1529 if (fuseBdiPath == "") {
Nikita Ioffedcee5c12020-06-12 12:59:45 +01001530 return;
1531 }
Martijn Coenena4850062020-06-29 11:53:34 +02001532 // We found the bdi path for our filesystem, time to configure read ahead!
1533 std::string read_ahead_file = StringPrintf("%s/read_ahead_kb", fuseBdiPath.c_str());
Nikita Ioffedcee5c12020-06-12 12:59:45 +01001534 unique_fd fd(TEMP_FAILURE_RETRY(open(read_ahead_file.c_str(), O_WRONLY | O_CLOEXEC)));
1535 if (fd.get() == -1) {
1536 PLOG(ERROR) << "Failed to open " << read_ahead_file;
1537 return;
1538 }
1539 LOG(INFO) << "Writing " << read_ahead_kb << " to " << read_ahead_file;
1540 if (!WriteStringToFd(std::to_string(read_ahead_kb), fd)) {
1541 PLOG(ERROR) << "Failed to write to " << read_ahead_file;
1542 }
1543}
1544
Zima438b242019-09-25 14:37:38 +01001545status_t MountUserFuse(userid_t user_id, const std::string& absolute_lower_path,
1546 const std::string& relative_upper_path, android::base::unique_fd* fuse_fd) {
1547 std::string pre_fuse_path(StringPrintf("/mnt/user/%d", user_id));
1548 std::string fuse_path(
1549 StringPrintf("%s/%s", pre_fuse_path.c_str(), relative_upper_path.c_str()));
1550
1551 std::string pre_pass_through_path(StringPrintf("/mnt/pass_through/%d", user_id));
1552 std::string pass_through_path(
1553 StringPrintf("%s/%s", pre_pass_through_path.c_str(), relative_upper_path.c_str()));
Zim3623a212019-07-19 16:46:53 +01001554
Zim1242be82020-01-22 18:22:29 +00001555 // Ensure that /mnt/user is 0700. With FUSE, apps don't need access to /mnt/user paths directly.
1556 // Without FUSE however, apps need /mnt/user access so /mnt/user in init.rc is 0755 until here
Zim4dd47092020-01-29 02:44:46 +00001557 auto result = PrepareDir("/mnt/user", 0750, AID_ROOT, AID_MEDIA_RW);
Zim1242be82020-01-22 18:22:29 +00001558 if (result != android::OK) {
1559 PLOG(ERROR) << "Failed to prepare directory /mnt/user";
1560 return -1;
1561 }
1562
Zim06b0caf2020-01-05 02:11:47 +00001563 // Shell is neither AID_ROOT nor AID_EVERYBODY. Since it equally needs 'execute' access to
1564 // /mnt/user/0 to 'adb shell ls /sdcard' for instance, we set the uid bit of /mnt/user/0 to
1565 // AID_SHELL. This gives shell access along with apps running as group everybody (user 0 apps)
1566 // These bits should be consistent with what is set in zygote in
1567 // com_android_internal_os_Zygote#MountEmulatedStorage on volume bind mount during app fork
Zim1242be82020-01-22 18:22:29 +00001568 result = PrepareDir(pre_fuse_path, 0710, user_id ? AID_ROOT : AID_SHELL,
Zim06b0caf2020-01-05 02:11:47 +00001569 multiuser_get_uid(user_id, AID_EVERYBODY));
Zim3623a212019-07-19 16:46:53 +01001570 if (result != android::OK) {
Zima438b242019-09-25 14:37:38 +01001571 PLOG(ERROR) << "Failed to prepare directory " << pre_fuse_path;
Zim3623a212019-07-19 16:46:53 +01001572 return -1;
1573 }
1574
Zima438b242019-09-25 14:37:38 +01001575 result = PrepareDir(fuse_path, 0700, AID_ROOT, AID_ROOT);
1576 if (result != android::OK) {
1577 PLOG(ERROR) << "Failed to prepare directory " << fuse_path;
1578 return -1;
1579 }
1580
Zim26eec702020-01-31 16:00:58 +00001581 result = PrepareDir(pre_pass_through_path, 0710, AID_ROOT, AID_MEDIA_RW);
Zima438b242019-09-25 14:37:38 +01001582 if (result != android::OK) {
1583 PLOG(ERROR) << "Failed to prepare directory " << pre_pass_through_path;
1584 return -1;
1585 }
1586
Zim26eec702020-01-31 16:00:58 +00001587 result = PrepareDir(pass_through_path, 0710, AID_ROOT, AID_MEDIA_RW);
Zima438b242019-09-25 14:37:38 +01001588 if (result != android::OK) {
1589 PLOG(ERROR) << "Failed to prepare directory " << pass_through_path;
1590 return -1;
1591 }
1592
1593 if (relative_upper_path == "emulated") {
Zime5393d42019-11-15 11:44:12 +00001594 std::string linkpath(StringPrintf("/mnt/user/%d/self", user_id));
1595 result = PrepareDir(linkpath, 0755, AID_ROOT, AID_ROOT);
Zima438b242019-09-25 14:37:38 +01001596 if (result != android::OK) {
Zime5393d42019-11-15 11:44:12 +00001597 PLOG(ERROR) << "Failed to prepare directory " << linkpath;
Zima438b242019-09-25 14:37:38 +01001598 return -1;
1599 }
Zime5393d42019-11-15 11:44:12 +00001600 linkpath += "/primary";
Zim53d16d32020-01-17 01:21:24 +00001601 Symlink("/storage/emulated/" + std::to_string(user_id), linkpath);
Zimaea12472020-01-08 11:09:47 +00001602
1603 std::string pass_through_linkpath(StringPrintf("/mnt/pass_through/%d/self", user_id));
Zim26eec702020-01-31 16:00:58 +00001604 result = PrepareDir(pass_through_linkpath, 0710, AID_ROOT, AID_MEDIA_RW);
Zimaea12472020-01-08 11:09:47 +00001605 if (result != android::OK) {
1606 PLOG(ERROR) << "Failed to prepare directory " << pass_through_linkpath;
1607 return -1;
1608 }
1609 pass_through_linkpath += "/primary";
Zim53d16d32020-01-17 01:21:24 +00001610 Symlink("/storage/emulated/" + std::to_string(user_id), pass_through_linkpath);
Zima438b242019-09-25 14:37:38 +01001611 }
1612
Nandana Dutta914cc72019-08-29 15:22:42 +01001613 // Open fuse fd.
1614 fuse_fd->reset(open("/dev/fuse", O_RDWR | O_CLOEXEC));
1615 if (fuse_fd->get() == -1) {
Zim3623a212019-07-19 16:46:53 +01001616 PLOG(ERROR) << "Failed to open /dev/fuse";
1617 return -1;
1618 }
1619
1620 // Note: leaving out default_permissions since we don't want kernel to do lower filesystem
1621 // permission checks before routing to FUSE daemon.
1622 const auto opts = StringPrintf(
1623 "fd=%i,"
1624 "rootmode=40000,"
1625 "allow_other,"
1626 "user_id=0,group_id=0,",
Nandana Dutta914cc72019-08-29 15:22:42 +01001627 fuse_fd->get());
Zim3623a212019-07-19 16:46:53 +01001628
Zima438b242019-09-25 14:37:38 +01001629 result = TEMP_FAILURE_RETRY(mount("/dev/fuse", fuse_path.c_str(), "fuse",
1630 MS_NOSUID | MS_NODEV | MS_NOEXEC | MS_NOATIME | MS_LAZYTIME,
1631 opts.c_str()));
1632 if (result != 0) {
1633 PLOG(ERROR) << "Failed to mount " << fuse_path;
Zim3623a212019-07-19 16:46:53 +01001634 return -errno;
1635 }
Martijn Coenen6f5802e2019-11-28 11:53:53 +01001636
Daniel Rosenbergf36bddd2020-05-11 22:58:42 -07001637 if (IsSdcardfsUsed()) {
Martijn Coenen86f21a22020-01-06 09:48:14 +01001638 std::string sdcardfs_path(
1639 StringPrintf("/mnt/runtime/full/%s", relative_upper_path.c_str()));
1640
1641 LOG(INFO) << "Bind mounting " << sdcardfs_path << " to " << pass_through_path;
1642 return BindMount(sdcardfs_path, pass_through_path);
1643 } else {
1644 LOG(INFO) << "Bind mounting " << absolute_lower_path << " to " << pass_through_path;
1645 return BindMount(absolute_lower_path, pass_through_path);
1646 }
Zima438b242019-09-25 14:37:38 +01001647}
1648
Martijn Coenen6f5802e2019-11-28 11:53:53 +01001649status_t UnmountUserFuse(userid_t user_id, const std::string& absolute_lower_path,
1650 const std::string& relative_upper_path) {
1651 std::string fuse_path(StringPrintf("/mnt/user/%d/%s", user_id, relative_upper_path.c_str()));
1652 std::string pass_through_path(
1653 StringPrintf("/mnt/pass_through/%d/%s", user_id, relative_upper_path.c_str()));
1654
Martijn Coenen6f5802e2019-11-28 11:53:53 +01001655 LOG(INFO) << "Unmounting fuse path " << fuse_path;
Zima438b242019-09-25 14:37:38 +01001656 android::status_t result = ForceUnmount(fuse_path);
Zima438b242019-09-25 14:37:38 +01001657 if (result != android::OK) {
1658 // TODO(b/135341433): MNT_DETACH is needed for fuse because umount2 can fail with EBUSY.
1659 // Figure out why we get EBUSY and remove this special casing if possible.
1660 PLOG(ERROR) << "Failed to unmount. Trying MNT_DETACH " << fuse_path << " ...";
1661 if (umount2(fuse_path.c_str(), UMOUNT_NOFOLLOW | MNT_DETACH) && errno != EINVAL &&
1662 errno != ENOENT) {
1663 PLOG(ERROR) << "Failed to unmount with MNT_DETACH " << fuse_path;
1664 return -errno;
1665 }
Martijn Coenen57002612019-11-28 11:56:13 +01001666 result = android::OK;
Zima438b242019-09-25 14:37:38 +01001667 }
Martijn Coenen57002612019-11-28 11:56:13 +01001668 rmdir(fuse_path.c_str());
1669
Martijn Coenen64b3bba2020-11-05 10:34:28 +01001670 LOG(INFO) << "Unmounting pass_through_path " << pass_through_path;
1671 auto status = ForceUnmount(pass_through_path);
1672 if (status != android::OK) {
1673 LOG(ERROR) << "Failed to unmount " << pass_through_path;
1674 }
1675 rmdir(pass_through_path.c_str());
1676
Zima438b242019-09-25 14:37:38 +01001677 return result;
Zim3623a212019-07-19 16:46:53 +01001678}
1679
Martijn Coenen62a4b272020-01-31 15:23:09 +01001680status_t PrepareAndroidDirs(const std::string& volumeRoot) {
1681 std::string androidDir = volumeRoot + kAndroidDir;
1682 std::string androidDataDir = volumeRoot + kAppDataDir;
1683 std::string androidObbDir = volumeRoot + kAppObbDir;
Zima13d81b2020-02-07 16:39:31 +00001684 std::string androidMediaDir = volumeRoot + kAppMediaDir;
Martijn Coenen62a4b272020-01-31 15:23:09 +01001685
Daniel Rosenbergf36bddd2020-05-11 22:58:42 -07001686 bool useSdcardFs = IsSdcardfsUsed();
Martijn Coenen62a4b272020-01-31 15:23:09 +01001687
Martijn Coenen10570c02020-02-18 10:41:37 +01001688 // mode 0771 + sticky bit for inheriting GIDs
1689 mode_t mode = S_IRWXU | S_IRWXG | S_IXOTH | S_ISGID;
1690 if (fs_prepare_dir(androidDir.c_str(), mode, AID_MEDIA_RW, AID_MEDIA_RW) != 0) {
Martijn Coenen62a4b272020-01-31 15:23:09 +01001691 PLOG(ERROR) << "Failed to create " << androidDir;
1692 return -errno;
1693 }
1694
1695 gid_t dataGid = useSdcardFs ? AID_MEDIA_RW : AID_EXT_DATA_RW;
Martijn Coenen10570c02020-02-18 10:41:37 +01001696 if (fs_prepare_dir(androidDataDir.c_str(), mode, AID_MEDIA_RW, dataGid) != 0) {
Martijn Coenen62a4b272020-01-31 15:23:09 +01001697 PLOG(ERROR) << "Failed to create " << androidDataDir;
1698 return -errno;
1699 }
1700
1701 gid_t obbGid = useSdcardFs ? AID_MEDIA_RW : AID_EXT_OBB_RW;
Martijn Coenen10570c02020-02-18 10:41:37 +01001702 if (fs_prepare_dir(androidObbDir.c_str(), mode, AID_MEDIA_RW, obbGid) != 0) {
Martijn Coenen62a4b272020-01-31 15:23:09 +01001703 PLOG(ERROR) << "Failed to create " << androidObbDir;
1704 return -errno;
1705 }
Martijn Coenen442bb832020-02-18 13:44:59 +01001706 // Some other apps, like installers, have write access to the OBB directory
1707 // to pre-download them. To make sure newly created folders in this directory
1708 // have the right permissions, set a default ACL.
Martijn Coenen1129b812020-06-16 14:58:52 +02001709 SetDefaultAcl(androidObbDir, mode, AID_MEDIA_RW, obbGid, {});
Martijn Coenen62a4b272020-01-31 15:23:09 +01001710
Martijn Coenen10570c02020-02-18 10:41:37 +01001711 if (fs_prepare_dir(androidMediaDir.c_str(), mode, AID_MEDIA_RW, AID_MEDIA_RW) != 0) {
Zima13d81b2020-02-07 16:39:31 +00001712 PLOG(ERROR) << "Failed to create " << androidMediaDir;
1713 return -errno;
1714 }
1715
Martijn Coenen62a4b272020-01-31 15:23:09 +01001716 return OK;
1717}
Yurii Zubrytskyi18eb8772021-10-18 22:33:15 -07001718
1719namespace ab = android::base;
1720
1721static ab::unique_fd openDirFd(int parentFd, const char* name) {
1722 return ab::unique_fd{::openat(parentFd, name, O_CLOEXEC | O_DIRECTORY | O_PATH | O_NOFOLLOW)};
1723}
1724
1725static ab::unique_fd openAbsolutePathFd(std::string_view path) {
1726 if (path.empty() || path[0] != '/') {
1727 errno = EINVAL;
1728 return {};
1729 }
1730 if (path == "/") {
1731 return openDirFd(-1, "/");
1732 }
1733
1734 // first component is special - it includes the leading slash
1735 auto next = path.find('/', 1);
1736 auto component = std::string(path.substr(0, next));
1737 if (component == "..") {
1738 errno = EINVAL;
1739 return {};
1740 }
1741 auto fd = openDirFd(-1, component.c_str());
1742 if (!fd.ok()) {
1743 return fd;
1744 }
1745 path.remove_prefix(std::min(next + 1, path.size()));
1746 while (next != path.npos && !path.empty()) {
1747 next = path.find('/');
1748 component.assign(path.substr(0, next));
1749 fd = openDirFd(fd, component.c_str());
1750 if (!fd.ok()) {
1751 return fd;
1752 }
1753 path.remove_prefix(std::min(next + 1, path.size()));
1754 }
1755 return fd;
1756}
1757
1758std::pair<android::base::unique_fd, std::string> OpenDirInProcfs(std::string_view path) {
1759 auto fd = openAbsolutePathFd(path);
1760 if (!fd.ok()) {
1761 return {};
1762 }
1763
1764 auto linkPath = std::string("/proc/self/fd/") += std::to_string(fd.get());
1765 return {std::move(fd), std::move(linkPath)};
1766}
1767
Jeff Sharkeydeb24052015-03-02 21:01:40 -08001768} // namespace vold
1769} // namespace android