7e79a43a72
Mounting encrypted OBB files has never worked reliably across devices, partly due to its reliance on Twofish encryption support in the kernel. This is because Twofish support (CONFIG_CRYPTO_TWOFISH) has never been required or even recommended for Android. It has never been enabled in GKI, but even before GKI it wasn't required or recommended. Moreover, this is now the only Android feature that still uses dm-crypt (CONFIG_DM_CRYPT), and some devices don't have that enabled either. Therefore, it appears that this feature is unused. That's perhaps not surprising, considering that the documentation for OBBs (https://developer.android.com/google/play/expansion-files) says that they are deprecated, and also it explains OBBs as being app files that are opaque to the platform; the ability of the platform to mount OBBs that happen to be in a particular format is never mentioned. That means that OBB mounting is probably rarely used even with unencrypted OBBs. Finally, the usefulness of OBBs having their own encryption layer (in addition to what the platform already provides via FBE) is not clear either, especially with such an unusual choice of cipher. To avoid the confusion that is being caused by having the broken code for mounting encrypted OBBs still sitting around, let's remove it. Test: atest StorageManagerTest # on Cuttlefish Test: atest StorageManagerIntegrationTest # on Cuttlefish Bug: 216475849 Change-Id: Iaef32cce90f95ea745ba2b143f89e66f533f3479
1089 lines
34 KiB
C++
1089 lines
34 KiB
C++
/*
|
|
* Copyright (C) 2017 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#define ATRACE_TAG ATRACE_TAG_PACKAGE_MANAGER
|
|
|
|
#include "VoldNativeService.h"
|
|
|
|
#include <android-base/logging.h>
|
|
#include <android-base/strings.h>
|
|
#include <fs_mgr.h>
|
|
#include <fscrypt/fscrypt.h>
|
|
#include <private/android_filesystem_config.h>
|
|
#include <utils/Trace.h>
|
|
|
|
#include <stdio.h>
|
|
#include <fstream>
|
|
#include <thread>
|
|
|
|
#include "Benchmark.h"
|
|
#include "Checkpoint.h"
|
|
#include "FsCrypt.h"
|
|
#include "IdleMaint.h"
|
|
#include "KeyStorage.h"
|
|
#include "Keystore.h"
|
|
#include "MetadataCrypt.h"
|
|
#include "MoveStorage.h"
|
|
#include "VoldNativeServiceValidation.h"
|
|
#include "VoldUtil.h"
|
|
#include "VolumeManager.h"
|
|
#include "cryptfs.h"
|
|
#include "incfs.h"
|
|
|
|
using namespace std::literals;
|
|
|
|
namespace android {
|
|
namespace vold {
|
|
|
|
namespace {
|
|
|
|
constexpr const char* kDump = "android.permission.DUMP";
|
|
constexpr auto kIncFsReadNoTimeoutMs = 100;
|
|
|
|
static binder::Status error(const std::string& msg) {
|
|
PLOG(ERROR) << msg;
|
|
return binder::Status::fromServiceSpecificError(errno, String8(msg.c_str()));
|
|
}
|
|
|
|
static binder::Status translate(int status) {
|
|
if (status == 0) {
|
|
return binder::Status::ok();
|
|
} else {
|
|
return binder::Status::fromServiceSpecificError(status);
|
|
}
|
|
}
|
|
|
|
static binder::Status translateBool(bool status) {
|
|
if (status) {
|
|
return binder::Status::ok();
|
|
} else {
|
|
return binder::Status::fromServiceSpecificError(status);
|
|
}
|
|
}
|
|
|
|
#define ENFORCE_SYSTEM_OR_ROOT \
|
|
{ \
|
|
binder::Status status = CheckUidOrRoot(AID_SYSTEM); \
|
|
if (!status.isOk()) { \
|
|
return status; \
|
|
} \
|
|
}
|
|
|
|
#define CHECK_ARGUMENT_ID(id) \
|
|
{ \
|
|
binder::Status status = CheckArgumentId((id)); \
|
|
if (!status.isOk()) { \
|
|
return status; \
|
|
} \
|
|
}
|
|
|
|
#define CHECK_ARGUMENT_PATH(path) \
|
|
{ \
|
|
binder::Status status = CheckArgumentPath((path)); \
|
|
if (!status.isOk()) { \
|
|
return status; \
|
|
} \
|
|
}
|
|
|
|
#define CHECK_ARGUMENT_HEX(hex) \
|
|
{ \
|
|
binder::Status status = CheckArgumentHex((hex)); \
|
|
if (!status.isOk()) { \
|
|
return status; \
|
|
} \
|
|
}
|
|
|
|
#define ACQUIRE_LOCK \
|
|
std::lock_guard<std::mutex> lock(VolumeManager::Instance()->getLock()); \
|
|
ATRACE_CALL();
|
|
|
|
#define ACQUIRE_CRYPT_LOCK \
|
|
std::lock_guard<std::mutex> lock(VolumeManager::Instance()->getCryptLock()); \
|
|
ATRACE_CALL();
|
|
|
|
} // namespace
|
|
|
|
status_t VoldNativeService::start() {
|
|
IPCThreadState::self()->disableBackgroundScheduling(true);
|
|
status_t ret = BinderService<VoldNativeService>::publish();
|
|
if (ret != android::OK) {
|
|
return ret;
|
|
}
|
|
sp<ProcessState> ps(ProcessState::self());
|
|
ps->startThreadPool();
|
|
ps->giveThreadPoolName();
|
|
return android::OK;
|
|
}
|
|
|
|
status_t VoldNativeService::dump(int fd, const Vector<String16>& /* args */) {
|
|
const binder::Status dump_permission = CheckPermission(kDump);
|
|
if (!dump_permission.isOk()) {
|
|
dprintf(fd, "%s\n", dump_permission.toString8().c_str());
|
|
return PERMISSION_DENIED;
|
|
}
|
|
|
|
ACQUIRE_LOCK;
|
|
dprintf(fd, "vold is happy!\n");
|
|
return NO_ERROR;
|
|
}
|
|
|
|
binder::Status VoldNativeService::setListener(
|
|
const android::sp<android::os::IVoldListener>& listener) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
VolumeManager::Instance()->setListener(listener);
|
|
return Ok();
|
|
}
|
|
|
|
binder::Status VoldNativeService::monitor() {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
|
|
// Simply acquire/release each lock for watchdog
|
|
{ ACQUIRE_LOCK; }
|
|
{ ACQUIRE_CRYPT_LOCK; }
|
|
|
|
return Ok();
|
|
}
|
|
|
|
binder::Status VoldNativeService::reset() {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
return translate(VolumeManager::Instance()->reset());
|
|
}
|
|
|
|
binder::Status VoldNativeService::shutdown() {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
return translate(VolumeManager::Instance()->shutdown());
|
|
}
|
|
|
|
binder::Status VoldNativeService::abortFuse() {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
// if acquire lock, maybe lead to a deadlock if lock is held by a
|
|
// thread that is blocked on a FUSE operation.
|
|
// abort fuse doesn't need to access any state, so do not acquire lock
|
|
|
|
return translate(VolumeManager::Instance()->abortFuse());
|
|
}
|
|
|
|
binder::Status VoldNativeService::onUserAdded(int32_t userId, int32_t userSerial) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
return translate(VolumeManager::Instance()->onUserAdded(userId, userSerial));
|
|
}
|
|
|
|
binder::Status VoldNativeService::onUserRemoved(int32_t userId) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
return translate(VolumeManager::Instance()->onUserRemoved(userId));
|
|
}
|
|
|
|
binder::Status VoldNativeService::onUserStarted(int32_t userId) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
return translate(VolumeManager::Instance()->onUserStarted(userId));
|
|
}
|
|
|
|
binder::Status VoldNativeService::onUserStopped(int32_t userId) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
return translate(VolumeManager::Instance()->onUserStopped(userId));
|
|
}
|
|
|
|
binder::Status VoldNativeService::addAppIds(const std::vector<std::string>& packageNames,
|
|
const std::vector<int32_t>& appIds) {
|
|
return Ok();
|
|
}
|
|
|
|
binder::Status VoldNativeService::addSandboxIds(const std::vector<int32_t>& appIds,
|
|
const std::vector<std::string>& sandboxIds) {
|
|
return Ok();
|
|
}
|
|
|
|
binder::Status VoldNativeService::onSecureKeyguardStateChanged(bool isShowing) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
return translate(VolumeManager::Instance()->onSecureKeyguardStateChanged(isShowing));
|
|
}
|
|
|
|
binder::Status VoldNativeService::partition(const std::string& diskId, int32_t partitionType,
|
|
int32_t ratio) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
CHECK_ARGUMENT_ID(diskId);
|
|
ACQUIRE_LOCK;
|
|
|
|
auto disk = VolumeManager::Instance()->findDisk(diskId);
|
|
if (disk == nullptr) {
|
|
return error("Failed to find disk " + diskId);
|
|
}
|
|
switch (partitionType) {
|
|
case PARTITION_TYPE_PUBLIC:
|
|
return translate(disk->partitionPublic());
|
|
case PARTITION_TYPE_PRIVATE:
|
|
return translate(disk->partitionPrivate());
|
|
case PARTITION_TYPE_MIXED:
|
|
return translate(disk->partitionMixed(ratio));
|
|
default:
|
|
return error("Unknown type " + std::to_string(partitionType));
|
|
}
|
|
}
|
|
|
|
binder::Status VoldNativeService::forgetPartition(const std::string& partGuid,
|
|
const std::string& fsUuid) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
CHECK_ARGUMENT_HEX(partGuid);
|
|
CHECK_ARGUMENT_HEX(fsUuid);
|
|
ACQUIRE_LOCK;
|
|
|
|
return translate(VolumeManager::Instance()->forgetPartition(partGuid, fsUuid));
|
|
}
|
|
|
|
binder::Status VoldNativeService::mount(
|
|
const std::string& volId, int32_t mountFlags, int32_t mountUserId,
|
|
const android::sp<android::os::IVoldMountCallback>& callback) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
CHECK_ARGUMENT_ID(volId);
|
|
ACQUIRE_LOCK;
|
|
|
|
auto vol = VolumeManager::Instance()->findVolume(volId);
|
|
if (vol == nullptr) {
|
|
return error("Failed to find volume " + volId);
|
|
}
|
|
|
|
vol->setMountFlags(mountFlags);
|
|
vol->setMountUserId(mountUserId);
|
|
|
|
vol->setMountCallback(callback);
|
|
int res = vol->mount();
|
|
vol->setMountCallback(nullptr);
|
|
|
|
if (res != OK) {
|
|
return translate(res);
|
|
}
|
|
|
|
return translate(OK);
|
|
}
|
|
|
|
binder::Status VoldNativeService::unmount(const std::string& volId) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
CHECK_ARGUMENT_ID(volId);
|
|
ACQUIRE_LOCK;
|
|
|
|
auto vol = VolumeManager::Instance()->findVolume(volId);
|
|
if (vol == nullptr) {
|
|
return error("Failed to find volume " + volId);
|
|
}
|
|
return translate(vol->unmount());
|
|
}
|
|
|
|
binder::Status VoldNativeService::format(const std::string& volId, const std::string& fsType) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
CHECK_ARGUMENT_ID(volId);
|
|
ACQUIRE_LOCK;
|
|
|
|
auto vol = VolumeManager::Instance()->findVolume(volId);
|
|
if (vol == nullptr) {
|
|
return error("Failed to find volume " + volId);
|
|
}
|
|
return translate(vol->format(fsType));
|
|
}
|
|
|
|
static binder::Status pathForVolId(const std::string& volId, std::string* path) {
|
|
if (volId == "private" || volId == "null") {
|
|
*path = "/data";
|
|
} else {
|
|
auto vol = VolumeManager::Instance()->findVolume(volId);
|
|
if (vol == nullptr) {
|
|
return error("Failed to find volume " + volId);
|
|
}
|
|
if (vol->getType() != VolumeBase::Type::kPrivate) {
|
|
return error("Volume " + volId + " not private");
|
|
}
|
|
if (vol->getState() != VolumeBase::State::kMounted) {
|
|
return error("Volume " + volId + " not mounted");
|
|
}
|
|
*path = vol->getPath();
|
|
if (path->empty()) {
|
|
return error("Volume " + volId + " missing path");
|
|
}
|
|
}
|
|
return Ok();
|
|
}
|
|
|
|
binder::Status VoldNativeService::benchmark(
|
|
const std::string& volId, const android::sp<android::os::IVoldTaskListener>& listener) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
CHECK_ARGUMENT_ID(volId);
|
|
ACQUIRE_LOCK;
|
|
|
|
std::string path;
|
|
auto status = pathForVolId(volId, &path);
|
|
if (!status.isOk()) return status;
|
|
|
|
std::thread([=]() { android::vold::Benchmark(path, listener); }).detach();
|
|
return Ok();
|
|
}
|
|
|
|
binder::Status VoldNativeService::moveStorage(
|
|
const std::string& fromVolId, const std::string& toVolId,
|
|
const android::sp<android::os::IVoldTaskListener>& listener) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
CHECK_ARGUMENT_ID(fromVolId);
|
|
CHECK_ARGUMENT_ID(toVolId);
|
|
ACQUIRE_LOCK;
|
|
|
|
auto fromVol = VolumeManager::Instance()->findVolume(fromVolId);
|
|
auto toVol = VolumeManager::Instance()->findVolume(toVolId);
|
|
if (fromVol == nullptr) {
|
|
return error("Failed to find volume " + fromVolId);
|
|
} else if (toVol == nullptr) {
|
|
return error("Failed to find volume " + toVolId);
|
|
}
|
|
|
|
std::thread([=]() { android::vold::MoveStorage(fromVol, toVol, listener); }).detach();
|
|
return Ok();
|
|
}
|
|
|
|
binder::Status VoldNativeService::remountUid(int32_t uid, int32_t remountMode) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
return translate(VolumeManager::Instance()->remountUid(uid, remountMode));
|
|
}
|
|
|
|
binder::Status VoldNativeService::remountAppStorageDirs(int uid, int pid,
|
|
const std::vector<std::string>& packageNames) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
return translate(VolumeManager::Instance()->handleAppStorageDirs(uid, pid,
|
|
false /* doUnmount */, packageNames));
|
|
}
|
|
|
|
binder::Status VoldNativeService::unmountAppStorageDirs(int uid, int pid,
|
|
const std::vector<std::string>& packageNames) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
return translate(VolumeManager::Instance()->handleAppStorageDirs(uid, pid,
|
|
true /* doUnmount */, packageNames));
|
|
}
|
|
|
|
binder::Status VoldNativeService::setupAppDir(const std::string& path, int32_t appUid) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
CHECK_ARGUMENT_PATH(path);
|
|
ACQUIRE_LOCK;
|
|
|
|
return translate(VolumeManager::Instance()->setupAppDir(path, appUid));
|
|
}
|
|
|
|
binder::Status VoldNativeService::ensureAppDirsCreated(const std::vector<std::string>& paths,
|
|
int32_t appUid) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
return translate(VolumeManager::Instance()->ensureAppDirsCreated(paths, appUid));
|
|
}
|
|
|
|
binder::Status VoldNativeService::fixupAppDir(const std::string& path, int32_t appUid) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
CHECK_ARGUMENT_PATH(path);
|
|
ACQUIRE_LOCK;
|
|
|
|
return translate(VolumeManager::Instance()->fixupAppDir(path, appUid));
|
|
}
|
|
|
|
binder::Status VoldNativeService::createObb(const std::string& sourcePath, int32_t ownerGid,
|
|
std::string* _aidl_return) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
CHECK_ARGUMENT_PATH(sourcePath);
|
|
ACQUIRE_LOCK;
|
|
|
|
return translate(VolumeManager::Instance()->createObb(sourcePath, ownerGid, _aidl_return));
|
|
}
|
|
|
|
binder::Status VoldNativeService::destroyObb(const std::string& volId) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
CHECK_ARGUMENT_ID(volId);
|
|
ACQUIRE_LOCK;
|
|
|
|
return translate(VolumeManager::Instance()->destroyObb(volId));
|
|
}
|
|
|
|
binder::Status VoldNativeService::createStubVolume(const std::string& sourcePath,
|
|
const std::string& mountPath,
|
|
const std::string& fsType,
|
|
const std::string& fsUuid,
|
|
const std::string& fsLabel, int32_t flags,
|
|
std::string* _aidl_return) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
CHECK_ARGUMENT_PATH(sourcePath);
|
|
CHECK_ARGUMENT_PATH(mountPath);
|
|
CHECK_ARGUMENT_HEX(fsUuid);
|
|
// Label limitation seems to be different between fs (including allowed characters), so checking
|
|
// is quite meaningless.
|
|
ACQUIRE_LOCK;
|
|
|
|
return translate(VolumeManager::Instance()->createStubVolume(
|
|
sourcePath, mountPath, fsType, fsUuid, fsLabel, flags, _aidl_return));
|
|
}
|
|
|
|
binder::Status VoldNativeService::destroyStubVolume(const std::string& volId) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
CHECK_ARGUMENT_ID(volId);
|
|
ACQUIRE_LOCK;
|
|
|
|
return translate(VolumeManager::Instance()->destroyStubVolume(volId));
|
|
}
|
|
|
|
binder::Status VoldNativeService::fstrim(
|
|
int32_t fstrimFlags, const android::sp<android::os::IVoldTaskListener>& listener) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
std::thread([=]() { android::vold::Trim(listener); }).detach();
|
|
return Ok();
|
|
}
|
|
|
|
binder::Status VoldNativeService::runIdleMaint(
|
|
bool needGC, const android::sp<android::os::IVoldTaskListener>& listener) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
std::thread([=]() { android::vold::RunIdleMaint(needGC, listener); }).detach();
|
|
return Ok();
|
|
}
|
|
|
|
binder::Status VoldNativeService::abortIdleMaint(
|
|
const android::sp<android::os::IVoldTaskListener>& listener) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
std::thread([=]() { android::vold::AbortIdleMaint(listener); }).detach();
|
|
return Ok();
|
|
}
|
|
|
|
binder::Status VoldNativeService::getStorageLifeTime(int32_t* _aidl_return) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
*_aidl_return = GetStorageLifeTime();
|
|
return Ok();
|
|
}
|
|
|
|
binder::Status VoldNativeService::setGCUrgentPace(int32_t neededSegments,
|
|
int32_t minSegmentThreshold,
|
|
float dirtyReclaimRate, float reclaimWeight) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
SetGCUrgentPace(neededSegments, minSegmentThreshold, dirtyReclaimRate, reclaimWeight);
|
|
return Ok();
|
|
}
|
|
|
|
binder::Status VoldNativeService::refreshLatestWrite() {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
RefreshLatestWrite();
|
|
return Ok();
|
|
}
|
|
|
|
binder::Status VoldNativeService::getWriteAmount(int32_t* _aidl_return) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
*_aidl_return = GetWriteAmount();
|
|
return Ok();
|
|
}
|
|
|
|
binder::Status VoldNativeService::mountAppFuse(int32_t uid, int32_t mountId,
|
|
android::base::unique_fd* _aidl_return) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
return translate(VolumeManager::Instance()->mountAppFuse(uid, mountId, _aidl_return));
|
|
}
|
|
|
|
binder::Status VoldNativeService::unmountAppFuse(int32_t uid, int32_t mountId) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
return translate(VolumeManager::Instance()->unmountAppFuse(uid, mountId));
|
|
}
|
|
|
|
binder::Status VoldNativeService::openAppFuseFile(int32_t uid, int32_t mountId, int32_t fileId,
|
|
int32_t flags,
|
|
android::base::unique_fd* _aidl_return) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
int fd = VolumeManager::Instance()->openAppFuseFile(uid, mountId, fileId, flags);
|
|
if (fd == -1) {
|
|
return error("Failed to open AppFuse file for uid: " + std::to_string(uid) +
|
|
" mountId: " + std::to_string(mountId) + " fileId: " + std::to_string(fileId) +
|
|
" flags: " + std::to_string(flags));
|
|
}
|
|
|
|
*_aidl_return = android::base::unique_fd(fd);
|
|
return Ok();
|
|
}
|
|
|
|
// TODO(b/191796797) remove this once caller is removed
|
|
binder::Status VoldNativeService::fdeCheckPassword(const std::string& password) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_CRYPT_LOCK;
|
|
|
|
SLOGE("fdeCheckPassword is no longer supported");
|
|
return translate(-1);
|
|
}
|
|
|
|
// TODO(b/191796797) remove this once caller is removed
|
|
binder::Status VoldNativeService::fdeRestart() {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_CRYPT_LOCK;
|
|
|
|
SLOGE("fdeRestart is no longer supported");
|
|
return Ok();
|
|
}
|
|
|
|
// TODO(b/191796797) remove this once caller is removed
|
|
#define CRYPTO_COMPLETE_NOT_ENCRYPTED 1
|
|
binder::Status VoldNativeService::fdeComplete(int32_t* _aidl_return) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_CRYPT_LOCK;
|
|
|
|
SLOGE("fdeComplete is no longer supported");
|
|
*_aidl_return = CRYPTO_COMPLETE_NOT_ENCRYPTED;
|
|
return Ok();
|
|
}
|
|
|
|
// TODO(b/191796797) remove this once caller is removed
|
|
binder::Status VoldNativeService::fdeEnable(int32_t passwordType, const std::string& password,
|
|
int32_t encryptionFlags) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_CRYPT_LOCK;
|
|
|
|
SLOGE("fdeEnable is no longer supported");
|
|
return translate(-1);
|
|
}
|
|
|
|
// TODO(b/191796797) remove this once caller is removed
|
|
binder::Status VoldNativeService::fdeChangePassword(int32_t passwordType,
|
|
const std::string& password) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_CRYPT_LOCK;
|
|
|
|
SLOGE("fdeChangePassword is no longer supported");
|
|
return translate(-1);
|
|
}
|
|
|
|
// TODO(b/191796797) remove this once caller is removed
|
|
binder::Status VoldNativeService::fdeVerifyPassword(const std::string& password) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_CRYPT_LOCK;
|
|
|
|
SLOGE("fdeVerifyPassword is no longer supported");
|
|
return translate(-1);
|
|
}
|
|
|
|
// TODO(b/191796797) remove this once caller is removed
|
|
binder::Status VoldNativeService::fdeGetField(const std::string& key, std::string* _aidl_return) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_CRYPT_LOCK;
|
|
|
|
SLOGE("fdeGetField is no longer supported");
|
|
return translate(-1);
|
|
}
|
|
|
|
// TODO(b/191796797) remove this once caller is removed
|
|
binder::Status VoldNativeService::fdeSetField(const std::string& key, const std::string& value) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_CRYPT_LOCK;
|
|
|
|
SLOGE("fdeSetField is no longer supported");
|
|
return translate(-1);
|
|
}
|
|
|
|
// TODO(b/191796797) remove this once caller is removed
|
|
binder::Status VoldNativeService::fdeGetPasswordType(int32_t* _aidl_return) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_CRYPT_LOCK;
|
|
|
|
SLOGE("fdeGetPasswordType is no longer supported");
|
|
*_aidl_return = -1;
|
|
return Ok();
|
|
}
|
|
|
|
// TODO(b/191796797) remove this once caller is removed
|
|
binder::Status VoldNativeService::fdeGetPassword(std::string* _aidl_return) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_CRYPT_LOCK;
|
|
|
|
SLOGE("fdeGetPassword is no longer supported");
|
|
return Ok();
|
|
}
|
|
|
|
// TODO(b/191796797) remove this once caller is removed
|
|
binder::Status VoldNativeService::fdeClearPassword() {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_CRYPT_LOCK;
|
|
|
|
SLOGE("fdeClearPassword is no longer supported");
|
|
return Ok();
|
|
}
|
|
|
|
binder::Status VoldNativeService::fbeEnable() {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_CRYPT_LOCK;
|
|
|
|
return translateBool(fscrypt_initialize_systemwide_keys());
|
|
}
|
|
|
|
// TODO(b/191796797) remove this once caller is removed
|
|
binder::Status VoldNativeService::mountDefaultEncrypted() {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_CRYPT_LOCK;
|
|
|
|
SLOGE("mountDefaultEncrypted is no longer supported");
|
|
return Ok();
|
|
}
|
|
|
|
binder::Status VoldNativeService::initUser0() {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_CRYPT_LOCK;
|
|
|
|
return translateBool(fscrypt_init_user0());
|
|
}
|
|
|
|
// TODO(b/191796797) remove this once caller is removed
|
|
binder::Status VoldNativeService::isConvertibleToFbe(bool* _aidl_return) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_CRYPT_LOCK;
|
|
|
|
SLOGE("isConvertibleToFbe is no longer supported");
|
|
*_aidl_return = false;
|
|
return Ok();
|
|
}
|
|
|
|
binder::Status VoldNativeService::mountFstab(const std::string& blkDevice,
|
|
const std::string& mountPoint) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
return translateBool(
|
|
fscrypt_mount_metadata_encrypted(blkDevice, mountPoint, false, false, "null"));
|
|
}
|
|
|
|
binder::Status VoldNativeService::encryptFstab(const std::string& blkDevice,
|
|
const std::string& mountPoint, bool shouldFormat,
|
|
const std::string& fsType) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
return translateBool(
|
|
fscrypt_mount_metadata_encrypted(blkDevice, mountPoint, true, shouldFormat, fsType));
|
|
}
|
|
|
|
binder::Status VoldNativeService::setStorageBindingSeed(const std::vector<uint8_t>& seed) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_CRYPT_LOCK;
|
|
|
|
return translateBool(setKeyStorageBindingSeed(seed));
|
|
}
|
|
|
|
binder::Status VoldNativeService::createUserKey(int32_t userId, int32_t userSerial,
|
|
bool ephemeral) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_CRYPT_LOCK;
|
|
|
|
return translateBool(fscrypt_vold_create_user_key(userId, userSerial, ephemeral));
|
|
}
|
|
|
|
binder::Status VoldNativeService::destroyUserKey(int32_t userId) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_CRYPT_LOCK;
|
|
|
|
return translateBool(fscrypt_destroy_user_key(userId));
|
|
}
|
|
|
|
static bool token_empty(const std::string& token) {
|
|
return token.size() == 0 || token == "!";
|
|
}
|
|
|
|
binder::Status VoldNativeService::addUserKeyAuth(int32_t userId, int32_t userSerial,
|
|
const std::string& token,
|
|
const std::string& secret) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_CRYPT_LOCK;
|
|
|
|
if (!token_empty(token)) {
|
|
LOG(ERROR) << "Vold doesn't use auth tokens, but non-empty token passed to addUserKeyAuth.";
|
|
return binder::Status::fromServiceSpecificError(-EINVAL);
|
|
}
|
|
|
|
return translateBool(fscrypt_add_user_key_auth(userId, userSerial, secret));
|
|
}
|
|
|
|
binder::Status VoldNativeService::clearUserKeyAuth(int32_t userId, int32_t userSerial,
|
|
const std::string& token,
|
|
const std::string& secret) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_CRYPT_LOCK;
|
|
|
|
if (!token_empty(token)) {
|
|
LOG(ERROR)
|
|
<< "Vold doesn't use auth tokens, but non-empty token passed to clearUserKeyAuth.";
|
|
return binder::Status::fromServiceSpecificError(-EINVAL);
|
|
}
|
|
|
|
return translateBool(fscrypt_clear_user_key_auth(userId, userSerial, secret));
|
|
}
|
|
|
|
binder::Status VoldNativeService::fixateNewestUserKeyAuth(int32_t userId) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_CRYPT_LOCK;
|
|
|
|
return translateBool(fscrypt_fixate_newest_user_key_auth(userId));
|
|
}
|
|
|
|
binder::Status VoldNativeService::getUnlockedUsers(std::vector<int>* _aidl_return) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_CRYPT_LOCK;
|
|
|
|
*_aidl_return = fscrypt_get_unlocked_users();
|
|
return Ok();
|
|
}
|
|
|
|
binder::Status VoldNativeService::unlockUserKey(int32_t userId, int32_t userSerial,
|
|
const std::string& token,
|
|
const std::string& secret) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_CRYPT_LOCK;
|
|
|
|
if (!token_empty(token)) {
|
|
LOG(ERROR) << "Vold doesn't use auth tokens, but non-empty token passed to unlockUserKey.";
|
|
return binder::Status::fromServiceSpecificError(-EINVAL);
|
|
}
|
|
|
|
return translateBool(fscrypt_unlock_user_key(userId, userSerial, secret));
|
|
}
|
|
|
|
binder::Status VoldNativeService::lockUserKey(int32_t userId) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_CRYPT_LOCK;
|
|
|
|
return translateBool(fscrypt_lock_user_key(userId));
|
|
}
|
|
|
|
binder::Status VoldNativeService::prepareUserStorage(const std::optional<std::string>& uuid,
|
|
int32_t userId, int32_t userSerial,
|
|
int32_t flags) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
std::string empty_string = "";
|
|
auto uuid_ = uuid ? *uuid : empty_string;
|
|
CHECK_ARGUMENT_HEX(uuid_);
|
|
|
|
ACQUIRE_CRYPT_LOCK;
|
|
return translateBool(fscrypt_prepare_user_storage(uuid_, userId, userSerial, flags));
|
|
}
|
|
|
|
binder::Status VoldNativeService::destroyUserStorage(const std::optional<std::string>& uuid,
|
|
int32_t userId, int32_t flags) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
std::string empty_string = "";
|
|
auto uuid_ = uuid ? *uuid : empty_string;
|
|
CHECK_ARGUMENT_HEX(uuid_);
|
|
|
|
ACQUIRE_CRYPT_LOCK;
|
|
return translateBool(fscrypt_destroy_user_storage(uuid_, userId, flags));
|
|
}
|
|
|
|
binder::Status VoldNativeService::prepareSandboxForApp(const std::string& packageName,
|
|
int32_t appId, const std::string& sandboxId,
|
|
int32_t userId) {
|
|
return Ok();
|
|
}
|
|
|
|
binder::Status VoldNativeService::destroySandboxForApp(const std::string& packageName,
|
|
const std::string& sandboxId,
|
|
int32_t userId) {
|
|
return Ok();
|
|
}
|
|
|
|
binder::Status VoldNativeService::startCheckpoint(int32_t retry) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
return cp_startCheckpoint(retry);
|
|
}
|
|
|
|
binder::Status VoldNativeService::needsRollback(bool* _aidl_return) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
*_aidl_return = cp_needsRollback();
|
|
return Ok();
|
|
}
|
|
|
|
binder::Status VoldNativeService::needsCheckpoint(bool* _aidl_return) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
*_aidl_return = cp_needsCheckpoint();
|
|
return Ok();
|
|
}
|
|
|
|
binder::Status VoldNativeService::isCheckpointing(bool* _aidl_return) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
*_aidl_return = cp_isCheckpointing();
|
|
return Ok();
|
|
}
|
|
|
|
binder::Status VoldNativeService::commitChanges() {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
return cp_commitChanges();
|
|
}
|
|
|
|
binder::Status VoldNativeService::prepareCheckpoint() {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
return cp_prepareCheckpoint();
|
|
}
|
|
|
|
binder::Status VoldNativeService::restoreCheckpoint(const std::string& mountPoint) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
CHECK_ARGUMENT_PATH(mountPoint);
|
|
ACQUIRE_LOCK;
|
|
|
|
return cp_restoreCheckpoint(mountPoint);
|
|
}
|
|
|
|
binder::Status VoldNativeService::restoreCheckpointPart(const std::string& mountPoint, int count) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
CHECK_ARGUMENT_PATH(mountPoint);
|
|
ACQUIRE_LOCK;
|
|
|
|
return cp_restoreCheckpoint(mountPoint, count);
|
|
}
|
|
|
|
binder::Status VoldNativeService::markBootAttempt() {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
return cp_markBootAttempt();
|
|
}
|
|
|
|
binder::Status VoldNativeService::abortChanges(const std::string& message, bool retry) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
cp_abortChanges(message, retry);
|
|
return Ok();
|
|
}
|
|
|
|
binder::Status VoldNativeService::supportsCheckpoint(bool* _aidl_return) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
return cp_supportsCheckpoint(*_aidl_return);
|
|
}
|
|
|
|
binder::Status VoldNativeService::supportsBlockCheckpoint(bool* _aidl_return) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
return cp_supportsBlockCheckpoint(*_aidl_return);
|
|
}
|
|
|
|
binder::Status VoldNativeService::supportsFileCheckpoint(bool* _aidl_return) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
return cp_supportsFileCheckpoint(*_aidl_return);
|
|
}
|
|
|
|
binder::Status VoldNativeService::resetCheckpoint() {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
cp_resetCheckpoint();
|
|
return Ok();
|
|
}
|
|
|
|
static void initializeIncFs() {
|
|
// Obtaining IncFS features triggers initialization of IncFS.
|
|
incfs::features();
|
|
}
|
|
|
|
binder::Status VoldNativeService::earlyBootEnded() {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
initializeIncFs();
|
|
Keystore::earlyBootEnded();
|
|
return Ok();
|
|
}
|
|
|
|
binder::Status VoldNativeService::incFsEnabled(bool* _aidl_return) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
|
|
*_aidl_return = incfs::enabled();
|
|
return Ok();
|
|
}
|
|
|
|
binder::Status VoldNativeService::mountIncFs(
|
|
const std::string& backingPath, const std::string& targetDir, int32_t flags,
|
|
const std::string& sysfsName,
|
|
::android::os::incremental::IncrementalFileSystemControlParcel* _aidl_return) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
if (auto status = CheckIncrementalPath(IncrementalPathKind::MountTarget, targetDir);
|
|
!status.isOk()) {
|
|
return status;
|
|
}
|
|
if (auto status = CheckIncrementalPath(IncrementalPathKind::MountSource, backingPath);
|
|
!status.isOk()) {
|
|
return status;
|
|
}
|
|
|
|
auto [backingFd, backingSymlink] = OpenDirInProcfs(backingPath);
|
|
if (!backingFd.ok()) {
|
|
return translate(-errno);
|
|
}
|
|
auto [targetFd, targetSymlink] = OpenDirInProcfs(targetDir);
|
|
if (!targetFd.ok()) {
|
|
return translate(-errno);
|
|
}
|
|
|
|
auto control = incfs::mount(backingSymlink, targetSymlink,
|
|
{.flags = IncFsMountFlags(flags),
|
|
// Mount with read timeouts.
|
|
.defaultReadTimeoutMs = INCFS_DEFAULT_READ_TIMEOUT_MS,
|
|
// Mount with read logs disabled.
|
|
.readLogBufferPages = 0,
|
|
.sysfsName = sysfsName.c_str()});
|
|
if (!control) {
|
|
return translate(-errno);
|
|
}
|
|
auto fds = control.releaseFds();
|
|
using android::base::unique_fd;
|
|
_aidl_return->cmd.reset(unique_fd(fds[CMD].release()));
|
|
_aidl_return->pendingReads.reset(unique_fd(fds[PENDING_READS].release()));
|
|
_aidl_return->log.reset(unique_fd(fds[LOGS].release()));
|
|
if (fds[BLOCKS_WRITTEN].ok()) {
|
|
_aidl_return->blocksWritten.emplace(unique_fd(fds[BLOCKS_WRITTEN].release()));
|
|
}
|
|
return Ok();
|
|
}
|
|
|
|
binder::Status VoldNativeService::unmountIncFs(const std::string& dir) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
if (auto status = CheckIncrementalPath(IncrementalPathKind::Any, dir); !status.isOk()) {
|
|
return status;
|
|
}
|
|
|
|
auto [fd, symLink] = OpenDirInProcfs(dir);
|
|
if (!fd.ok()) {
|
|
return translate(-errno);
|
|
}
|
|
return translate(incfs::unmount(symLink));
|
|
}
|
|
|
|
binder::Status VoldNativeService::setIncFsMountOptions(
|
|
const ::android::os::incremental::IncrementalFileSystemControlParcel& control,
|
|
bool enableReadLogs, bool enableReadTimeouts, const std::string& sysfsName) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
|
|
auto incfsControl =
|
|
incfs::createControl(control.cmd.get(), control.pendingReads.get(), control.log.get(),
|
|
control.blocksWritten ? control.blocksWritten->get() : -1);
|
|
auto cleanupFunc = [](auto incfsControl) {
|
|
for (auto& fd : incfsControl->releaseFds()) {
|
|
(void)fd.release();
|
|
}
|
|
};
|
|
auto cleanup =
|
|
std::unique_ptr<incfs::Control, decltype(cleanupFunc)>(&incfsControl, cleanupFunc);
|
|
|
|
constexpr auto minReadLogBufferPages = INCFS_DEFAULT_PAGE_READ_BUFFER_PAGES;
|
|
constexpr auto maxReadLogBufferPages = 8 * INCFS_DEFAULT_PAGE_READ_BUFFER_PAGES;
|
|
auto options = incfs::MountOptions{
|
|
.defaultReadTimeoutMs =
|
|
enableReadTimeouts ? INCFS_DEFAULT_READ_TIMEOUT_MS : kIncFsReadNoTimeoutMs,
|
|
.readLogBufferPages = enableReadLogs ? maxReadLogBufferPages : 0,
|
|
.sysfsName = sysfsName.c_str()};
|
|
|
|
for (;;) {
|
|
const auto error = incfs::setOptions(incfsControl, options);
|
|
if (!error) {
|
|
return Ok();
|
|
}
|
|
if (!enableReadLogs || error != -ENOMEM) {
|
|
return binder::Status::fromServiceSpecificError(error);
|
|
}
|
|
// In case of memory allocation error retry with a smaller buffer.
|
|
options.readLogBufferPages /= 2;
|
|
if (options.readLogBufferPages < minReadLogBufferPages) {
|
|
return binder::Status::fromServiceSpecificError(error);
|
|
}
|
|
}
|
|
// unreachable, but makes the compiler happy
|
|
return Ok();
|
|
}
|
|
|
|
binder::Status VoldNativeService::bindMount(const std::string& sourceDir,
|
|
const std::string& targetDir) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
if (auto status = CheckIncrementalPath(IncrementalPathKind::Any, sourceDir); !status.isOk()) {
|
|
return status;
|
|
}
|
|
if (auto status = CheckIncrementalPath(IncrementalPathKind::Bind, targetDir); !status.isOk()) {
|
|
return status;
|
|
}
|
|
|
|
auto [sourceFd, sourceSymlink] = OpenDirInProcfs(sourceDir);
|
|
if (!sourceFd.ok()) {
|
|
return translate(-errno);
|
|
}
|
|
auto [targetFd, targetSymlink] = OpenDirInProcfs(targetDir);
|
|
if (!targetFd.ok()) {
|
|
return translate(-errno);
|
|
}
|
|
return translate(incfs::bindMount(sourceSymlink, targetSymlink));
|
|
}
|
|
|
|
binder::Status VoldNativeService::destroyDsuMetadataKey(const std::string& dsuSlot) {
|
|
ENFORCE_SYSTEM_OR_ROOT;
|
|
ACQUIRE_LOCK;
|
|
|
|
return translateBool(destroy_dsu_metadata_key(dsuSlot));
|
|
}
|
|
|
|
} // namespace vold
|
|
} // namespace android
|