Skip to content

Commit

Permalink
kernel loader: don't try to reload modules already loaded by init
Browse files Browse the repository at this point in the history 
Change-Id: I58fb2ee369bdb9f5c5f9e6c8ea3f15781ae60ece
  • Loading branch information
@bigbiff @epicX67
bigbiff authored and epicX67 committed Nov 4, 2021
1 parent 4133cee commit 3f56998
Show file tree
Hide file tree
Showing 4 changed files with 138 additions and 100 deletions.
217 changes: 126 additions & 91 deletions kernel_module_loader.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,85 +2,120 @@

const std::vector<std::string> kernel_modules_requested = TWFunc::split_string(EXPAND(TW_LOAD_VENDOR_MODULES), ' ', true);

bool KernelModuleLoader::Load_Vendor_Modules(BOOT_MODE mode) {
// check /lib/modules (ramdisk vendor_boot)
// check /lib/modules/N.N (ramdisk vendor_boot)
// check /lib/modules/N.N-gki (ramdisk vendor_boot)
// check /vendor/lib/modules (ramdisk)
// check /vendor/lib/modules/1.1 (ramdisk prebuilt modules)
// check /vendor/lib/modules/N.N (vendor mounted)
// check /vendor/lib/modules/N.N-gki (vendor mounted)
int modules_loaded = 0;

LOGINFO("Attempting to load modules\n");
std::string vendor_base_dir(VENDOR_MODULE_DIR);
std::string base_dir(VENDOR_BOOT_MODULE_DIR);
std::vector<std::string> module_dirs;
std::vector<std::string> vendor_module_dirs;

TWPartition* ven = PartitionManager.Find_Partition_By_Path("/vendor");
vendor_module_dirs.push_back(VENDOR_MODULE_DIR);
vendor_module_dirs.push_back(vendor_base_dir + "/1.1");

module_dirs.push_back(base_dir);

struct utsname uts;
if (uname(&uts)) {
LOGERR("Unable to query kernel for version info\n");
}

std::string rls(uts.release);
std::vector<std::string> release = TWFunc::split_string(rls, '.', true);
int expected_module_count = kernel_modules_requested.size();
module_dirs.push_back(base_dir + "/" + release[0] + "." + release[1]);

for (auto&& module_dir:module_dirs) {
modules_loaded += Try_And_Load_Modules(module_dir);
if (modules_loaded >= expected_module_count) goto exit;
}

for (auto&& module_dir:vendor_module_dirs) {
modules_loaded += Try_And_Load_Modules(module_dir);
if (modules_loaded >= expected_module_count) goto exit;
}

if (ven) {
LOGINFO("Checking mounted /vendor\n");
ven->Mount(true);
}

for (auto&& module_dir:vendor_module_dirs) {
modules_loaded += Try_And_Load_Modules(module_dir);
if (modules_loaded >= expected_module_count) goto exit;
}
bool KernelModuleLoader::Load_Vendor_Modules() {
// check /lib/modules (ramdisk vendor_boot)
// check /lib/modules/N.N (ramdisk vendor_boot)
// check /lib/modules/N.N-gki (ramdisk vendor_boot)
// check /vendor/lib/modules (ramdisk)
// check /vendor/lib/modules/1.1 (ramdisk prebuilt modules)
// check /vendor/lib/modules/N.N (vendor mounted)
// check /vendor/lib/modules/N.N-gki (vendor mounted)
int modules_loaded = 0;

LOGINFO("Attempting to load modules\n");
std::string vendor_base_dir(VENDOR_MODULE_DIR);
std::string base_dir(VENDOR_BOOT_MODULE_DIR);
std::vector<std::string> module_dirs;
std::vector<std::string> vendor_module_dirs;

TWPartition* ven = PartitionManager.Find_Partition_By_Path("/vendor");
vendor_module_dirs.push_back(VENDOR_MODULE_DIR);
vendor_module_dirs.push_back(vendor_base_dir + "/1.1");

module_dirs.push_back(base_dir);

struct utsname uts;
if (uname(&uts)) {
LOGERR("Unable to query kernel for version info\n");
}

std::string rls(uts.release);
std::vector<std::string> release = TWFunc::split_string(rls, '.', true);
int expected_module_count = kernel_modules_requested.size();
module_dirs.push_back(base_dir + "/" + release[0] + "." + release[1]);

for (auto&& module_dir:module_dirs) {
modules_loaded += Try_And_Load_Modules(module_dir, false);
if (modules_loaded >= expected_module_count) goto exit;
}

for (auto&& module_dir:vendor_module_dirs) {
modules_loaded += Try_And_Load_Modules(module_dir, false);
if (modules_loaded >= expected_module_count) goto exit;
}

if (ven) {
LOGINFO("Checking mounted /vendor\n");
ven->Mount(true);
}

for (auto&& module_dir:vendor_module_dirs) {
modules_loaded += Try_And_Load_Modules(module_dir, true);
if (modules_loaded >= expected_module_count) goto exit;
}

exit:
if (ven)
ven->UnMount(false);
if (ven)
ven->UnMount(false);

return true;
}

int KernelModuleLoader::Try_And_Load_Modules(std::string module_dir) {
LOGINFO("Checking directory: %s\n", module_dir.c_str());
std::string dest_module_dir;
dest_module_dir = "/tmp" + module_dir;
TWFunc::Recursive_Mkdir(dest_module_dir);
Copy_Modules_To_Tmpfs(module_dir);
Write_Module_List(dest_module_dir);
Modprobe m({dest_module_dir}, "modules.load.twrp");
m.EnableVerbose(true);
m.LoadListedModules(false);
int modules_loaded = m.GetModuleCount();
LOGINFO("Modules Loaded: %d\n", modules_loaded);
return modules_loaded;
int KernelModuleLoader::Try_And_Load_Modules(std::string module_dir, bool vendor_is_mounted) {
LOGINFO("Checking directory: %s\n", module_dir.c_str());
int modules_loaded = 0;
std::string dest_module_dir;
dest_module_dir = "/tmp" + module_dir;
TWFunc::Recursive_Mkdir(dest_module_dir);
Copy_Modules_To_Tmpfs(module_dir);
if (!Write_Module_List(dest_module_dir))
return kernel_modules_requested.size();
if (!vendor_is_mounted && module_dir == "/vendor/lib/modules") {
module_dir = "/lib/modules";
}
LOGINFO("mounting %s on %s\n", dest_module_dir.c_str(), module_dir.c_str());
if (mount(dest_module_dir.c_str(), module_dir.c_str(), "", MS_BIND, NULL) == 0) {
Modprobe m({module_dir}, "modules.load.twrp");
m.EnableVerbose(true);
m.LoadListedModules(false);
modules_loaded = m.GetModuleCount();
umount2(module_dir.c_str(), MNT_DETACH);
LOGINFO("Modules Loaded: %d\n", modules_loaded);
}
return modules_loaded;
}

std::vector<string> KernelModuleLoader::Skip_Loaded_Kernel_Modules() {
std::vector<string> kernel_modules = kernel_modules_requested;
std::vector<string> loaded_modules;
std::string kernel_module_file = "/proc/modules";
if (TWFunc::read_file(kernel_module_file, loaded_modules) < 0)
LOGINFO("failed to get loaded kernel modules\n");
LOGINFO("number of modules loaded by init: %lu\n", loaded_modules.size());
if (loaded_modules.size() == 0)
return kernel_modules;
for (auto&& module_line:loaded_modules) {
auto module = TWFunc::Split_String(module_line, " ")[0];
std::string full_module_name = module + ".ko";
auto found = std::find(kernel_modules.begin(), kernel_modules.end(), full_module_name);
if (found != kernel_modules.end()) {
LOGINFO("found module to dedupe: %s\n", (*found).c_str());
kernel_modules.erase(found);
}
}
return kernel_modules;
}

bool KernelModuleLoader::Write_Module_List(std::string module_dir) {
DIR* d;
struct dirent* de;
std::vector<std::string> kernel_modules;
d = opendir(module_dir.c_str());
auto deduped_modules = Skip_Loaded_Kernel_Modules();
if (deduped_modules.size() == 0) {
LOGINFO("Requested modules are loaded\n");
return false;
}
if (d != nullptr) {
while ((de = readdir(d)) != nullptr) {
std::string kernel_module = de->d_name;
Expand All @@ -89,40 +124,40 @@ bool KernelModuleLoader::Write_Module_List(std::string module_dir) {
for (auto&& requested:kernel_modules_requested) {
if (kernel_module == requested) {
kernel_modules.push_back(kernel_module);
continue;
}
continue;
}
}
continue;
}
}
}
std::string module_file = module_dir + "/modules.load.twrp";
std::string module_file = module_dir + "/modules.load.twrp";
TWFunc::write_to_file(module_file, kernel_modules);
closedir(d);
closedir(d);
}
return true;
}

bool KernelModuleLoader::Copy_Modules_To_Tmpfs(std::string module_dir) {
std::string ramdisk_dir = "/tmp" + module_dir;
DIR* d;
std::string ramdisk_dir = "/tmp" + module_dir;
DIR* d;
struct dirent* de;
d = opendir(module_dir.c_str());
if (d != nullptr) {
while ((de = readdir(d)) != nullptr) {
std::string kernel_module = de->d_name;
if (de->d_type == DT_REG) {
std::string src = module_dir + "/" + de->d_name;
std::string dest = ramdisk_dir + "/" + de->d_name;
if (TWFunc::copy_file(src, dest, 0700, false) != 0) {
return false;
}
}
}
closedir(d);
} else {
LOGINFO("Unable to open module directory: %s. Skipping\n", module_dir.c_str());
return false;
}
return true;
}
d = opendir(module_dir.c_str());
if (d != nullptr) {
while ((de = readdir(d)) != nullptr) {
std::string kernel_module = de->d_name;
if (de->d_type == DT_REG) {
std::string src = module_dir + "/" + de->d_name;
std::string dest = ramdisk_dir + "/" + de->d_name;
if (TWFunc::copy_file(src, dest, 0700, false) != 0) {
return false;
}
}
}
closedir(d);
} else {
LOGINFO("Unable to open module directory: %s. Skipping\n", module_dir.c_str());
return false;
}
return true;
}
6 changes: 4 additions & 2 deletions kernel_module_loader.hpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,6 +6,7 @@
#include <vector>
#include <android-base/strings.h>
#include <modprobe/modprobe.h>
#include <sys/mount.h>
#include <sys/utsname.h>

#include "twcommon.h"
Expand All @@ -22,12 +23,13 @@ typedef enum {
class KernelModuleLoader
{
public:
static bool Load_Vendor_Modules(BOOT_MODE mode); // Load specific maintainer defined kernel modules in TWRP
static bool Load_Vendor_Modules(); // Load specific maintainer defined kernel modules in TWRP

private:
static int Try_And_Load_Modules(std::string module_dir); // Use libmodprobe to attempt loading kernel modules
static int Try_And_Load_Modules(std::string module_dir, bool vendor_is_mounted); // Use libmodprobe to attempt loading kernel modules
static bool Write_Module_List(std::string module_dir); // Write list of modules to load from TW_LOAD_VENDOR_MODULES
static bool Copy_Modules_To_Tmpfs(std::string module_dir); // Copy modules to ramdisk for loading
static std::vector<string> Skip_Loaded_Kernel_Modules(); // return list of loaded kernel modules already done by init
};

#endif // _KERNELMODULELOADER_HPP
5 changes: 1 addition & 4 deletions twrp-functions.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -726,10 +726,7 @@ int TWFunc::copy_file(string src, string dst, int mode, bool mount_paths) {
std::ifstream srcfile(src.c_str(), ios::binary);
std::ofstream dstfile(dst.c_str(), ios::binary);
dstfile << srcfile.rdbuf();
if (!dstfile.bad()) {
LOGINFO("Copied file %s to %s\n", src.c_str(), dst.c_str());
}
else {
if (dstfile.bad()) {
LOGINFO("Unable to copy file %s to %s\n", src.c_str(), dst.c_str());
return -1;
}
Expand Down
10 changes: 7 additions & 3 deletions twrp.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -141,8 +141,12 @@ static void process_fastbootd_mode() {
PartitionManager.Setup_Super_Devices();
PartitionManager.Prepare_Super_Volume(ven);
#ifdef TW_LOAD_VENDOR_MODULES
KernelModuleLoader::Load_Vendor_Modules(FASTBOOTD_MODE);
KernelModuleLoader::Load_Vendor_Modules();
if (android::base::GetBoolProperty("ro.virtual_ab.enabled", false)) {
PartitionManager.Unmap_Super_Devices();
}
#endif

gui_msg(Msg("fastboot_console_msg=Entered Fastboot mode..."));
if (gui_startPage("fastboot", 1, 1) != 0) {
LOGERR("Failed to start fastbootd page.\n");
Expand Down Expand Up @@ -190,9 +194,9 @@ static void process_recovery_mode(twrpAdbBuFifo* adb_bu_fifo, bool skip_decrypti
#ifdef TW_LOAD_VENDOR_MODULES
bool fastboot_mode = cmdline.find("twrpfastboot=1") != std::string::npos;
if (fastboot_mode)
KernelModuleLoader::Load_Vendor_Modules(RECOVERY_FASTBOOT_MODE);
KernelModuleLoader::Load_Vendor_Modules();
else
KernelModuleLoader::Load_Vendor_Modules(RECOVERY_IN_BOOT_MODE);
KernelModuleLoader::Load_Vendor_Modules();
#endif

// We are doing this here to allow super partition to be set up prior to overriding properties
Expand Down

0 comments on commit 3f56998

Please sign in to comment.