path: root/modutils/modprobe-small.c (plain)
blob: 652ff4dfa984ec0e4792be91f0efbe3842de4a0e

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	extern int init_module(void *module, unsigned long len, const char *options);
43	extern int delete_module(const char *module, unsigned 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
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
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
123	static void bksp(void)
124	{
125	if (stringbuf_idx)
126	stringbuf_idx--;
127	}
128
129	static void reset_stringbuf(void)
130	{
131	stringbuf_idx = 0;
132	}
133
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
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
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
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
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 */
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... */
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
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 */
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
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
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
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
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
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()
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
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
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;
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