xref: /netbsd-src/sys/kern/kern_module.c (revision 2de962bd804263c16657f586aa00f1704045df8e)
1 /*	$NetBSD: kern_module.c,v 1.20 2008/05/20 19:20:38 ad Exp $	*/
2 
3 /*-
4  * Copyright (c) 2008 The NetBSD Foundation, Inc.
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
17  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
18  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
20  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26  * POSSIBILITY OF SUCH DAMAGE.
27  */
28 
29 /*
30  * Kernel module support.
31  */
32 
33 #include "opt_modular.h"
34 
35 #include <sys/cdefs.h>
36 __KERNEL_RCSID(0, "$NetBSD: kern_module.c,v 1.20 2008/05/20 19:20:38 ad Exp $");
37 
38 #include <sys/param.h>
39 #include <sys/systm.h>
40 #include <sys/fcntl.h>
41 #include <sys/proc.h>
42 #include <sys/kauth.h>
43 #include <sys/kobj.h>
44 #include <sys/kmem.h>
45 #include <sys/module.h>
46 #include <sys/kauth.h>
47 
48 #include <uvm/uvm_extern.h>
49 
50 #include <machine/stdarg.h>
51 
52 #ifndef LKM	/* XXX */
53 struct vm_map *lkm_map;
54 #endif
55 
56 struct modlist	module_list = TAILQ_HEAD_INITIALIZER(module_list);
57 struct modlist	module_bootlist = TAILQ_HEAD_INITIALIZER(module_bootlist);
58 static module_t	*module_active;
59 static char	module_base[64];
60 u_int		module_count;
61 kmutex_t	module_lock;
62 
63 /* Ensure that the kernel's link set isn't empty. */
64 static modinfo_t module_dummy;
65 __link_set_add_rodata(modules, module_dummy);
66 
67 static module_t	*module_lookup(const char *);
68 static int	module_do_load(const char *, bool, int, prop_dictionary_t,
69 		    module_t **, modclass_t class, bool);
70 static int	module_do_unload(const char *);
71 static void	module_error(const char *, ...);
72 static int	module_do_builtin(const char *, module_t **);
73 static int	module_fetch_info(module_t *);
74 
75 /*
76  * module_error:
77  *
78  *	Utility function: log an error.
79  */
80 static void
81 module_error(const char *fmt, ...)
82 {
83 	va_list ap;
84 
85 	va_start(ap, fmt);
86 	printf("WARNING: module error: ");
87 	vprintf(fmt, ap);
88 	printf("\n");
89 	va_end(ap);
90 }
91 
92 /*
93  * module_init:
94  *
95  *	Initialize the module subsystem.
96  */
97 void
98 module_init(void)
99 {
100 	extern struct vm_map *lkm_map;
101 
102 	if (lkm_map == NULL)
103 		lkm_map = kernel_map;
104 	mutex_init(&module_lock, MUTEX_DEFAULT, IPL_NONE);
105 #ifdef MODULAR	/* XXX */
106 	module_init_md();
107 #endif
108 
109 #if __NetBSD_Version__ / 1000000 % 100 == 99	/* -current */
110 	snprintf(module_base, sizeof(module_base), "/stand/%s/%s/modules",
111 	    machine, osrelease);
112 #else						/* release */
113 	snprintf(module_base, sizeof(module_base), "/stand/%s/%d.%d/modules",
114 	    machine, __NetBSD_Version__ / 100000000,
115 	    __NetBSD_Version__ / 1000000 % 100);
116 #endif
117 }
118 
119 /*
120  * module_init_class:
121  *
122  *	Initialize all built-in and pre-loaded modules of the
123  *	specified class.
124  */
125 void
126 module_init_class(modclass_t class)
127 {
128 	__link_set_decl(modules, modinfo_t);
129 	modinfo_t *const *mip, *mi;
130 	module_t *mod;
131 
132 	mutex_enter(&module_lock);
133 	/*
134 	 * Builtins first.  These can't depend on pre-loaded modules.
135 	 */
136 	__link_set_foreach(mip, modules) {
137 		mi = *mip;
138 		if (mi == &module_dummy) {
139 			continue;
140 		}
141 		if (class != MODULE_CLASS_ANY && class != mi->mi_class) {
142 			continue;
143 		}
144 		(void)module_do_builtin(mi->mi_name, NULL);
145 	}
146 	/*
147 	 * Now preloaded modules.  These will be pulled off the
148 	 * list as we call module_do_load();
149 	 */
150 	do {
151 		TAILQ_FOREACH(mod, &module_bootlist, mod_chain) {
152 			mi = mod->mod_info;
153 			if (class != MODULE_CLASS_ANY &&
154 			    class != mi->mi_class)
155 				continue;
156 			module_do_load(mi->mi_name, false, 0, NULL, NULL,
157 			    class, true);
158 			break;
159 		}
160 	} while (mod != NULL);
161 	mutex_exit(&module_lock);
162 }
163 
164 /*
165  * module_jettison:
166  *
167  *	Return memory used by pre-loaded modules to the freelist.
168  */
169 void
170 module_jettison(void)
171 {
172 
173 	/* XXX nothing yet */
174 }
175 
176 /*
177  * module_load:
178  *
179  *	Load a single module from the file system.
180  */
181 int
182 module_load(const char *filename, int flags, prop_dictionary_t props,
183 	    modclass_t class, bool autoload)
184 {
185 	int error;
186 
187 	/* Authorize. */
188 	error = kauth_authorize_system(kauth_cred_get(), KAUTH_SYSTEM_MODULE,
189 	    0, (void *)(uintptr_t)MODCTL_LOAD, NULL, NULL);
190 	if (error != 0) {
191 		return error;
192 	}
193 
194 	mutex_enter(&module_lock);
195 	error = module_do_load(filename, false, flags, props, NULL, class,
196 	    autoload);
197 	mutex_exit(&module_lock);
198 
199 	return error;
200 }
201 
202 /*
203  * module_unload:
204  *
205  *	Find and unload a module by name.
206  */
207 int
208 module_unload(const char *name)
209 {
210 	int error;
211 
212 	/* Authorize. */
213 	error = kauth_authorize_system(kauth_cred_get(), KAUTH_SYSTEM_MODULE,
214 	    0, (void *)(uintptr_t)MODCTL_UNLOAD, NULL, NULL);
215 	if (error != 0) {
216 		return error;
217 	}
218 
219 	mutex_enter(&module_lock);
220 	error = module_do_unload(name);
221 	mutex_exit(&module_lock);
222 
223 	return error;
224 }
225 
226 /*
227  * module_lookup:
228  *
229  *	Look up a module by name.
230  */
231 module_t *
232 module_lookup(const char *name)
233 {
234 	module_t *mod;
235 
236 	KASSERT(mutex_owned(&module_lock));
237 
238 	TAILQ_FOREACH(mod, &module_list, mod_chain) {
239 		if (strcmp(mod->mod_info->mi_name, name) == 0) {
240 			break;
241 		}
242 	}
243 
244 	return mod;
245 }
246 
247 /*
248  * module_hold:
249  *
250  *	Add a single reference to a module.  It's the caller's
251  *	responsibility to ensure that the reference is dropped
252  *	later.
253  */
254 int
255 module_hold(const char *name)
256 {
257 	module_t *mod;
258 
259 	mutex_enter(&module_lock);
260 	mod = module_lookup(name);
261 	if (mod == NULL) {
262 		mutex_exit(&module_lock);
263 		return ENOENT;
264 	}
265 	mod->mod_refcnt++;
266 	mutex_exit(&module_lock);
267 
268 	return 0;
269 }
270 
271 /*
272  * module_rele:
273  *
274  *	Release a reference acquired with module_hold().
275  */
276 void
277 module_rele(const char *name)
278 {
279 	module_t *mod;
280 
281 	mutex_enter(&module_lock);
282 	mod = module_lookup(name);
283 	if (mod == NULL) {
284 		mutex_exit(&module_lock);
285 		panic("module_rele: gone");
286 	}
287 	mod->mod_refcnt--;
288 	mutex_exit(&module_lock);
289 }
290 
291 /*
292  * module_do_builtin:
293  *
294  *	Initialize a single module from the list of modules that are
295  *	built into the kernel (linked into the kernel image).
296  */
297 static int
298 module_do_builtin(const char *name, module_t **modp)
299 {
300 	__link_set_decl(modules, modinfo_t);
301 	modinfo_t *const *mip;
302 	const char *p, *s;
303 	char buf[MAXMODNAME];
304 	modinfo_t *mi;
305 	module_t *mod, *mod2;
306 	size_t len;
307 	int error, i;
308 
309 	KASSERT(mutex_owned(&module_lock));
310 
311 	/*
312 	 * Check to see if already loaded.
313 	 */
314 	if ((mod = module_lookup(name)) != NULL) {
315 		if (modp != NULL) {
316 			*modp = mod;
317 		}
318 		return 0;
319 	}
320 
321 	/*
322 	 * Search the list to see if we have a module by this name.
323 	 */
324 	error = ENOENT;
325 	__link_set_foreach(mip, modules) {
326 		mi = *mip;
327 		if (mi == &module_dummy) {
328 			continue;
329 		}
330 		if (strcmp(mi->mi_name, name) == 0) {
331 			error = 0;
332 			break;
333 		}
334 	}
335 	if (error != 0) {
336 		return error;
337 	}
338 
339 	/*
340 	 * Initialize pre-requisites.
341 	 */
342 	mod = kmem_zalloc(sizeof(*mod), KM_SLEEP);
343 	if (mod == NULL) {
344 		return ENOMEM;
345 	}
346 	if (modp != NULL) {
347 		*modp = mod;
348 	}
349 	if (mi->mi_required != NULL) {
350 		for (s = mi->mi_required; *s != '\0'; s = p) {
351 			if (*s == ',')
352 				s++;
353 			p = s;
354 			while (*p != '\0' && *p != ',')
355 				p++;
356 			len = min(p - s + 1, sizeof(buf));
357 			strlcpy(buf, s, len);
358 			if (buf[0] == '\0')
359 				break;
360 			if (mod->mod_nrequired == MAXMODDEPS - 1) {
361 				module_error("too many required modules");
362 				kmem_free(mod, sizeof(*mod));
363 				return EINVAL;
364 			}
365 			error = module_do_builtin(buf, &mod2);
366 			if (error != 0) {
367 				kmem_free(mod, sizeof(*mod));
368 				return error;
369 			}
370 			mod->mod_required[mod->mod_nrequired++] = mod2;
371 		}
372 	}
373 
374 	/*
375 	 * Try to initialize the module.
376 	 */
377 	KASSERT(module_active == NULL);
378 	module_active = mod;
379 	error = (*mi->mi_modcmd)(MODULE_CMD_INIT, NULL);
380 	module_active = NULL;
381 	if (error != 0) {
382 		module_error("builtin module `%s' "
383 		    "failed to init", mi->mi_name);
384 		kmem_free(mod, sizeof(*mod));
385 		return error;
386 	}
387 	mod->mod_info = mi;
388 	mod->mod_source = MODULE_SOURCE_KERNEL;
389 	module_count++;
390 	TAILQ_INSERT_TAIL(&module_list, mod, mod_chain);
391 
392 	/*
393 	 * If that worked, count dependencies.
394 	 */
395 	for (i = 0; i < mod->mod_nrequired; i++) {
396 		mod->mod_required[i]->mod_refcnt++;
397 	}
398 
399 	return 0;
400 }
401 
402 /*
403  * module_do_load:
404  *
405  *	Helper routine: load a module from the file system, or one
406  *	pushed by the boot loader.
407  */
408 static int
409 module_do_load(const char *filename, bool isdep, int flags,
410 	       prop_dictionary_t props, module_t **modp, modclass_t class,
411 	       bool autoload)
412 {
413 	static TAILQ_HEAD(,module) pending = TAILQ_HEAD_INITIALIZER(pending);
414 	static int depth;
415 	const int maxdepth = 6;
416 	modinfo_t *mi;
417 	module_t *mod, *mod2;
418 	char buf[MAXMODNAME];
419 	const char *s, *p;
420 	int error;
421 	size_t len;
422 	u_int i;
423 
424 	KASSERT(mutex_owned(&module_lock));
425 
426 	error = 0;
427 
428 	/*
429 	 * Avoid recursing too far.
430 	 */
431 	if (++depth > maxdepth) {
432 		module_error("too many required modules");
433 		depth--;
434 		return EMLINK;
435 	}
436 
437 	/*
438 	 * Load the module and link.  Before going to the file system,
439 	 * scan the list of modules loaded by the boot loader.  Just
440 	 * before init is started the list of modules loaded at boot
441 	 * will be purged.  Before init is started we can assume that
442 	 * `filename' is a module name and not a path name.
443 	 */
444 	TAILQ_FOREACH(mod, &module_bootlist, mod_chain) {
445 		if (strcmp(mod->mod_info->mi_name, filename) == 0) {
446 			TAILQ_REMOVE(&module_bootlist, mod, mod_chain);
447 			break;
448 		}
449 	}
450 	if (mod != NULL) {
451 		TAILQ_INSERT_TAIL(&pending, mod, mod_chain);
452 	} else {
453 		mod = kmem_zalloc(sizeof(*mod), KM_SLEEP);
454 		if (mod == NULL) {
455 			depth--;
456 			return ENOMEM;
457 		}
458 		error = kobj_load_file(&mod->mod_kobj, filename, module_base,
459 		    autoload);
460 		if (error != 0) {
461 			kmem_free(mod, sizeof(*mod));
462 			depth--;
463 			module_error("unable to load kernel object");
464 			return error;
465 		}
466 		TAILQ_INSERT_TAIL(&pending, mod, mod_chain);
467 		mod->mod_source = MODULE_SOURCE_FILESYS;
468 		error = module_fetch_info(mod);
469 		if (error != 0) {
470 			goto fail;
471 		}
472 	}
473 
474 	/*
475 	 * Check compatibility.
476 	 */
477 	mi = mod->mod_info;
478 	if (strlen(mi->mi_name) >= MAXMODNAME) {
479 		error = EINVAL;
480 		module_error("module name too long");
481 		goto fail;
482 	}
483 
484 	/*
485 	 * If a specific kind of module was requested, ensure that we have
486 	 * a match.
487 	 */
488 	if (class != MODULE_CLASS_ANY && class != mi->mi_class) {
489 		error = ENOENT;
490 		goto fail;
491 	}
492 
493 	/*
494 	 * If loading a dependency, `filename' is a plain module name.
495 	 * The name must match.
496 	 */
497 	if (isdep && strcmp(mi->mi_name, filename) != 0) {
498 		error = ENOENT;
499 		goto fail;
500 	}
501 
502 	/*
503 	 * Check to see if the module is already loaded.  If so, we may
504 	 * have been recursively called to handle a dependency, so be sure
505 	 * to set modp.
506 	 */
507 	if ((mod2 = module_lookup(mi->mi_name)) != NULL) {
508 		if (modp != NULL)
509 			*modp = mod2;
510 		error = EEXIST;
511 		goto fail;
512 	}
513 
514 	/*
515 	 * Block circular dependencies.
516 	 */
517 	TAILQ_FOREACH(mod2, &pending, mod_chain) {
518 		if (mod == mod2) {
519 			continue;
520 		}
521 		if (strcmp(mod2->mod_info->mi_name, mi->mi_name) == 0) {
522 		    	error = EDEADLK;
523 			module_error("circular dependency detected");
524 		    	goto fail;
525 		}
526 	}
527 
528 	/*
529 	 * Now try to load any requisite modules.
530 	 */
531 	if (mi->mi_required != NULL) {
532 		for (s = mi->mi_required; *s != '\0'; s = p) {
533 			if (*s == ',')
534 				s++;
535 			p = s;
536 			while (*p != '\0' && *p != ',')
537 				p++;
538 			len = p - s + 1;
539 			if (len >= MAXMODNAME) {
540 				error = EINVAL;
541 				module_error("required module name too long");
542 				goto fail;
543 			}
544 			strlcpy(buf, s, len);
545 			if (buf[0] == '\0')
546 				break;
547 			if (mod->mod_nrequired == MAXMODDEPS - 1) {
548 				error = EINVAL;
549 				module_error("too many required modules");
550 				goto fail;
551 			}
552 			if (strcmp(buf, mi->mi_name) == 0) {
553 				error = EDEADLK;
554 				module_error("self-dependency detected");
555 				goto fail;
556 			}
557 			error = module_do_load(buf, true, flags, NULL,
558 			    &mod->mod_required[mod->mod_nrequired++],
559 			    MODULE_CLASS_ANY, true);
560 			if (error != 0 && error != EEXIST)
561 				goto fail;
562 		}
563 	}
564 
565 	/*
566 	 * We loaded all needed modules successfully: perform global
567 	 * relocations and initialize.
568 	 */
569 	error = kobj_affix(mod->mod_kobj, mi->mi_name);
570 	if (error != 0) {
571 		module_error("unable to affix module");
572 		goto fail2;
573 	}
574 
575 	KASSERT(module_active == NULL);
576 	module_active = mod;
577 	error = (*mi->mi_modcmd)(MODULE_CMD_INIT, props);
578 	module_active = NULL;
579 	if (error != 0) {
580 		module_error("modctl function returned error %d", error);
581 		goto fail;
582 	}
583 
584 	/*
585 	 * Good, the module loaded successfully.  Put it onto the
586 	 * list and add references to its requisite modules.
587 	 */
588 	module_count++;
589 	TAILQ_REMOVE(&pending, mod, mod_chain);
590 	TAILQ_INSERT_TAIL(&module_list, mod, mod_chain);
591 	for (i = 0; i < mod->mod_nrequired; i++) {
592 		KASSERT(mod->mod_required[i] != NULL);
593 		mod->mod_required[i]->mod_refcnt++;
594 	}
595 	if (modp != NULL) {
596 		*modp = mod;
597 	}
598 	depth--;
599 	return 0;
600 
601  fail:
602 	kobj_unload(mod->mod_kobj);
603  fail2:
604 	TAILQ_REMOVE(&pending, mod, mod_chain);
605 	kmem_free(mod, sizeof(*mod));
606 	depth--;
607 	return error;
608 }
609 
610 /*
611  * module_do_unload:
612  *
613  *	Helper routine: do the dirty work of unloading a module.
614  */
615 static int
616 module_do_unload(const char *name)
617 {
618 	module_t *mod;
619 	int error;
620 	u_int i;
621 
622 	KASSERT(mutex_owned(&module_lock));
623 
624 	mod = module_lookup(name);
625 	if (mod == NULL) {
626 		return ENOENT;
627 	}
628 	if (mod->mod_refcnt != 0 || mod->mod_source == MODULE_SOURCE_KERNEL) {
629 		return EBUSY;
630 	}
631 	KASSERT(module_active == NULL);
632 	module_active = mod;
633 	error = (*mod->mod_info->mi_modcmd)(MODULE_CMD_FINI, NULL);
634 	module_active = NULL;
635 	if (error != 0) {
636 		return error;
637 	}
638 	module_count--;
639 	TAILQ_REMOVE(&module_list, mod, mod_chain);
640 	for (i = 0; i < mod->mod_nrequired; i++) {
641 		mod->mod_required[i]->mod_refcnt--;
642 	}
643 	if (mod->mod_kobj != NULL) {
644 		kobj_unload(mod->mod_kobj);
645 	}
646 	kmem_free(mod, sizeof(*mod));
647 
648 	return 0;
649 }
650 
651 /*
652  * module_prime:
653  *
654  *	Push a module loaded by the bootloader onto our internal
655  *	list.
656  */
657 int
658 module_prime(void *base, size_t size)
659 {
660 	module_t *mod;
661 	int error;
662 
663 	mod = kmem_zalloc(sizeof(*mod), KM_SLEEP);
664 	if (mod == NULL) {
665 		return ENOMEM;
666 	}
667 	mod->mod_source = MODULE_SOURCE_BOOT;
668 
669 	error = kobj_load_mem(&mod->mod_kobj, base, size);
670 	if (error != 0) {
671 		kmem_free(mod, sizeof(*mod));
672 		module_error("unable to load object pushed by boot loader");
673 		return error;
674 	}
675 	error = module_fetch_info(mod);
676 	if (error != 0) {
677 		kobj_unload(mod->mod_kobj);
678 		kmem_free(mod, sizeof(*mod));
679 		module_error("unable to load object pushed by boot loader");
680 		return error;
681 	}
682 
683 	TAILQ_INSERT_TAIL(&module_bootlist, mod, mod_chain);
684 
685 	return 0;
686 }
687 
688 /*
689  * module_fetch_into:
690  *
691  *	Fetch modinfo record from a loaded module.
692  */
693 static int
694 module_fetch_info(module_t *mod)
695 {
696 	int error;
697 	void *addr;
698 	size_t size;
699 
700 	/*
701 	 * Find module info record and check compatibility.
702 	 */
703 	error = kobj_find_section(mod->mod_kobj, "link_set_modules",
704 	    &addr, &size);
705 	if (error != 0) {
706 		module_error("`link_set_modules' section not present");
707 		return error;
708 	}
709 	if (size != sizeof(modinfo_t **)) {
710 		module_error("`link_set_modules' section wrong size");
711 		return error;
712 	}
713 	mod->mod_info = *(modinfo_t **)addr;
714 
715 	return 0;
716 }
717 
718 /*
719  * module_find_section:
720  *
721  *	Allows a module that is being initialized to look up a section
722  *	within its ELF object.
723  */
724 int
725 module_find_section(const char *name, void **addr, size_t *size)
726 {
727 
728 	KASSERT(mutex_owned(&module_lock));
729 	KASSERT(module_active != NULL);
730 
731 	return kobj_find_section(module_active->mod_kobj, name, addr, size);
732 }
733