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