kmodloader.c

   1 /*
   2  * Copyright (C) 2013 Felix Fietkau <nbd@openwrt.org>
   3  * Copyright (C) 2013 John Crispin <blogic@openwrt.org>
   4  *
   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
   8  *
   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.
  13  */
  14
  15 #define _GNU_SOURCE
  16 #include <sys/syscall.h>
  17 #include <sys/mman.h>
  18 #include <sys/utsname.h>
  19
  20 #include <stdlib.h>
  21 #include <unistd.h>
  22 #include <sys/syscall.h>
  23 #include <sys/types.h>
  24 #include <values.h>
  25 #include <errno.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <sys/stat.h>
  29 #include <fcntl.h>
  30 #include <syslog.h>
  31 #include <libgen.h>
  32 #include <glob.h>
  33 #include <elf.h>
  34
  35 #include <libubox/avl.h>
  36 #include <libubox/avl-cmp.h>
  37 #include <libubox/utils.h>
  38
  39 #define DEF_MOD_PATH "/lib/modules/%s/"
  40
  41 #define LOG(fmt, ...) do { \
  42         syslog(LOG_INFO, fmt, ## __VA_ARGS__); \
  43         printf("kmod: "fmt, ## __VA_ARGS__); \
  44         } while (0)
  45
  46
  47 enum {
  48         SCANNED,
  49         PROBE,
  50         LOADED,
  51 };
  52
  53 struct module {
  54         struct avl_node avl;
  55
  56         char *name;
  57         char *depends;
  58
  59         int size;
  60         int usage;
  61         int state;
  62         int error;
  63 };
  64
  65 static struct avl_tree modules;
  66 static char *prefix = "";
  67
  68 static struct module *find_module(const char *name)
  69 {
  70         struct module *m;
  71         return avl_find_element(&modules, name, m, avl);
  72 }
  73
  74 static void free_modules(void)
  75 {
  76         struct module *m, *tmp;
  77
  78         avl_remove_all_elements(&modules, m, avl, tmp)
  79                 free(m);
  80 }
  81
  82 static char* get_module_path(char *name)
  83 {
  84         static char path[256];
  85         struct utsname ver;
  86         struct stat s;
  87
  88         if (!stat(name, &s))
  89                 return name;
  90
  91         uname(&ver);
  92         snprintf(path, 256, "%s" DEF_MOD_PATH "%s.ko", prefix, ver.release, name);
  93
  94         if (!stat(path, &s))
  95                 return path;
  96
  97         return NULL;
  98 }
  99
 100 static char* get_module_name(char *path)
 101 {
 102         static char name[32];
 103         char *t;
 104
 105         strncpy(name, basename(path), sizeof(name));
 106
 107         t = strstr(name, ".ko");
 108         if (t)
 109                 *t = '\0';
 110
 111         return name;
 112 }
 113
 114 #if __WORDSIZE == 64
 115 static int elf_find_section(char *map, const char *section, unsigned int *offset, unsigned int *size)
 116 {
 117         const char *secnames;
 118         Elf64_Ehdr *e;
 119         Elf64_Shdr *sh;
 120         int i;
 121
 122         e = (Elf64_Ehdr *) map;
 123         sh = (Elf64_Shdr *) (map + e->e_shoff);
 124
 125         secnames = map + sh[e->e_shstrndx].sh_offset;
 126         for (i = 0; i < e->e_shnum; i++) {
 127                 if (!strcmp(section, secnames + sh[i].sh_name)) {
 128                         *size = sh[i].sh_size;
 129                         *offset = sh[i].sh_offset;
 130                         return 0;
 131                 }
 132         }
 133
 134         return -1;
 135 }
 136 #else
 137 static int elf_find_section(char *map, const char *section, unsigned int *offset, unsigned int *size)
 138 {
 139         const char *secnames;
 140         Elf32_Ehdr *e;
 141         Elf32_Shdr *sh;
 142         int i;
 143
 144         e = (Elf32_Ehdr *) map;
 145         sh = (Elf32_Shdr *) (map + e->e_shoff);
 146
 147         secnames = map + sh[e->e_shstrndx].sh_offset;
 148         for (i = 0; i < e->e_shnum; i++) {
 149                 if (!strcmp(section, secnames + sh[i].sh_name)) {
 150                         *size = sh[i].sh_size;
 151                         *offset = sh[i].sh_offset;
 152                         return 0;
 153                 }
 154         }
 155
 156         return -1;
 157 }
 158 #endif
 159
 160 static struct module *
 161 alloc_module(const char *name, const char *depends, int size)
 162 {
 163         struct module *m;
 164         char *_name, *_dep;
 165
 166         m = calloc_a(sizeof(*m),
 167                 &_name, strlen(name) + 1,
 168                 &_dep, depends ? strlen(depends) + 2 : 0);
 169         if (!m)
 170                 return NULL;
 171
 172         m->avl.key = m->name = strcpy(_name, name);
 173
 174         if (depends) {
 175                 m->depends = strcpy(_dep, depends);
 176                 while (*_dep) {
 177                         if (*_dep == ',')
 178                                 *_dep = '\0';
 179                         _dep++;
 180                 }
 181         }
 182
 183         m->size = size;
 184         avl_insert(&modules, &m->avl);
 185
 186         return m;
 187 }
 188
 189 static int scan_loaded_modules(void)
 190 {
 191         size_t buf_len = 0;
 192         char *buf = NULL;
 193         FILE *fp;
 194
 195         fp = fopen("/proc/modules", "r");
 196         if (!fp) {
 197                 LOG("failed to open /proc/modules\n");
 198                 return -1;
 199         }
 200
 201         while (getline(&buf, &buf_len, fp) > 0) {
 202                 struct module m;
 203                 struct module *n;
 204
 205                 m.name = strtok(buf, " ");
 206                 m.size = atoi(strtok(NULL, " "));
 207                 m.usage = atoi(strtok(NULL, " "));
 208                 m.depends = strtok(NULL, " ");
 209
 210                 if (!m.name || !m.depends)
 211                         continue;
 212
 213                 n = alloc_module(m.name, m.depends, m.size);
 214                 n->usage = m.usage;
 215                 n->state = LOADED;
 216         }
 217         free(buf);
 218         fclose(fp);
 219
 220         return 0;
 221 }
 222
 223 static struct module* get_module_info(const char *module, const char *name)
 224 {
 225         int fd = open(module, O_RDONLY);
 226         unsigned int offset, size;
 227         char *map, *strings, *dep = NULL;
 228         struct module *m;
 229         struct stat s;
 230
 231         if (!fd) {
 232                 LOG("failed to open %s\n", module);
 233                 return NULL;
 234         }
 235
 236         if (fstat(fd, &s) == -1) {
 237                 LOG("failed to stat %s\n", module);
 238                 return NULL;
 239         }
 240
 241         map = mmap(NULL, s.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
 242         if (map == MAP_FAILED) {
 243                 LOG("failed to mmap %s\n", module);
 244                 return NULL;
 245         }
 246
 247         if (elf_find_section(map, ".modinfo", &offset, &size)) {
 248                 LOG("failed to load the .modinfo section from %s\n", module);
 249                 return NULL;
 250         }
 251
 252         strings = map + offset;
 253         while (strings && (strings < map + offset + size)) {
 254                 char *sep;
 255                 int len;
 256
 257                 while (!strings[0])
 258                         strings++;
 259                 sep = strstr(strings, "=");
 260                 if (!sep)
 261                         break;
 262                 len = sep - strings;
 263                 sep++;
 264                 if (!strncmp(strings, "depends=", len + 1))
 265                         dep = sep;
 266                 strings = &sep[strlen(sep)];
 267         }
 268
 269         m = alloc_module(name, dep, s.st_size);
 270         if (!m)
 271                 return NULL;
 272
 273         m->state = SCANNED;
 274
 275         return m;
 276 }
 277
 278 static int scan_module_folder(void)
 279 {
 280         int gl_flags = GLOB_NOESCAPE | GLOB_MARK;
 281         struct utsname ver;
 282         char *path;
 283         glob_t gl;
 284         int j;
 285
 286         uname(&ver);
 287         path = alloca(sizeof(DEF_MOD_PATH "*.ko") + strlen(prefix) + strlen(ver.release) + 1);
 288         sprintf(path, "%s" DEF_MOD_PATH "*.ko", prefix, ver.release);
 289
 290         if (glob(path, gl_flags, NULL, &gl) < 0)
 291                 return -1;
 292
 293         for (j = 0; j < gl.gl_pathc; j++) {
 294                 char *name = get_module_name(gl.gl_pathv[j]);
 295                 struct module *m;
 296
 297                 if (!name)
 298                         continue;
 299
 300                 m = find_module(name);
 301                 if (!m)
 302                         get_module_info(gl.gl_pathv[j], name);
 303         }
 304
 305         globfree(&gl);
 306
 307         return 0;
 308 }
 309
 310 static int print_modinfo(char *module)
 311 {
 312         int fd = open(module, O_RDONLY);
 313         unsigned int offset, size;
 314         struct stat s;
 315         char *map, *strings;
 316
 317         if (!fd) {
 318                 LOG("failed to open %s\n", module);
 319                 return -1;
 320         }
 321
 322         if (fstat(fd, &s) == -1) {
 323                 LOG("failed to stat %s\n", module);
 324                 return -1;
 325         }
 326
 327         map = mmap(NULL, s.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
 328         if (map == MAP_FAILED) {
 329                 LOG("failed to mmap %s\n", module);
 330                 return -1;
 331         }
 332
 333         if (elf_find_section(map, ".modinfo", &offset, &size)) {
 334                 LOG("failed to load the .modinfo section from %s\n", module);
 335                 return -1;
 336         }
 337
 338         strings = map + offset;
 339         printf("module:\t\t%s\n", module);
 340         while (strings && (strings < map + offset + size)) {
 341                 char *dup = NULL;
 342                 char *sep;
 343
 344                 while (!strings[0])
 345                         strings++;
 346                 sep = strstr(strings, "=");
 347                 if (!sep)
 348                         break;
 349                 dup = strndup(strings, sep - strings);
 350                 sep++;
 351                 if (strncmp(strings, "parm", 4)) {
 352                         if (strlen(dup) < 7)
 353                                 printf("%s:\t\t%s\n",  dup, sep);
 354                         else
 355                                 printf("%s:\t%s\n",  dup, sep);
 356                 }
 357                 strings = &sep[strlen(sep)];
 358                 if (dup)
 359                         free(dup);
 360         }
 361
 362         return 0;
 363 }
 364
 365 static int deps_available(struct module *m, int verbose)
 366 {
 367         char *dep;
 368         int err = 0;
 369
 370         if (!strcmp(m->depends, "-") || !strcmp(m->depends, ""))
 371                 return 0;
 372
 373         dep = m->depends;
 374
 375         while (*dep) {
 376                 m = find_module(dep);
 377
 378                 if (verbose && !m)
 379                         LOG("missing dependency %s\n", dep);
 380                 if (verbose && m && (m->state != LOADED))
 381                         LOG("dependency not loaded %s\n", dep);
 382                 if (!m || (m->state != LOADED))
 383                         err++;
 384                 dep += strlen(dep) + 1;
 385         }
 386
 387         return err;
 388 }
 389
 390 static int insert_module(char *path, const char *options)
 391 {
 392         void *data = 0;
 393         struct stat s;
 394         int fd, ret = -1;
 395
 396         if (stat(path, &s)) {
 397                 LOG("missing module %s\n", path);
 398                 return ret;
 399         }
 400
 401         fd = open(path, O_RDONLY);
 402         if (!fd) {
 403                 LOG("cannot open %s\n", path);
 404                 return ret;
 405         }
 406
 407         data = malloc(s.st_size);
 408         if (read(fd, data, s.st_size) == s.st_size)
 409                 ret = syscall(__NR_init_module, data, s.st_size, options);
 410         else
 411                 LOG("failed to read full module %s\n", path);
 412
 413         close(fd);
 414         free(data);
 415
 416         return ret;
 417 }
 418
 419 static void load_moddeps(struct module *_m)
 420 {
 421         char *dep;
 422         struct module *m;
 423
 424         if (!strcmp(_m->depends, "-") || !strcmp(_m->depends, ""))
 425                 return;
 426
 427         dep = _m->depends;
 428
 429         while (*dep) {
 430                 m = find_module(dep);
 431
 432                 if (!m)
 433                         LOG("failed to find dependency %s\n", dep);
 434                 if (m && (m->state != LOADED)) {
 435                         m->state = PROBE;
 436                         load_moddeps(m);
 437                 }
 438
 439                 dep = dep + strlen(dep) + 1;
 440         }
 441 }
 442
 443 static int iterations = 0;
 444 static int load_modprobe(void)
 445 {
 446         int loaded, todo;
 447         struct module *m;
 448
 449         avl_for_each_element(&modules, m, avl)
 450                 if (m->state == PROBE)
 451                         load_moddeps(m);
 452
 453         do {
 454                 loaded = 0;
 455                 todo = 0;
 456                 avl_for_each_element(&modules, m, avl) {
 457                         if ((m->state == PROBE) && (!deps_available(m, 0))) {
 458                                 if (!insert_module(get_module_path(m->name), "")) {
 459                                         m->state = LOADED;
 460                                         m->error = 0;
 461                                         loaded++;
 462                                         continue;
 463                                 }
 464                                 m->error = 1;
 465                         }
 466
 467                         if ((m->state == PROBE) || m->error)
 468                                 todo++;
 469                 }
 470                 iterations++;
 471         } while (loaded);
 472
 473         return todo;
 474 }
 475
 476 static int print_insmod_usage(void)
 477 {
 478         LOG("Usage:\n\tinsmod filename [args]\n");
 479
 480         return -1;
 481 }
 482
 483 static int print_usage(char *arg)
 484 {
 485         LOG("Usage:\n\t%s module\n", arg);
 486
 487         return -1;
 488 }
 489
 490 static int main_insmod(int argc, char **argv)
 491 {
 492         char *name, *cur, *options;
 493         int i, ret, len;
 494
 495         if (argc < 2)
 496                 return print_insmod_usage();
 497
 498         name = get_module_name(argv[1]);
 499         if (!name) {
 500                 LOG("cannot find module - %s\n", argv[1]);
 501                 return -1;
 502         }
 503
 504         if (scan_loaded_modules())
 505                 return -1;
 506
 507         if (find_module(name)) {
 508                 LOG("module is already loaded - %s\n", name);
 509                 return -1;
 510
 511         }
 512
 513         free_modules();
 514
 515         for (len = 0, i = 2; i < argc; i++)
 516                 len += strlen(argv[i]) + 1;
 517
 518         options = malloc(len);
 519         options[0] = 0;
 520         cur = options;
 521         for (i = 2; i < argc; i++) {
 522                 if (options[0]) {
 523                         *cur = ' ';
 524                         cur++;
 525                 }
 526                 cur += sprintf(cur, "%s", argv[i]);
 527         }
 528
 529         ret = insert_module(get_module_path(name), options);
 530         free(options);
 531
 532         if (ret)
 533                 LOG("failed to insert %s\n", get_module_path(name));
 534
 535         return ret;
 536 }
 537
 538 static int main_rmmod(int argc, char **argv)
 539 {
 540         struct module *m;
 541         char *name;
 542         int ret;
 543
 544         if (argc != 2)
 545                 return print_usage("rmmod");
 546
 547         if (scan_loaded_modules())
 548                 return -1;
 549
 550         name = get_module_name(argv[1]);
 551         m = find_module(name);
 552         if (!m) {
 553                 LOG("module is not loaded\n");
 554                 return -1;
 555         }
 556         ret = syscall(__NR_delete_module, m->name, 0);
 557
 558         if (ret)
 559                 LOG("unloading the module failed\n");
 560
 561         free_modules();
 562
 563         return ret;
 564 }
 565
 566 static int main_lsmod(int argc, char **argv)
 567 {
 568         struct module *m;
 569
 570         if (scan_loaded_modules())
 571                 return -1;
 572
 573         avl_for_each_element(&modules, m, avl)
 574                 if (m->state == LOADED)
 575                         printf("%-20s%8d%3d %s\n",
 576                                 m->name, m->size, m->usage,
 577                                 (*m->depends == '-') ? ("") : (m->depends));
 578
 579         free_modules();
 580
 581         return 0;
 582 }
 583
 584 static int main_modinfo(int argc, char **argv)
 585 {
 586         struct module *m;
 587         char *name;
 588
 589         if (argc != 2)
 590                 return print_usage("modinfo");
 591
 592         if (scan_module_folder())
 593                 return -1;
 594
 595         name = get_module_name(argv[1]);
 596         m = find_module(name);
 597         if (!m) {
 598                 LOG("cannot find module - %s\n", argv[1]);
 599                 return -1;
 600         }
 601
 602         name = get_module_path(m->name);
 603         if (!name) {
 604                 LOG("cannot find path of module - %s\n", m->name);
 605                 return -1;
 606         }
 607
 608         print_modinfo(name);
 609
 610         return 0;
 611 }
 612
 613 static int main_modprobe(int argc, char **argv)
 614 {
 615         struct module *m;
 616         char *name;
 617
 618         if (argc != 2)
 619                 return print_usage("modprobe");
 620
 621         if (scan_loaded_modules())
 622                 return -1;
 623
 624         if (scan_module_folder())
 625                 return -1;
 626
 627         name = get_module_name(argv[1]);
 628         m = find_module(name);
 629         if (m && m->state == LOADED) {
 630                 LOG("%s is already loaded\n", name);
 631                 return -1;
 632         } else if (!m) {
 633                 LOG("failed to find a module named %s\n", name);
 634         } else {
 635                 int fail;
 636
 637                 m->state = PROBE;
 638
 639                 fail = load_modprobe();
 640
 641                 if (fail) {
 642                         LOG("%d module%s could not be probed\n",
 643                                         fail, (fail == 1) ? ("") : ("s"));
 644
 645                         avl_for_each_element(&modules, m, avl)
 646                                 if ((m->state == PROBE) || m->error)
 647                                         LOG("- %s\n", m->name);
 648                 }
 649         }
 650
 651         free_modules();
 652
 653         return 0;
 654 }
 655
 656 static int main_loader(int argc, char **argv)
 657 {
 658         int gl_flags = GLOB_NOESCAPE | GLOB_MARK;
 659         char *dir = "/etc/modules.d/*";
 660         struct module *m;
 661         glob_t gl;
 662         char *path;
 663         int fail, j;
 664
 665         if (argc > 1)
 666                 dir = argv[1];
 667
 668         if (argc > 2)
 669                 prefix = argv[2];
 670
 671         path = malloc(strlen(dir) + 2);
 672         strcpy(path, dir);
 673         strcat(path, "*");
 674
 675         if (scan_loaded_modules())
 676                 return -1;
 677
 678         if (scan_module_folder())
 679                 return -1;
 680
 681         syslog(0, "kmodloader: loading kernel modules from %s\n", path);
 682
 683         if (glob(path, gl_flags, NULL, &gl) < 0)
 684                 goto out;
 685
 686         for (j = 0; j < gl.gl_pathc; j++) {
 687                 FILE *fp = fopen(gl.gl_pathv[j], "r");
 688                 size_t mod_len = 0;
 689                 char *mod = NULL;
 690
 691                 if (!fp) {
 692                         LOG("failed to open %s\n", gl.gl_pathv[j]);
 693                         continue;
 694                 }
 695
 696                 while (getline(&mod, &mod_len, fp) > 0) {
 697                         char *nl = strchr(mod, '\n');
 698                         struct module *m;
 699                         char *opts;
 700
 701                         if (nl)
 702                                 *nl = '\0';
 703
 704                         opts = strchr(mod, ' ');
 705                         if (opts)
 706                                 *opts++ = '\0';
 707
 708                         m = find_module(get_module_name(mod));
 709                         if (!m || (m->state == LOADED))
 710                                 continue;
 711
 712                         m->state = PROBE;
 713                         if (basename(gl.gl_pathv[j])[0] - '0' <= 9)
 714                                 load_modprobe();
 715
 716                 }
 717                 free(mod);
 718                 fclose(fp);
 719         }
 720
 721         fail = load_modprobe();
 722         LOG("ran %d iterations\n", iterations);
 723
 724         if (fail) {
 725                 LOG("%d module%s could not be probed\n",
 726                                 fail, (fail == 1) ? ("") : ("s"));
 727
 728                 avl_for_each_element(&modules, m, avl)
 729                         if ((m->state == PROBE) || (m->error))
 730                                 LOG("- %s - %d\n", m->name, deps_available(m, 1));
 731         }
 732
 733 out:
 734         globfree(&gl);
 735         free(path);
 736
 737         return 0;
 738 }
 739
 740 static int avl_modcmp(const void *k1, const void *k2, void *ptr)
 741 {
 742         const char *s1 = k1;
 743         const char *s2 = k2;
 744
 745         while (*s1 && ((*s1 == *s2) ||
 746                        ((*s1 == '_') && (*s2 == '-')) ||
 747                        ((*s1 == '-') && (*s2 == '_'))))
 748         {
 749                 s1++;
 750                 s2++;
 751         }
 752
 753         return *(const unsigned char *)s1 - *(const unsigned char *)s2;
 754 }
 755
 756 int main(int argc, char **argv)
 757 {
 758         char *exec = basename(*argv);
 759
 760         avl_init(&modules, avl_modcmp, false, NULL);
 761         if (!strcmp(exec, "insmod"))
 762                 return main_insmod(argc, argv);
 763
 764         if (!strcmp(exec, "rmmod"))
 765                 return main_rmmod(argc, argv);
 766
 767         if (!strcmp(exec, "lsmod"))
 768                 return main_lsmod(argc, argv);
 769
 770         if (!strcmp(exec, "modinfo"))
 771                 return main_modinfo(argc, argv);
 772
 773         if (!strcmp(exec, "modprobe"))
 774                 return main_modprobe(argc, argv);
 775
 776         return main_loader(argc, argv);
 777 }