2 * Copyright (C) 2013 Felix Fietkau <nbd@openwrt.org>
3 * Copyright (C) 2013 John Crispin <blogic@openwrt.org>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU Lesser General Public License version 2.1
7 * as published by the Free Software Foundation
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
16 #include <sys/syscall.h>
18 #include <sys/utsname.h>
22 #include <sys/syscall.h>
23 #include <sys/types.h>
34 #include <libubox/avl.h>
35 #include <libubox/avl-cmp.h>
36 #include <libubox/utils.h>
37 #include <libubox/ulog.h>
39 #define DEF_MOD_PATH "/modules/%s/"
58 int refcnt; /* number of references from module_node.m */
67 static struct avl_tree modules;
69 static char **module_folders = NULL;
71 static void free_module(struct module *m);
73 static int init_module_folders(void)
78 char *s, *e, *p, path[256], ldpath[256];
81 s = getenv("LD_LIBRARY_PATH");
84 e += snprintf(ldpath, sizeof(ldpath), "%s:", s);
86 e += snprintf(e, sizeof(ldpath) - (e - ldpath), "/lib");
90 for (s = p = ldpath; p <= e; p++) {
91 if (*p != ':' && *p != '\0')
95 snprintf(path, sizeof(path), "%s" DEF_MOD_PATH, s, ver.release);
97 if (!stat(path, &st) && S_ISDIR(st.st_mode)) {
98 module_folders = realloc(module_folders, sizeof(p) * (n + 2));
103 module_folders[n++] = strdup(path);
112 module_folders[n] = NULL;
116 static struct module *find_module(const char *name)
118 struct module_node *mn;
119 mn = avl_find_element(&modules, name, mn, avl);
126 static void free_modules(void)
128 struct module_node *mn, *tmp;
130 avl_remove_all_elements(&modules, mn, avl, tmp) {
131 struct module *m = mn->m;
140 static char* get_module_path(char *name)
143 static char path[256];
146 if (!stat(name, &s) && S_ISREG(s.st_mode))
149 for (p = module_folders; *p; p++) {
150 snprintf(path, sizeof(path), "%s%s.ko", *p, name);
151 if (!stat(path, &s) && S_ISREG(s.st_mode))
158 static char* get_module_name(char *path)
160 static char name[32];
163 strncpy(name, basename(path), sizeof(name));
165 t = strstr(name, ".ko");
172 static int elf64_find_section(char *map, const char *section, unsigned int *offset, unsigned int *size)
174 const char *secnames;
179 e = (Elf64_Ehdr *) map;
180 sh = (Elf64_Shdr *) (map + e->e_shoff);
182 secnames = map + sh[e->e_shstrndx].sh_offset;
183 for (i = 0; i < e->e_shnum; i++) {
184 if (!strcmp(section, secnames + sh[i].sh_name)) {
185 *size = sh[i].sh_size;
186 *offset = sh[i].sh_offset;
194 static int elf32_find_section(char *map, const char *section, unsigned int *offset, unsigned int *size)
196 const char *secnames;
201 e = (Elf32_Ehdr *) map;
202 sh = (Elf32_Shdr *) (map + e->e_shoff);
204 secnames = map + sh[e->e_shstrndx].sh_offset;
205 for (i = 0; i < e->e_shnum; i++) {
206 if (!strcmp(section, secnames + sh[i].sh_name)) {
207 *size = sh[i].sh_size;
208 *offset = sh[i].sh_offset;
216 static int elf_find_section(char *map, const char *section, unsigned int *offset, unsigned int *size)
218 int clazz = map[EI_CLASS];
220 if (clazz == ELFCLASS32)
221 return elf32_find_section(map, section, offset, size);
222 else if (clazz == ELFCLASS64)
223 return elf64_find_section(map, section, offset, size);
225 ULOG_ERR("unknown elf format %d\n", clazz);
230 static struct module_node *
231 alloc_module_node(const char *name, struct module *m, bool is_alias)
233 struct module_node *mn;
236 mn = calloc_a(sizeof(*mn),
237 &_name, strlen(name) + 1);
239 mn->avl.key = strcpy(_name, name);
241 mn->is_alias = is_alias;
242 avl_insert(&modules, &mn->avl);
248 static struct module *
249 alloc_module(const char *name, const char * const *aliases, int naliases, const char *depends, int size)
256 len_aliases = naliases * sizeof(aliases[0]);
257 for (i = 0; i < naliases; i++)
258 len_aliases += strlen(aliases[i]) + 1;
259 m = calloc_a(sizeof(*m),
260 &_name, strlen(name) + 1,
261 &_dep, depends ? strlen(depends) + 2 : 0,
262 &_aliases, len_aliases);
266 m->name = strcpy(_name, name);
270 m->depends = strcpy(_dep, depends);
278 m->naliases = naliases;
282 char *ptr = (char *)_aliases + naliases * sizeof(_aliases[0]);
287 len = strlen(aliases[i]) + 1;
288 memcpy(ptr, aliases[i], len);
292 } while (i < naliases);
293 m->aliases = _aliases;
297 alloc_module_node(m->name, m, false);
298 for (i = 0; i < m->naliases; i++)
299 alloc_module_node(m->aliases[i], m, true);
304 static void free_module(struct module *m)
311 static int scan_loaded_modules(void)
317 fp = fopen("/proc/modules", "r");
319 ULOG_ERR("failed to open /proc/modules\n");
323 while (getline(&buf, &buf_len, fp) > 0) {
327 m.name = strtok(buf, " ");
328 m.size = atoi(strtok(NULL, " "));
329 m.usage = atoi(strtok(NULL, " "));
330 m.depends = strtok(NULL, " ");
332 if (!m.name || !m.depends)
335 n = find_module(m.name);
337 /* possibly a module outside /lib/modules/<ver>/ */
338 n = alloc_module(m.name, NULL, 0, m.depends, m.size);
349 static struct module* get_module_info(const char *module, const char *name)
351 int fd = open(module, O_RDONLY);
352 unsigned int offset, size;
353 char *map = MAP_FAILED, *strings, *dep = NULL;
354 const char *aliases[32];
356 struct module *m = NULL;
360 ULOG_ERR("failed to open %s\n", module);
364 if (fstat(fd, &s) == -1) {
365 ULOG_ERR("failed to stat %s\n", module);
369 map = mmap(NULL, s.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
370 if (map == MAP_FAILED) {
371 ULOG_ERR("failed to mmap %s\n", module);
375 if (elf_find_section(map, ".modinfo", &offset, &size)) {
376 ULOG_ERR("failed to load the .modinfo section from %s\n", module);
380 strings = map + offset;
387 if (strings >= map + offset + size)
389 sep = strstr(strings, "=");
394 if (!strncmp(strings, "depends=", len + 1))
396 else if (!strncmp(strings, "alias=", len + 1)) {
397 if (naliases < ARRAY_SIZE(aliases))
398 aliases[naliases++] = sep;
400 ULOG_WARN("module %s has more than %d aliases: truncated",
401 name, ARRAY_SIZE(aliases));
403 strings = &sep[strlen(sep)];
406 m = alloc_module(name, aliases, naliases, dep, s.st_size);
412 if (map != MAP_FAILED)
413 munmap(map, s.st_size);
421 static int scan_module_folder(const char *dir)
423 int gl_flags = GLOB_NOESCAPE | GLOB_MARK;
430 path = alloca(strlen(dir) + sizeof("*.ko") + 1);
431 sprintf(path, "%s*.ko", dir);
433 if (glob(path, gl_flags, NULL, &gl) < 0)
436 for (j = 0; j < gl.gl_pathc; j++) {
437 char *name = get_module_name(gl.gl_pathv[j]);
443 m = find_module(name);
445 get_module_info(gl.gl_pathv[j], name);
453 static int scan_module_folders(void)
458 if (init_module_folders())
461 for (p = module_folders; *p; p++)
462 rv |= scan_module_folder(*p);
467 static int print_modinfo(char *module)
469 int fd = open(module, O_RDONLY);
470 unsigned int offset, size;
472 char *map = MAP_FAILED, *strings;
476 ULOG_ERR("failed to open %s\n", module);
480 if (fstat(fd, &s) == -1) {
481 ULOG_ERR("failed to stat %s\n", module);
485 map = mmap(NULL, s.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
486 if (map == MAP_FAILED) {
487 ULOG_ERR("failed to mmap %s\n", module);
491 if (elf_find_section(map, ".modinfo", &offset, &size)) {
492 ULOG_ERR("failed to load the .modinfo section from %s\n", module);
496 strings = map + offset;
497 printf("module:\t\t%s\n", module);
504 if (strings >= map + offset + size)
506 sep = strstr(strings, "=");
509 dup = strndup(strings, sep - strings);
511 if (strncmp(strings, "parm", 4)) {
513 printf("%s:\t\t%s\n", dup, sep);
515 printf("%s:\t%s\n", dup, sep);
517 strings = &sep[strlen(sep)];
525 if (map != MAP_FAILED)
526 munmap(map, s.st_size);
534 static int deps_available(struct module *m, int verbose)
539 if (!m->depends || !strcmp(m->depends, "-") || !strcmp(m->depends, ""))
545 m = find_module(dep);
548 ULOG_ERR("missing dependency %s\n", dep);
549 if (verbose && m && (m->state != LOADED))
550 ULOG_ERR("dependency not loaded %s\n", dep);
551 if (!m || (m->state != LOADED))
553 dep += strlen(dep) + 1;
559 static int insert_module(char *path, const char *options)
565 if (stat(path, &s)) {
566 ULOG_ERR("missing module %s\n", path);
570 fd = open(path, O_RDONLY);
572 ULOG_ERR("cannot open %s\n", path);
576 data = malloc(s.st_size);
577 if (read(fd, data, s.st_size) == s.st_size)
578 ret = syscall(__NR_init_module, data, (unsigned long) s.st_size, options);
580 ULOG_ERR("failed to read full module %s\n", path);
588 static void load_moddeps(struct module *_m)
593 if (!strcmp(_m->depends, "-") || !strcmp(_m->depends, ""))
599 m = find_module(dep);
602 ULOG_ERR("failed to find dependency %s\n", dep);
603 if (m && (m->state != LOADED)) {
608 dep = dep + strlen(dep) + 1;
612 static int iterations = 0;
613 static int load_modprobe(void)
616 struct module_node *mn;
619 avl_for_each_element(&modules, mn, avl) {
623 if (m->state == PROBE)
630 avl_for_each_element(&modules, mn, avl) {
634 if ((m->state == PROBE) && (!deps_available(m, 0))) {
635 if (!insert_module(get_module_path(m->name), (m->opts) ? (m->opts) : (""))) {
644 if ((m->state == PROBE) || m->error)
653 static int print_insmod_usage(void)
655 ULOG_INFO("Usage:\n\tinsmod filename [args]\n");
660 static int print_usage(char *arg)
662 ULOG_INFO("Usage:\n\t%s module\n", arg);
667 static int main_insmod(int argc, char **argv)
669 char *name, *cur, *options;
673 return print_insmod_usage();
675 name = get_module_name(argv[1]);
677 ULOG_ERR("cannot find module - %s\n", argv[1]);
681 if (scan_loaded_modules())
684 if (find_module(name)) {
685 ULOG_ERR("module is already loaded - %s\n", name);
692 for (len = 0, i = 2; i < argc; i++)
693 len += strlen(argv[i]) + 1;
695 options = malloc(len);
698 for (i = 2; i < argc; i++) {
703 cur += sprintf(cur, "%s", argv[i]);
706 if (init_module_folders()) {
707 fprintf(stderr, "Failed to find the folder holding the modules\n");
711 if (get_module_path(argv[1])) {
713 } else if (!get_module_path(name)) {
714 fprintf(stderr, "Failed to find %s. Maybe it is a built in module ?\n", name);
718 ret = insert_module(get_module_path(name), options);
722 ULOG_ERR("failed to insert %s\n", get_module_path(name));
727 static int main_rmmod(int argc, char **argv)
734 return print_usage("rmmod");
736 if (scan_loaded_modules())
739 name = get_module_name(argv[1]);
740 m = find_module(name);
742 ULOG_ERR("module is not loaded\n");
745 ret = syscall(__NR_delete_module, m->name, 0);
748 ULOG_ERR("unloading the module failed\n");
755 static int main_lsmod(int argc, char **argv)
757 struct module_node *mn;
761 if (scan_loaded_modules())
764 avl_for_each_element(&modules, mn, avl) {
768 if (m->state == LOADED) {
769 printf("%-20s%8d%3d ",
770 m->name, m->size, m->usage);
771 if (m->depends && strcmp(m->depends, "-") && strcmp(m->depends, "")) {
775 dep = dep + strlen(dep) + 1;
789 static int main_modinfo(int argc, char **argv)
795 return print_usage("modinfo");
797 if (scan_module_folders())
800 name = get_module_name(argv[1]);
801 m = find_module(name);
803 ULOG_ERR("cannot find module - %s\n", argv[1]);
807 name = get_module_path(m->name);
809 ULOG_ERR("cannot find path of module - %s\n", m->name);
818 static int main_modprobe(int argc, char **argv)
820 struct module_node *mn;
826 for (i = 1; i < argc; i++)
827 if (argv[i][0] != '-') {
832 return print_usage("modprobe");
834 if (scan_module_folders())
837 if (scan_loaded_modules())
840 name = get_module_name(mod);
841 m = find_module(name);
842 if (m && m->state == LOADED) {
843 ULOG_ERR("%s is already loaded\n", name);
846 ULOG_ERR("failed to find a module named %s\n", name);
852 fail = load_modprobe();
855 ULOG_ERR("%d module%s could not be probed\n",
856 fail, (fail == 1) ? ("") : ("s"));
858 avl_for_each_element(&modules, mn, avl) {
862 if ((m->state == PROBE) || m->error)
863 ULOG_ERR("- %s\n", m->name);
873 static int main_loader(int argc, char **argv)
875 int gl_flags = GLOB_NOESCAPE | GLOB_MARK;
876 char *dir = "/etc/modules.d/";
877 struct module_node *mn;
886 path = malloc(strlen(dir) + 2);
890 if (scan_module_folders()) {
895 if (scan_loaded_modules()) {
900 ULOG_INFO("loading kernel modules from %s\n", path);
902 if (glob(path, gl_flags, NULL, &gl) < 0)
905 for (j = 0; j < gl.gl_pathc; j++) {
906 FILE *fp = fopen(gl.gl_pathv[j], "r");
911 ULOG_ERR("failed to open %s\n", gl.gl_pathv[j]);
915 while (getline(&mod, &mod_len, fp) > 0) {
916 char *nl = strchr(mod, '\n');
923 opts = strchr(mod, ' ');
927 m = find_module(get_module_name(mod));
928 if (!m || (m->state == LOADED))
932 m->opts = strdup(opts);
934 if (basename(gl.gl_pathv[j])[0] - '0' <= 9)
942 fail = load_modprobe();
945 ULOG_ERR("%d module%s could not be probed\n",
946 fail, (fail == 1) ? ("") : ("s"));
948 avl_for_each_element(&modules, mn, avl) {
952 if ((m->state == PROBE) || (m->error))
953 ULOG_ERR("- %s - %d\n", m->name, deps_available(m, 1));
956 ULOG_INFO("done loading kernel modules from %s\n", path);
966 static int avl_modcmp(const void *k1, const void *k2, void *ptr)
971 while (*s1 && ((*s1 == *s2) ||
972 ((*s1 == '_') && (*s2 == '-')) ||
973 ((*s1 == '-') && (*s2 == '_'))))
979 return *(const unsigned char *)s1 - *(const unsigned char *)s2;
982 int main(int argc, char **argv)
984 char *exec = basename(*argv);
986 avl_init(&modules, avl_modcmp, false, NULL);
987 if (!strcmp(exec, "insmod"))
988 return main_insmod(argc, argv);
990 if (!strcmp(exec, "rmmod"))
991 return main_rmmod(argc, argv);
993 if (!strcmp(exec, "lsmod"))
994 return main_lsmod(argc, argv);
996 if (!strcmp(exec, "modinfo"))
997 return main_modinfo(argc, argv);
999 if (!strcmp(exec, "modprobe"))
1000 return main_modprobe(argc, argv);
1002 ulog_open(ULOG_KMSG, LOG_USER, "kmodloader");
1003 return main_loader(argc, argv);