Utils.cpp

   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 "Utils.h"
  18
  19 #include "Process.h"
  20 #include "sehandle.h"
  21
  22 #include <android-base/chrono_utils.h>
  23 #include <android-base/file.h>
  24 #include <android-base/logging.h>
  25 #include <android-base/properties.h>
  26 #include <android-base/stringprintf.h>
  27 #include <android-base/strings.h>
  28 #include <android-base/unique_fd.h>
  29 #include <cutils/fs.h>
  30 #include <logwrap/logwrap.h>
  31 #include <private/android_filesystem_config.h>
  32
  33 #include <dirent.h>
  34 #include <fcntl.h>
  35 #include <linux/fs.h>
  36 #include <mntent.h>
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <sys/mount.h>
  40 #include <sys/stat.h>
  41 #include <sys/statvfs.h>
  42 #include <sys/sysmacros.h>
  43 #include <sys/types.h>
  44 #include <sys/wait.h>
  45
  46 #include <list>
  47 #include <mutex>
  48 #include <thread>
  49
  50 #ifndef UMOUNT_NOFOLLOW
  51 #define UMOUNT_NOFOLLOW 0x00000008 /* Don't follow symlink on umount */
  52 #endif
  53
  54 using namespace std::chrono_literals;
  55 using android::base::ReadFileToString;
  56 using android::base::StringPrintf;
  57
  58 namespace android {
  59 namespace vold {
  60
  61 security_context_t sBlkidContext = nullptr;
  62 security_context_t sBlkidUntrustedContext = nullptr;
  63 security_context_t sFsckContext = nullptr;
  64 security_context_t sFsckUntrustedContext = nullptr;
  65
  66 bool sSleepOnUnmount = true;
  67
  68 static const char* kBlkidPath = "/system/bin/blkid";
  69 static const char* kKeyPath = "/data/misc/vold";
  70
  71 static const char* kProcFilesystems = "/proc/filesystems";
  72
  73 // Lock used to protect process-level SELinux changes from racing with each
  74 // other between multiple threads.
  75 static std::mutex kSecurityLock;
  76
  77 status_t CreateDeviceNode(const std::string& path, dev_t dev) {
  78     std::lock_guard<std::mutex> lock(kSecurityLock);
  79     const char* cpath = path.c_str();
  80     status_t res = 0;
  81
  82     char* secontext = nullptr;
  83     if (sehandle) {
  84         if (!selabel_lookup(sehandle, &secontext, cpath, S_IFBLK)) {
  85             setfscreatecon(secontext);
  86         }
  87     }
  88
  89     mode_t mode = 0660 | S_IFBLK;
  90     if (mknod(cpath, mode, dev) < 0) {
  91         if (errno != EEXIST) {
  92             PLOG(ERROR) << "Failed to create device node for " << major(dev) << ":" << minor(dev)
  93                         << " at " << path;
  94             res = -errno;
  95         }
  96     }
  97
  98     if (secontext) {
  99         setfscreatecon(nullptr);
 100         freecon(secontext);
 101     }
 102
 103     return res;
 104 }
 105
 106 status_t DestroyDeviceNode(const std::string& path) {
 107     const char* cpath = path.c_str();
 108     if (TEMP_FAILURE_RETRY(unlink(cpath))) {
 109         return -errno;
 110     } else {
 111         return OK;
 112     }
 113 }
 114
 115 status_t PrepareDir(const std::string& path, mode_t mode, uid_t uid, gid_t gid) {
 116     std::lock_guard<std::mutex> lock(kSecurityLock);
 117     const char* cpath = path.c_str();
 118
 119     char* secontext = nullptr;
 120     if (sehandle) {
 121         if (!selabel_lookup(sehandle, &secontext, cpath, S_IFDIR)) {
 122             setfscreatecon(secontext);
 123         }
 124     }
 125
 126     int res = fs_prepare_dir(cpath, mode, uid, gid);
 127
 128     if (secontext) {
 129         setfscreatecon(nullptr);
 130         freecon(secontext);
 131     }
 132
 133     if (res == 0) {
 134         return OK;
 135     } else {
 136         return -errno;
 137     }
 138 }
 139
 140 status_t ForceUnmount(const std::string& path) {
 141     const char* cpath = path.c_str();
 142     if (!umount2(cpath, UMOUNT_NOFOLLOW) || errno == EINVAL || errno == ENOENT) {
 143         return OK;
 144     }
 145     // Apps might still be handling eject request, so wait before
 146     // we start sending signals
 147     if (sSleepOnUnmount) sleep(5);
 148
 149     KillProcessesWithOpenFiles(path, SIGINT);
 150     if (sSleepOnUnmount) sleep(5);
 151     if (!umount2(cpath, UMOUNT_NOFOLLOW) || errno == EINVAL || errno == ENOENT) {
 152         return OK;
 153     }
 154
 155     KillProcessesWithOpenFiles(path, SIGTERM);
 156     if (sSleepOnUnmount) sleep(5);
 157     if (!umount2(cpath, UMOUNT_NOFOLLOW) || errno == EINVAL || errno == ENOENT) {
 158         return OK;
 159     }
 160
 161     KillProcessesWithOpenFiles(path, SIGKILL);
 162     if (sSleepOnUnmount) sleep(5);
 163     if (!umount2(cpath, UMOUNT_NOFOLLOW) || errno == EINVAL || errno == ENOENT) {
 164         return OK;
 165     }
 166
 167     return -errno;
 168 }
 169
 170 status_t KillProcessesUsingPath(const std::string& path) {
 171     if (KillProcessesWithOpenFiles(path, SIGINT) == 0) {
 172         return OK;
 173     }
 174     if (sSleepOnUnmount) sleep(5);
 175
 176     if (KillProcessesWithOpenFiles(path, SIGTERM) == 0) {
 177         return OK;
 178     }
 179     if (sSleepOnUnmount) sleep(5);
 180
 181     if (KillProcessesWithOpenFiles(path, SIGKILL) == 0) {
 182         return OK;
 183     }
 184     if (sSleepOnUnmount) sleep(5);
 185
 186     // Send SIGKILL a second time to determine if we've
 187     // actually killed everyone with open files
 188     if (KillProcessesWithOpenFiles(path, SIGKILL) == 0) {
 189         return OK;
 190     }
 191     PLOG(ERROR) << "Failed to kill processes using " << path;
 192     return -EBUSY;
 193 }
 194
 195 status_t BindMount(const std::string& source, const std::string& target) {
 196     if (::mount(source.c_str(), target.c_str(), "", MS_BIND, NULL)) {
 197         PLOG(ERROR) << "Failed to bind mount " << source << " to " << target;
 198         return -errno;
 199     }
 200     return OK;
 201 }
 202
 203 bool FindValue(const std::string& raw, const std::string& key, std::string* value) {
 204     auto qual = key + "=\"";
 205     size_t start = 0;
 206     while (true) {
 207         start = raw.find(qual, start);
 208         if (start == std::string::npos) return false;
 209         if (start == 0 || raw[start - 1] == ' ') {
 210             break;
 211         }
 212         start += 1;
 213     }
 214     start += qual.length();
 215
 216     auto end = raw.find("\"", start);
 217     if (end == std::string::npos) return false;
 218
 219     *value = raw.substr(start, end - start);
 220     return true;
 221 }
 222
 223 static status_t readMetadata(const std::string& path, std::string* fsType, std::string* fsUuid,
 224                              std::string* fsLabel, bool untrusted) {
 225     fsType->clear();
 226     fsUuid->clear();
 227     fsLabel->clear();
 228
 229     std::vector<std::string> cmd;
 230     cmd.push_back(kBlkidPath);
 231     cmd.push_back("-c");
 232     cmd.push_back("/dev/null");
 233     cmd.push_back("-s");
 234     cmd.push_back("TYPE");
 235     cmd.push_back("-s");
 236     cmd.push_back("UUID");
 237     cmd.push_back("-s");
 238     cmd.push_back("LABEL");
 239     cmd.push_back(path);
 240
 241     std::vector<std::string> output;
 242     status_t res = ForkExecvp(cmd, &output, untrusted ? sBlkidUntrustedContext : sBlkidContext);
 243     if (res != OK) {
 244         LOG(WARNING) << "blkid failed to identify " << path;
 245         return res;
 246     }
 247
 248     for (const auto& line : output) {
 249         // Extract values from blkid output, if defined
 250         FindValue(line, "TYPE", fsType);
 251         FindValue(line, "UUID", fsUuid);
 252         FindValue(line, "LABEL", fsLabel);
 253     }
 254
 255     return OK;
 256 }
 257
 258 status_t ReadMetadata(const std::string& path, std::string* fsType, std::string* fsUuid,
 259                       std::string* fsLabel) {
 260     return readMetadata(path, fsType, fsUuid, fsLabel, false);
 261 }
 262
 263 status_t ReadMetadataUntrusted(const std::string& path, std::string* fsType, std::string* fsUuid,
 264                                std::string* fsLabel) {
 265     return readMetadata(path, fsType, fsUuid, fsLabel, true);
 266 }
 267
 268 static std::vector<const char*> ConvertToArgv(const std::vector<std::string>& args) {
 269     std::vector<const char*> argv;
 270     argv.reserve(args.size() + 1);
 271     for (const auto& arg : args) {
 272         if (argv.empty()) {
 273             LOG(DEBUG) << arg;
 274         } else {
 275             LOG(DEBUG) << "    " << arg;
 276         }
 277         argv.emplace_back(arg.data());
 278     }
 279     argv.emplace_back(nullptr);
 280     return argv;
 281 }
 282
 283 static status_t ReadLinesFromFdAndLog(std::vector<std::string>* output,
 284                                       android::base::unique_fd ufd) {
 285     std::unique_ptr<FILE, int (*)(FILE*)> fp(android::base::Fdopen(std::move(ufd), "r"), fclose);
 286     if (!fp) {
 287         PLOG(ERROR) << "fdopen in ReadLinesFromFdAndLog";
 288         return -errno;
 289     }
 290     if (output) output->clear();
 291     char line[1024];
 292     while (fgets(line, sizeof(line), fp.get()) != nullptr) {
 293         LOG(DEBUG) << line;
 294         if (output) output->emplace_back(line);
 295     }
 296     return OK;
 297 }
 298
 299 status_t ForkExecvp(const std::vector<std::string>& args, std::vector<std::string>* output,
 300                     security_context_t context) {
 301     auto argv = ConvertToArgv(args);
 302
 303     android::base::unique_fd pipe_read, pipe_write;
 304     if (!android::base::Pipe(&pipe_read, &pipe_write)) {
 305         PLOG(ERROR) << "Pipe in ForkExecvp";
 306         return -errno;
 307     }
 308
 309     pid_t pid = fork();
 310     if (pid == 0) {
 311         if (context) {
 312             if (setexeccon(context)) {
 313                 LOG(ERROR) << "Failed to setexeccon in ForkExecvp";
 314                 abort();
 315             }
 316         }
 317         pipe_read.reset();
 318         if (dup2(pipe_write.get(), STDOUT_FILENO) == -1) {
 319             PLOG(ERROR) << "dup2 in ForkExecvp";
 320             _exit(EXIT_FAILURE);
 321         }
 322         pipe_write.reset();
 323         execvp(argv[0], const_cast<char**>(argv.data()));
 324         PLOG(ERROR) << "exec in ForkExecvp";
 325         _exit(EXIT_FAILURE);
 326     }
 327     if (pid == -1) {
 328         PLOG(ERROR) << "fork in ForkExecvp";
 329         return -errno;
 330     }
 331
 332     pipe_write.reset();
 333     auto st = ReadLinesFromFdAndLog(output, std::move(pipe_read));
 334     if (st != 0) return st;
 335
 336     int status;
 337     if (waitpid(pid, &status, 0) == -1) {
 338         PLOG(ERROR) << "waitpid in ForkExecvp";
 339         return -errno;
 340     }
 341     if (!WIFEXITED(status)) {
 342         LOG(ERROR) << "Process did not exit normally, status: " << status;
 343         return -ECHILD;
 344     }
 345     if (WEXITSTATUS(status)) {
 346         LOG(ERROR) << "Process exited with code: " << WEXITSTATUS(status);
 347         return WEXITSTATUS(status);
 348     }
 349     return OK;
 350 }
 351
 352 pid_t ForkExecvpAsync(const std::vector<std::string>& args) {
 353     auto argv = ConvertToArgv(args);
 354
 355     pid_t pid = fork();
 356     if (pid == 0) {
 357         close(STDIN_FILENO);
 358         close(STDOUT_FILENO);
 359         close(STDERR_FILENO);
 360
 361         execvp(argv[0], const_cast<char**>(argv.data()));
 362         PLOG(ERROR) << "exec in ForkExecvpAsync";
 363         _exit(EXIT_FAILURE);
 364     }
 365     if (pid == -1) {
 366         PLOG(ERROR) << "fork in ForkExecvpAsync";
 367         return -1;
 368     }
 369     return pid;
 370 }
 371
 372 status_t ReadRandomBytes(size_t bytes, std::string& out) {
 373     out.resize(bytes);
 374     return ReadRandomBytes(bytes, &out[0]);
 375 }
 376
 377 status_t ReadRandomBytes(size_t bytes, char* buf) {
 378     int fd = TEMP_FAILURE_RETRY(open("/dev/urandom", O_RDONLY | O_CLOEXEC | O_NOFOLLOW));
 379     if (fd == -1) {
 380         return -errno;
 381     }
 382
 383     ssize_t n;
 384     while ((n = TEMP_FAILURE_RETRY(read(fd, &buf[0], bytes))) > 0) {
 385         bytes -= n;
 386         buf += n;
 387     }
 388     close(fd);
 389
 390     if (bytes == 0) {
 391         return OK;
 392     } else {
 393         return -EIO;
 394     }
 395 }
 396
 397 status_t GenerateRandomUuid(std::string& out) {
 398     status_t res = ReadRandomBytes(16, out);
 399     if (res == OK) {
 400         out[6] &= 0x0f; /* clear version        */
 401         out[6] |= 0x40; /* set to version 4     */
 402         out[8] &= 0x3f; /* clear variant        */
 403         out[8] |= 0x80; /* set to IETF variant  */
 404     }
 405     return res;
 406 }
 407
 408 status_t HexToStr(const std::string& hex, std::string& str) {
 409     str.clear();
 410     bool even = true;
 411     char cur = 0;
 412     for (size_t i = 0; i < hex.size(); i++) {
 413         int val = 0;
 414         switch (hex[i]) {
 415             // clang-format off
 416             case ' ': case '-': case ':': continue;
 417             case 'f': case 'F': val = 15; break;
 418             case 'e': case 'E': val = 14; break;
 419             case 'd': case 'D': val = 13; break;
 420             case 'c': case 'C': val = 12; break;
 421             case 'b': case 'B': val = 11; break;
 422             case 'a': case 'A': val = 10; break;
 423             case '9': val = 9; break;
 424             case '8': val = 8; break;
 425             case '7': val = 7; break;
 426             case '6': val = 6; break;
 427             case '5': val = 5; break;
 428             case '4': val = 4; break;
 429             case '3': val = 3; break;
 430             case '2': val = 2; break;
 431             case '1': val = 1; break;
 432             case '0': val = 0; break;
 433             default: return -EINVAL;
 434                 // clang-format on
 435         }
 436
 437         if (even) {
 438             cur = val << 4;
 439         } else {
 440             cur += val;
 441             str.push_back(cur);
 442             cur = 0;
 443         }
 444         even = !even;
 445     }
 446     return even ? OK : -EINVAL;
 447 }
 448
 449 static const char* kLookup = "0123456789abcdef";
 450
 451 status_t StrToHex(const std::string& str, std::string& hex) {
 452     hex.clear();
 453     for (size_t i = 0; i < str.size(); i++) {
 454         hex.push_back(kLookup[(str[i] & 0xF0) >> 4]);
 455         hex.push_back(kLookup[str[i] & 0x0F]);
 456     }
 457     return OK;
 458 }
 459
 460 status_t StrToHex(const KeyBuffer& str, KeyBuffer& hex) {
 461     hex.clear();
 462     for (size_t i = 0; i < str.size(); i++) {
 463         hex.push_back(kLookup[(str.data()[i] & 0xF0) >> 4]);
 464         hex.push_back(kLookup[str.data()[i] & 0x0F]);
 465     }
 466     return OK;
 467 }
 468
 469 status_t NormalizeHex(const std::string& in, std::string& out) {
 470     std::string tmp;
 471     if (HexToStr(in, tmp)) {
 472         return -EINVAL;
 473     }
 474     return StrToHex(tmp, out);
 475 }
 476
 477 status_t GetBlockDevSize(int fd, uint64_t* size) {
 478     if (ioctl(fd, BLKGETSIZE64, size)) {
 479         return -errno;
 480     }
 481
 482     return OK;
 483 }
 484
 485 status_t GetBlockDevSize(const std::string& path, uint64_t* size) {
 486     int fd = open(path.c_str(), O_RDONLY | O_CLOEXEC);
 487     status_t res = OK;
 488
 489     if (fd < 0) {
 490         return -errno;
 491     }
 492
 493     res = GetBlockDevSize(fd, size);
 494
 495     close(fd);
 496
 497     return res;
 498 }
 499
 500 status_t GetBlockDev512Sectors(const std::string& path, uint64_t* nr_sec) {
 501     uint64_t size;
 502     status_t res = GetBlockDevSize(path, &size);
 503
 504     if (res != OK) {
 505         return res;
 506     }
 507
 508     *nr_sec = size / 512;
 509
 510     return OK;
 511 }
 512
 513 uint64_t GetFreeBytes(const std::string& path) {
 514     struct statvfs sb;
 515     if (statvfs(path.c_str(), &sb) == 0) {
 516         return (uint64_t)sb.f_bavail * sb.f_frsize;
 517     } else {
 518         return -1;
 519     }
 520 }
 521
 522 // TODO: borrowed from frameworks/native/libs/diskusage/ which should
 523 // eventually be migrated into system/
 524 static int64_t stat_size(struct stat* s) {
 525     int64_t blksize = s->st_blksize;
 526     // count actual blocks used instead of nominal file size
 527     int64_t size = s->st_blocks * 512;
 528
 529     if (blksize) {
 530         /* round up to filesystem block size */
 531         size = (size + blksize - 1) & (~(blksize - 1));
 532     }
 533
 534     return size;
 535 }
 536
 537 // TODO: borrowed from frameworks/native/libs/diskusage/ which should
 538 // eventually be migrated into system/
 539 int64_t calculate_dir_size(int dfd) {
 540     int64_t size = 0;
 541     struct stat s;
 542     DIR* d;
 543     struct dirent* de;
 544
 545     d = fdopendir(dfd);
 546     if (d == NULL) {
 547         close(dfd);
 548         return 0;
 549     }
 550
 551     while ((de = readdir(d))) {
 552         const char* name = de->d_name;
 553         if (fstatat(dfd, name, &s, AT_SYMLINK_NOFOLLOW) == 0) {
 554             size += stat_size(&s);
 555         }
 556         if (de->d_type == DT_DIR) {
 557             int subfd;
 558
 559             /* always skip "." and ".." */
 560             if (name[0] == '.') {
 561                 if (name[1] == 0) continue;
 562                 if ((name[1] == '.') && (name[2] == 0)) continue;
 563             }
 564
 565             subfd = openat(dfd, name, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
 566             if (subfd >= 0) {
 567                 size += calculate_dir_size(subfd);
 568             }
 569         }
 570     }
 571     closedir(d);
 572     return size;
 573 }
 574
 575 uint64_t GetTreeBytes(const std::string& path) {
 576     int dirfd = open(path.c_str(), O_RDONLY | O_DIRECTORY | O_CLOEXEC);
 577     if (dirfd < 0) {
 578         PLOG(WARNING) << "Failed to open " << path;
 579         return -1;
 580     } else {
 581         return calculate_dir_size(dirfd);
 582     }
 583 }
 584
 585 bool IsFilesystemSupported(const std::string& fsType) {
 586     std::string supported;
 587     if (!ReadFileToString(kProcFilesystems, &supported)) {
 588         PLOG(ERROR) << "Failed to read supported filesystems";
 589         return false;
 590     }
 591     return supported.find(fsType + "\n") != std::string::npos;
 592 }
 593
 594 status_t WipeBlockDevice(const std::string& path) {
 595     status_t res = -1;
 596     const char* c_path = path.c_str();
 597     uint64_t range[2] = {0, 0};
 598
 599     int fd = TEMP_FAILURE_RETRY(open(c_path, O_RDWR | O_CLOEXEC));
 600     if (fd == -1) {
 601         PLOG(ERROR) << "Failed to open " << path;
 602         goto done;
 603     }
 604
 605     if (GetBlockDevSize(fd, &range[1]) != OK) {
 606         PLOG(ERROR) << "Failed to determine size of " << path;
 607         goto done;
 608     }
 609
 610     LOG(INFO) << "About to discard " << range[1] << " on " << path;
 611     if (ioctl(fd, BLKDISCARD, &range) == 0) {
 612         LOG(INFO) << "Discard success on " << path;
 613         res = 0;
 614     } else {
 615         PLOG(ERROR) << "Discard failure on " << path;
 616     }
 617
 618 done:
 619     close(fd);
 620     return res;
 621 }
 622
 623 static bool isValidFilename(const std::string& name) {
 624     if (name.empty() || (name == ".") || (name == "..") || (name.find('/') != std::string::npos)) {
 625         return false;
 626     } else {
 627         return true;
 628     }
 629 }
 630
 631 std::string BuildKeyPath(const std::string& partGuid) {
 632     return StringPrintf("%s/expand_%s.key", kKeyPath, partGuid.c_str());
 633 }
 634
 635 std::string BuildDataSystemLegacyPath(userid_t userId) {
 636     return StringPrintf("%s/system/users/%u", BuildDataPath("").c_str(), userId);
 637 }
 638
 639 std::string BuildDataSystemCePath(userid_t userId) {
 640     return StringPrintf("%s/system_ce/%u", BuildDataPath("").c_str(), userId);
 641 }
 642
 643 std::string BuildDataSystemDePath(userid_t userId) {
 644     return StringPrintf("%s/system_de/%u", BuildDataPath("").c_str(), userId);
 645 }
 646
 647 std::string BuildDataMiscLegacyPath(userid_t userId) {
 648     return StringPrintf("%s/misc/user/%u", BuildDataPath("").c_str(), userId);
 649 }
 650
 651 std::string BuildDataMiscCePath(userid_t userId) {
 652     return StringPrintf("%s/misc_ce/%u", BuildDataPath("").c_str(), userId);
 653 }
 654
 655 std::string BuildDataMiscDePath(userid_t userId) {
 656     return StringPrintf("%s/misc_de/%u", BuildDataPath("").c_str(), userId);
 657 }
 658
 659 // Keep in sync with installd (frameworks/native/cmds/installd/utils.h)
 660 std::string BuildDataProfilesDePath(userid_t userId) {
 661     return StringPrintf("%s/misc/profiles/cur/%u", BuildDataPath("").c_str(), userId);
 662 }
 663
 664 std::string BuildDataVendorCePath(userid_t userId) {
 665     return StringPrintf("%s/vendor_ce/%u", BuildDataPath("").c_str(), userId);
 666 }
 667
 668 std::string BuildDataVendorDePath(userid_t userId) {
 669     return StringPrintf("%s/vendor_de/%u", BuildDataPath("").c_str(), userId);
 670 }
 671
 672 std::string BuildDataPath(const std::string& volumeUuid) {
 673     // TODO: unify with installd path generation logic
 674     if (volumeUuid.empty()) {
 675         return "/data";
 676     } else {
 677         CHECK(isValidFilename(volumeUuid));
 678         return StringPrintf("/mnt/expand/%s", volumeUuid.c_str());
 679     }
 680 }
 681
 682 std::string BuildDataMediaCePath(const std::string& volumeUuid, userid_t userId) {
 683     // TODO: unify with installd path generation logic
 684     std::string data(BuildDataPath(volumeUuid));
 685     return StringPrintf("%s/media/%u", data.c_str(), userId);
 686 }
 687
 688 std::string BuildDataUserCePath(const std::string& volumeUuid, userid_t userId) {
 689     // TODO: unify with installd path generation logic
 690     std::string data(BuildDataPath(volumeUuid));
 691     if (volumeUuid.empty() && userId == 0) {
 692         std::string legacy = StringPrintf("%s/data", data.c_str());
 693         struct stat sb;
 694         if (lstat(legacy.c_str(), &sb) == 0 && S_ISDIR(sb.st_mode)) {
 695             /* /data/data is dir, return /data/data for legacy system */
 696             return legacy;
 697         }
 698     }
 699     return StringPrintf("%s/user/%u", data.c_str(), userId);
 700 }
 701
 702 std::string BuildDataUserDePath(const std::string& volumeUuid, userid_t userId) {
 703     // TODO: unify with installd path generation logic
 704     std::string data(BuildDataPath(volumeUuid));
 705     return StringPrintf("%s/user_de/%u", data.c_str(), userId);
 706 }
 707
 708 dev_t GetDevice(const std::string& path) {
 709     struct stat sb;
 710     if (stat(path.c_str(), &sb)) {
 711         PLOG(WARNING) << "Failed to stat " << path;
 712         return 0;
 713     } else {
 714         return sb.st_dev;
 715     }
 716 }
 717
 718 status_t RestoreconRecursive(const std::string& path) {
 719     LOG(DEBUG) << "Starting restorecon of " << path;
 720
 721     static constexpr const char* kRestoreconString = "selinux.restorecon_recursive";
 722
 723     android::base::SetProperty(kRestoreconString, "");
 724     android::base::SetProperty(kRestoreconString, path);
 725
 726     android::base::WaitForProperty(kRestoreconString, path);
 727
 728     LOG(DEBUG) << "Finished restorecon of " << path;
 729     return OK;
 730 }
 731
 732 bool Readlinkat(int dirfd, const std::string& path, std::string* result) {
 733     // Shamelessly borrowed from android::base::Readlink()
 734     result->clear();
 735
 736     // Most Linux file systems (ext2 and ext4, say) limit symbolic links to
 737     // 4095 bytes. Since we'll copy out into the string anyway, it doesn't
 738     // waste memory to just start there. We add 1 so that we can recognize
 739     // whether it actually fit (rather than being truncated to 4095).
 740     std::vector<char> buf(4095 + 1);
 741     while (true) {
 742         ssize_t size = readlinkat(dirfd, path.c_str(), &buf[0], buf.size());
 743         // Unrecoverable error?
 744         if (size == -1) return false;
 745         // It fit! (If size == buf.size(), it may have been truncated.)
 746         if (static_cast<size_t>(size) < buf.size()) {
 747             result->assign(&buf[0], size);
 748             return true;
 749         }
 750         // Double our buffer and try again.
 751         buf.resize(buf.size() * 2);
 752     }
 753 }
 754
 755 bool IsRunningInEmulator() {
 756     return android::base::GetBoolProperty("ro.kernel.qemu", false);
 757 }
 758
 759 static status_t findMountPointsWithPrefix(const std::string& prefix,
 760                                           std::list<std::string>& mountPoints) {
 761     // Add a trailing slash if the client didn't provide one so that we don't match /foo/barbaz
 762     // when the prefix is /foo/bar
 763     std::string prefixWithSlash(prefix);
 764     if (prefix.back() != '/') {
 765         android::base::StringAppendF(&prefixWithSlash, "/");
 766     }
 767
 768     std::unique_ptr<FILE, int (*)(FILE*)> mnts(setmntent("/proc/mounts", "re"), endmntent);
 769     if (!mnts) {
 770         PLOG(ERROR) << "Unable to open /proc/mounts";
 771         return -errno;
 772     }
 773
 774     // Some volumes can be stacked on each other, so force unmount in
 775     // reverse order to give us the best chance of success.
 776     struct mntent* mnt;  // getmntent returns a thread local, so it's safe.
 777     while ((mnt = getmntent(mnts.get())) != nullptr) {
 778         auto mountPoint = std::string(mnt->mnt_dir) + "/";
 779         if (android::base::StartsWith(mountPoint, prefixWithSlash)) {
 780             mountPoints.push_front(mountPoint);
 781         }
 782     }
 783     return OK;
 784 }
 785
 786 // Unmount all mountpoints that start with prefix. prefix itself doesn't need to be a mountpoint.
 787 status_t UnmountTreeWithPrefix(const std::string& prefix) {
 788     std::list<std::string> toUnmount;
 789     status_t result = findMountPointsWithPrefix(prefix, toUnmount);
 790     if (result < 0) {
 791         return result;
 792     }
 793     for (const auto& path : toUnmount) {
 794         if (umount2(path.c_str(), MNT_DETACH)) {
 795             PLOG(ERROR) << "Failed to unmount " << path;
 796             result = -errno;
 797         }
 798     }
 799     return result;
 800 }
 801
 802 status_t UnmountTree(const std::string& mountPoint) {
 803     if (umount2(mountPoint.c_str(), MNT_DETACH)) {
 804         PLOG(ERROR) << "Failed to unmount " << mountPoint;
 805         return -errno;
 806     }
 807     return OK;
 808 }
 809
 810 // TODO(118708649): fix duplication with init/util.h
 811 status_t WaitForFile(const char* filename, std::chrono::nanoseconds timeout) {
 812     android::base::Timer t;
 813     while (t.duration() < timeout) {
 814         struct stat sb;
 815         if (stat(filename, &sb) != -1) {
 816             LOG(INFO) << "wait for '" << filename << "' took " << t;
 817             return 0;
 818         }
 819         std::this_thread::sleep_for(10ms);
 820     }
 821     LOG(WARNING) << "wait for '" << filename << "' timed out and took " << t;
 822     return -1;
 823 }
 824
 825 bool FsyncDirectory(const std::string& dirname) {
 826     android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(dirname.c_str(), O_RDONLY | O_CLOEXEC)));
 827     if (fd == -1) {
 828         PLOG(ERROR) << "Failed to open " << dirname;
 829         return false;
 830     }
 831     if (fsync(fd) == -1) {
 832         if (errno == EROFS || errno == EINVAL) {
 833             PLOG(WARNING) << "Skip fsync " << dirname
 834                           << " on a file system does not support synchronization";
 835         } else {
 836             PLOG(ERROR) << "Failed to fsync " << dirname;
 837             return false;
 838         }
 839     }
 840     return true;
 841 }
 842
 843 }  // namespace vold
 844 }  // namespace android