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

Commit 484283a7 authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "libmodprobe: allow module with soft dependencies to load in parallel"... 

Merge "libmodprobe: allow module with soft dependencies to load in parallel" am: 16efb76c am: 57677b3a

Original change: https://android-review.googlesource.com/c/platform/system/core/+/2134303



Change-Id: I1c27a75d2a8557dfc5eeb7d09ca4b88a239051b3
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 1908c247 57677b3a

libmodprobe/libmodprobe.cpp

+17 −22
Original line number Diff line number Diff line
@@ -440,12 +440,11 @@ bool Modprobe::IsBlocklisted(const std::string& module_name) { 
}



// Another option to load kernel modules. load in independent modules in parallel

// and then load modules which only have soft dependency, third update dependency list of other

// remaining modules, repeat these steps until all modules are loaded.

// and then update dependency list of other remaining modules, repeat these steps

// until all modules are loaded.

bool Modprobe::LoadModulesParallel(int num_threads) {

    bool ret = true;

    std::map<std::string, std::set<std::string>> mod_with_deps;

    std::map<std::string, std::set<std::string>> mod_with_softdeps;



    // Get dependencies

    for (const auto& module : module_load_) {
@@ -458,26 +457,33 @@ bool Modprobe::LoadModulesParallel(int num_threads) { 


    // Get soft dependencies

    for (const auto& [it_mod, it_softdep] : module_pre_softdep_) {

        mod_with_softdeps[MakeCanonical(it_mod)].emplace(it_softdep);

        if (mod_with_deps.find(MakeCanonical(it_softdep)) != mod_with_deps.end()) {

            mod_with_deps[MakeCanonical(it_mod)].emplace(

                GetDependencies(MakeCanonical(it_softdep))[0]);

        }

    }



    // Get soft post dependencies

    for (const auto& [it_mod, it_softdep] : module_post_softdep_) {

        mod_with_softdeps[MakeCanonical(it_mod)].emplace(it_softdep);

        if (mod_with_deps.find(MakeCanonical(it_softdep)) != mod_with_deps.end()) {

            mod_with_deps[MakeCanonical(it_softdep)].emplace(

                GetDependencies(MakeCanonical(it_mod))[0]);

        }

    }



    while (!mod_with_deps.empty()) {

        std::vector<std::thread> threads;

        std::vector<std::string> mods_path_to_load;

        std::vector<std::string> mods_with_softdep_to_load;

        std::mutex vector_lock;



        // Find independent modules and modules only having soft dependencies

        // Find independent modules

        for (const auto& [it_mod, it_dep] : mod_with_deps) {

            if (it_dep.size() == 1 && mod_with_softdeps[it_mod].empty()) {

            if (it_dep.size() == 1) {

                if (module_options_[it_mod].find("load_sequential=1") != std::string::npos) {

                    LoadWithAliases(it_mod, true);

                } else {

                    mods_path_to_load.emplace_back(*(it_dep.begin()));

            } else if (it_dep.size() == 1) {

                mods_with_softdep_to_load.emplace_back(it_mod);

                }

            }

        }
@@ -502,21 +508,10 @@ bool Modprobe::LoadModulesParallel(int num_threads) { 
            thread.join();

        }



        // Since we cannot assure if these soft dependencies tree are overlap,

        // we loaded these modules one by one.

        for (auto dep = mods_with_softdep_to_load.rbegin(); dep != mods_with_softdep_to_load.rend();

             dep++) {

            ret &= LoadWithAliases(*dep, true);

        }



        std::lock_guard guard(module_loaded_lock_);

        // Remove loaded module form mod_with_deps and soft dependencies of other modules

        for (const auto& module_loaded : module_loaded_) {

            mod_with_deps.erase(module_loaded);



            for (auto& [mod, softdeps] : mod_with_softdeps) {

                softdeps.erase(module_loaded);

            }

        }



        // Remove loaded module form dependencies of other modules which are not loaded yet