VoldNativeService.cpp

   1 /*
   2  * Copyright (C) 2017 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 #define ATRACE_TAG ATRACE_TAG_PACKAGE_MANAGER
  18
  19 #include "VoldNativeService.h"
  20
  21 #include <android-base/logging.h>
  22 #include <android-base/stringprintf.h>
  23 #include <android-base/strings.h>
  24 #include <fs_mgr.h>
  25 #include <fscrypt/fscrypt.h>
  26 #include <private/android_filesystem_config.h>
  27 #include <utils/Trace.h>
  28
  29 #include <fstream>
  30 #include <thread>
  31
  32 #include "Benchmark.h"
  33 #include "Checkpoint.h"
  34 #include "FsCrypt.h"
  35 #include "IdleMaint.h"
  36 #include "KeyStorage.h"
  37 #include "Keymaster.h"
  38 #include "MetadataCrypt.h"
  39 #include "MoveStorage.h"
  40 #include "Process.h"
  41 #include "VoldNativeServiceValidation.h"
  42 #include "VoldUtil.h"
  43 #include "VolumeManager.h"
  44 #include "cryptfs.h"
  45 #include "incfs.h"
  46
  47 using android::base::StringPrintf;
  48 using std::endl;
  49 using namespace std::literals;
  50
  51 namespace android {
  52 namespace vold {
  53
  54 namespace {
  55
  56 constexpr const char* kDump = "android.permission.DUMP";
  57
  58 static binder::Status error(const std::string& msg) {
  59     PLOG(ERROR) << msg;
  60     return binder::Status::fromServiceSpecificError(errno, String8(msg.c_str()));
  61 }
  62
  63 static binder::Status translate(int status) {
  64     if (status == 0) {
  65         return binder::Status::ok();
  66     } else {
  67         return binder::Status::fromServiceSpecificError(status);
  68     }
  69 }
  70
  71 static binder::Status translateBool(bool status) {
  72     if (status) {
  73         return binder::Status::ok();
  74     } else {
  75         return binder::Status::fromServiceSpecificError(status);
  76     }
  77 }
  78
  79 #define ENFORCE_SYSTEM_OR_ROOT                              \
  80     {                                                       \
  81         binder::Status status = CheckUidOrRoot(AID_SYSTEM); \
  82         if (!status.isOk()) {                               \
  83             return status;                                  \
  84         }                                                   \
  85     }
  86
  87 #define CHECK_ARGUMENT_ID(id)                          \
  88     {                                                  \
  89         binder::Status status = CheckArgumentId((id)); \
  90         if (!status.isOk()) {                          \
  91             return status;                             \
  92         }                                              \
  93     }
  94
  95 #define CHECK_ARGUMENT_PATH(path)                          \
  96     {                                                      \
  97         binder::Status status = CheckArgumentPath((path)); \
  98         if (!status.isOk()) {                              \
  99             return status;                                 \
 100         }                                                  \
 101     }
 102
 103 #define CHECK_ARGUMENT_HEX(hex)                          \
 104     {                                                    \
 105         binder::Status status = CheckArgumentHex((hex)); \
 106         if (!status.isOk()) {                            \
 107             return status;                               \
 108         }                                                \
 109     }
 110
 111 #define ACQUIRE_LOCK                                                        \
 112     std::lock_guard<std::mutex> lock(VolumeManager::Instance()->getLock()); \
 113     ATRACE_CALL();
 114
 115 #define ACQUIRE_CRYPT_LOCK                                                       \
 116     std::lock_guard<std::mutex> lock(VolumeManager::Instance()->getCryptLock()); \
 117     ATRACE_CALL();
 118
 119 }  // namespace
 120
 121 status_t VoldNativeService::start() {
 122     IPCThreadState::self()->disableBackgroundScheduling(true);
 123     status_t ret = BinderService<VoldNativeService>::publish();
 124     if (ret != android::OK) {
 125         return ret;
 126     }
 127     sp<ProcessState> ps(ProcessState::self());
 128     ps->startThreadPool();
 129     ps->giveThreadPoolName();
 130     return android::OK;
 131 }
 132
 133 status_t VoldNativeService::dump(int fd, const Vector<String16>& /* args */) {
 134     auto out = std::fstream(StringPrintf("/proc/self/fd/%d", fd));
 135     const binder::Status dump_permission = CheckPermission(kDump);
 136     if (!dump_permission.isOk()) {
 137         out << dump_permission.toString8() << endl;
 138         return PERMISSION_DENIED;
 139     }
 140
 141     ACQUIRE_LOCK;
 142     out << "vold is happy!" << endl;
 143     return NO_ERROR;
 144 }
 145
 146 binder::Status VoldNativeService::setListener(
 147         const android::sp<android::os::IVoldListener>& listener) {
 148     ENFORCE_SYSTEM_OR_ROOT;
 149     ACQUIRE_LOCK;
 150
 151     VolumeManager::Instance()->setListener(listener);
 152     return Ok();
 153 }
 154
 155 binder::Status VoldNativeService::monitor() {
 156     ENFORCE_SYSTEM_OR_ROOT;
 157
 158     // Simply acquire/release each lock for watchdog
 159     { ACQUIRE_LOCK; }
 160     { ACQUIRE_CRYPT_LOCK; }
 161
 162     return Ok();
 163 }
 164
 165 binder::Status VoldNativeService::reset() {
 166     ENFORCE_SYSTEM_OR_ROOT;
 167     ACQUIRE_LOCK;
 168
 169     return translate(VolumeManager::Instance()->reset());
 170 }
 171
 172 binder::Status VoldNativeService::shutdown() {
 173     ENFORCE_SYSTEM_OR_ROOT;
 174     ACQUIRE_LOCK;
 175
 176     return translate(VolumeManager::Instance()->shutdown());
 177 }
 178
 179 binder::Status VoldNativeService::abortFuse() {
 180     ENFORCE_SYSTEM_OR_ROOT;
 181     // if acquire lock, maybe lead to a deadlock if lock is held by a
 182     // thread that is blocked on a FUSE operation.
 183     // abort fuse doesn't need to access any state, so do not acquire lock
 184
 185     return translate(VolumeManager::Instance()->abortFuse());
 186 }
 187
 188 binder::Status VoldNativeService::onUserAdded(int32_t userId, int32_t userSerial) {
 189     ENFORCE_SYSTEM_OR_ROOT;
 190     ACQUIRE_LOCK;
 191
 192     return translate(VolumeManager::Instance()->onUserAdded(userId, userSerial));
 193 }
 194
 195 binder::Status VoldNativeService::onUserRemoved(int32_t userId) {
 196     ENFORCE_SYSTEM_OR_ROOT;
 197     ACQUIRE_LOCK;
 198
 199     return translate(VolumeManager::Instance()->onUserRemoved(userId));
 200 }
 201
 202 binder::Status VoldNativeService::onUserStarted(int32_t userId) {
 203     ENFORCE_SYSTEM_OR_ROOT;
 204     ACQUIRE_LOCK;
 205
 206     return translate(VolumeManager::Instance()->onUserStarted(userId));
 207 }
 208
 209 binder::Status VoldNativeService::onUserStopped(int32_t userId) {
 210     ENFORCE_SYSTEM_OR_ROOT;
 211     ACQUIRE_LOCK;
 212
 213     return translate(VolumeManager::Instance()->onUserStopped(userId));
 214 }
 215
 216 binder::Status VoldNativeService::addAppIds(const std::vector<std::string>& packageNames,
 217                                             const std::vector<int32_t>& appIds) {
 218     return Ok();
 219 }
 220
 221 binder::Status VoldNativeService::addSandboxIds(const std::vector<int32_t>& appIds,
 222                                                 const std::vector<std::string>& sandboxIds) {
 223     return Ok();
 224 }
 225
 226 binder::Status VoldNativeService::onSecureKeyguardStateChanged(bool isShowing) {
 227     ENFORCE_SYSTEM_OR_ROOT;
 228     ACQUIRE_LOCK;
 229
 230     return translate(VolumeManager::Instance()->onSecureKeyguardStateChanged(isShowing));
 231 }
 232
 233 binder::Status VoldNativeService::partition(const std::string& diskId, int32_t partitionType,
 234                                             int32_t ratio) {
 235     ENFORCE_SYSTEM_OR_ROOT;
 236     CHECK_ARGUMENT_ID(diskId);
 237     ACQUIRE_LOCK;
 238
 239     auto disk = VolumeManager::Instance()->findDisk(diskId);
 240     if (disk == nullptr) {
 241         return error("Failed to find disk " + diskId);
 242     }
 243     switch (partitionType) {
 244         case PARTITION_TYPE_PUBLIC:
 245             return translate(disk->partitionPublic());
 246         case PARTITION_TYPE_PRIVATE:
 247             return translate(disk->partitionPrivate());
 248         case PARTITION_TYPE_MIXED:
 249             return translate(disk->partitionMixed(ratio));
 250         default:
 251             return error("Unknown type " + std::to_string(partitionType));
 252     }
 253 }
 254
 255 binder::Status VoldNativeService::forgetPartition(const std::string& partGuid,
 256                                                   const std::string& fsUuid) {
 257     ENFORCE_SYSTEM_OR_ROOT;
 258     CHECK_ARGUMENT_HEX(partGuid);
 259     CHECK_ARGUMENT_HEX(fsUuid);
 260     ACQUIRE_LOCK;
 261
 262     return translate(VolumeManager::Instance()->forgetPartition(partGuid, fsUuid));
 263 }
 264
 265 binder::Status VoldNativeService::mount(
 266         const std::string& volId, int32_t mountFlags, int32_t mountUserId,
 267         const android::sp<android::os::IVoldMountCallback>& callback) {
 268     ENFORCE_SYSTEM_OR_ROOT;
 269     CHECK_ARGUMENT_ID(volId);
 270     ACQUIRE_LOCK;
 271
 272     auto vol = VolumeManager::Instance()->findVolume(volId);
 273     if (vol == nullptr) {
 274         return error("Failed to find volume " + volId);
 275     }
 276
 277     vol->setMountFlags(mountFlags);
 278     vol->setMountUserId(mountUserId);
 279
 280     vol->setMountCallback(callback);
 281     int res = vol->mount();
 282     vol->setMountCallback(nullptr);
 283
 284     if (res != OK) {
 285         return translate(res);
 286     }
 287
 288     return translate(OK);
 289 }
 290
 291 binder::Status VoldNativeService::unmount(const std::string& volId) {
 292     ENFORCE_SYSTEM_OR_ROOT;
 293     CHECK_ARGUMENT_ID(volId);
 294     ACQUIRE_LOCK;
 295
 296     auto vol = VolumeManager::Instance()->findVolume(volId);
 297     if (vol == nullptr) {
 298         return error("Failed to find volume " + volId);
 299     }
 300     return translate(vol->unmount());
 301 }
 302
 303 binder::Status VoldNativeService::format(const std::string& volId, const std::string& fsType) {
 304     ENFORCE_SYSTEM_OR_ROOT;
 305     CHECK_ARGUMENT_ID(volId);
 306     ACQUIRE_LOCK;
 307
 308     auto vol = VolumeManager::Instance()->findVolume(volId);
 309     if (vol == nullptr) {
 310         return error("Failed to find volume " + volId);
 311     }
 312     return translate(vol->format(fsType));
 313 }
 314
 315 static binder::Status pathForVolId(const std::string& volId, std::string* path) {
 316     if (volId == "private" || volId == "null") {
 317         *path = "/data";
 318     } else {
 319         auto vol = VolumeManager::Instance()->findVolume(volId);
 320         if (vol == nullptr) {
 321             return error("Failed to find volume " + volId);
 322         }
 323         if (vol->getType() != VolumeBase::Type::kPrivate) {
 324             return error("Volume " + volId + " not private");
 325         }
 326         if (vol->getState() != VolumeBase::State::kMounted) {
 327             return error("Volume " + volId + " not mounted");
 328         }
 329         *path = vol->getPath();
 330         if (path->empty()) {
 331             return error("Volume " + volId + " missing path");
 332         }
 333     }
 334     return Ok();
 335 }
 336
 337 binder::Status VoldNativeService::benchmark(
 338         const std::string& volId, const android::sp<android::os::IVoldTaskListener>& listener) {
 339     ENFORCE_SYSTEM_OR_ROOT;
 340     CHECK_ARGUMENT_ID(volId);
 341     ACQUIRE_LOCK;
 342
 343     std::string path;
 344     auto status = pathForVolId(volId, &path);
 345     if (!status.isOk()) return status;
 346
 347     std::thread([=]() { android::vold::Benchmark(path, listener); }).detach();
 348     return Ok();
 349 }
 350
 351 binder::Status VoldNativeService::moveStorage(
 352         const std::string& fromVolId, const std::string& toVolId,
 353         const android::sp<android::os::IVoldTaskListener>& listener) {
 354     ENFORCE_SYSTEM_OR_ROOT;
 355     CHECK_ARGUMENT_ID(fromVolId);
 356     CHECK_ARGUMENT_ID(toVolId);
 357     ACQUIRE_LOCK;
 358
 359     auto fromVol = VolumeManager::Instance()->findVolume(fromVolId);
 360     auto toVol = VolumeManager::Instance()->findVolume(toVolId);
 361     if (fromVol == nullptr) {
 362         return error("Failed to find volume " + fromVolId);
 363     } else if (toVol == nullptr) {
 364         return error("Failed to find volume " + toVolId);
 365     }
 366
 367     std::thread([=]() { android::vold::MoveStorage(fromVol, toVol, listener); }).detach();
 368     return Ok();
 369 }
 370
 371 binder::Status VoldNativeService::remountUid(int32_t uid, int32_t remountMode) {
 372     ENFORCE_SYSTEM_OR_ROOT;
 373     ACQUIRE_LOCK;
 374
 375     return translate(VolumeManager::Instance()->remountUid(uid, remountMode));
 376 }
 377
 378 binder::Status VoldNativeService::remountAppStorageDirs(int uid, int pid,
 379         const std::vector<std::string>& packageNames) {
 380     ENFORCE_SYSTEM_OR_ROOT;
 381     ACQUIRE_LOCK;
 382
 383     return translate(VolumeManager::Instance()->handleAppStorageDirs(uid, pid,
 384             false /* doUnmount */, packageNames));
 385 }
 386
 387 binder::Status VoldNativeService::unmountAppStorageDirs(int uid, int pid,
 388         const std::vector<std::string>& packageNames) {
 389     ENFORCE_SYSTEM_OR_ROOT;
 390     ACQUIRE_LOCK;
 391
 392     return translate(VolumeManager::Instance()->handleAppStorageDirs(uid, pid,
 393             true /* doUnmount */, packageNames));
 394 }
 395
 396 binder::Status VoldNativeService::setupAppDir(const std::string& path, int32_t appUid) {
 397     ENFORCE_SYSTEM_OR_ROOT;
 398     CHECK_ARGUMENT_PATH(path);
 399     ACQUIRE_LOCK;
 400
 401     return translate(VolumeManager::Instance()->setupAppDir(path, appUid));
 402 }
 403
 404 binder::Status VoldNativeService::ensureAppDirsCreated(const std::vector<std::string>& paths,
 405         int32_t appUid) {
 406     ENFORCE_SYSTEM_OR_ROOT;
 407     ACQUIRE_LOCK;
 408
 409     return translate(VolumeManager::Instance()->ensureAppDirsCreated(paths, appUid));
 410 }
 411
 412 binder::Status VoldNativeService::fixupAppDir(const std::string& path, int32_t appUid) {
 413     ENFORCE_SYSTEM_OR_ROOT;
 414     CHECK_ARGUMENT_PATH(path);
 415     ACQUIRE_LOCK;
 416
 417     return translate(VolumeManager::Instance()->fixupAppDir(path, appUid));
 418 }
 419
 420 binder::Status VoldNativeService::createObb(const std::string& sourcePath,
 421                                             const std::string& sourceKey, int32_t ownerGid,
 422                                             std::string* _aidl_return) {
 423     ENFORCE_SYSTEM_OR_ROOT;
 424     CHECK_ARGUMENT_PATH(sourcePath);
 425     CHECK_ARGUMENT_HEX(sourceKey);
 426     ACQUIRE_LOCK;
 427
 428     return translate(
 429             VolumeManager::Instance()->createObb(sourcePath, sourceKey, ownerGid, _aidl_return));
 430 }
 431
 432 binder::Status VoldNativeService::destroyObb(const std::string& volId) {
 433     ENFORCE_SYSTEM_OR_ROOT;
 434     CHECK_ARGUMENT_ID(volId);
 435     ACQUIRE_LOCK;
 436
 437     return translate(VolumeManager::Instance()->destroyObb(volId));
 438 }
 439
 440 binder::Status VoldNativeService::createStubVolume(const std::string& sourcePath,
 441                                                    const std::string& mountPath,
 442                                                    const std::string& fsType,
 443                                                    const std::string& fsUuid,
 444                                                    const std::string& fsLabel, int32_t flags,
 445                                                    std::string* _aidl_return) {
 446     ENFORCE_SYSTEM_OR_ROOT;
 447     CHECK_ARGUMENT_PATH(sourcePath);
 448     CHECK_ARGUMENT_PATH(mountPath);
 449     CHECK_ARGUMENT_HEX(fsUuid);
 450     // Label limitation seems to be different between fs (including allowed characters), so checking
 451     // is quite meaningless.
 452     ACQUIRE_LOCK;
 453
 454     return translate(VolumeManager::Instance()->createStubVolume(
 455             sourcePath, mountPath, fsType, fsUuid, fsLabel, flags, _aidl_return));
 456 }
 457
 458 binder::Status VoldNativeService::destroyStubVolume(const std::string& volId) {
 459     ENFORCE_SYSTEM_OR_ROOT;
 460     CHECK_ARGUMENT_ID(volId);
 461     ACQUIRE_LOCK;
 462
 463     return translate(VolumeManager::Instance()->destroyStubVolume(volId));
 464 }
 465
 466 binder::Status VoldNativeService::fstrim(
 467         int32_t fstrimFlags, const android::sp<android::os::IVoldTaskListener>& listener) {
 468     ENFORCE_SYSTEM_OR_ROOT;
 469     ACQUIRE_LOCK;
 470
 471     std::thread([=]() { android::vold::Trim(listener); }).detach();
 472     return Ok();
 473 }
 474
 475 binder::Status VoldNativeService::runIdleMaint(
 476         const android::sp<android::os::IVoldTaskListener>& listener) {
 477     ENFORCE_SYSTEM_OR_ROOT;
 478     ACQUIRE_LOCK;
 479
 480     std::thread([=]() { android::vold::RunIdleMaint(listener); }).detach();
 481     return Ok();
 482 }
 483
 484 binder::Status VoldNativeService::abortIdleMaint(
 485         const android::sp<android::os::IVoldTaskListener>& listener) {
 486     ENFORCE_SYSTEM_OR_ROOT;
 487     ACQUIRE_LOCK;
 488
 489     std::thread([=]() { android::vold::AbortIdleMaint(listener); }).detach();
 490     return Ok();
 491 }
 492
 493 binder::Status VoldNativeService::mountAppFuse(int32_t uid, int32_t mountId,
 494                                                android::base::unique_fd* _aidl_return) {
 495     ENFORCE_SYSTEM_OR_ROOT;
 496     ACQUIRE_LOCK;
 497
 498     return translate(VolumeManager::Instance()->mountAppFuse(uid, mountId, _aidl_return));
 499 }
 500
 501 binder::Status VoldNativeService::unmountAppFuse(int32_t uid, int32_t mountId) {
 502     ENFORCE_SYSTEM_OR_ROOT;
 503     ACQUIRE_LOCK;
 504
 505     return translate(VolumeManager::Instance()->unmountAppFuse(uid, mountId));
 506 }
 507
 508 binder::Status VoldNativeService::openAppFuseFile(int32_t uid, int32_t mountId, int32_t fileId,
 509                                                   int32_t flags,
 510                                                   android::base::unique_fd* _aidl_return) {
 511     ENFORCE_SYSTEM_OR_ROOT;
 512     ACQUIRE_LOCK;
 513
 514     int fd = VolumeManager::Instance()->openAppFuseFile(uid, mountId, fileId, flags);
 515     if (fd == -1) {
 516         return error("Failed to open AppFuse file for uid: " + std::to_string(uid) +
 517                      " mountId: " + std::to_string(mountId) + " fileId: " + std::to_string(fileId) +
 518                      " flags: " + std::to_string(flags));
 519     }
 520
 521     *_aidl_return = android::base::unique_fd(fd);
 522     return Ok();
 523 }
 524
 525 binder::Status VoldNativeService::fdeCheckPassword(const std::string& password) {
 526     ENFORCE_SYSTEM_OR_ROOT;
 527     ACQUIRE_CRYPT_LOCK;
 528
 529     return translate(cryptfs_check_passwd(password.c_str()));
 530 }
 531
 532 binder::Status VoldNativeService::fdeRestart() {
 533     ENFORCE_SYSTEM_OR_ROOT;
 534     ACQUIRE_CRYPT_LOCK;
 535
 536     // Spawn as thread so init can issue commands back to vold without
 537     // causing deadlock, usually as a result of prep_data_fs.
 538     std::thread(&cryptfs_restart).detach();
 539     return Ok();
 540 }
 541
 542 binder::Status VoldNativeService::fdeComplete(int32_t* _aidl_return) {
 543     ENFORCE_SYSTEM_OR_ROOT;
 544     ACQUIRE_CRYPT_LOCK;
 545
 546     *_aidl_return = cryptfs_crypto_complete();
 547     return Ok();
 548 }
 549
 550 static int fdeEnableInternal(int32_t passwordType, const std::string& password,
 551                              int32_t encryptionFlags) {
 552     bool noUi = (encryptionFlags & VoldNativeService::ENCRYPTION_FLAG_NO_UI) != 0;
 553
 554     for (int tries = 0; tries < 2; ++tries) {
 555         int rc;
 556         if (passwordType == VoldNativeService::PASSWORD_TYPE_DEFAULT) {
 557             rc = cryptfs_enable_default(noUi);
 558         } else {
 559             rc = cryptfs_enable(passwordType, password.c_str(), noUi);
 560         }
 561
 562         if (rc == 0) {
 563             return 0;
 564         } else if (tries == 0) {
 565             KillProcessesWithOpenFiles(DATA_MNT_POINT, SIGKILL);
 566         }
 567     }
 568
 569     return -1;
 570 }
 571
 572 binder::Status VoldNativeService::fdeEnable(int32_t passwordType, const std::string& password,
 573                                             int32_t encryptionFlags) {
 574     ENFORCE_SYSTEM_OR_ROOT;
 575     ACQUIRE_CRYPT_LOCK;
 576
 577     LOG(DEBUG) << "fdeEnable(" << passwordType << ", *, " << encryptionFlags << ")";
 578     if (fscrypt_is_native()) {
 579         LOG(ERROR) << "fscrypt_is_native, fdeEnable invalid";
 580         return error("fscrypt_is_native, fdeEnable invalid");
 581     }
 582     LOG(DEBUG) << "!fscrypt_is_native, spawning fdeEnableInternal";
 583
 584     // Spawn as thread so init can issue commands back to vold without
 585     // causing deadlock, usually as a result of prep_data_fs.
 586     std::thread(&fdeEnableInternal, passwordType, password, encryptionFlags).detach();
 587     return Ok();
 588 }
 589
 590 binder::Status VoldNativeService::fdeChangePassword(int32_t passwordType,
 591                                                     const std::string& password) {
 592     ENFORCE_SYSTEM_OR_ROOT;
 593     ACQUIRE_CRYPT_LOCK;
 594
 595     return translate(cryptfs_changepw(passwordType, password.c_str()));
 596 }
 597
 598 binder::Status VoldNativeService::fdeVerifyPassword(const std::string& password) {
 599     ENFORCE_SYSTEM_OR_ROOT;
 600     ACQUIRE_CRYPT_LOCK;
 601
 602     return translate(cryptfs_verify_passwd(password.c_str()));
 603 }
 604
 605 binder::Status VoldNativeService::fdeGetField(const std::string& key, std::string* _aidl_return) {
 606     ENFORCE_SYSTEM_OR_ROOT;
 607     ACQUIRE_CRYPT_LOCK;
 608
 609     char buf[PROPERTY_VALUE_MAX];
 610     if (cryptfs_getfield(key.c_str(), buf, sizeof(buf)) != CRYPTO_GETFIELD_OK) {
 611         return error(StringPrintf("Failed to read field %s", key.c_str()));
 612     } else {
 613         *_aidl_return = buf;
 614         return Ok();
 615     }
 616 }
 617
 618 binder::Status VoldNativeService::fdeSetField(const std::string& key, const std::string& value) {
 619     ENFORCE_SYSTEM_OR_ROOT;
 620     ACQUIRE_CRYPT_LOCK;
 621
 622     return translate(cryptfs_setfield(key.c_str(), value.c_str()));
 623 }
 624
 625 binder::Status VoldNativeService::fdeGetPasswordType(int32_t* _aidl_return) {
 626     ENFORCE_SYSTEM_OR_ROOT;
 627     ACQUIRE_CRYPT_LOCK;
 628
 629     *_aidl_return = cryptfs_get_password_type();
 630     return Ok();
 631 }
 632
 633 binder::Status VoldNativeService::fdeGetPassword(std::string* _aidl_return) {
 634     ENFORCE_SYSTEM_OR_ROOT;
 635     ACQUIRE_CRYPT_LOCK;
 636
 637     const char* res = cryptfs_get_password();
 638     if (res != nullptr) {
 639         *_aidl_return = res;
 640     }
 641     return Ok();
 642 }
 643
 644 binder::Status VoldNativeService::fdeClearPassword() {
 645     ENFORCE_SYSTEM_OR_ROOT;
 646     ACQUIRE_CRYPT_LOCK;
 647
 648     cryptfs_clear_password();
 649     return Ok();
 650 }
 651
 652 binder::Status VoldNativeService::fbeEnable() {
 653     ENFORCE_SYSTEM_OR_ROOT;
 654     ACQUIRE_CRYPT_LOCK;
 655
 656     return translateBool(fscrypt_initialize_systemwide_keys());
 657 }
 658
 659 binder::Status VoldNativeService::mountDefaultEncrypted() {
 660     ENFORCE_SYSTEM_OR_ROOT;
 661     ACQUIRE_CRYPT_LOCK;
 662
 663     if (!fscrypt_is_native()) {
 664         // Spawn as thread so init can issue commands back to vold without
 665         // causing deadlock, usually as a result of prep_data_fs.
 666         std::thread(&cryptfs_mount_default_encrypted).detach();
 667     }
 668     return Ok();
 669 }
 670
 671 binder::Status VoldNativeService::initUser0() {
 672     ENFORCE_SYSTEM_OR_ROOT;
 673     ACQUIRE_CRYPT_LOCK;
 674
 675     return translateBool(fscrypt_init_user0());
 676 }
 677
 678 binder::Status VoldNativeService::isConvertibleToFbe(bool* _aidl_return) {
 679     ENFORCE_SYSTEM_OR_ROOT;
 680     ACQUIRE_CRYPT_LOCK;
 681
 682     *_aidl_return = cryptfs_isConvertibleToFBE() != 0;
 683     return Ok();
 684 }
 685
 686 binder::Status VoldNativeService::mountFstab(const std::string& blkDevice,
 687                                              const std::string& mountPoint) {
 688     ENFORCE_SYSTEM_OR_ROOT;
 689     ACQUIRE_LOCK;
 690
 691     return translateBool(
 692             fscrypt_mount_metadata_encrypted(blkDevice, mountPoint, false, false, "null"));
 693 }
 694
 695 binder::Status VoldNativeService::encryptFstab(const std::string& blkDevice,
 696                                                const std::string& mountPoint, bool shouldFormat,
 697                                                const std::string& fsType) {
 698     ENFORCE_SYSTEM_OR_ROOT;
 699     ACQUIRE_LOCK;
 700
 701     return translateBool(
 702             fscrypt_mount_metadata_encrypted(blkDevice, mountPoint, true, shouldFormat, fsType));
 703 }
 704
 705 binder::Status VoldNativeService::setStorageBindingSeed(const std::vector<uint8_t>& seed) {
 706     ENFORCE_SYSTEM_OR_ROOT;
 707     ACQUIRE_CRYPT_LOCK;
 708
 709     return translateBool(setKeyStorageBindingSeed(seed));
 710 }
 711
 712 binder::Status VoldNativeService::createUserKey(int32_t userId, int32_t userSerial,
 713                                                 bool ephemeral) {
 714     ENFORCE_SYSTEM_OR_ROOT;
 715     ACQUIRE_CRYPT_LOCK;
 716
 717     return translateBool(fscrypt_vold_create_user_key(userId, userSerial, ephemeral));
 718 }
 719
 720 binder::Status VoldNativeService::destroyUserKey(int32_t userId) {
 721     ENFORCE_SYSTEM_OR_ROOT;
 722     ACQUIRE_CRYPT_LOCK;
 723
 724     return translateBool(fscrypt_destroy_user_key(userId));
 725 }
 726
 727 static bool token_empty(const std::string& token) {
 728     return token.size() == 0 || token == "!";
 729 }
 730
 731 binder::Status VoldNativeService::addUserKeyAuth(int32_t userId, int32_t userSerial,
 732                                                  const std::string& token,
 733                                                  const std::string& secret) {
 734     ENFORCE_SYSTEM_OR_ROOT;
 735     ACQUIRE_CRYPT_LOCK;
 736
 737     if (!token_empty(token)) {
 738         LOG(ERROR) << "Vold doesn't use auth tokens, but non-empty token passed to addUserKeyAuth.";
 739         return binder::Status::fromServiceSpecificError(-EINVAL);
 740     }
 741
 742     return translateBool(fscrypt_add_user_key_auth(userId, userSerial, secret));
 743 }
 744
 745 binder::Status VoldNativeService::clearUserKeyAuth(int32_t userId, int32_t userSerial,
 746                                                    const std::string& token,
 747                                                    const std::string& secret) {
 748     ENFORCE_SYSTEM_OR_ROOT;
 749     ACQUIRE_CRYPT_LOCK;
 750
 751     if (!token_empty(token)) {
 752         LOG(ERROR)
 753                 << "Vold doesn't use auth tokens, but non-empty token passed to clearUserKeyAuth.";
 754         return binder::Status::fromServiceSpecificError(-EINVAL);
 755     }
 756
 757     return translateBool(fscrypt_clear_user_key_auth(userId, userSerial, secret));
 758 }
 759
 760 binder::Status VoldNativeService::fixateNewestUserKeyAuth(int32_t userId) {
 761     ENFORCE_SYSTEM_OR_ROOT;
 762     ACQUIRE_CRYPT_LOCK;
 763
 764     return translateBool(fscrypt_fixate_newest_user_key_auth(userId));
 765 }
 766
 767 binder::Status VoldNativeService::getUnlockedUsers(std::vector<int>* _aidl_return) {
 768     ENFORCE_SYSTEM_OR_ROOT;
 769     ACQUIRE_CRYPT_LOCK;
 770
 771     *_aidl_return = fscrypt_get_unlocked_users();
 772     return Ok();
 773 }
 774
 775 binder::Status VoldNativeService::unlockUserKey(int32_t userId, int32_t userSerial,
 776                                                 const std::string& token,
 777                                                 const std::string& secret) {
 778     ENFORCE_SYSTEM_OR_ROOT;
 779     ACQUIRE_CRYPT_LOCK;
 780
 781     if (!token_empty(token)) {
 782         LOG(ERROR) << "Vold doesn't use auth tokens, but non-empty token passed to unlockUserKey.";
 783         return binder::Status::fromServiceSpecificError(-EINVAL);
 784     }
 785
 786     return translateBool(fscrypt_unlock_user_key(userId, userSerial, secret));
 787 }
 788
 789 binder::Status VoldNativeService::lockUserKey(int32_t userId) {
 790     ENFORCE_SYSTEM_OR_ROOT;
 791     ACQUIRE_CRYPT_LOCK;
 792
 793     return translateBool(fscrypt_lock_user_key(userId));
 794 }
 795
 796 binder::Status VoldNativeService::prepareUserStorage(const std::optional<std::string>& uuid,
 797                                                      int32_t userId, int32_t userSerial,
 798                                                      int32_t flags) {
 799     ENFORCE_SYSTEM_OR_ROOT;
 800     std::string empty_string = "";
 801     auto uuid_ = uuid ? *uuid : empty_string;
 802     CHECK_ARGUMENT_HEX(uuid_);
 803
 804     ACQUIRE_CRYPT_LOCK;
 805     return translateBool(fscrypt_prepare_user_storage(uuid_, userId, userSerial, flags));
 806 }
 807
 808 binder::Status VoldNativeService::destroyUserStorage(const std::optional<std::string>& uuid,
 809                                                      int32_t userId, int32_t flags) {
 810     ENFORCE_SYSTEM_OR_ROOT;
 811     std::string empty_string = "";
 812     auto uuid_ = uuid ? *uuid : empty_string;
 813     CHECK_ARGUMENT_HEX(uuid_);
 814
 815     ACQUIRE_CRYPT_LOCK;
 816     return translateBool(fscrypt_destroy_user_storage(uuid_, userId, flags));
 817 }
 818
 819 binder::Status VoldNativeService::prepareSandboxForApp(const std::string& packageName,
 820                                                        int32_t appId, const std::string& sandboxId,
 821                                                        int32_t userId) {
 822     return Ok();
 823 }
 824
 825 binder::Status VoldNativeService::destroySandboxForApp(const std::string& packageName,
 826                                                        const std::string& sandboxId,
 827                                                        int32_t userId) {
 828     return Ok();
 829 }
 830
 831 binder::Status VoldNativeService::startCheckpoint(int32_t retry) {
 832     ENFORCE_SYSTEM_OR_ROOT;
 833     ACQUIRE_LOCK;
 834
 835     return cp_startCheckpoint(retry);
 836 }
 837
 838 binder::Status VoldNativeService::needsRollback(bool* _aidl_return) {
 839     ENFORCE_SYSTEM_OR_ROOT;
 840     ACQUIRE_LOCK;
 841
 842     *_aidl_return = cp_needsRollback();
 843     return Ok();
 844 }
 845
 846 binder::Status VoldNativeService::needsCheckpoint(bool* _aidl_return) {
 847     ENFORCE_SYSTEM_OR_ROOT;
 848     ACQUIRE_LOCK;
 849
 850     *_aidl_return = cp_needsCheckpoint();
 851     return Ok();
 852 }
 853
 854 binder::Status VoldNativeService::isCheckpointing(bool* _aidl_return) {
 855     ENFORCE_SYSTEM_OR_ROOT;
 856     ACQUIRE_LOCK;
 857
 858     *_aidl_return = cp_isCheckpointing();
 859     return Ok();
 860 }
 861
 862 binder::Status VoldNativeService::commitChanges() {
 863     ENFORCE_SYSTEM_OR_ROOT;
 864     ACQUIRE_LOCK;
 865
 866     return cp_commitChanges();
 867 }
 868
 869 binder::Status VoldNativeService::prepareCheckpoint() {
 870     ENFORCE_SYSTEM_OR_ROOT;
 871     ACQUIRE_LOCK;
 872
 873     return cp_prepareCheckpoint();
 874 }
 875
 876 binder::Status VoldNativeService::restoreCheckpoint(const std::string& mountPoint) {
 877     ENFORCE_SYSTEM_OR_ROOT;
 878     CHECK_ARGUMENT_PATH(mountPoint);
 879     ACQUIRE_LOCK;
 880
 881     return cp_restoreCheckpoint(mountPoint);
 882 }
 883
 884 binder::Status VoldNativeService::restoreCheckpointPart(const std::string& mountPoint, int count) {
 885     ENFORCE_SYSTEM_OR_ROOT;
 886     CHECK_ARGUMENT_PATH(mountPoint);
 887     ACQUIRE_LOCK;
 888
 889     return cp_restoreCheckpoint(mountPoint, count);
 890 }
 891
 892 binder::Status VoldNativeService::markBootAttempt() {
 893     ENFORCE_SYSTEM_OR_ROOT;
 894     ACQUIRE_LOCK;
 895
 896     return cp_markBootAttempt();
 897 }
 898
 899 binder::Status VoldNativeService::abortChanges(const std::string& message, bool retry) {
 900     ENFORCE_SYSTEM_OR_ROOT;
 901     ACQUIRE_LOCK;
 902
 903     cp_abortChanges(message, retry);
 904     return Ok();
 905 }
 906
 907 binder::Status VoldNativeService::supportsCheckpoint(bool* _aidl_return) {
 908     ENFORCE_SYSTEM_OR_ROOT;
 909     ACQUIRE_LOCK;
 910
 911     return cp_supportsCheckpoint(*_aidl_return);
 912 }
 913
 914 binder::Status VoldNativeService::supportsBlockCheckpoint(bool* _aidl_return) {
 915     ENFORCE_SYSTEM_OR_ROOT;
 916     ACQUIRE_LOCK;
 917
 918     return cp_supportsBlockCheckpoint(*_aidl_return);
 919 }
 920
 921 binder::Status VoldNativeService::supportsFileCheckpoint(bool* _aidl_return) {
 922     ENFORCE_SYSTEM_OR_ROOT;
 923     ACQUIRE_LOCK;
 924
 925     return cp_supportsFileCheckpoint(*_aidl_return);
 926 }
 927
 928 binder::Status VoldNativeService::resetCheckpoint() {
 929     ENFORCE_SYSTEM_OR_ROOT;
 930     ACQUIRE_LOCK;
 931
 932     cp_resetCheckpoint();
 933     return Ok();
 934 }
 935
 936 static void initializeIncFs() {
 937     // Obtaining IncFS features triggers initialization of IncFS.
 938     incfs::features();
 939 }
 940
 941 binder::Status VoldNativeService::earlyBootEnded() {
 942     ENFORCE_SYSTEM_OR_ROOT;
 943     ACQUIRE_LOCK;
 944
 945     initializeIncFs();
 946     Keymaster::earlyBootEnded();
 947     return Ok();
 948 }
 949
 950 binder::Status VoldNativeService::incFsEnabled(bool* _aidl_return) {
 951     ENFORCE_SYSTEM_OR_ROOT;
 952
 953     *_aidl_return = incfs::enabled();
 954     return Ok();
 955 }
 956
 957 binder::Status VoldNativeService::mountIncFs(
 958         const std::string& backingPath, const std::string& targetDir, int32_t flags,
 959         ::android::os::incremental::IncrementalFileSystemControlParcel* _aidl_return) {
 960     ENFORCE_SYSTEM_OR_ROOT;
 961     CHECK_ARGUMENT_PATH(backingPath);
 962     CHECK_ARGUMENT_PATH(targetDir);
 963
 964     auto control = incfs::mount(backingPath, targetDir,
 965                                 {.flags = IncFsMountFlags(flags),
 966                                  .defaultReadTimeoutMs = INCFS_DEFAULT_READ_TIMEOUT_MS,
 967                                  // Mount with read logs disabled.
 968                                  .readLogBufferPages = 0});
 969     if (!control) {
 970         return translate(-errno);
 971     }
 972     auto fds = control.releaseFds();
 973     using android::base::unique_fd;
 974     _aidl_return->cmd.reset(unique_fd(fds[CMD].release()));
 975     _aidl_return->pendingReads.reset(unique_fd(fds[PENDING_READS].release()));
 976     _aidl_return->log.reset(unique_fd(fds[LOGS].release()));
 977     return Ok();
 978 }
 979
 980 binder::Status VoldNativeService::unmountIncFs(const std::string& dir) {
 981     ENFORCE_SYSTEM_OR_ROOT;
 982     CHECK_ARGUMENT_PATH(dir);
 983
 984     return translate(incfs::unmount(dir));
 985 }
 986
 987 binder::Status VoldNativeService::setIncFsMountOptions(
 988         const ::android::os::incremental::IncrementalFileSystemControlParcel& control,
 989         bool enableReadLogs) {
 990     ENFORCE_SYSTEM_OR_ROOT;
 991
 992     auto incfsControl =
 993             incfs::createControl(control.cmd.get(), control.pendingReads.get(), control.log.get());
 994     auto cleanupFunc = [](auto incfsControl) {
 995         for (auto& fd : incfsControl->releaseFds()) {
 996             (void)fd.release();
 997         }
 998     };
 999     auto cleanup =
1000             std::unique_ptr<incfs::Control, decltype(cleanupFunc)>(&incfsControl, cleanupFunc);
1001     if (auto error = incfs::setOptions(
1002                 incfsControl,
1003                 {.defaultReadTimeoutMs = INCFS_DEFAULT_READ_TIMEOUT_MS,
1004                  .readLogBufferPages = enableReadLogs ? INCFS_DEFAULT_PAGE_READ_BUFFER_PAGES : 0});
1005         error < 0) {
1006         return binder::Status::fromServiceSpecificError(error);
1007     }
1008
1009     return Ok();
1010 }
1011
1012 binder::Status VoldNativeService::bindMount(const std::string& sourceDir,
1013                                             const std::string& targetDir) {
1014     ENFORCE_SYSTEM_OR_ROOT;
1015     CHECK_ARGUMENT_PATH(sourceDir);
1016     CHECK_ARGUMENT_PATH(targetDir);
1017
1018     return translate(incfs::bindMount(sourceDir, targetDir));
1019 }
1020
1021 binder::Status VoldNativeService::destroyDsuMetadataKey(const std::string& dsuSlot) {
1022     ENFORCE_SYSTEM_OR_ROOT;
1023     ACQUIRE_LOCK;
1024
1025     return translateBool(destroy_dsu_metadata_key(dsuSlot));
1026 }
1027
1028 }  // namespace vold
1029 }  // namespace android