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

Commit c4454bf5 authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Automerger Merge Worker
Browse files

Merge "[incfs] Use the new IncFs_MakeDirs() function" into rvc-dev am: 62292c85 

Change-Id: Ic8715f0994f3b2681ffe6b99aa015492298f275d
parents c4d35974 62292c85

services/incremental/IncrementalService.cpp

+23 −28
Original line number Original line Diff line number Diff line
@@ -212,6 +212,7 @@ auto IncrementalService::IncFsMount::makeStorage(StorageId id) -> StorageMap::it 
template <class Func>

template <class Func>

static auto makeCleanup(Func&& f) {

static auto makeCleanup(Func&& f) {

    auto deleter = [f = std::move(f)](auto) { f(); };

    auto deleter = [f = std::move(f)](auto) { f(); };

    // &f is a dangling pointer here, but we actually never use it as deleter moves it in.

    return std::unique_ptr<Func, decltype(deleter)>(&f, std::move(deleter));

    return std::unique_ptr<Func, decltype(deleter)>(&f, std::move(deleter));

}

}
@@ -719,7 +720,7 @@ int IncrementalService::bind(StorageId storage, std::string_view source, std::st 
        LOG(ERROR) << "no storage";

        LOG(ERROR) << "no storage";

        return -EINVAL;

        return -EINVAL;

    }

    }

    std::string normSource = normalizePathToStorageLocked(ifs, storageInfo, source);

    std::string normSource = normalizePathToStorageLocked(*ifs, storageInfo, source);

    if (normSource.empty()) {

    if (normSource.empty()) {

        LOG(ERROR) << "invalid source path";

        LOG(ERROR) << "invalid source path";

        return -EINVAL;

        return -EINVAL;
@@ -773,7 +774,7 @@ int IncrementalService::unbind(StorageId storage, std::string_view target) { 
}

}





std::string IncrementalService::normalizePathToStorageLocked(

std::string IncrementalService::normalizePathToStorageLocked(

        const IfsMountPtr& incfs, IncFsMount::StorageMap::iterator storageIt,

        const IncFsMount& incfs, IncFsMount::StorageMap::const_iterator storageIt,

        std::string_view path) const {

        std::string_view path) const {

    if (!path::isAbsolute(path)) {

    if (!path::isAbsolute(path)) {

        return path::normalize(path::join(storageIt->second.name, path));

        return path::normalize(path::join(storageIt->second.name, path));
@@ -783,19 +784,18 @@ std::string IncrementalService::normalizePathToStorageLocked( 
        return normPath;

        return normPath;

    }

    }

    // not that easy: need to find if any of the bind points match

    // not that easy: need to find if any of the bind points match

    const auto bindIt = findParentPath(incfs->bindPoints, normPath);

    const auto bindIt = findParentPath(incfs.bindPoints, normPath);

    if (bindIt == incfs->bindPoints.end()) {

    if (bindIt == incfs.bindPoints.end()) {

        return {};

        return {};

    }

    }

    return path::join(bindIt->second.sourceDir, path::relativize(bindIt->first, normPath));

    return path::join(bindIt->second.sourceDir, path::relativize(bindIt->first, normPath));

}

}





std::string IncrementalService::normalizePathToStorage(const IncrementalService::IfsMountPtr& ifs,

std::string IncrementalService::normalizePathToStorage(const IncFsMount& ifs, StorageId storage,

                                                       StorageId storage,

                                                       std::string_view path) const {

                                                       std::string_view path) const {

    std::unique_lock l(ifs->lock);

    std::unique_lock l(ifs.lock);

    const auto storageInfo = ifs->storages.find(storage);

    const auto storageInfo = ifs.storages.find(storage);

    if (storageInfo == ifs->storages.end()) {

    if (storageInfo == ifs.storages.end()) {

        return {};

        return {};

    }

    }

    return normalizePathToStorageLocked(ifs, storageInfo, path);

    return normalizePathToStorageLocked(ifs, storageInfo, path);
@@ -804,7 +804,7 @@ std::string IncrementalService::normalizePathToStorage(const IncrementalService: 
int IncrementalService::makeFile(StorageId storage, std::string_view path, int mode, FileId id,

int IncrementalService::makeFile(StorageId storage, std::string_view path, int mode, FileId id,

                                 incfs::NewFileParams params) {

                                 incfs::NewFileParams params) {

    if (auto ifs = getIfs(storage)) {

    if (auto ifs = getIfs(storage)) {

        std::string normPath = normalizePathToStorage(ifs, storage, path);

        std::string normPath = normalizePathToStorage(*ifs, storage, path);

        if (normPath.empty()) {

        if (normPath.empty()) {

            LOG(ERROR) << "Internal error: storageId " << storage

            LOG(ERROR) << "Internal error: storageId " << storage

                       << " failed to normalize: " << path;

                       << " failed to normalize: " << path;
@@ -822,7 +822,7 @@ int IncrementalService::makeFile(StorageId storage, std::string_view path, int m 




int IncrementalService::makeDir(StorageId storageId, std::string_view path, int mode) {

int IncrementalService::makeDir(StorageId storageId, std::string_view path, int mode) {

    if (auto ifs = getIfs(storageId)) {

    if (auto ifs = getIfs(storageId)) {

        std::string normPath = normalizePathToStorage(ifs, storageId, path);

        std::string normPath = normalizePathToStorage(*ifs, storageId, path);

        if (normPath.empty()) {

        if (normPath.empty()) {

            return -EINVAL;

            return -EINVAL;

        }

        }
@@ -836,21 +836,16 @@ int IncrementalService::makeDirs(StorageId storageId, std::string_view path, int 
    if (!ifs) {

    if (!ifs) {

        return -EINVAL;

        return -EINVAL;

    }

    }

    return makeDirs(*ifs, storageId, path, mode);

}



int IncrementalService::makeDirs(const IncFsMount& ifs, StorageId storageId, std::string_view path,

                                 int mode) {

    std::string normPath = normalizePathToStorage(ifs, storageId, path);

    std::string normPath = normalizePathToStorage(ifs, storageId, path);

    if (normPath.empty()) {

    if (normPath.empty()) {

        return -EINVAL;

        return -EINVAL;

    }

    }

    auto err = mIncFs->makeDir(ifs->control, normPath, mode);

    return mIncFs->makeDirs(ifs.control, normPath, mode);

    if (err == -EEXIST) {

        return 0;

    }

    if (err != -ENOENT) {

        return err;

    }

    if (auto err = makeDirs(storageId, path::dirname(normPath), mode)) {

        return err;

    }

    return mIncFs->makeDir(ifs->control, normPath, mode);

}

}





int IncrementalService::link(StorageId sourceStorageId, std::string_view oldPath,

int IncrementalService::link(StorageId sourceStorageId, std::string_view oldPath,
@@ -864,8 +859,8 @@ int IncrementalService::link(StorageId sourceStorageId, std::string_view oldPath 
        return -EINVAL;

        return -EINVAL;

    }

    }

    l.unlock();

    l.unlock();

    std::string normOldPath = normalizePathToStorage(ifsSrc, sourceStorageId, oldPath);

    std::string normOldPath = normalizePathToStorage(*ifsSrc, sourceStorageId, oldPath);

    std::string normNewPath = normalizePathToStorage(ifsSrc, destStorageId, newPath);

    std::string normNewPath = normalizePathToStorage(*ifsSrc, destStorageId, newPath);

    if (normOldPath.empty() || normNewPath.empty()) {

    if (normOldPath.empty() || normNewPath.empty()) {

        LOG(ERROR) << "Invalid paths in link(): " << normOldPath << " | " << normNewPath;

        LOG(ERROR) << "Invalid paths in link(): " << normOldPath << " | " << normNewPath;

        return -EINVAL;

        return -EINVAL;
@@ -875,7 +870,7 @@ int IncrementalService::link(StorageId sourceStorageId, std::string_view oldPath 




int IncrementalService::unlink(StorageId storage, std::string_view path) {

int IncrementalService::unlink(StorageId storage, std::string_view path) {

    if (auto ifs = getIfs(storage)) {

    if (auto ifs = getIfs(storage)) {

        std::string normOldPath = normalizePathToStorage(ifs, storage, path);

        std::string normOldPath = normalizePathToStorage(*ifs, storage, path);

        return mIncFs->unlink(ifs->control, normOldPath);

        return mIncFs->unlink(ifs->control, normOldPath);

    }

    }

    return -EINVAL;

    return -EINVAL;
@@ -960,7 +955,7 @@ RawMetadata IncrementalService::getMetadata(StorageId storage, std::string_view 
    if (!ifs) {

    if (!ifs) {

        return {};

        return {};

    }

    }

    const auto normPath = normalizePathToStorage(ifs, storage, path);

    const auto normPath = normalizePathToStorage(*ifs, storage, path);

    if (normPath.empty()) {

    if (normPath.empty()) {

        return {};

        return {};

    }

    }
@@ -1363,7 +1358,7 @@ bool IncrementalService::configureNativeBinaries(StorageId storage, std::string_ 
    }

    }





    // First prepare target directories if they don't exist yet

    // First prepare target directories if they don't exist yet

    if (auto res = makeDirs(storage, libDirRelativePath, 0755)) {

    if (auto res = makeDirs(*ifs, storage, libDirRelativePath, 0755)) {

        LOG(ERROR) << "Failed to prepare target lib directory " << libDirRelativePath

        LOG(ERROR) << "Failed to prepare target lib directory " << libDirRelativePath

                   << " errno: " << res;

                   << " errno: " << res;

        return false;

        return false;
@@ -1401,7 +1396,7 @@ bool IncrementalService::configureNativeBinaries(StorageId storage, std::string_ 




        const auto libName = path::basename(fileName);

        const auto libName = path::basename(fileName);

        const auto targetLibPath = path::join(libDirRelativePath, libName);

        const auto targetLibPath = path::join(libDirRelativePath, libName);

        const auto targetLibPathAbsolute = normalizePathToStorage(ifs, storage, targetLibPath);

        const auto targetLibPathAbsolute = normalizePathToStorage(*ifs, storage, targetLibPath);

        // If the extract file already exists, skip

        // If the extract file already exists, skip

        if (access(targetLibPathAbsolute.c_str(), F_OK) == 0) {

        if (access(targetLibPathAbsolute.c_str(), F_OK) == 0) {

            if (perfLoggingEnabled()) {

            if (perfLoggingEnabled()) {

services/incremental/IncrementalService.h

+4 −4
Original line number Original line Diff line number Diff line
@@ -280,12 +280,12 @@ private: 
    void deleteStorage(IncFsMount& ifs);

    void deleteStorage(IncFsMount& ifs);

    void deleteStorageLocked(IncFsMount& ifs, std::unique_lock<std::mutex>&& ifsLock);

    void deleteStorageLocked(IncFsMount& ifs, std::unique_lock<std::mutex>&& ifsLock);

    MountMap::iterator getStorageSlotLocked();

    MountMap::iterator getStorageSlotLocked();

    std::string normalizePathToStorage(const IfsMountPtr& incfs, StorageId storage,

    std::string normalizePathToStorage(const IncFsMount& incfs, StorageId storage,

                                       std::string_view path) const;

                                       std::string_view path) const;

    std::string normalizePathToStorageLocked(const IfsMountPtr& incfs,

    std::string normalizePathToStorageLocked(const IncFsMount& incfs,

                                             IncFsMount::StorageMap::iterator storageIt,

                                             IncFsMount::StorageMap::const_iterator storageIt,

                                             std::string_view path) const;

                                             std::string_view path) const;



    int makeDirs(const IncFsMount& ifs, StorageId storageId, std::string_view path, int mode);

    binder::Status applyStorageParams(IncFsMount& ifs, bool enableReadLogs);

    binder::Status applyStorageParams(IncFsMount& ifs, bool enableReadLogs);





    void registerAppOpsCallback(const std::string& packageName);

    void registerAppOpsCallback(const std::string& packageName);

services/incremental/ServiceWrappers.cpp

+3 −0
Original line number Original line Diff line number Diff line
@@ -135,6 +135,9 @@ public: 
    ErrorCode makeDir(const Control& control, std::string_view path, int mode) const final {

    ErrorCode makeDir(const Control& control, std::string_view path, int mode) const final {

        return incfs::makeDir(control, path, mode);

        return incfs::makeDir(control, path, mode);

    }

    }

    ErrorCode makeDirs(const Control& control, std::string_view path, int mode) const final {

        return incfs::makeDirs(control, path, mode);

    }

    incfs::RawMetadata getMetadata(const Control& control, FileId fileid) const final {

    incfs::RawMetadata getMetadata(const Control& control, FileId fileid) const final {

        return incfs::getMetadata(control, fileid);

        return incfs::getMetadata(control, fileid);

    }

    }

services/incremental/ServiceWrappers.h

+1 −0
Original line number Original line Diff line number Diff line
@@ -81,6 +81,7 @@ public: 
    virtual ErrorCode makeFile(const Control& control, std::string_view path, int mode, FileId id,

    virtual ErrorCode makeFile(const Control& control, std::string_view path, int mode, FileId id,

                               incfs::NewFileParams params) const = 0;

                               incfs::NewFileParams params) const = 0;

    virtual ErrorCode makeDir(const Control& control, std::string_view path, int mode) const = 0;

    virtual ErrorCode makeDir(const Control& control, std::string_view path, int mode) const = 0;

    virtual ErrorCode makeDirs(const Control& control, std::string_view path, int mode) const = 0;

    virtual incfs::RawMetadata getMetadata(const Control& control, FileId fileid) const = 0;

    virtual incfs::RawMetadata getMetadata(const Control& control, FileId fileid) const = 0;

    virtual incfs::RawMetadata getMetadata(const Control& control, std::string_view path) const = 0;

    virtual incfs::RawMetadata getMetadata(const Control& control, std::string_view path) const = 0;

    virtual FileId getFileId(const Control& control, std::string_view path) const = 0;

    virtual FileId getFileId(const Control& control, std::string_view path) const = 0;

services/incremental/test/IncrementalServiceTest.cpp

+10 −25
Original line number Original line Diff line number Diff line
@@ -270,6 +270,8 @@ public: 
                       ErrorCode(const Control& control, std::string_view path, int mode, FileId id,

                       ErrorCode(const Control& control, std::string_view path, int mode, FileId id,

                                 NewFileParams params));

                                 NewFileParams params));

    MOCK_CONST_METHOD3(makeDir, ErrorCode(const Control& control, std::string_view path, int mode));

    MOCK_CONST_METHOD3(makeDir, ErrorCode(const Control& control, std::string_view path, int mode));

    MOCK_CONST_METHOD3(makeDirs,

                       ErrorCode(const Control& control, std::string_view path, int mode));

    MOCK_CONST_METHOD2(getMetadata, RawMetadata(const Control& control, FileId fileid));

    MOCK_CONST_METHOD2(getMetadata, RawMetadata(const Control& control, FileId fileid));

    MOCK_CONST_METHOD2(getMetadata, RawMetadata(const Control& control, std::string_view path));

    MOCK_CONST_METHOD2(getMetadata, RawMetadata(const Control& control, std::string_view path));

    MOCK_CONST_METHOD2(getFileId, FileId(const Control& control, std::string_view path));

    MOCK_CONST_METHOD2(getFileId, FileId(const Control& control, std::string_view path));
@@ -723,31 +725,14 @@ TEST_F(IncrementalServiceTest, testMakeDirectories) { 
    auto first = "first"sv;

    auto first = "first"sv;

    auto second = "second"sv;

    auto second = "second"sv;

    auto third = "third"sv;

    auto third = "third"sv;

    auto parent_path = std::string(first) + "/" + std::string(second);

    auto dir_path = std::string(first) + "/" + std::string(second) + "/" + std::string(third);

    auto dir_path = parent_path + "/" + std::string(third);





    auto checkArgFor = [&](std::string_view expected, std::string_view arg) {

        return arg.starts_with(mRootDir.path) && arg.ends_with("/mount/st_1_0/"s += expected);

    };



    {

        InSequence seq;

        EXPECT_CALL(*mIncFs,

                    makeDir(_, Truly([&](auto arg) { return checkArgFor(dir_path, arg); }), _))

                .WillOnce(Return(-ENOENT));

        EXPECT_CALL(*mIncFs,

                    makeDir(_, Truly([&](auto arg) { return checkArgFor(parent_path, arg); }), _))

                .WillOnce(Return(-ENOENT));

        EXPECT_CALL(*mIncFs,

                    makeDir(_, Truly([&](auto arg) { return checkArgFor(first, arg); }), _))

                .WillOnce(Return(0));

        EXPECT_CALL(*mIncFs,

                    makeDir(_, Truly([&](auto arg) { return checkArgFor(parent_path, arg); }), _))

                .WillOnce(Return(0));

    EXPECT_CALL(*mIncFs,

    EXPECT_CALL(*mIncFs,

                    makeDir(_, Truly([&](auto arg) { return checkArgFor(dir_path, arg); }), _))

                makeDirs(_, Truly([&](std::string_view arg) {

                .WillOnce(Return(0));

                             return arg.starts_with(mRootDir.path) &&

    }

                                     arg.ends_with("/mount/st_1_0/" + dir_path);

                         }),

                         _));

    auto res = mIncrementalService->makeDirs(storageId, dir_path, 0555);

    auto res = mIncrementalService->makeDirs(storageId, dir_path, 0555);

    ASSERT_EQ(res, 0);

    ASSERT_EQ(res, 0);

}

}