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

Commit 68645c42 authored by Songchun Fan's avatar Songchun Fan
Browse files

directly call data loader manager service from incremental service 

BUG: 150406132
Test: atest service.incremental_test
Test: atest PackageManagerShellCommandIncrementalTest
Change-Id: I2bb75d5adae58d2471478f6a4d2354058d7b0dab
parent 6381d619

services/incremental/IncrementalService.cpp

+17 −19
Original line number Diff line number Diff line
@@ -155,7 +155,7 @@ std::string makeBindMdName() { 
} // namespace



IncrementalService::IncFsMount::~IncFsMount() {

    incrementalService.mIncrementalManager->destroyDataLoader(mountId);

    incrementalService.mDataLoaderManager->destroyDataLoader(mountId);

    control.reset();

    LOG(INFO) << "Unmounting and cleaning up mount " << mountId << " with root '" << root << '\'';

    for (auto&& [target, _] : bindPoints) {
@@ -229,14 +229,14 @@ void IncrementalService::IncFsMount::cleanupFilesystem(std::string_view root) { 


IncrementalService::IncrementalService(ServiceManagerWrapper&& sm, std::string_view rootDir)

      : mVold(sm.getVoldService()),

        mIncrementalManager(sm.getIncrementalManager()),

        mDataLoaderManager(sm.getDataLoaderManager()),

        mIncFs(sm.getIncFs()),

        mIncrementalDir(rootDir) {

    if (!mVold) {

        LOG(FATAL) << "Vold service is unavailable";

    }

    if (!mIncrementalManager) {

        LOG(FATAL) << "IncrementalManager service is unavailable";

    if (!mDataLoaderManager) {

        LOG(FATAL) << "DataLoaderManagerService is unavailable";

    }

    mountExistingImages();

}
@@ -921,7 +921,6 @@ bool IncrementalService::startLoading(StorageId storage) const { 
    if (!ifs) {

        return false;

    }

    bool started = false;

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

    if (ifs->dataLoaderStatus != IDataLoaderStatusListener::DATA_LOADER_CREATED) {

        if (ifs->dataLoaderReady.wait_for(l, Seconds(5)) == std::cv_status::timeout) {
@@ -929,11 +928,19 @@ bool IncrementalService::startLoading(StorageId storage) const { 
            return false;

        }

    }

    auto status = mIncrementalManager->startDataLoader(ifs->mountId, &started);

    sp<IDataLoader> dataloader;

    auto status = mDataLoaderManager->getDataLoader(ifs->mountId, &dataloader);

    if (!status.isOk()) {

        return false;

    }

    return started;

    if (!dataloader) {

        return false;

    }

    status = dataloader->start();

    if (!status.isOk()) {

        return false;

    }

    return true;

}



void IncrementalService::mountExistingImages() {
@@ -1086,7 +1093,7 @@ bool IncrementalService::prepareDataLoader(IncrementalService::IncFsMount& ifs, 
    sp<IncrementalDataLoaderListener> listener =

            new IncrementalDataLoaderListener(*this, *externalListener);

    bool created = false;

    auto status = mIncrementalManager->prepareDataLoader(ifs.mountId, fsControlParcel, *dlp,

    auto status = mDataLoaderManager->initializeDataLoader(ifs.mountId, *dlp, fsControlParcel,

                                                           listener, &created);

    if (!status.isOk() || !created) {

        LOG(ERROR) << "Failed to create a data loader for mount " << ifs.mountId;
@@ -1229,16 +1236,7 @@ binder::Status IncrementalService::IncrementalDataLoaderListener::onStatusChange 
    ifs->dataLoaderStatus = newStatus;

    switch (newStatus) {

        case IDataLoaderStatusListener::DATA_LOADER_NO_CONNECTION: {

            auto now = Clock::now();

            if (ifs->connectionLostTime.time_since_epoch().count() == 0) {

                ifs->connectionLostTime = now;

                break;

            }

            auto duration =

                    std::chrono::duration_cast<Seconds>(now - ifs->connectionLostTime).count();

            if (duration >= 10) {

                incrementalService.mIncrementalManager->showHealthBlockedUI(mountId);

            }

            // TODO(b/150411019): handle data loader connection loss

            break;

        }

        case IDataLoaderStatusListener::DATA_LOADER_CONNECTION_OK: {

services/incremental/IncrementalService.h

+1 −2
Original line number Diff line number Diff line
@@ -19,7 +19,6 @@ 
#include <android-base/strings.h>

#include <android-base/unique_fd.h>

#include <android/content/pm/DataLoaderParamsParcel.h>

#include <android/os/incremental/IIncrementalManager.h>

#include <binder/IServiceManager.h>

#include <utils/String16.h>

#include <utils/StrongPointer.h>
@@ -220,7 +219,7 @@ private: 


    // Member variables

    std::unique_ptr<VoldServiceWrapper> mVold;

    std::unique_ptr<IncrementalManagerWrapper> mIncrementalManager;

    std::unique_ptr<DataLoaderManagerWrapper> mDataLoaderManager;

    std::unique_ptr<IncFsWrapper> mIncFs;

    const std::string mIncrementalDir;

services/incremental/ServiceWrappers.cpp

+5 −5
Original line number Diff line number Diff line
@@ -23,7 +23,7 @@ using namespace std::literals; 
namespace android::os::incremental {



static constexpr auto kVoldServiceName = "vold"sv;

static constexpr auto kIncrementalManagerName = "incremental"sv;

static constexpr auto kDataLoaderManagerName = "dataloader_manager"sv;



RealServiceManager::RealServiceManager(sp<IServiceManager> serviceManager)

      : mServiceManager(std::move(serviceManager)) {}
@@ -46,11 +46,11 @@ std::unique_ptr<VoldServiceWrapper> RealServiceManager::getVoldService() { 
    return nullptr;

}



std::unique_ptr<IncrementalManagerWrapper> RealServiceManager::getIncrementalManager() {

    sp<IIncrementalManager> manager =

            RealServiceManager::getRealService<IIncrementalManager>(kIncrementalManagerName);

std::unique_ptr<DataLoaderManagerWrapper> RealServiceManager::getDataLoaderManager() {

    sp<IDataLoaderManager> manager =

            RealServiceManager::getRealService<IDataLoaderManager>(kDataLoaderManagerName);

    if (manager) {

        return std::make_unique<RealIncrementalManager>(manager);

        return std::make_unique<RealDataLoaderManager>(manager);

    }

    return nullptr;

}

services/incremental/ServiceWrappers.h

+23 −26
Original line number Diff line number Diff line
@@ -20,9 +20,10 @@ 
#include <android-base/unique_fd.h>

#include <android/content/pm/DataLoaderParamsParcel.h>

#include <android/content/pm/FileSystemControlParcel.h>

#include <android/content/pm/IDataLoader.h>

#include <android/content/pm/IDataLoaderManager.h>

#include <android/content/pm/IDataLoaderStatusListener.h>

#include <android/os/IVold.h>

#include <android/os/incremental/IIncrementalManager.h>

#include <binder/IServiceManager.h>

#include <incfs.h>
@@ -50,17 +51,16 @@ public: 
                                     const std::string& targetDir) const = 0;

};



class IncrementalManagerWrapper {

class DataLoaderManagerWrapper {

public:

    virtual ~IncrementalManagerWrapper() = default;

    virtual binder::Status prepareDataLoader(MountId mountId,

                                             const FileSystemControlParcel& control,

    virtual ~DataLoaderManagerWrapper() = default;

    virtual binder::Status initializeDataLoader(MountId mountId,

                                                const DataLoaderParamsParcel& params,

                                                const FileSystemControlParcel& control,

                                                const sp<IDataLoaderStatusListener>& listener,

                                                bool* _aidl_return) const = 0;

    virtual binder::Status startDataLoader(MountId mountId, bool* _aidl_return) const = 0;

    virtual binder::Status getDataLoader(MountId mountId, sp<IDataLoader>* _aidl_return) const = 0;

    virtual binder::Status destroyDataLoader(MountId mountId) const = 0;

    virtual binder::Status showHealthBlockedUI(MountId mountId) const = 0;

};



class IncFsWrapper {
@@ -82,7 +82,7 @@ class ServiceManagerWrapper { 
public:

    virtual ~ServiceManagerWrapper() = default;

    virtual std::unique_ptr<VoldServiceWrapper> getVoldService() = 0;

    virtual std::unique_ptr<IncrementalManagerWrapper> getIncrementalManager() = 0;

    virtual std::unique_ptr<DataLoaderManagerWrapper> getDataLoaderManager() = 0;

    virtual std::unique_ptr<IncFsWrapper> getIncFs() = 0;

};
@@ -109,29 +109,26 @@ private: 
    sp<os::IVold> mInterface;

};



class RealIncrementalManager : public IncrementalManagerWrapper {

class RealDataLoaderManager : public DataLoaderManagerWrapper {

public:

    RealIncrementalManager(const sp<os::incremental::IIncrementalManager> manager)

    RealDataLoaderManager(const sp<content::pm::IDataLoaderManager> manager)

          : mInterface(manager) {}

    ~RealIncrementalManager() = default;

    binder::Status prepareDataLoader(MountId mountId, const FileSystemControlParcel& control,

                                     const DataLoaderParamsParcel& params,

    ~RealDataLoaderManager() = default;

    binder::Status initializeDataLoader(MountId mountId, const DataLoaderParamsParcel& params,

                                        const FileSystemControlParcel& control,

                                        const sp<IDataLoaderStatusListener>& listener,

                                        bool* _aidl_return) const override {

        return mInterface->prepareDataLoader(mountId, control, params, listener, _aidl_return);

        return mInterface->initializeDataLoader(mountId, params, control, listener, _aidl_return);

    }

    binder::Status startDataLoader(MountId mountId, bool* _aidl_return) const override {

        return mInterface->startDataLoader(mountId, _aidl_return);

    binder::Status getDataLoader(MountId mountId, sp<IDataLoader>* _aidl_return) const override {

        return mInterface->getDataLoader(mountId, _aidl_return);

    }

    binder::Status destroyDataLoader(MountId mountId) const override {

        return mInterface->destroyDataLoader(mountId);

    }

    binder::Status showHealthBlockedUI(MountId mountId) const override {

        return mInterface->showHealthBlockedUI(mountId);

    }



private:

    sp<os::incremental::IIncrementalManager> mInterface;

    sp<content::pm::IDataLoaderManager> mInterface;

};



class RealServiceManager : public ServiceManagerWrapper {
@@ -139,7 +136,7 @@ public: 
    RealServiceManager(sp<IServiceManager> serviceManager);

    ~RealServiceManager() = default;

    std::unique_ptr<VoldServiceWrapper> getVoldService() override;

    std::unique_ptr<IncrementalManagerWrapper> getIncrementalManager() override;

    std::unique_ptr<DataLoaderManagerWrapper> getDataLoaderManager() override;

    std::unique_ptr<IncFsWrapper> getIncFs() override;



private:

services/incremental/test/IncrementalServiceTest.cpp

+68 −54
Original line number Diff line number Diff line
@@ -93,22 +93,35 @@ private: 
    TemporaryFile logFile;

};



class MockIncrementalManager : public IncrementalManagerWrapper {

class FakeDataLoader : public IDataLoader {

public:

    MOCK_CONST_METHOD5(prepareDataLoader,

                       binder::Status(int32_t mountId, const FileSystemControlParcel& control,

                                      const DataLoaderParamsParcel& params,

    IBinder* onAsBinder() override { return nullptr; }

    binder::Status create(int32_t, const DataLoaderParamsParcel&, const FileSystemControlParcel&,

                          const sp<IDataLoaderStatusListener>&) override {

        return binder::Status::ok();

    }

    binder::Status start() override { return binder::Status::ok(); }

    binder::Status stop() override { return binder::Status::ok(); }

    binder::Status destroy() override { return binder::Status::ok(); }

    binder::Status prepareImage(const std::vector<InstallationFileParcel>&,

                                const std::vector<std::string>&) override {

        return binder::Status::ok();

    }

};



class MockDataLoaderManager : public DataLoaderManagerWrapper {

public:

    MOCK_CONST_METHOD5(initializeDataLoader,

                       binder::Status(int32_t mountId, const DataLoaderParamsParcel& params,

                                      const FileSystemControlParcel& control,

                                      const sp<IDataLoaderStatusListener>& listener,

                                      bool* _aidl_return));

    MOCK_CONST_METHOD2(startDataLoader, binder::Status(int32_t mountId, bool* _aidl_return));

    MOCK_CONST_METHOD2(getDataLoader,

                       binder::Status(int32_t mountId, sp<IDataLoader>* _aidl_return));

    MOCK_CONST_METHOD1(destroyDataLoader, binder::Status(int32_t mountId));

    MOCK_CONST_METHOD3(newFileForDataLoader,

                       binder::Status(int32_t mountId, FileId fileId,

                                      const ::std::vector<uint8_t>& metadata));

    MOCK_CONST_METHOD1(showHealthBlockedUI, binder::Status(int32_t mountId));



    binder::Status prepareDataLoaderOk(int32_t mountId, const FileSystemControlParcel& control,

                                       const DataLoaderParamsParcel& params,

    binder::Status initializeDataLoaderOk(int32_t mountId, const DataLoaderParamsParcel& params,

                                          const FileSystemControlParcel& control,

                                          const sp<IDataLoaderStatusListener>& listener,

                                          bool* _aidl_return) {

        mId = mountId;
@@ -117,23 +130,23 @@ public: 
        return binder::Status::ok();

    }



    binder::Status startDataLoaderOk(int32_t mountId, bool* _aidl_return) {

        *_aidl_return = true;

    binder::Status getDataLoaderOk(int32_t mountId, sp<IDataLoader>* _aidl_return) {

        *_aidl_return = mDataLoader;

        return binder::Status::ok();

    }



    void prepareDataLoaderFails() {

        ON_CALL(*this, prepareDataLoader(_, _, _, _, _))

    void initializeDataLoaderFails() {

        ON_CALL(*this, initializeDataLoader(_, _, _, _, _))

                .WillByDefault(Return(

                        (binder::Status::fromExceptionCode(1, String8("failed to prepare")))));

    }

    void prepareDataLoaderSuccess() {

        ON_CALL(*this, prepareDataLoader(_, _, _, _, _))

                .WillByDefault(Invoke(this, &MockIncrementalManager::prepareDataLoaderOk));

    void initializeDataLoaderSuccess() {

        ON_CALL(*this, initializeDataLoader(_, _, _, _, _))

                .WillByDefault(Invoke(this, &MockDataLoaderManager::initializeDataLoaderOk));

    }

    void startDataLoaderSuccess() {

        ON_CALL(*this, startDataLoader(_, _))

                .WillByDefault(Invoke(this, &MockIncrementalManager::startDataLoaderOk));

    void getDataLoaderSuccess() {

        ON_CALL(*this, getDataLoader(_, _))

                .WillByDefault(Invoke(this, &MockDataLoaderManager::getDataLoaderOk));

    }

    void setDataLoaderStatusNotReady() {

        mListener->onStatusChanged(mId, IDataLoaderStatusListener::DATA_LOADER_DESTROYED);
@@ -145,6 +158,7 @@ public: 
private:

    int mId;

    sp<IDataLoaderStatusListener> mListener;

    sp<IDataLoader> mDataLoader = sp<IDataLoader>(new FakeDataLoader());

};



class MockIncFs : public IncFsWrapper {
@@ -197,20 +211,20 @@ public: 
class MockServiceManager : public ServiceManagerWrapper {

public:

    MockServiceManager(std::unique_ptr<MockVoldService> vold,

                       std::unique_ptr<MockIncrementalManager> manager,

                       std::unique_ptr<MockDataLoaderManager> manager,

                       std::unique_ptr<MockIncFs> incfs)

          : mVold(std::move(vold)),

            mIncrementalManager(std::move(manager)),

            mDataLoaderManager(std::move(manager)),

            mIncFs(std::move(incfs)) {}

    std::unique_ptr<VoldServiceWrapper> getVoldService() final { return std::move(mVold); }

    std::unique_ptr<IncrementalManagerWrapper> getIncrementalManager() final {

        return std::move(mIncrementalManager);

    std::unique_ptr<DataLoaderManagerWrapper> getDataLoaderManager() final {

        return std::move(mDataLoaderManager);

    }

    std::unique_ptr<IncFsWrapper> getIncFs() final { return std::move(mIncFs); }



private:

    std::unique_ptr<MockVoldService> mVold;

    std::unique_ptr<MockIncrementalManager> mIncrementalManager;

    std::unique_ptr<MockDataLoaderManager> mDataLoaderManager;

    std::unique_ptr<MockIncFs> mIncFs;

};
@@ -221,14 +235,14 @@ public: 
    void SetUp() override {

        auto vold = std::make_unique<NiceMock<MockVoldService>>();

        mVold = vold.get();

        auto incrementalManager = std::make_unique<NiceMock<MockIncrementalManager>>();

        mIncrementalManager = incrementalManager.get();

        auto dataloaderManager = std::make_unique<NiceMock<MockDataLoaderManager>>();

        mDataLoaderManager = dataloaderManager.get();

        auto incFs = std::make_unique<NiceMock<MockIncFs>>();

        mIncFs = incFs.get();

        mIncrementalService =

                std::make_unique<IncrementalService>(MockServiceManager(std::move(vold),

                                                                        std::move(

                                                                                incrementalManager),

                                                                                dataloaderManager),

                                                                        std::move(incFs)),

                                                     mRootDir.path);

        mDataLoaderParcel.packageName = "com.test";
@@ -260,7 +274,7 @@ public: 
protected:

    NiceMock<MockVoldService>* mVold;

    NiceMock<MockIncFs>* mIncFs;

    NiceMock<MockIncrementalManager>* mIncrementalManager;

    NiceMock<MockDataLoaderManager>* mDataLoaderManager;

    std::unique_ptr<IncrementalService> mIncrementalService;

    TemporaryDir mRootDir;

    DataLoaderParamsParcel mDataLoaderParcel;
@@ -268,7 +282,7 @@ protected: 


TEST_F(IncrementalServiceTest, testCreateStorageMountIncFsFails) {

    mVold->mountIncFsFails();

    EXPECT_CALL(*mIncrementalManager, prepareDataLoader(_, _, _, _, _)).Times(0);

    EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(0);

    TemporaryDir tempDir;

    int storageId =

            mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},
@@ -278,7 +292,7 @@ TEST_F(IncrementalServiceTest, testCreateStorageMountIncFsFails) { 


TEST_F(IncrementalServiceTest, testCreateStorageMountIncFsInvalidControlParcel) {

    mVold->mountIncFsInvalidControlParcel();

    EXPECT_CALL(*mIncrementalManager, prepareDataLoader(_, _, _, _, _)).Times(0);

    EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(0);

    TemporaryDir tempDir;

    int storageId =

            mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},
@@ -289,8 +303,8 @@ TEST_F(IncrementalServiceTest, testCreateStorageMountIncFsInvalidControlParcel) 
TEST_F(IncrementalServiceTest, testCreateStorageMakeFileFails) {

    mVold->mountIncFsSuccess();

    mIncFs->makeFileFails();

    EXPECT_CALL(*mIncrementalManager, prepareDataLoader(_, _, _, _, _)).Times(0);

    EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));

    EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(0);

    EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));

    EXPECT_CALL(*mVold, unmountIncFs(_));

    TemporaryDir tempDir;

    int storageId =
@@ -303,8 +317,8 @@ TEST_F(IncrementalServiceTest, testCreateStorageBindMountFails) { 
    mVold->mountIncFsSuccess();

    mIncFs->makeFileSuccess();

    mVold->bindMountFails();

    EXPECT_CALL(*mIncrementalManager, prepareDataLoader(_, _, _, _, _)).Times(0);

    EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));

    EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(0);

    EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));

    EXPECT_CALL(*mVold, unmountIncFs(_));

    TemporaryDir tempDir;

    int storageId =
@@ -317,8 +331,8 @@ TEST_F(IncrementalServiceTest, testCreateStoragePrepareDataLoaderFails) { 
    mVold->mountIncFsSuccess();

    mIncFs->makeFileSuccess();

    mVold->bindMountSuccess();

    mIncrementalManager->prepareDataLoaderFails();

    EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));

    mDataLoaderManager->initializeDataLoaderFails();

    EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));

    EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);

    TemporaryDir tempDir;

    int storageId =
@@ -331,8 +345,8 @@ TEST_F(IncrementalServiceTest, testDeleteStorageSuccess) { 
    mVold->mountIncFsSuccess();

    mIncFs->makeFileSuccess();

    mVold->bindMountSuccess();

    mIncrementalManager->prepareDataLoaderSuccess();

    EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));

    mDataLoaderManager->initializeDataLoaderSuccess();

    EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));

    EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);

    TemporaryDir tempDir;

    int storageId =
@@ -346,31 +360,31 @@ TEST_F(IncrementalServiceTest, testOnStatusNotReady) { 
    mVold->mountIncFsSuccess();

    mIncFs->makeFileSuccess();

    mVold->bindMountSuccess();

    mIncrementalManager->prepareDataLoaderSuccess();

    EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));

    mDataLoaderManager->initializeDataLoaderSuccess();

    EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));

    EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);

    TemporaryDir tempDir;

    int storageId =

            mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},

                                               IncrementalService::CreateOptions::CreateNew);

    ASSERT_GE(storageId, 0);

    mIncrementalManager->setDataLoaderStatusNotReady();

    mDataLoaderManager->setDataLoaderStatusNotReady();

}



TEST_F(IncrementalServiceTest, testStartDataLoaderSuccess) {

    mVold->mountIncFsSuccess();

    mIncFs->makeFileSuccess();

    mVold->bindMountSuccess();

    mIncrementalManager->prepareDataLoaderSuccess();

    mIncrementalManager->startDataLoaderSuccess();

    EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));

    mDataLoaderManager->initializeDataLoaderSuccess();

    mDataLoaderManager->getDataLoaderSuccess();

    EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));

    EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);

    TemporaryDir tempDir;

    int storageId =

            mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},

                                               IncrementalService::CreateOptions::CreateNew);

    ASSERT_GE(storageId, 0);

    mIncrementalManager->setDataLoaderStatusReady();

    mDataLoaderManager->setDataLoaderStatusReady();

    ASSERT_TRUE(mIncrementalService->startLoading(storageId));

}
@@ -378,8 +392,8 @@ TEST_F(IncrementalServiceTest, testMakeDirectory) { 
    mVold->mountIncFsSuccess();

    mIncFs->makeFileSuccess();

    mVold->bindMountSuccess();

    mIncrementalManager->prepareDataLoaderSuccess();

    mIncrementalManager->startDataLoaderSuccess();

    mDataLoaderManager->initializeDataLoaderSuccess();

    mDataLoaderManager->getDataLoaderSuccess();

    TemporaryDir tempDir;

    int storageId =

            mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},
@@ -402,8 +416,8 @@ TEST_F(IncrementalServiceTest, testMakeDirectories) { 
    mVold->mountIncFsSuccess();

    mIncFs->makeFileSuccess();

    mVold->bindMountSuccess();

    mIncrementalManager->prepareDataLoaderSuccess();

    mIncrementalManager->startDataLoaderSuccess();

    mDataLoaderManager->initializeDataLoaderSuccess();

    mDataLoaderManager->getDataLoaderSuccess();

    TemporaryDir tempDir;

    int storageId =

            mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},