Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 149be4a2 authored by Jooyung Han's avatar Jooyung Han
Browse files

Use std::optional for @nullable (AIDL) 

Previously, nullable types were mapped to std::unique_ptr for C++
backend. But std::unique_ptr typically involves unnecessary alloc/dealloc.

For example, if nullable string is represented in unique_ptr<string>, we
should do "unique_ptr<string>(new string(value))" to set a value.

To avoid breaking all hand-written parcelables, only new read/write
functions are added to Parcel class and they are used only by
aidl-generated code and their implementations.

Bug: 144773267
Test: build/flash/boot
      atest --test-mapping frameworks/native/libs/binder

Change-Id: I2c801e3b69f2f8ccf44267f15cbf79e1d8fbf19e
Exempt-From-Owner-Approval: already got ORV from smoreland
parent 818ac485

cmds/installd/CrateManager.cpp

+12 −12
Original line number Original line Diff line number Diff line
@@ -86,7 +86,7 @@ void CrateManager::traverseChildDir(const std::string& targetDir, 
}

}





void CrateManager::traverseAllPackagesForUser(

void CrateManager::traverseAllPackagesForUser(

        const std::unique_ptr<std::string>& uuid, userid_t userId,

        const std::optional<std::string>& uuid, userid_t userId,

        std::function<void(FTSENT*)>& onHandlingPackage) {

        std::function<void(FTSENT*)>& onHandlingPackage) {

    const char* uuid_ = uuid ? uuid->c_str() : nullptr;

    const char* uuid_ = uuid ? uuid->c_str() : nullptr;
@@ -96,21 +96,21 @@ void CrateManager::traverseAllPackagesForUser( 




void CrateManager::createCrate(

void CrateManager::createCrate(

        CratedFolder cratedFolder,

        CratedFolder cratedFolder,

        std::function<void(CratedFolder, std::unique_ptr<CrateMetadata>&)>& onCreateCrate) {

        std::function<void(CratedFolder, CrateMetadata&&)>& onCreateCrate) {

    const char* path = cratedFolder->fts_path;

    const char* path = cratedFolder->fts_path;

    if (path == nullptr || *path == '\0') {

    if (path == nullptr || *path == '\0') {

        return;

        return;

    }

    }





    std::unique_ptr<CrateMetadata> crateMetadata = std::make_unique<CrateMetadata>();

    CrateMetadata crateMetadata;

    crateMetadata->uid = cratedFolder->fts_statp->st_uid;

    crateMetadata.uid = cratedFolder->fts_statp->st_uid;

    crateMetadata->packageName = mPackageName;

    crateMetadata.packageName = mPackageName;

    crateMetadata->id = getValidatedCratedPath(path);

    crateMetadata.id = getValidatedCratedPath(path);





    onCreateCrate(cratedFolder, crateMetadata);

    onCreateCrate(cratedFolder, std::move(crateMetadata));

}

}





void CrateManager::traverseAllCrates(std::function<void(CratedFolder, std::unique_ptr<CrateMetadata>&)>& onCreateCrate) {

void CrateManager::traverseAllCrates(std::function<void(CratedFolder, CrateMetadata&&)>& onCreateCrate) {

    std::function<void(FTSENT*)> onVisitCrateDir = [&](FTSENT* cratedFolder) -> void {

    std::function<void(FTSENT*)> onVisitCrateDir = [&](FTSENT* cratedFolder) -> void {

        createCrate(cratedFolder, onCreateCrate);

        createCrate(cratedFolder, onCreateCrate);

    };

    };
@@ -118,11 +118,11 @@ void CrateManager::traverseAllCrates(std::function<void(CratedFolder, std::uniqu 
}

}





#if CRATE_DEBUG

#if CRATE_DEBUG

void CrateManager::dump(std::unique_ptr<CrateMetadata>& CrateMetadata) {

void CrateManager::dump(const CrateMetadata& CrateMetadata) {

    LOG(DEBUG) << "CrateMetadata = {"

    LOG(DEBUG) << "CrateMetadata = {"

            << "uid : \"" << CrateMetadata->uid

            << "uid : \"" << CrateMetadata.uid

            << "\", packageName : \"" << CrateMetadata->packageName

            << "\", packageName : \"" << CrateMetadata.packageName

            << "\", id : \"" << CrateMetadata->id

            << "\", id : \"" << CrateMetadata.id

            << "\"}";

            << "\"}";

}

}

#endif

#endif

cmds/installd/CrateManager.h

+5 −5
Original line number Original line Diff line number Diff line
@@ -25,7 +25,7 @@ 
#include <sys/stat.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <sys/types.h>





#include <memory>

#include <optional>

#include <string>

#include <string>

#include <vector>

#include <vector>
@@ -55,18 +55,18 @@ public: 
    CrateManager(const char* uuid, userid_t userId, const std::string& packageName);

    CrateManager(const char* uuid, userid_t userId, const std::string& packageName);

    ~CrateManager();

    ~CrateManager();





    void traverseAllCrates(std::function<void(CratedFolder, std::unique_ptr<CrateMetadata>&)>& onCreateCrate);

    void traverseAllCrates(std::function<void(CratedFolder, CrateMetadata&&)>& onCreateCrate);





    static void traverseChildDir(const std::string& targetDir,

    static void traverseChildDir(const std::string& targetDir,

            std::function<void(FTSENT*)>& onVisitChildDir);

            std::function<void(FTSENT*)>& onVisitChildDir);





    static void traverseAllPackagesForUser(

    static void traverseAllPackagesForUser(

        const std::unique_ptr<std::string>& uuid,

        const std::optional<std::string>& uuid,

        userid_t userId,

        userid_t userId,

        std::function<void(FTSENT*)>& onHandlingPackage);

        std::function<void(FTSENT*)>& onHandlingPackage);





#if CRATE_DEBUG

#if CRATE_DEBUG

    static void dump(std::unique_ptr<CrateMetadata>& CrateMetadata);

    static void dump(const CrateMetadata& CrateMetadata);

#endif

#endif

private:

private:

    std::string mRoot;

    std::string mRoot;
@@ -75,7 +75,7 @@ private: 




    void createCrate(

    void createCrate(

        CratedFolder cratedFolder,

        CratedFolder cratedFolder,

        std::function<void(CratedFolder, std::unique_ptr<CrateMetadata>&)>& onCreateCrate);

        std::function<void(CratedFolder, CrateMetadata&&)>& onCreateCrate);

};

};





} // namespace installd

} // namespace installd

cmds/installd/InstalldNativeService.cpp

+64 −65
Original line number Original line Diff line number Diff line
@@ -164,7 +164,7 @@ binder::Status checkUid(uid_t expectedUid) { 
    }

    }

}

}





binder::Status checkArgumentUuid(const std::unique_ptr<std::string>& uuid) {

binder::Status checkArgumentUuid(const std::optional<std::string>& uuid) {

    if (!uuid || is_valid_filename(*uuid)) {

    if (!uuid || is_valid_filename(*uuid)) {

        return ok();

        return ok();

    } else {

    } else {
@@ -173,7 +173,7 @@ binder::Status checkArgumentUuid(const std::unique_ptr<std::string>& uuid) { 
    }

    }

}

}





binder::Status checkArgumentUuidTestOrNull(const std::unique_ptr<std::string>& uuid) {

binder::Status checkArgumentUuidTestOrNull(const std::optional<std::string>& uuid) {

    if (!uuid || strcmp(uuid->c_str(), kTestUuid) == 0) {

    if (!uuid || strcmp(uuid->c_str(), kTestUuid) == 0) {

        return ok();

        return ok();

    } else {

    } else {
@@ -212,7 +212,7 @@ binder::Status checkArgumentPath(const std::string& path) { 
    return ok();

    return ok();

}

}





binder::Status checkArgumentPath(const std::unique_ptr<std::string>& path) {

binder::Status checkArgumentPath(const std::optional<std::string>& path) {

    if (path) {

    if (path) {

        return checkArgumentPath(*path);

        return checkArgumentPath(*path);

    } else {

    } else {
@@ -418,7 +418,7 @@ static bool prepare_app_profile_dir(const std::string& packageName, int32_t appI 
    return true;

    return true;

}

}





binder::Status InstalldNativeService::createAppData(const std::unique_ptr<std::string>& uuid,

binder::Status InstalldNativeService::createAppData(const std::optional<std::string>& uuid,

        const std::string& packageName, int32_t userId, int32_t flags, int32_t appId,

        const std::string& packageName, int32_t userId, int32_t flags, int32_t appId,

        const std::string& seInfo, int32_t targetSdkVersion, int64_t* _aidl_return) {

        const std::string& seInfo, int32_t targetSdkVersion, int64_t* _aidl_return) {

    ENFORCE_UID(AID_SYSTEM);

    ENFORCE_UID(AID_SYSTEM);
@@ -499,7 +499,7 @@ binder::Status InstalldNativeService::createAppData(const std::unique_ptr<std::s 
    return ok();

    return ok();

}

}





binder::Status InstalldNativeService::migrateAppData(const std::unique_ptr<std::string>& uuid,

binder::Status InstalldNativeService::migrateAppData(const std::optional<std::string>& uuid,

        const std::string& packageName, int32_t userId, int32_t flags) {

        const std::string& packageName, int32_t userId, int32_t flags) {

    ENFORCE_UID(AID_SYSTEM);

    ENFORCE_UID(AID_SYSTEM);

    CHECK_ARGUMENT_UUID(uuid);

    CHECK_ARGUMENT_UUID(uuid);
@@ -560,7 +560,7 @@ binder::Status InstalldNativeService::clearAppProfiles(const std::string& packag 
    return res;

    return res;

}

}





binder::Status InstalldNativeService::clearAppData(const std::unique_ptr<std::string>& uuid,

binder::Status InstalldNativeService::clearAppData(const std::optional<std::string>& uuid,

        const std::string& packageName, int32_t userId, int32_t flags, int64_t ceDataInode) {

        const std::string& packageName, int32_t userId, int32_t flags, int64_t ceDataInode) {

    ENFORCE_UID(AID_SYSTEM);

    ENFORCE_UID(AID_SYSTEM);

    CHECK_ARGUMENT_UUID(uuid);

    CHECK_ARGUMENT_UUID(uuid);
@@ -680,7 +680,7 @@ binder::Status InstalldNativeService::destroyAppProfiles(const std::string& pack 
    return res;

    return res;

}

}





binder::Status InstalldNativeService::destroyAppData(const std::unique_ptr<std::string>& uuid,

binder::Status InstalldNativeService::destroyAppData(const std::optional<std::string>& uuid,

        const std::string& packageName, int32_t userId, int32_t flags, int64_t ceDataInode) {

        const std::string& packageName, int32_t userId, int32_t flags, int64_t ceDataInode) {

    ENFORCE_UID(AID_SYSTEM);

    ENFORCE_UID(AID_SYSTEM);

    CHECK_ARGUMENT_UUID(uuid);

    CHECK_ARGUMENT_UUID(uuid);
@@ -752,7 +752,7 @@ static gid_t get_cache_gid(uid_t uid) { 
    return (gid != -1) ? gid : uid;

    return (gid != -1) ? gid : uid;

}

}





binder::Status InstalldNativeService::fixupAppData(const std::unique_ptr<std::string>& uuid,

binder::Status InstalldNativeService::fixupAppData(const std::optional<std::string>& uuid,

        int32_t flags) {

        int32_t flags) {

    ENFORCE_UID(AID_SYSTEM);

    ENFORCE_UID(AID_SYSTEM);

    CHECK_ARGUMENT_UUID(uuid);

    CHECK_ARGUMENT_UUID(uuid);
@@ -872,7 +872,7 @@ static int32_t copy_directory_recursive(const char* from, const char* to) { 
}

}





binder::Status InstalldNativeService::snapshotAppData(

binder::Status InstalldNativeService::snapshotAppData(

        const std::unique_ptr<std::string>& volumeUuid,

        const std::optional<std::string>& volumeUuid,

        const std::string& packageName, int32_t user, int32_t snapshotId,

        const std::string& packageName, int32_t user, int32_t snapshotId,

        int32_t storageFlags, int64_t* _aidl_return) {

        int32_t storageFlags, int64_t* _aidl_return) {

    ENFORCE_UID(AID_SYSTEM);

    ENFORCE_UID(AID_SYSTEM);
@@ -999,7 +999,7 @@ binder::Status InstalldNativeService::snapshotAppData( 
}

}





binder::Status InstalldNativeService::restoreAppDataSnapshot(

binder::Status InstalldNativeService::restoreAppDataSnapshot(

        const std::unique_ptr<std::string>& volumeUuid, const std::string& packageName,

        const std::optional<std::string>& volumeUuid, const std::string& packageName,

        const int32_t appId, const std::string& seInfo, const int32_t user,

        const int32_t appId, const std::string& seInfo, const int32_t user,

        const int32_t snapshotId, int32_t storageFlags) {

        const int32_t snapshotId, int32_t storageFlags) {

    ENFORCE_UID(AID_SYSTEM);

    ENFORCE_UID(AID_SYSTEM);
@@ -1069,7 +1069,7 @@ binder::Status InstalldNativeService::restoreAppDataSnapshot( 
}

}





binder::Status InstalldNativeService::destroyAppDataSnapshot(

binder::Status InstalldNativeService::destroyAppDataSnapshot(

        const std::unique_ptr<std::string> &volumeUuid, const std::string& packageName,

        const std::optional<std::string> &volumeUuid, const std::string& packageName,

        const int32_t user, const int64_t ceSnapshotInode, const int32_t snapshotId,

        const int32_t user, const int64_t ceSnapshotInode, const int32_t snapshotId,

        int32_t storageFlags) {

        int32_t storageFlags) {

    ENFORCE_UID(AID_SYSTEM);

    ENFORCE_UID(AID_SYSTEM);
@@ -1102,8 +1102,8 @@ binder::Status InstalldNativeService::destroyAppDataSnapshot( 
}

}









binder::Status InstalldNativeService::moveCompleteApp(const std::unique_ptr<std::string>& fromUuid,

binder::Status InstalldNativeService::moveCompleteApp(const std::optional<std::string>& fromUuid,

        const std::unique_ptr<std::string>& toUuid, const std::string& packageName,

        const std::optional<std::string>& toUuid, const std::string& packageName,

        int32_t appId, const std::string& seInfo,

        int32_t appId, const std::string& seInfo,

        int32_t targetSdkVersion, const std::string& fromCodePath) {

        int32_t targetSdkVersion, const std::string& fromCodePath) {

    ENFORCE_UID(AID_SYSTEM);

    ENFORCE_UID(AID_SYSTEM);
@@ -1210,7 +1210,7 @@ fail: 
    return res;

    return res;

}

}





binder::Status InstalldNativeService::createUserData(const std::unique_ptr<std::string>& uuid,

binder::Status InstalldNativeService::createUserData(const std::optional<std::string>& uuid,

        int32_t userId, int32_t userSerial ATTRIBUTE_UNUSED, int32_t flags) {

        int32_t userId, int32_t userSerial ATTRIBUTE_UNUSED, int32_t flags) {

    ENFORCE_UID(AID_SYSTEM);

    ENFORCE_UID(AID_SYSTEM);

    CHECK_ARGUMENT_UUID(uuid);

    CHECK_ARGUMENT_UUID(uuid);
@@ -1228,7 +1228,7 @@ binder::Status InstalldNativeService::createUserData(const std::unique_ptr<std:: 
    return ok();

    return ok();

}

}





binder::Status InstalldNativeService::destroyUserData(const std::unique_ptr<std::string>& uuid,

binder::Status InstalldNativeService::destroyUserData(const std::optional<std::string>& uuid,

        int32_t userId, int32_t flags) {

        int32_t userId, int32_t flags) {

    ENFORCE_UID(AID_SYSTEM);

    ENFORCE_UID(AID_SYSTEM);

    CHECK_ARGUMENT_UUID(uuid);

    CHECK_ARGUMENT_UUID(uuid);
@@ -1265,13 +1265,13 @@ binder::Status InstalldNativeService::destroyUserData(const std::unique_ptr<std: 
    return res;

    return res;

}

}





binder::Status InstalldNativeService::freeCache(const std::unique_ptr<std::string>& uuid,

binder::Status InstalldNativeService::freeCache(const std::optional<std::string>& uuid,

        int64_t targetFreeBytes, int64_t cacheReservedBytes, int32_t flags) {

        int64_t targetFreeBytes, int64_t cacheReservedBytes, int32_t flags) {

    ENFORCE_UID(AID_SYSTEM);

    ENFORCE_UID(AID_SYSTEM);

    CHECK_ARGUMENT_UUID(uuid);

    CHECK_ARGUMENT_UUID(uuid);

    std::lock_guard<std::recursive_mutex> lock(mLock);

    std::lock_guard<std::recursive_mutex> lock(mLock);





    auto uuidString = uuid ? *uuid : "";

    auto uuidString = uuid.value_or("");

    const char* uuid_ = uuid ? uuid->c_str() : nullptr;

    const char* uuid_ = uuid ? uuid->c_str() : nullptr;

    auto data_path = create_data_path(uuid_);

    auto data_path = create_data_path(uuid_);

    auto noop = (flags & FLAG_FREE_CACHE_NOOP);

    auto noop = (flags & FLAG_FREE_CACHE_NOOP);
@@ -1669,7 +1669,7 @@ static void collectManualExternalStatsForUser(const std::string& path, struct st 
    fts_close(fts);

    fts_close(fts);

}

}





binder::Status InstalldNativeService::getAppSize(const std::unique_ptr<std::string>& uuid,

binder::Status InstalldNativeService::getAppSize(const std::optional<std::string>& uuid,

        const std::vector<std::string>& packageNames, int32_t userId, int32_t flags,

        const std::vector<std::string>& packageNames, int32_t userId, int32_t flags,

        int32_t appId, const std::vector<int64_t>& ceDataInodes,

        int32_t appId, const std::vector<int64_t>& ceDataInodes,

        const std::vector<std::string>& codePaths, std::vector<int64_t>* _aidl_return) {

        const std::vector<std::string>& codePaths, std::vector<int64_t>* _aidl_return) {
@@ -1709,7 +1709,7 @@ binder::Status InstalldNativeService::getAppSize(const std::unique_ptr<std::stri 
    memset(&stats, 0, sizeof(stats));

    memset(&stats, 0, sizeof(stats));

    memset(&extStats, 0, sizeof(extStats));

    memset(&extStats, 0, sizeof(extStats));





    auto uuidString = uuid ? *uuid : "";

    auto uuidString = uuid.value_or("");

    const char* uuid_ = uuid ? uuid->c_str() : nullptr;

    const char* uuid_ = uuid ? uuid->c_str() : nullptr;





    if (!IsQuotaSupported(uuidString)) {

    if (!IsQuotaSupported(uuidString)) {
@@ -1896,7 +1896,7 @@ static external_sizes getExternalSizesForUserWithQuota(const std::string& uuid, 
    return sizes;

    return sizes;

}

}





binder::Status InstalldNativeService::getUserSize(const std::unique_ptr<std::string>& uuid,

binder::Status InstalldNativeService::getUserSize(const std::optional<std::string>& uuid,

        int32_t userId, int32_t flags, const std::vector<int32_t>& appIds,

        int32_t userId, int32_t flags, const std::vector<int32_t>& appIds,

        std::vector<int64_t>* _aidl_return) {

        std::vector<int64_t>* _aidl_return) {

    ENFORCE_UID(AID_SYSTEM);

    ENFORCE_UID(AID_SYSTEM);
@@ -1916,7 +1916,7 @@ binder::Status InstalldNativeService::getUserSize(const std::unique_ptr<std::str 
    memset(&stats, 0, sizeof(stats));

    memset(&stats, 0, sizeof(stats));

    memset(&extStats, 0, sizeof(extStats));

    memset(&extStats, 0, sizeof(extStats));





    auto uuidString = uuid ? *uuid : "";

    auto uuidString = uuid.value_or("");

    const char* uuid_ = uuid ? uuid->c_str() : nullptr;

    const char* uuid_ = uuid ? uuid->c_str() : nullptr;





    if (!IsQuotaSupported(uuidString)) {

    if (!IsQuotaSupported(uuidString)) {
@@ -2028,7 +2028,7 @@ binder::Status InstalldNativeService::getUserSize(const std::unique_ptr<std::str 
    return ok();

    return ok();

}

}





binder::Status InstalldNativeService::getExternalSize(const std::unique_ptr<std::string>& uuid,

binder::Status InstalldNativeService::getExternalSize(const std::optional<std::string>& uuid,

        int32_t userId, int32_t flags, const std::vector<int32_t>& appIds,

        int32_t userId, int32_t flags, const std::vector<int32_t>& appIds,

        std::vector<int64_t>* _aidl_return) {

        std::vector<int64_t>* _aidl_return) {

    ENFORCE_UID(AID_SYSTEM);

    ENFORCE_UID(AID_SYSTEM);
@@ -2043,7 +2043,7 @@ binder::Status InstalldNativeService::getExternalSize(const std::unique_ptr<std: 
    LOG(INFO) << "Measuring external " << userId;

    LOG(INFO) << "Measuring external " << userId;

#endif

#endif





    auto uuidString = uuid ? *uuid : "";

    auto uuidString = uuid.value_or("");

    const char* uuid_ = uuid ? uuid->c_str() : nullptr;

    const char* uuid_ = uuid ? uuid->c_str() : nullptr;





    int64_t totalSize = 0;

    int64_t totalSize = 0;
@@ -2145,9 +2145,9 @@ binder::Status InstalldNativeService::getExternalSize(const std::unique_ptr<std: 
}

}





binder::Status InstalldNativeService::getAppCrates(

binder::Status InstalldNativeService::getAppCrates(

        const std::unique_ptr<std::string>& uuid,

        const std::optional<std::string>& uuid,

        const std::vector<std::string>& packageNames, int32_t userId,

        const std::vector<std::string>& packageNames, int32_t userId,

        std::unique_ptr<std::vector<std::unique_ptr<CrateMetadata>>>* _aidl_return) {

        std::optional<std::vector<std::optional<CrateMetadata>>>* _aidl_return) {

    ENFORCE_UID(AID_SYSTEM);

    ENFORCE_UID(AID_SYSTEM);

    CHECK_ARGUMENT_UUID(uuid);

    CHECK_ARGUMENT_UUID(uuid);

    for (const auto& packageName : packageNames) {

    for (const auto& packageName : packageNames) {
@@ -2156,15 +2156,15 @@ binder::Status InstalldNativeService::getAppCrates( 
#ifdef ENABLE_STORAGE_CRATES

#ifdef ENABLE_STORAGE_CRATES

    std::lock_guard<std::recursive_mutex> lock(mLock);

    std::lock_guard<std::recursive_mutex> lock(mLock);





    auto retVector = std::make_unique<std::vector<std::unique_ptr<CrateMetadata>>>();

    auto retVector = std::vector<std::optional<CrateMetadata>>();

    const char* uuid_ = uuid ? uuid->c_str() : nullptr;

    const char* uuid_ = uuid ? uuid->c_str() : nullptr;





    std::function<void(CratedFolder, std::unique_ptr<CrateMetadata> &)> onCreateCrate =

    std::function<void(CratedFolder, CrateMetadata&&)> onCreateCrate =

            [&](CratedFolder cratedFolder, std::unique_ptr<CrateMetadata> &crateMetadata) -> void {

            [&](CratedFolder cratedFolder, CrateMetadata&& crateMetadata) -> void {

        if (cratedFolder == nullptr) {

        if (cratedFolder == nullptr) {

            return;

            return;

        }

        }

        retVector->push_back(std::move(crateMetadata));

        retVector.push_back(std::move(crateMetadata));

    };

    };





    for (const auto& packageName : packageNames) {

    for (const auto& packageName : packageNames) {
@@ -2176,15 +2176,15 @@ binder::Status InstalldNativeService::getAppCrates( 
    }

    }





#if CRATE_DEBUG

#if CRATE_DEBUG

    LOG(WARNING) << "retVector->size() =" << retVector->size();

    LOG(WARNING) << "retVector.size() =" << retVector.size();

    for (auto iter = retVector->begin(); iter != retVector->end(); ++iter) {

    for (auto& item : retVector) {

        CrateManager::dump(*iter);

        CrateManager::dump(item);

    }

    }

#endif

#endif





    *_aidl_return = std::move(retVector);

    *_aidl_return = std::move(retVector);

#else // ENABLE_STORAGE_CRATES

#else // ENABLE_STORAGE_CRATES

    *_aidl_return = nullptr;

    _aidl_return->reset();





    /* prevent compile warning fail */

    /* prevent compile warning fail */

    if (userId < 0) {

    if (userId < 0) {
@@ -2195,18 +2195,18 @@ binder::Status InstalldNativeService::getAppCrates( 
}

}





binder::Status InstalldNativeService::getUserCrates(

binder::Status InstalldNativeService::getUserCrates(

        const std::unique_ptr<std::string>& uuid, int32_t userId,

        const std::optional<std::string>& uuid, int32_t userId,

        std::unique_ptr<std::vector<std::unique_ptr<CrateMetadata>>>* _aidl_return) {

        std::optional<std::vector<std::optional<CrateMetadata>>>* _aidl_return) {

    ENFORCE_UID(AID_SYSTEM);

    ENFORCE_UID(AID_SYSTEM);

    CHECK_ARGUMENT_UUID(uuid);

    CHECK_ARGUMENT_UUID(uuid);

#ifdef ENABLE_STORAGE_CRATES

#ifdef ENABLE_STORAGE_CRATES

    std::lock_guard<std::recursive_mutex> lock(mLock);

    std::lock_guard<std::recursive_mutex> lock(mLock);





    const char* uuid_ = uuid ? uuid->c_str() : nullptr;

    const char* uuid_ = uuid ? uuid->c_str() : nullptr;

    auto retVector = std::make_unique<std::vector<std::unique_ptr<CrateMetadata>>>();

    auto retVector = std::vector<std::optional<CrateMetadata>>();





    std::function<void(CratedFolder, std::unique_ptr<CrateMetadata> &)> onCreateCrate =

    std::function<void(CratedFolder, CrateMetadata&&)> onCreateCrate =

            [&](CratedFolder cratedFolder, std::unique_ptr<CrateMetadata> &crateMetadata) -> void {

            [&](CratedFolder cratedFolder, CrateMetadata&& crateMetadata) -> void {

        if (cratedFolder == nullptr) {

        if (cratedFolder == nullptr) {

            return;

            return;

        }

        }
@@ -2220,15 +2220,15 @@ binder::Status InstalldNativeService::getUserCrates( 
    CrateManager::traverseAllPackagesForUser(uuid, userId, onHandingPackage);

    CrateManager::traverseAllPackagesForUser(uuid, userId, onHandingPackage);





#if CRATE_DEBUG

#if CRATE_DEBUG

    LOG(DEBUG) << "retVector->size() =" << retVector->size();

    LOG(DEBUG) << "retVector.size() =" << retVector.size();

    for (auto iter = retVector->begin(); iter != retVector->end(); ++iter) {

    for (auto& item : retVector) {

        CrateManager::dump(*iter);

        CrateManager::dump(item);

    }

    }

#endif

#endif





    *_aidl_return = std::move(retVector);

    *_aidl_return = std::move(retVector);

#else // ENABLE_STORAGE_CRATES

#else // ENABLE_STORAGE_CRATES

    *_aidl_return = nullptr;

    _aidl_return->reset();





    /* prevent compile warning fail */

    /* prevent compile warning fail */

    if (userId < 0) {

    if (userId < 0) {
@@ -2238,7 +2238,7 @@ binder::Status InstalldNativeService::getUserCrates( 
    return ok();

    return ok();

}

}





binder::Status InstalldNativeService::setAppQuota(const std::unique_ptr<std::string>& uuid,

binder::Status InstalldNativeService::setAppQuota(const std::optional<std::string>& uuid,

        int32_t userId, int32_t appId, int64_t cacheQuota) {

        int32_t userId, int32_t appId, int64_t cacheQuota) {

    ENFORCE_UID(AID_SYSTEM);

    ENFORCE_UID(AID_SYSTEM);

    CHECK_ARGUMENT_UUID(uuid);

    CHECK_ARGUMENT_UUID(uuid);
@@ -2309,19 +2309,19 @@ binder::Status InstalldNativeService::destroyProfileSnapshot(const std::string& 
    return ok();

    return ok();

}

}





static const char* getCStr(const std::unique_ptr<std::string>& data,

static const char* getCStr(const std::optional<std::string>& data,

        const char* default_value = nullptr) {

        const char* default_value = nullptr) {

    return data == nullptr ? default_value : data->c_str();

    return data ? data->c_str() : default_value;

}

}

binder::Status InstalldNativeService::dexopt(const std::string& apkPath, int32_t uid,

binder::Status InstalldNativeService::dexopt(const std::string& apkPath, int32_t uid,

        const std::unique_ptr<std::string>& packageName, const std::string& instructionSet,

        const std::optional<std::string>& packageName, const std::string& instructionSet,

        int32_t dexoptNeeded, const std::unique_ptr<std::string>& outputPath, int32_t dexFlags,

        int32_t dexoptNeeded, const std::optional<std::string>& outputPath, int32_t dexFlags,

        const std::string& compilerFilter, const std::unique_ptr<std::string>& uuid,

        const std::string& compilerFilter, const std::optional<std::string>& uuid,

        const std::unique_ptr<std::string>& classLoaderContext,

        const std::optional<std::string>& classLoaderContext,

        const std::unique_ptr<std::string>& seInfo, bool downgrade, int32_t targetSdkVersion,

        const std::optional<std::string>& seInfo, bool downgrade, int32_t targetSdkVersion,

        const std::unique_ptr<std::string>& profileName,

        const std::optional<std::string>& profileName,

        const std::unique_ptr<std::string>& dexMetadataPath,

        const std::optional<std::string>& dexMetadataPath,

        const std::unique_ptr<std::string>& compilationReason) {

        const std::optional<std::string>& compilationReason) {

    ENFORCE_UID(AID_SYSTEM);

    ENFORCE_UID(AID_SYSTEM);

    CHECK_ARGUMENT_UUID(uuid);

    CHECK_ARGUMENT_UUID(uuid);

    CHECK_ARGUMENT_PATH(apkPath);

    CHECK_ARGUMENT_PATH(apkPath);
@@ -2367,7 +2367,7 @@ binder::Status InstalldNativeService::compileLayouts(const std::string& apkPath, 
}

}





binder::Status InstalldNativeService::linkNativeLibraryDirectory(

binder::Status InstalldNativeService::linkNativeLibraryDirectory(

        const std::unique_ptr<std::string>& uuid, const std::string& packageName,

        const std::optional<std::string>& uuid, const std::string& packageName,

        const std::string& nativeLibPath32, int32_t userId) {

        const std::string& nativeLibPath32, int32_t userId) {

    ENFORCE_UID(AID_SYSTEM);

    ENFORCE_UID(AID_SYSTEM);

    CHECK_ARGUMENT_UUID(uuid);

    CHECK_ARGUMENT_UUID(uuid);
@@ -2458,7 +2458,7 @@ out: 
    return res;

    return res;

}

}





binder::Status InstalldNativeService::restoreconAppData(const std::unique_ptr<std::string>& uuid,

binder::Status InstalldNativeService::restoreconAppData(const std::optional<std::string>& uuid,

        const std::string& packageName, int32_t userId, int32_t flags, int32_t appId,

        const std::string& packageName, int32_t userId, int32_t flags, int32_t appId,

        const std::string& seInfo) {

        const std::string& seInfo) {

    ENFORCE_UID(AID_SYSTEM);

    ENFORCE_UID(AID_SYSTEM);
@@ -2576,7 +2576,7 @@ binder::Status InstalldNativeService::moveAb(const std::string& apkPath, 
}

}





binder::Status InstalldNativeService::deleteOdex(const std::string& apkPath,

binder::Status InstalldNativeService::deleteOdex(const std::string& apkPath,

        const std::string& instructionSet, const std::unique_ptr<std::string>& outputPath) {

        const std::string& instructionSet, const std::optional<std::string>& outputPath) {

    ENFORCE_UID(AID_SYSTEM);

    ENFORCE_UID(AID_SYSTEM);

    CHECK_ARGUMENT_PATH(apkPath);

    CHECK_ARGUMENT_PATH(apkPath);

    CHECK_ARGUMENT_PATH(outputPath);

    CHECK_ARGUMENT_PATH(outputPath);
@@ -2728,7 +2728,7 @@ binder::Status InstalldNativeService::assertFsverityRootHashMatches(const std::s 




binder::Status InstalldNativeService::reconcileSecondaryDexFile(

binder::Status InstalldNativeService::reconcileSecondaryDexFile(

        const std::string& dexPath, const std::string& packageName, int32_t uid,

        const std::string& dexPath, const std::string& packageName, int32_t uid,

        const std::vector<std::string>& isas, const std::unique_ptr<std::string>& volumeUuid,

        const std::vector<std::string>& isas, const std::optional<std::string>& volumeUuid,

        int32_t storage_flag, bool* _aidl_return) {

        int32_t storage_flag, bool* _aidl_return) {

    ENFORCE_UID(AID_SYSTEM);

    ENFORCE_UID(AID_SYSTEM);

    CHECK_ARGUMENT_UUID(volumeUuid);

    CHECK_ARGUMENT_UUID(volumeUuid);
@@ -2743,7 +2743,7 @@ binder::Status InstalldNativeService::reconcileSecondaryDexFile( 




binder::Status InstalldNativeService::hashSecondaryDexFile(

binder::Status InstalldNativeService::hashSecondaryDexFile(

        const std::string& dexPath, const std::string& packageName, int32_t uid,

        const std::string& dexPath, const std::string& packageName, int32_t uid,

        const std::unique_ptr<std::string>& volumeUuid, int32_t storageFlag,

        const std::optional<std::string>& volumeUuid, int32_t storageFlag,

        std::vector<uint8_t>* _aidl_return) {

        std::vector<uint8_t>* _aidl_return) {

    ENFORCE_UID(AID_SYSTEM);

    ENFORCE_UID(AID_SYSTEM);

    CHECK_ARGUMENT_UUID(volumeUuid);

    CHECK_ARGUMENT_UUID(volumeUuid);
@@ -2802,7 +2802,7 @@ binder::Status InstalldNativeService::invalidateMounts() { 




// Mount volume's CE and DE storage to mirror

// Mount volume's CE and DE storage to mirror

binder::Status InstalldNativeService::tryMountDataMirror(

binder::Status InstalldNativeService::tryMountDataMirror(

        const std::unique_ptr<std::string>& uuid) {

        const std::optional<std::string>& uuid) {

    ENFORCE_UID(AID_SYSTEM);

    ENFORCE_UID(AID_SYSTEM);

    CHECK_ARGUMENT_UUID(uuid);

    CHECK_ARGUMENT_UUID(uuid);

    if (!sAppDataIsolationEnabled) {

    if (!sAppDataIsolationEnabled) {
@@ -2866,7 +2866,7 @@ binder::Status InstalldNativeService::tryMountDataMirror( 




// Unmount volume's CE and DE storage from mirror

// Unmount volume's CE and DE storage from mirror

binder::Status InstalldNativeService::onPrivateVolumeRemoved(

binder::Status InstalldNativeService::onPrivateVolumeRemoved(

        const std::unique_ptr<std::string>& uuid) {

        const std::optional<std::string>& uuid) {

    ENFORCE_UID(AID_SYSTEM);

    ENFORCE_UID(AID_SYSTEM);

    CHECK_ARGUMENT_UUID(uuid);

    CHECK_ARGUMENT_UUID(uuid);

    if (!sAppDataIsolationEnabled) {

    if (!sAppDataIsolationEnabled) {
@@ -2910,7 +2910,7 @@ binder::Status InstalldNativeService::onPrivateVolumeRemoved( 
}

}





std::string InstalldNativeService::findDataMediaPath(

std::string InstalldNativeService::findDataMediaPath(

        const std::unique_ptr<std::string>& uuid, userid_t userid) {

        const std::optional<std::string>& uuid, userid_t userid) {

    std::lock_guard<std::recursive_mutex> lock(mMountsLock);

    std::lock_guard<std::recursive_mutex> lock(mMountsLock);

    const char* uuid_ = uuid ? uuid->c_str() : nullptr;

    const char* uuid_ = uuid ? uuid->c_str() : nullptr;

    auto path = StringPrintf("%s/media", create_data_path(uuid_).c_str());

    auto path = StringPrintf("%s/media", create_data_path(uuid_).c_str());
@@ -2923,15 +2923,14 @@ std::string InstalldNativeService::findDataMediaPath( 
}

}





binder::Status InstalldNativeService::isQuotaSupported(

binder::Status InstalldNativeService::isQuotaSupported(

        const std::unique_ptr<std::string>& uuid, bool* _aidl_return) {

        const std::optional<std::string>& uuid, bool* _aidl_return) {

    auto uuidString = uuid ? *uuid : "";

    *_aidl_return = IsQuotaSupported(uuid.value_or(""));

    *_aidl_return = IsQuotaSupported(uuidString);

    return ok();

    return ok();

}

}





binder::Status InstalldNativeService::prepareAppProfile(const std::string& packageName,

binder::Status InstalldNativeService::prepareAppProfile(const std::string& packageName,

        int32_t userId, int32_t appId, const std::string& profileName, const std::string& codePath,

        int32_t userId, int32_t appId, const std::string& profileName, const std::string& codePath,

        const std::unique_ptr<std::string>& dexMetadata, bool* _aidl_return) {

        const std::optional<std::string>& dexMetadata, bool* _aidl_return) {

    ENFORCE_UID(AID_SYSTEM);

    ENFORCE_UID(AID_SYSTEM);

    CHECK_ARGUMENT_PACKAGE_NAME(packageName);

    CHECK_ARGUMENT_PACKAGE_NAME(packageName);

    CHECK_ARGUMENT_PATH(codePath);

    CHECK_ARGUMENT_PATH(codePath);

cmds/installd/InstalldNativeService.h

+39 −39

File changed.

Preview size limit exceeded, changes collapsed.

cmds/installd/dexopt.cpp

+6 −6
Original line number Original line Diff line number Diff line
@@ -2277,7 +2277,7 @@ enum ReconcileSecondaryDexResult { 
//   out_secondary_dex_exists will be set to false.

//   out_secondary_dex_exists will be set to false.

bool reconcile_secondary_dex_file(const std::string& dex_path,

bool reconcile_secondary_dex_file(const std::string& dex_path,

        const std::string& pkgname, int uid, const std::vector<std::string>& isas,

        const std::string& pkgname, int uid, const std::vector<std::string>& isas,

        const std::unique_ptr<std::string>& volume_uuid, int storage_flag,

        const std::optional<std::string>& volume_uuid, int storage_flag,

        /*out*/bool* out_secondary_dex_exists) {

        /*out*/bool* out_secondary_dex_exists) {

    *out_secondary_dex_exists = false;  // start by assuming the file does not exist.

    *out_secondary_dex_exists = false;  // start by assuming the file does not exist.

    if (isas.size() == 0) {

    if (isas.size() == 0) {
@@ -2298,7 +2298,7 @@ bool reconcile_secondary_dex_file(const std::string& dex_path, 
        /* child -- drop privileges before continuing */

        /* child -- drop privileges before continuing */

        drop_capabilities(uid);

        drop_capabilities(uid);





        const char* volume_uuid_cstr = volume_uuid == nullptr ? nullptr : volume_uuid->c_str();

        const char* volume_uuid_cstr = volume_uuid ? volume_uuid->c_str() : nullptr;

        if (!validate_secondary_dex_path(pkgname, dex_path, volume_uuid_cstr,

        if (!validate_secondary_dex_path(pkgname, dex_path, volume_uuid_cstr,

                uid, storage_flag)) {

                uid, storage_flag)) {

            LOG(ERROR) << "Could not validate secondary dex path " << dex_path;

            LOG(ERROR) << "Could not validate secondary dex path " << dex_path;
@@ -2399,11 +2399,11 @@ bool reconcile_secondary_dex_file(const std::string& dex_path, 
// the app.

// the app.

// For any other errors (e.g. if any of the parameters are invalid) returns false.

// For any other errors (e.g. if any of the parameters are invalid) returns false.

bool hash_secondary_dex_file(const std::string& dex_path, const std::string& pkgname, int uid,

bool hash_secondary_dex_file(const std::string& dex_path, const std::string& pkgname, int uid,

        const std::unique_ptr<std::string>& volume_uuid, int storage_flag,

        const std::optional<std::string>& volume_uuid, int storage_flag,

        std::vector<uint8_t>* out_secondary_dex_hash) {

        std::vector<uint8_t>* out_secondary_dex_hash) {

    out_secondary_dex_hash->clear();

    out_secondary_dex_hash->clear();





    const char* volume_uuid_cstr = volume_uuid == nullptr ? nullptr : volume_uuid->c_str();

    const char* volume_uuid_cstr = volume_uuid ? volume_uuid->c_str() : nullptr;





    if (storage_flag != FLAG_STORAGE_CE && storage_flag != FLAG_STORAGE_DE) {

    if (storage_flag != FLAG_STORAGE_CE && storage_flag != FLAG_STORAGE_DE) {

        LOG(ERROR) << "hash_secondary_dex_file called with invalid storage_flag: "

        LOG(ERROR) << "hash_secondary_dex_file called with invalid storage_flag: "
@@ -2924,7 +2924,7 @@ bool prepare_app_profile(const std::string& package_name, 
                         appid_t app_id,

                         appid_t app_id,

                         const std::string& profile_name,

                         const std::string& profile_name,

                         const std::string& code_path,

                         const std::string& code_path,

                         const std::unique_ptr<std::string>& dex_metadata) {

                         const std::optional<std::string>& dex_metadata) {

    // Prepare the current profile.

    // Prepare the current profile.

    std::string cur_profile  = create_current_profile_path(user_id, package_name, profile_name,

    std::string cur_profile  = create_current_profile_path(user_id, package_name, profile_name,

            /*is_secondary_dex*/ false);

            /*is_secondary_dex*/ false);
@@ -2935,7 +2935,7 @@ bool prepare_app_profile(const std::string& package_name, 
    }

    }





    // Check if we need to install the profile from the dex metadata.

    // Check if we need to install the profile from the dex metadata.

    if (dex_metadata == nullptr) {

    if (!dex_metadata) {

        return true;

        return true;

    }

    }