blob: a78e54beaf5f224e807754752863c4e9d895c676 [file] [log] [blame]
bigbiff22851b92021-09-01 16:46:57 -04001#include "kernel_module_loader.hpp"
Adithya Ra327aa72021-12-19 00:49:54 +05302#include "common.h"
bigbiff22851b92021-09-01 16:46:57 -04003
bigbiffe3aa02e2021-10-01 13:07:38 -04004const std::vector<std::string> kernel_modules_requested = TWFunc::split_string(EXPAND(TW_LOAD_VENDOR_MODULES), ' ', true);
5
bigbiff850fa282021-10-09 12:37:29 -04006bool KernelModuleLoader::Load_Vendor_Modules() {
7 // check /lib/modules (ramdisk vendor_boot)
8 // check /lib/modules/N.N (ramdisk vendor_boot)
9 // check /lib/modules/N.N-gki (ramdisk vendor_boot)
10 // check /vendor/lib/modules (ramdisk)
11 // check /vendor/lib/modules/1.1 (ramdisk prebuilt modules)
12 // check /vendor/lib/modules/N.N (vendor mounted)
13 // check /vendor/lib/modules/N.N-gki (vendor mounted)
14 int modules_loaded = 0;
bigbiff22851b92021-09-01 16:46:57 -040015
bigbiff850fa282021-10-09 12:37:29 -040016 LOGINFO("Attempting to load modules\n");
17 std::string vendor_base_dir(VENDOR_MODULE_DIR);
18 std::string base_dir(VENDOR_BOOT_MODULE_DIR);
19 std::vector<std::string> module_dirs;
20 std::vector<std::string> vendor_module_dirs;
bigbiff22851b92021-09-01 16:46:57 -040021
bigbiff850fa282021-10-09 12:37:29 -040022 TWPartition* ven = PartitionManager.Find_Partition_By_Path("/vendor");
23 vendor_module_dirs.push_back(VENDOR_MODULE_DIR);
24 vendor_module_dirs.push_back(vendor_base_dir + "/1.1");
bigbiff22851b92021-09-01 16:46:57 -040025
bigbiff850fa282021-10-09 12:37:29 -040026 module_dirs.push_back(base_dir);
bigbiff22851b92021-09-01 16:46:57 -040027
bigbiff850fa282021-10-09 12:37:29 -040028 struct utsname uts;
29 if (uname(&uts)) {
30 LOGERR("Unable to query kernel for version info\n");
31 }
bigbiff22851b92021-09-01 16:46:57 -040032
bigbiff850fa282021-10-09 12:37:29 -040033 std::string rls(uts.release);
34 std::vector<std::string> release = TWFunc::split_string(rls, '.', true);
35 int expected_module_count = kernel_modules_requested.size();
36 module_dirs.push_back(base_dir + "/" + release[0] + "." + release[1]);
sekaiacge86b9c72021-12-31 19:30:44 +080037 std::string gki = "/" + release[0] + "." + release[1] + "-gki";
38 module_dirs.push_back(base_dir + gki);
39 vendor_module_dirs.push_back(vendor_base_dir + gki);
bigbiff22851b92021-09-01 16:46:57 -040040
bigbiff850fa282021-10-09 12:37:29 -040041 for (auto&& module_dir:module_dirs) {
42 modules_loaded += Try_And_Load_Modules(module_dir, false);
43 if (modules_loaded >= expected_module_count) goto exit;
44 }
bigbiff22851b92021-09-01 16:46:57 -040045
bigbiff850fa282021-10-09 12:37:29 -040046 for (auto&& module_dir:vendor_module_dirs) {
47 modules_loaded += Try_And_Load_Modules(module_dir, false);
48 if (modules_loaded >= expected_module_count) goto exit;
49 }
bigbiff22851b92021-09-01 16:46:57 -040050
bigbiff850fa282021-10-09 12:37:29 -040051 if (ven) {
52 LOGINFO("Checking mounted /vendor\n");
53 ven->Mount(true);
54 }
bigbiff22851b92021-09-01 16:46:57 -040055
bigbiff850fa282021-10-09 12:37:29 -040056 for (auto&& module_dir:vendor_module_dirs) {
57 modules_loaded += Try_And_Load_Modules(module_dir, true);
58 if (modules_loaded >= expected_module_count) goto exit;
59 }
bigbiff22851b92021-09-01 16:46:57 -040060
bigbiffe3aa02e2021-10-01 13:07:38 -040061exit:
bigbiff850fa282021-10-09 12:37:29 -040062 if (ven)
63 ven->UnMount(false);
bigbiff22851b92021-09-01 16:46:57 -040064
Adithya Ra327aa72021-12-19 00:49:54 +053065 android::base::SetProperty("twrp.modules.loaded", "true");
66
67 TWFunc::Wait_For_Battery(3s);
68
bigbiff22851b92021-09-01 16:46:57 -040069 return true;
70}
71
bigbiff850fa282021-10-09 12:37:29 -040072int KernelModuleLoader::Try_And_Load_Modules(std::string module_dir, bool vendor_is_mounted) {
73 LOGINFO("Checking directory: %s\n", module_dir.c_str());
74 int modules_loaded = 0;
75 std::string dest_module_dir;
76 dest_module_dir = "/tmp" + module_dir;
77 TWFunc::Recursive_Mkdir(dest_module_dir);
78 Copy_Modules_To_Tmpfs(module_dir);
79 if (!Write_Module_List(dest_module_dir))
80 return kernel_modules_requested.size();
81 if (!vendor_is_mounted && module_dir == "/vendor/lib/modules") {
82 module_dir = "/lib/modules";
83 }
84 LOGINFO("mounting %s on %s\n", dest_module_dir.c_str(), module_dir.c_str());
85 if (mount(dest_module_dir.c_str(), module_dir.c_str(), "", MS_BIND, NULL) == 0) {
86 Modprobe m({module_dir}, "modules.load.twrp");
bigbiff850fa282021-10-09 12:37:29 -040087 m.LoadListedModules(false);
88 modules_loaded = m.GetModuleCount();
89 umount2(module_dir.c_str(), MNT_DETACH);
90 LOGINFO("Modules Loaded: %d\n", modules_loaded);
91 }
92 return modules_loaded;
93}
94
95std::vector<string> KernelModuleLoader::Skip_Loaded_Kernel_Modules() {
96 std::vector<string> kernel_modules = kernel_modules_requested;
97 std::vector<string> loaded_modules;
98 std::string kernel_module_file = "/proc/modules";
99 if (TWFunc::read_file(kernel_module_file, loaded_modules) < 0)
100 LOGINFO("failed to get loaded kernel modules\n");
Magendanz84164b92021-12-12 14:53:41 -0800101 LOGINFO("number of modules loaded by init: %zu\n", loaded_modules.size());
bigbiff850fa282021-10-09 12:37:29 -0400102 if (loaded_modules.size() == 0)
103 return kernel_modules;
104 for (auto&& module_line:loaded_modules) {
105 auto module = TWFunc::Split_String(module_line, " ")[0];
106 std::string full_module_name = module + ".ko";
107 auto found = std::find(kernel_modules.begin(), kernel_modules.end(), full_module_name);
108 if (found != kernel_modules.end()) {
109 LOGINFO("found module to dedupe: %s\n", (*found).c_str());
110 kernel_modules.erase(found);
111 }
112 }
113 return kernel_modules;
bigbiff22851b92021-09-01 16:46:57 -0400114}
115
116bool KernelModuleLoader::Write_Module_List(std::string module_dir) {
117 DIR* d;
118 struct dirent* de;
119 std::vector<std::string> kernel_modules;
bigbiff22851b92021-09-01 16:46:57 -0400120 d = opendir(module_dir.c_str());
bigbiff850fa282021-10-09 12:37:29 -0400121 auto deduped_modules = Skip_Loaded_Kernel_Modules();
122 if (deduped_modules.size() == 0) {
123 LOGINFO("Requested modules are loaded\n");
124 return false;
125 }
bigbiff22851b92021-09-01 16:46:57 -0400126 if (d != nullptr) {
127 while ((de = readdir(d)) != nullptr) {
128 std::string kernel_module = de->d_name;
129 if (de->d_type == DT_REG) {
130 if (android::base::EndsWith(kernel_module, ".ko")) {
131 for (auto&& requested:kernel_modules_requested) {
132 if (kernel_module == requested) {
133 kernel_modules.push_back(kernel_module);
bigbiff850fa282021-10-09 12:37:29 -0400134 continue;
135 }
bigbiff22851b92021-09-01 16:46:57 -0400136 }
137 continue;
138 }
139 }
140 }
bigbiff850fa282021-10-09 12:37:29 -0400141 std::string module_file = module_dir + "/modules.load.twrp";
bigbiff22851b92021-09-01 16:46:57 -0400142 TWFunc::write_to_file(module_file, kernel_modules);
bigbiff850fa282021-10-09 12:37:29 -0400143 closedir(d);
bigbiff22851b92021-09-01 16:46:57 -0400144 }
145 return true;
146}
147
148bool KernelModuleLoader::Copy_Modules_To_Tmpfs(std::string module_dir) {
bigbiff850fa282021-10-09 12:37:29 -0400149 std::string ramdisk_dir = "/tmp" + module_dir;
150 DIR* d;
bigbiff22851b92021-09-01 16:46:57 -0400151 struct dirent* de;
bigbiff850fa282021-10-09 12:37:29 -0400152 d = opendir(module_dir.c_str());
153 if (d != nullptr) {
154 while ((de = readdir(d)) != nullptr) {
155 std::string kernel_module = de->d_name;
156 if (de->d_type == DT_REG) {
157 std::string src = module_dir + "/" + de->d_name;
158 std::string dest = ramdisk_dir + "/" + de->d_name;
159 if (TWFunc::copy_file(src, dest, 0700, false) != 0) {
160 return false;
161 }
162 }
163 }
164 closedir(d);
165 } else {
166 LOGINFO("Unable to open module directory: %s. Skipping\n", module_dir.c_str());
167 return false;
168 }
169 return true;
170}