modutils/modprobe-small.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * simplified modprobe
   4  *
   5  * Copyright (c) 2008 Vladimir Dronnikov
   6  * Copyright (c) 2008 Bernhard Reutner-Fischer (initial depmod code)
   7  *
   8  * Licensed under GPLv2, see file LICENSE in this source tree.
   9  */
  10
  11 /* modprobe-small configs are defined in Config.src to ensure better
  12  * "make config" order */
  13
  14 //applet:IF_LSMOD(   IF_MODPROBE_SMALL(APPLET_NOEXEC( lsmod,    lsmod,    BB_DIR_SBIN, BB_SUID_DROP, lsmod   )))
  15 //applet:IF_MODPROBE(IF_MODPROBE_SMALL(APPLET_NOEXEC( modprobe, modprobe, BB_DIR_SBIN, BB_SUID_DROP, modprobe)))
  16 //                                     APPLET_ODDNAME:name      main      location     suid_type     help
  17 //applet:IF_DEPMOD(  IF_MODPROBE_SMALL(APPLET_ODDNAME(depmod,   modprobe, BB_DIR_SBIN, BB_SUID_DROP, depmod  )))
  18 //applet:IF_INSMOD(  IF_MODPROBE_SMALL(APPLET_NOEXEC( insmod,   modprobe, BB_DIR_SBIN, BB_SUID_DROP, insmod  )))
  19 //applet:IF_RMMOD(   IF_MODPROBE_SMALL(APPLET_NOEXEC( rmmod,    modprobe, BB_DIR_SBIN, BB_SUID_DROP, rmmod   )))
  20 /* noexec speeds up boot with many modules loaded (need SH_STANDALONE=y) */
  21 /* I measured about ~5 times faster insmod */
  22 /* depmod is not noexec, it runs longer and benefits from memory trimming via exec */
  23
  24 //kbuild:lib-$(CONFIG_MODPROBE_SMALL) += modprobe-small.o
  25
  26 #include "libbb.h"
  27 /* After libbb.h, since it needs sys/types.h on some systems */
  28 #include <sys/utsname.h> /* uname() */
  29 #include <fnmatch.h>
  30 #include <sys/syscall.h>
  31
  32 #define init_module(mod, len, opts) syscall(__NR_init_module, mod, len, opts)
  33 #define delete_module(mod, flags) syscall(__NR_delete_module, mod, flags)
  34 #ifdef __NR_finit_module
  35 # define finit_module(fd, uargs, flags) syscall(__NR_finit_module, fd, uargs, flags)
  36 #endif
  37 /* linux/include/linux/module.h has limit of 64 chars on module names */
  38 #undef MODULE_NAME_LEN
  39 #define MODULE_NAME_LEN 64
  40
  41
  42 #if 1
  43 # define dbg1_error_msg(...) ((void)0)
  44 # define dbg2_error_msg(...) ((void)0)
  45 #else
  46 # define dbg1_error_msg(...) bb_error_msg(__VA_ARGS__)
  47 # define dbg2_error_msg(...) bb_error_msg(__VA_ARGS__)
  48 #endif
  49
  50 #define DEPFILE_BB CONFIG_DEFAULT_DEPMOD_FILE".bb"
  51
  52 //usage:#if ENABLE_MODPROBE_SMALL
  53
  54 //usage:#define lsmod_trivial_usage
  55 //usage:       ""
  56 //usage:#define lsmod_full_usage "\n\n"
  57 //usage:       "List loaded kernel modules"
  58
  59 //usage:#endif
  60
  61 #if ENABLE_LSMOD
  62 int lsmod_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
  63 int lsmod_main(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
  64 {
  65         xprint_and_close_file(xfopen_for_read("/proc/modules"));
  66         return EXIT_SUCCESS;
  67 }
  68 #endif
  69
  70 /* Num of applets that use modprobe_main() entry point. */
  71 /* lsmod is not here. */
  72 #define MOD_APPLET_CNT (ENABLE_MODPROBE + ENABLE_DEPMOD + ENABLE_INSMOD + ENABLE_RMMOD)
  73
  74 /* Do not bother if MODPROBE_SMALL=y but no applets selected. */
  75 /* The rest of the file is in this if block. */
  76 #if MOD_APPLET_CNT > 0
  77
  78 #define ONLY_APPLET (MOD_APPLET_CNT == 1)
  79 #define is_modprobe (ENABLE_MODPROBE && (ONLY_APPLET || applet_name[0] == 'm'))
  80 #define is_depmod   (ENABLE_DEPMOD   && (ONLY_APPLET || applet_name[0] == 'd'))
  81 #define is_insmod   (ENABLE_INSMOD   && (ONLY_APPLET || applet_name[0] == 'i'))
  82 #define is_rmmod    (ENABLE_RMMOD    && (ONLY_APPLET || applet_name[0] == 'r'))
  83
  84 enum {
  85         DEPMOD_OPT_n = (1 << 0), /* dry-run, print to stdout */
  86         OPT_q = (1 << 0), /* be quiet */
  87         OPT_r = (1 << 1), /* module removal instead of loading */
  88 };
  89
  90 typedef struct module_info {
  91         char *pathname;
  92         char *aliases;
  93         char *deps;
  94         smallint open_read_failed;
  95 } module_info;
  96
  97 /*
  98  * GLOBALS
  99  */
 100 struct globals {
 101         module_info *modinfo;
 102         char *module_load_options;
 103         smallint dep_bb_seen;
 104         smallint wrote_dep_bb_ok;
 105         unsigned module_count;
 106         int module_found_idx;
 107         unsigned stringbuf_idx;
 108         unsigned stringbuf_size;
 109         char *stringbuf; /* some modules have lots of stuff */
 110         /* for example, drivers/media/video/saa7134/saa7134.ko */
 111         /* therefore having a fixed biggish buffer is not wise */
 112 };
 113 #define G (*ptr_to_globals)
 114 #define modinfo             (G.modinfo            )
 115 #define dep_bb_seen         (G.dep_bb_seen        )
 116 #define wrote_dep_bb_ok     (G.wrote_dep_bb_ok    )
 117 #define module_count        (G.module_count       )
 118 #define module_found_idx    (G.module_found_idx   )
 119 #define module_load_options (G.module_load_options)
 120 #define stringbuf_idx       (G.stringbuf_idx      )
 121 #define stringbuf_size      (G.stringbuf_size     )
 122 #define stringbuf           (G.stringbuf          )
 123 #define INIT_G() do { \
 124         SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
 125 } while (0)
 126
 127 static void append(const char *s)
 128 {
 129         unsigned len = strlen(s);
 130         if (stringbuf_idx + len + 15 > stringbuf_size) {
 131                 stringbuf_size = stringbuf_idx + len + 127;
 132                 dbg2_error_msg("grow stringbuf to %u", stringbuf_size);
 133                 stringbuf = xrealloc(stringbuf, stringbuf_size);
 134         }
 135         memcpy(stringbuf + stringbuf_idx, s, len);
 136         stringbuf_idx += len;
 137 }
 138
 139 static void appendc(char c)
 140 {
 141         /* We appendc() only after append(), + 15 trick in append()
 142          * makes it unnecessary to check for overflow here */
 143         stringbuf[stringbuf_idx++] = c;
 144 }
 145
 146 static void bksp(void)
 147 {
 148         if (stringbuf_idx)
 149                 stringbuf_idx--;
 150 }
 151
 152 static void reset_stringbuf(void)
 153 {
 154         stringbuf_idx = 0;
 155 }
 156
 157 static char* copy_stringbuf(void)
 158 {
 159         char *copy = xzalloc(stringbuf_idx + 1); /* terminating NUL */
 160         return memcpy(copy, stringbuf, stringbuf_idx);
 161 }
 162
 163 static char* find_keyword(char *ptr, size_t len, const char *word)
 164 {
 165         if (!ptr) /* happens if xmalloc_open_zipped_read_close cannot read it */
 166                 return NULL;
 167
 168         len -= strlen(word) - 1;
 169         while ((ssize_t)len > 0) {
 170                 char *old = ptr;
 171                 char *after_word;
 172
 173                 /* search for the first char in word */
 174                 ptr = memchr(ptr, word[0], len);
 175                 if (ptr == NULL) /* no occurrence left, done */
 176                         break;
 177                 after_word = is_prefixed_with(ptr, word);
 178                 if (after_word)
 179                         return after_word; /* found, return ptr past it */
 180                 ++ptr;
 181                 len -= (ptr - old);
 182         }
 183         return NULL;
 184 }
 185
 186 static void replace(char *s, char what, char with)
 187 {
 188         while (*s) {
 189                 if (what == *s)
 190                         *s = with;
 191                 ++s;
 192         }
 193 }
 194
 195 static char *filename2modname(const char *filename, char *modname)
 196 {
 197         int i;
 198         const char *from;
 199
 200         // Disabled since otherwise "modprobe dir/name" would work
 201         // as if it is "modprobe name". It is unclear why
 202         // 'basenamization' was here in the first place.
 203         //from = bb_get_last_path_component_nostrip(filename);
 204         from = filename;
 205         for (i = 0; i < (MODULE_NAME_LEN-1) && from[i] != '\0' && from[i] != '.'; i++)
 206                 modname[i] = (from[i] == '-') ? '_' : from[i];
 207         modname[i] = '\0';
 208
 209         return modname;
 210 }
 211
 212 static int pathname_matches_modname(const char *pathname, const char *modname)
 213 {
 214         int r;
 215         char name[MODULE_NAME_LEN];
 216         filename2modname(bb_get_last_path_component_nostrip(pathname), name);
 217         r = (strcmp(name, modname) == 0);
 218         return r;
 219 }
 220
 221 /* Take "word word", return malloced "word",NUL,"word",NUL,NUL */
 222 static char* str_2_list(const char *str)
 223 {
 224         int len = strlen(str) + 1;
 225         char *dst = xmalloc(len + 1);
 226
 227         dst[len] = '\0';
 228         memcpy(dst, str, len);
 229 //TODO: protect against 2+ spaces: "word  word"
 230         replace(dst, ' ', '\0');
 231         return dst;
 232 }
 233
 234 /* We use error numbers in a loose translation... */
 235 static const char *moderror(int err)
 236 {
 237         switch (err) {
 238         case ENOEXEC:
 239                 return "invalid module format";
 240         case ENOENT:
 241                 return "unknown symbol in module or invalid parameter";
 242         case ESRCH:
 243                 return "module has wrong symbol version";
 244         case EINVAL: /* "invalid parameter" */
 245                 return "unknown symbol in module or invalid parameter"
 246                 + sizeof("unknown symbol in module or");
 247         default:
 248                 return strerror(err);
 249         }
 250 }
 251
 252 static int load_module(const char *fname, const char *options)
 253 {
 254 #if 1
 255         int r;
 256         size_t len = MAXINT(ssize_t);
 257         char *module_image;
 258
 259         if (!options)
 260                 options = "";
 261
 262         dbg1_error_msg("load_module('%s','%s')", fname, options);
 263
 264         /*
 265          * First we try finit_module if available.  Some kernels are configured
 266          * to only allow loading of modules off of secure storage (like a read-
 267          * only rootfs) which needs the finit_module call.  If it fails, we fall
 268          * back to normal module loading to support compressed modules.
 269          */
 270         r = 1;
 271 # ifdef __NR_finit_module
 272         {
 273                 int fd = open(fname, O_RDONLY | O_CLOEXEC);
 274                 if (fd >= 0) {
 275                         r = finit_module(fd, options, 0) != 0;
 276                         close(fd);
 277                 }
 278         }
 279 # endif
 280         if (r != 0) {
 281                 module_image = xmalloc_open_zipped_read_close(fname, &len);
 282                 r = (!module_image || init_module(module_image, len, options) != 0);
 283                 free(module_image);
 284         }
 285
 286         dbg1_error_msg("load_module:%d", r);
 287         return r; /* 0 = success */
 288 #else
 289         /* For testing */
 290         dbg1_error_msg("load_module('%s','%s')", fname, options);
 291         return 1;
 292 #endif
 293 }
 294
 295 /* Returns !0 if open/read was unsuccessful */
 296 static int parse_module(module_info *info, const char *pathname)
 297 {
 298         char *module_image;
 299         char *ptr;
 300         size_t len;
 301         size_t pos;
 302         dbg1_error_msg("parse_module('%s')", pathname);
 303
 304         /* Read (possibly compressed) module */
 305         errno = 0;
 306         len = 64 * 1024 * 1024; /* 64 Mb at most */
 307         module_image = xmalloc_open_zipped_read_close(pathname, &len);
 308         /* module_image == NULL is ok here, find_keyword handles it */
 309 //TODO: optimize redundant module body reads
 310
 311         /* "alias1 symbol:sym1 alias2 symbol:sym2" */
 312         reset_stringbuf();
 313         pos = 0;
 314         while (1) {
 315                 unsigned start = stringbuf_idx;
 316                 ptr = find_keyword(module_image + pos, len - pos, "alias=");
 317                 if (!ptr) {
 318                         ptr = find_keyword(module_image + pos, len - pos, "__ksymtab_");
 319                         if (!ptr)
 320                                 break;
 321                         /* DOCME: __ksymtab_gpl and __ksymtab_strings occur
 322                          * in many modules. What do they mean? */
 323                         if (strcmp(ptr, "gpl") == 0 || strcmp(ptr, "strings") == 0)
 324                                 goto skip;
 325                         dbg2_error_msg("alias:'symbol:%s'", ptr);
 326                         append("symbol:");
 327                 } else {
 328                         dbg2_error_msg("alias:'%s'", ptr);
 329                 }
 330                 append(ptr);
 331                 appendc(' ');
 332                 /*
 333                  * Don't add redundant aliases, such as:
 334                  * libcrc32c.ko symbol:crc32c symbol:crc32c
 335                  */
 336                 if (start) { /* "if we aren't the first alias" */
 337                         char *found, *last;
 338                         stringbuf[stringbuf_idx] = '\0';
 339                         last = stringbuf + start;
 340                         /*
 341                          * String at last-1 is " symbol:crc32c "
 342                          * (with both leading and trailing spaces).
 343                          */
 344                         if (strncmp(stringbuf, last, stringbuf_idx - start) == 0)
 345                                 /* First alias matches us */
 346                                 found = stringbuf;
 347                         else
 348                                 /* Does any other alias match? */
 349                                 found = strstr(stringbuf, last-1);
 350                         if (found < last-1) {
 351                                 /* There is absolutely the same string before us */
 352                                 dbg2_error_msg("redundant:'%s'", last);
 353                                 stringbuf_idx = start;
 354                                 goto skip;
 355                         }
 356                 }
 357  skip:
 358                 pos = (ptr - module_image);
 359         }
 360         bksp(); /* remove last ' ' */
 361         info->aliases = copy_stringbuf();
 362         replace(info->aliases, '-', '_');
 363
 364         /* "dependency1 depandency2" */
 365         reset_stringbuf();
 366         ptr = find_keyword(module_image, len, "depends=");
 367         if (ptr && *ptr) {
 368                 replace(ptr, ',', ' ');
 369                 replace(ptr, '-', '_');
 370                 dbg2_error_msg("dep:'%s'", ptr);
 371                 append(ptr);
 372         }
 373         free(module_image);
 374         info->deps = copy_stringbuf();
 375
 376         info->open_read_failed = (module_image == NULL);
 377         return info->open_read_failed;
 378 }
 379
 380 static FAST_FUNC int fileAction(const char *pathname,
 381                 struct stat *sb UNUSED_PARAM,
 382                 void *modname_to_match,
 383                 int depth UNUSED_PARAM)
 384 {
 385         int cur;
 386         const char *fname;
 387         bool is_remove = (ENABLE_RMMOD && ONLY_APPLET)
 388                 || ((ENABLE_RMMOD || ENABLE_MODPROBE) && (option_mask32 & OPT_r));
 389
 390         pathname += 2; /* skip "./" */
 391         fname = bb_get_last_path_component_nostrip(pathname);
 392         if (!strrstr(fname, ".ko")) {
 393                 dbg1_error_msg("'%s' is not a module", pathname);
 394                 return TRUE; /* not a module, continue search */
 395         }
 396
 397         cur = module_count++;
 398         modinfo = xrealloc_vector(modinfo, 12, cur);
 399         modinfo[cur].pathname = xstrdup(pathname);
 400         /*modinfo[cur].aliases = NULL; - xrealloc_vector did it */
 401         /*modinfo[cur+1].pathname = NULL;*/
 402
 403         if (!pathname_matches_modname(fname, modname_to_match)) {
 404                 dbg1_error_msg("'%s' module name doesn't match", pathname);
 405                 return TRUE; /* module name doesn't match, continue search */
 406         }
 407
 408         dbg1_error_msg("'%s' module name matches", pathname);
 409         module_found_idx = cur;
 410         if (parse_module(&modinfo[cur], pathname) != 0)
 411                 return TRUE; /* failed to open/read it, no point in trying loading */
 412
 413         if (!is_remove) {
 414                 if (load_module(pathname, module_load_options) == 0) {
 415                         /* Load was successful, there is nothing else to do.
 416                          * This can happen ONLY for "top-level" module load,
 417                          * not a dep, because deps don't do dirscan. */
 418                         exit(EXIT_SUCCESS);
 419                 }
 420         }
 421
 422         return TRUE;
 423 }
 424
 425 static int load_dep_bb(void)
 426 {
 427         char *line;
 428         FILE *fp = fopen_for_read(DEPFILE_BB);
 429
 430         if (!fp)
 431                 return 0;
 432
 433         dep_bb_seen = 1;
 434         dbg1_error_msg("loading "DEPFILE_BB);
 435
 436         /* Why? There is a rare scenario: we did not find modprobe.dep.bb,
 437          * we scanned the dir and found no module by name, then we search
 438          * for alias (full scan), and we decided to generate modprobe.dep.bb.
 439          * But we see modprobe.dep.bb.new! Other modprobe is at work!
 440          * We wait and other modprobe renames it to modprobe.dep.bb.
 441          * Now we can use it.
 442          * But we already have modinfo[] filled, and "module_count = 0"
 443          * makes us start anew. Yes, we leak modinfo[].xxx pointers -
 444          * there is not much of data there anyway. */
 445         module_count = 0;
 446         memset(&modinfo[0], 0, sizeof(modinfo[0]));
 447
 448         while ((line = xmalloc_fgetline(fp)) != NULL) {
 449                 char* space;
 450                 char* linebuf;
 451                 int cur;
 452
 453                 if (!line[0]) {
 454                         free(line);
 455                         continue;
 456                 }
 457                 space = strchrnul(line, ' ');
 458                 cur = module_count++;
 459                 modinfo = xrealloc_vector(modinfo, 12, cur);
 460                 /*modinfo[cur+1].pathname = NULL; - xrealloc_vector did it */
 461                 modinfo[cur].pathname = line; /* we take ownership of malloced block here */
 462                 if (*space)
 463                         *space++ = '\0';
 464                 modinfo[cur].aliases = space;
 465                 linebuf = xmalloc_fgetline(fp);
 466                 modinfo[cur].deps = linebuf ? linebuf : xzalloc(1);
 467                 if (modinfo[cur].deps[0]) {
 468                         /* deps are not "", so next line must be empty */
 469                         line = xmalloc_fgetline(fp);
 470                         /* Refuse to work with damaged config file */
 471                         if (line && line[0])
 472                                 bb_error_msg_and_die("error in %s at '%s'", DEPFILE_BB, line);
 473                         free(line);
 474                 }
 475         }
 476         return 1;
 477 }
 478
 479 static int start_dep_bb_writeout(void)
 480 {
 481         int fd;
 482
 483         /* depmod -n: write result to stdout */
 484         if (is_depmod && (option_mask32 & DEPMOD_OPT_n))
 485                 return STDOUT_FILENO;
 486
 487         fd = open(DEPFILE_BB".new", O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, 0644);
 488         if (fd < 0) {
 489                 if (errno == EEXIST) {
 490                         int count = 5 * 20;
 491                         dbg1_error_msg(DEPFILE_BB".new exists, waiting for "DEPFILE_BB);
 492                         while (1) {
 493                                 usleep(1000*1000 / 20);
 494                                 if (load_dep_bb()) {
 495                                         dbg1_error_msg(DEPFILE_BB" appeared");
 496                                         return -2; /* magic number */
 497                                 }
 498                                 if (!--count)
 499                                         break;
 500                         }
 501                         bb_error_msg("deleting stale %s", DEPFILE_BB".new");
 502                         fd = open_or_warn(DEPFILE_BB".new", O_WRONLY | O_CREAT | O_TRUNC);
 503                 }
 504         }
 505         dbg1_error_msg("opened "DEPFILE_BB".new:%d", fd);
 506         return fd;
 507 }
 508
 509 static void write_out_dep_bb(int fd)
 510 {
 511         int i;
 512         FILE *fp;
 513
 514         /* We want good error reporting. fdprintf is not good enough. */
 515         fp = xfdopen_for_write(fd);
 516         i = 0;
 517         while (modinfo[i].pathname) {
 518                 fprintf(fp, "%s%s%s\n" "%s%s\n",
 519                         modinfo[i].pathname, modinfo[i].aliases[0] ? " " : "", modinfo[i].aliases,
 520                         modinfo[i].deps, modinfo[i].deps[0] ? "\n" : "");
 521                 i++;
 522         }
 523         /* Badly formatted depfile is a no-no. Be paranoid. */
 524         errno = 0;
 525         if (ferror(fp) | fclose(fp)) /* | instead of || is intended */
 526                 goto err;
 527
 528         if (fd == STDOUT_FILENO) /* it was depmod -n */
 529                 goto ok;
 530
 531         if (rename(DEPFILE_BB".new", DEPFILE_BB) != 0) {
 532  err:
 533                 bb_perror_msg("can't create '%s'", DEPFILE_BB);
 534                 unlink(DEPFILE_BB".new");
 535         } else {
 536  ok:
 537                 wrote_dep_bb_ok = 1;
 538                 dbg1_error_msg("created "DEPFILE_BB);
 539         }
 540 }
 541
 542 static module_info** find_alias(const char *alias)
 543 {
 544         int i;
 545         int dep_bb_fd;
 546         int infoidx;
 547         module_info **infovec;
 548         dbg1_error_msg("find_alias('%s')", alias);
 549
 550  try_again:
 551         /* First try to find by name (cheaper) */
 552         i = 0;
 553         while (modinfo[i].pathname) {
 554                 if (pathname_matches_modname(modinfo[i].pathname, alias)) {
 555                         dbg1_error_msg("found '%s' in module '%s'",
 556                                         alias, modinfo[i].pathname);
 557                         if (!modinfo[i].aliases) {
 558                                 parse_module(&modinfo[i], modinfo[i].pathname);
 559                         }
 560                         infovec = xzalloc(2 * sizeof(infovec[0]));
 561                         infovec[0] = &modinfo[i];
 562                         return infovec;
 563                 }
 564                 i++;
 565         }
 566
 567         /* Ok, we definitely have to scan module bodies. This is a good
 568          * moment to generate modprobe.dep.bb, if it does not exist yet */
 569         dep_bb_fd = dep_bb_seen ? -1 : start_dep_bb_writeout();
 570         if (dep_bb_fd == -2) /* modprobe.dep.bb appeared? */
 571                 goto try_again;
 572
 573         /* Scan all module bodies, extract modinfo (it contains aliases) */
 574         i = 0;
 575         infoidx = 0;
 576         infovec = NULL;
 577         while (modinfo[i].pathname) {
 578                 char *desc, *s;
 579                 if (!modinfo[i].aliases) {
 580                         parse_module(&modinfo[i], modinfo[i].pathname);
 581                 }
 582                 /* "alias1 symbol:sym1 alias2 symbol:sym2" */
 583                 desc = str_2_list(modinfo[i].aliases);
 584                 /* Does matching substring exist? */
 585                 for (s = desc; *s; s += strlen(s) + 1) {
 586                         /* Aliases in module bodies can be defined with
 587                          * shell patterns. Example:
 588                          * "pci:v000010DEd000000D9sv*sd*bc*sc*i*".
 589                          * Plain strcmp() won't catch that */
 590                         if (fnmatch(s, alias, 0) == 0) {
 591                                 dbg1_error_msg("found alias '%s' in module '%s'",
 592                                                 alias, modinfo[i].pathname);
 593                                 infovec = xrealloc_vector(infovec, 1, infoidx);
 594                                 infovec[infoidx++] = &modinfo[i];
 595                                 break;
 596                         }
 597                 }
 598                 free(desc);
 599                 i++;
 600         }
 601
 602         /* Create module.dep.bb if needed */
 603         if (dep_bb_fd >= 0) {
 604                 write_out_dep_bb(dep_bb_fd);
 605         }
 606
 607         dbg1_error_msg("find_alias '%s' returns %d results", alias, infoidx);
 608         return infovec;
 609 }
 610
 611 #if ENABLE_FEATURE_MODPROBE_SMALL_CHECK_ALREADY_LOADED
 612 // TODO: open only once, invent config_rewind()
 613 static int already_loaded(const char *name)
 614 {
 615         int ret;
 616         char *line;
 617         FILE *fp;
 618
 619         ret = 5 * 2;
 620  again:
 621         fp = fopen_for_read("/proc/modules");
 622         if (!fp)
 623                 return 0;
 624         while ((line = xmalloc_fgetline(fp)) != NULL) {
 625                 char *live;
 626                 char *after_name;
 627
 628                 // Examples from kernel 3.14.6:
 629                 //pcspkr 12718 0 - Live 0xffffffffa017e000
 630                 //snd_timer 28690 2 snd_seq,snd_pcm, Live 0xffffffffa025e000
 631                 //i915 801405 2 - Live 0xffffffffa0096000
 632                 after_name = is_prefixed_with(line, name);
 633                 if (!after_name || *after_name != ' ') {
 634                         free(line);
 635                         continue;
 636                 }
 637                 live = strstr(line, " Live");
 638                 free(line);
 639                 if (!live) {
 640                         /* State can be Unloading, Loading, or Live.
 641                          * modprobe must not return prematurely if we see "Loading":
 642                          * it can cause further programs to assume load completed,
 643                          * but it did not (yet)!
 644                          * Wait up to 5*20 ms for it to resolve.
 645                          */
 646                         ret -= 2;
 647                         if (ret == 0)
 648                                 break;  /* huh? report as "not loaded" */
 649                         fclose(fp);
 650                         usleep(20*1000);
 651                         goto again;
 652                 }
 653                 ret = 1;
 654                 break;
 655         }
 656         fclose(fp);
 657
 658         return ret & 1;
 659 }
 660 #else
 661 #define already_loaded(name) 0
 662 #endif
 663
 664 static int rmmod(const char *filename)
 665 {
 666         int r;
 667         char modname[MODULE_NAME_LEN];
 668
 669         filename2modname(filename, modname);
 670         r = delete_module(modname, O_NONBLOCK | O_EXCL);
 671         dbg1_error_msg("delete_module('%s', O_NONBLOCK | O_EXCL):%d", modname, r);
 672         if (r != 0 && !(option_mask32 & OPT_q)) {
 673                 bb_perror_msg("remove '%s'", modname);
 674         }
 675         return r;
 676 }
 677
 678 /*
 679  * Given modules definition and module name (or alias, or symbol)
 680  * load/remove the module respecting dependencies.
 681  * NB: also called by depmod with bogus name "/",
 682  * just in order to force modprobe.dep.bb creation.
 683 */
 684 #if !ENABLE_FEATURE_CMDLINE_MODULE_OPTIONS
 685 #define process_module(a,b) process_module(a)
 686 #define cmdline_options ""
 687 #endif
 688 static int process_module(char *name, const char *cmdline_options)
 689 {
 690         char *s, *deps, *options;
 691         module_info **infovec;
 692         module_info *info;
 693         int infoidx;
 694         bool is_remove = (ENABLE_RMMOD && ONLY_APPLET)
 695                 || ((ENABLE_RMMOD || ENABLE_MODPROBE) && (option_mask32 & OPT_r));
 696         int exitcode = EXIT_SUCCESS;
 697
 698         dbg1_error_msg("process_module('%s','%s')", name, cmdline_options);
 699
 700         replace(name, '-', '_');
 701
 702         dbg1_error_msg("already_loaded:%d is_remove:%d", already_loaded(name), is_remove);
 703
 704         if (is_rmmod) {
 705                 /* Does not remove dependencies, no need to scan, just remove.
 706                  * (compat note: this allows and strips .ko suffix)
 707                  */
 708                 rmmod(name);
 709                 return EXIT_SUCCESS;
 710         }
 711
 712         /*
 713          * We used to have "is_remove != already_loaded(name)" check here, but
 714          *  modprobe -r pci:v00008086d00007010sv00000000sd00000000bc01sc01i80
 715          * won't unload modules (there are more than one)
 716          * which have this alias.
 717          */
 718         if (!is_remove && already_loaded(name)) {
 719                 dbg1_error_msg("nothing to do for '%s'", name);
 720                 return EXIT_SUCCESS;
 721         }
 722
 723         options = NULL;
 724         if (!is_remove) {
 725                 char *opt_filename = xasprintf("/etc/modules/%s", name);
 726                 options = xmalloc_open_read_close(opt_filename, NULL);
 727                 if (options)
 728                         replace(options, '\n', ' ');
 729 #if ENABLE_FEATURE_CMDLINE_MODULE_OPTIONS
 730                 if (cmdline_options) {
 731                         /* NB: cmdline_options always have one leading ' '
 732                          * (see main()), we remove it here */
 733                         char *op = xasprintf(options ? "%s %s" : "%s %s" + 3,
 734                                                 cmdline_options + 1, options);
 735                         free(options);
 736                         options = op;
 737                 }
 738 #endif
 739                 free(opt_filename);
 740                 module_load_options = options;
 741                 dbg1_error_msg("process_module('%s'): options:'%s'", name, options);
 742         }
 743
 744         if (!module_count) {
 745                 /* Scan module directory. This is done only once.
 746                  * It will attempt module load, and will exit(EXIT_SUCCESS)
 747                  * on success.
 748                  */
 749                 module_found_idx = -1;
 750                 recursive_action(".",
 751                         ACTION_RECURSE, /* flags */
 752                         fileAction, /* file action */
 753                         NULL, /* dir action */
 754                         name, /* user data */
 755                         0 /* depth */
 756                 );
 757                 dbg1_error_msg("dirscan complete");
 758                 /* Module was not found, or load failed, or is_remove */
 759                 if (module_found_idx >= 0) { /* module was found */
 760                         infovec = xzalloc(2 * sizeof(infovec[0]));
 761                         infovec[0] = &modinfo[module_found_idx];
 762                 } else { /* search for alias, not a plain module name */
 763                         infovec = find_alias(name);
 764                 }
 765         } else {
 766                 infovec = find_alias(name);
 767         }
 768
 769         if (!infovec) {
 770                 /* both dirscan and find_alias found nothing */
 771                 if (!is_remove && !is_depmod) { /* it wasn't rmmod or depmod */
 772                         bb_error_msg("module '%s' not found", name);
 773 //TODO: _and_die()? or should we continue (un)loading modules listed on cmdline?
 774                         /* "modprobe non-existing-module; echo $?" must print 1 */
 775                         exitcode = EXIT_FAILURE;
 776                 }
 777                 goto ret;
 778         }
 779
 780         /* There can be more than one module for the given alias. For example,
 781          * "pci:v00008086d00007010sv00000000sd00000000bc01sc01i80" matches
 782          * ata_piix because it has alias "pci:v00008086d00007010sv*sd*bc*sc*i*"
 783          * and ata_generic, it has alias "pci:v*d*sv*sd*bc01sc01i*"
 784          * Standard modprobe loads them both. We achieve it by returning
 785          * a *list* of modinfo pointers from find_alias().
 786          */
 787
 788         /* modprobe -r? unload module(s) */
 789         if (is_remove) {
 790                 infoidx = 0;
 791                 while ((info = infovec[infoidx++]) != NULL) {
 792                         int r = rmmod(bb_get_last_path_component_nostrip(info->pathname));
 793                         if (r != 0) {
 794                                 goto ret; /* error */
 795                         }
 796                 }
 797                 /* modprobe -r: we do not stop here -
 798                  * continue to unload modules on which the module depends:
 799                  * "-r --remove: option causes modprobe to remove a module.
 800                  * If the modules it depends on are also unused, modprobe
 801                  * will try to remove them, too."
 802                  */
 803         }
 804
 805         infoidx = 0;
 806         while ((info = infovec[infoidx++]) != NULL) {
 807                 /* Iterate thru dependencies, trying to (un)load them */
 808                 deps = str_2_list(info->deps);
 809                 for (s = deps; *s; s += strlen(s) + 1) {
 810                         //if (strcmp(name, s) != 0) // N.B. do loops exist?
 811                         dbg1_error_msg("recurse on dep '%s'", s);
 812                         process_module(s, NULL);
 813                         dbg1_error_msg("recurse on dep '%s' done", s);
 814                 }
 815                 free(deps);
 816
 817                 if (is_remove)
 818                         continue;
 819
 820                 /* We are modprobe: load it */
 821                 if (options && strstr(options, "blacklist")) {
 822                         dbg1_error_msg("'%s': blacklisted", info->pathname);
 823                         continue;
 824                 }
 825                 if (info->open_read_failed) {
 826                         /* We already tried it, didn't work. Don't try load again */
 827                         exitcode = EXIT_FAILURE;
 828                         continue;
 829                 }
 830                 errno = 0;
 831                 if (load_module(info->pathname, options) != 0) {
 832                         if (EEXIST != errno) {
 833                                 bb_error_msg("'%s': %s",
 834                                         info->pathname,
 835                                         moderror(errno));
 836                         } else {
 837                                 dbg1_error_msg("'%s': %s",
 838                                         info->pathname,
 839                                         moderror(errno));
 840                         }
 841                         exitcode = EXIT_FAILURE;
 842                 }
 843         }
 844  ret:
 845         free(infovec);
 846         free(options);
 847
 848         return exitcode;
 849 }
 850 #undef cmdline_options
 851
 852
 853 /* For reference, module-init-tools v3.4 options:
 854
 855 # insmod
 856 Usage: insmod filename [args]
 857
 858 # rmmod --help
 859 Usage: rmmod [-fhswvV] modulename ...
 860  -f (or --force) forces a module unload, and may crash your
 861     machine. This requires the Forced Module Removal option
 862     when the kernel was compiled.
 863  -h (or --help) prints this help text
 864  -s (or --syslog) says use syslog, not stderr
 865  -v (or --verbose) enables more messages
 866  -V (or --version) prints the version code
 867  -w (or --wait) begins module removal even if it is used
 868     and will stop new users from accessing the module (so it
 869     should eventually fall to zero).
 870
 871 # modprobe
 872 Usage: modprobe [-v] [-V] [-C config-file] [-d <dirname> ] [-n] [-i] [-q]
 873     [-b] [-o <modname>] [ --dump-modversions ] <modname> [parameters...]
 874 modprobe -r [-n] [-i] [-v] <modulename> ...
 875 modprobe -l -t <dirname> [ -a <modulename> ...]
 876
 877 # depmod --help
 878 depmod 3.13 -- part of module-init-tools
 879 depmod -[aA] [-n -e -v -q -V -r -u -w -m]
 880       [-b basedirectory] [forced_version]
 881 depmod [-n -e -v -q -r -u -w] [-F kernelsyms] module1.ko module2.ko ...
 882 If no arguments (except options) are given, "depmod -a" is assumed.
 883 depmod will output a dependency list suitable for the modprobe utility.
 884 Options:
 885     -a, --all           Probe all modules
 886     -A, --quick         Only does the work if there's a new module
 887     -e, --errsyms       Report not supplied symbols
 888     -m, --map           Create the legacy map files
 889     -n, --show          Write the dependency file on stdout only
 890     -P, --symbol-prefix Architecture symbol prefix
 891     -V, --version       Print the release version
 892     -v, --verbose       Enable verbose mode
 893     -w, --warn          Warn on duplicates
 894     -h, --help          Print this usage message
 895 The following options are useful for people managing distributions:
 896     -b basedirectory
 897     --basedir basedirectory
 898                         Use an image of a module tree
 899     -F kernelsyms
 900     --filesyms kernelsyms
 901                         Use the file instead of the current kernel symbols
 902     -E Module.symvers
 903     --symvers Module.symvers
 904                         Use Module.symvers file to check symbol versions
 905 */
 906
 907 //usage:#if ENABLE_MODPROBE_SMALL
 908
 909 //usage:#define depmod_trivial_usage "[-n]"
 910 //usage:#define depmod_full_usage "\n\n"
 911 //usage:       "Generate modules.dep.bb"
 912 //usage:     "\n"
 913 //usage:     "\n        -n      Dry run: print file to stdout"
 914
 915 //usage:#define insmod_trivial_usage
 916 //usage:        "FILE" IF_FEATURE_CMDLINE_MODULE_OPTIONS(" [SYMBOL=VALUE]...")
 917 //usage:#define insmod_full_usage "\n\n"
 918 //usage:       "Load kernel module"
 919
 920 //usage:#define rmmod_trivial_usage
 921 //usage:       "MODULE..."
 922 //usage:#define rmmod_full_usage "\n\n"
 923 //usage:       "Unload kernel modules"
 924
 925 //usage:#define modprobe_trivial_usage
 926 //usage:        "[-rq] MODULE" IF_FEATURE_CMDLINE_MODULE_OPTIONS(" [SYMBOL=VALUE]...")
 927 //usage:#define modprobe_full_usage "\n\n"
 928 //usage:       "        -r      Remove MODULE"
 929 //usage:     "\n        -q      Quiet"
 930
 931 //usage:#endif
 932
 933 int modprobe_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 934 int modprobe_main(int argc UNUSED_PARAM, char **argv)
 935 {
 936 #if ENABLE_MODPROBE || ENABLE_INSMOD || ENABLE_RMMOD
 937         int exitcode;
 938 #endif
 939         struct utsname uts;
 940         IF_FEATURE_CMDLINE_MODULE_OPTIONS(char *options = NULL;)
 941
 942         INIT_G();
 943
 944         /* Prevent ugly corner cases with no modules at all */
 945         modinfo = xzalloc(sizeof(modinfo[0]));
 946
 947         if ((MOD_APPLET_CNT == 2 && ENABLE_DEPMOD && ENABLE_MODPROBE)
 948          || is_depmod || is_modprobe
 949         ) {
 950                 /* Goto modules directory */
 951                 xchdir(CONFIG_DEFAULT_MODULES_DIR);
 952                 uname(&uts); /* never fails */
 953         }
 954
 955         /* depmod? */
 956         if (is_depmod) {
 957                 /* Supported:
 958                  * -n: print result to stdout
 959                  * -a: process all modules (default)
 960                  * optional VERSION parameter
 961                  * Ignored:
 962                  * -A: do work only if a module is newer than depfile
 963                  * -e: report any symbols which a module needs
 964                  *  which are not supplied by other modules or the kernel
 965                  * -F FILE: System.map (symbols for -e)
 966                  * -q, -r, -u: noop
 967                  * Not supported:
 968                  * -b BASEDIR: (TODO!) modules are in
 969                  *  $BASEDIR/lib/modules/$VERSION
 970                  * -m: create legacy "modules.*map" files (deprecated; in
 971                  *  kmod's depmod, prints a warning message and continues)
 972                  * -v: human readable deps to stdout
 973                  * -V: version (don't want to support it - people may depend
 974                  *  on it as an indicator of "standard" depmod)
 975                  * -h: help (well duh)
 976                  * module1.o module2.o parameters (just ignored for now)
 977                  */
 978                 getopt32(argv, "na" "AeF:qru" /* "b:vV", NULL */, NULL);
 979                 argv += optind;
 980                 /* if (argv[0] && argv[1]) bb_show_usage(); */
 981                 /* Goto $VERSION directory */
 982                 xchdir(argv[0] ? argv[0] : uts.release);
 983                 /* Force full module scan by asking to find a bogus module.
 984                  * This will generate modules.dep.bb as a side effect. */
 985                 process_module((char*)"/", NULL);
 986                 return !wrote_dep_bb_ok;
 987         }
 988
 989 #if ENABLE_MODPROBE || ENABLE_INSMOD || ENABLE_RMMOD
 990         /* modprobe, insmod, rmmod require at least one argument */
 991         /* only -q (quiet) and -r (rmmod),
 992          * the rest are accepted and ignored (compat) */
 993         getopt32(argv, "^" "qrfsvwb" "\0" "-1");
 994         argv += optind;
 995
 996         if (is_modprobe) {
 997                 /* Goto $VERSION directory */
 998                 xchdir(uts.release);
 999         }
1000
1001         /* are we rmmod? -> simulate modprobe -r, but don't bother the flag if
1002          * there're no other applets here */
1003         if (is_rmmod) {
1004                 if (!ONLY_APPLET)
1005                         option_mask32 |= OPT_r;
1006         } else if (!ENABLE_MODPROBE || !(option_mask32 & OPT_r)) {
1007 # if ENABLE_FEATURE_CMDLINE_MODULE_OPTIONS
1008         /* If not rmmod/-r, parse possible module options given on command line.
1009          * insmod/modprobe takes one module name, the rest are parameters. */
1010                 char **arg = argv;
1011                 while (*++arg) {
1012                         /* Enclose options in quotes */
1013                         char *s = options;
1014                         options = xasprintf("%s \"%s\"", s ? s : "", *arg);
1015                         free(s);
1016                         *arg = NULL;
1017                 }
1018 # else
1019                 argv[1] = NULL;
1020 # endif
1021         }
1022
1023         if (is_insmod) {
1024                 size_t len;
1025                 void *map;
1026
1027                 len = MAXINT(ssize_t);
1028                 map = xmalloc_open_zipped_read_close(*argv, &len);
1029                 if (!map)
1030                         bb_perror_msg_and_die("can't read '%s'", *argv);
1031                 if (init_module(map, len,
1032                         (IF_FEATURE_CMDLINE_MODULE_OPTIONS(options ? options : ) "")
1033                         ) != 0
1034                 ) {
1035                         bb_error_msg_and_die("can't insert '%s': %s",
1036                                         *argv, moderror(errno));
1037                 }
1038                 return EXIT_SUCCESS;
1039         }
1040
1041         /* Try to load modprobe.dep.bb */
1042         if (!is_rmmod) {
1043                 load_dep_bb();
1044         }
1045
1046         /* Load/remove modules.
1047          * Only rmmod/modprobe -r loops here, insmod/modprobe has only argv[0] */
1048         exitcode = EXIT_SUCCESS;
1049         do {
1050                 exitcode |= process_module(*argv, options);
1051         } while (*++argv);
1052
1053         if (ENABLE_FEATURE_CLEAN_UP) {
1054                 IF_FEATURE_CMDLINE_MODULE_OPTIONS(free(options);)
1055         }
1056         return exitcode;
1057 #endif /* MODPROBE || INSMOD || RMMOD */
1058 }
1059
1060 #endif /* MOD_APPLET_CNT > 0 */