xref: /freebsd/stand/common/module.c (revision 731d06abf2105cc0873fa84e972178f9f37ca760)
1 /*-
2  * Copyright (c) 1998 Michael Smith <msmith@freebsd.org>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  */
26 
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
29 
30 /*
31  * file/module function dispatcher, support, etc.
32  */
33 
34 #include <stand.h>
35 #include <string.h>
36 #include <sys/param.h>
37 #include <sys/linker.h>
38 #include <sys/module.h>
39 #include <sys/queue.h>
40 #include <sys/stdint.h>
41 
42 #include "bootstrap.h"
43 
44 #define	MDIR_REMOVED	0x0001
45 #define	MDIR_NOHINTS	0x0002
46 
47 struct moduledir {
48 	char	*d_path;	/* path of modules directory */
49 	u_char	*d_hints;	/* content of linker.hints file */
50 	int	d_hintsz;	/* size of hints data */
51 	int	d_flags;
52 	STAILQ_ENTRY(moduledir) d_link;
53 };
54 
55 static int file_load(char *, vm_offset_t, struct preloaded_file **);
56 static int file_load_dependencies(struct preloaded_file *);
57 static char * file_search(const char *, char **);
58 static struct kernel_module *file_findmodule(struct preloaded_file *, char *,
59     struct mod_depend *);
60 static int file_havepath(const char *);
61 static char *mod_searchmodule(char *, struct mod_depend *);
62 static void file_insert_tail(struct preloaded_file *);
63 static void file_remove(struct preloaded_file *);
64 struct file_metadata *metadata_next(struct file_metadata *, int);
65 static void moduledir_readhints(struct moduledir *);
66 static void moduledir_rebuild(void);
67 
68 /* load address should be tweaked by first module loaded (kernel) */
69 static vm_offset_t	loadaddr = 0;
70 
71 #if defined(LOADER_FDT_SUPPORT)
72 static const char	*default_searchpath =
73     "/boot/kernel;/boot/modules;/boot/dtb";
74 #else
75 static const char	*default_searchpath = "/boot/kernel;/boot/modules";
76 #endif
77 
78 static STAILQ_HEAD(, moduledir) moduledir_list =
79     STAILQ_HEAD_INITIALIZER(moduledir_list);
80 
81 struct preloaded_file *preloaded_files = NULL;
82 
83 static char *kld_ext_list[] = {
84     ".ko",
85     "",
86     ".debug",
87     NULL
88 };
89 
90 
91 /*
92  * load an object, either a disk file or code module.
93  *
94  * To load a file, the syntax is:
95  *
96  * load -t <type> <path>
97  *
98  * code modules are loaded as:
99  *
100  * load <path> <options>
101  */
102 
103 COMMAND_SET(load, "load", "load a kernel or module", command_load);
104 
105 static int
106 command_load(int argc, char *argv[])
107 {
108 	struct preloaded_file *fp;
109 	char	*typestr;
110 	char	*prefix;
111 	char	*skip;
112 	int		dflag, dofile, dokld, ch, error;
113 
114 	dflag = dokld = dofile = 0;
115 	optind = 1;
116 	optreset = 1;
117 	typestr = NULL;
118 	if (argc == 1) {
119 		command_errmsg = "no filename specified";
120 		return (CMD_CRIT);
121 	}
122 	prefix = skip = NULL;
123 	while ((ch = getopt(argc, argv, "dkp:s:t:")) != -1) {
124 		switch(ch) {
125 		case 'd':
126 			dflag++;
127 			break;
128 		case 'k':
129 			dokld = 1;
130 			break;
131 		case 'p':
132 			prefix = optarg;
133 			break;
134 		case 's':
135 			skip = optarg;
136 			break;
137 		case 't':
138 			typestr = optarg;
139 			dofile = 1;
140 			break;
141 		case '?':
142 		default:
143 			/* getopt has already reported an error */
144 			return (CMD_OK);
145 		}
146 	}
147 	argv += (optind - 1);
148 	argc -= (optind - 1);
149 
150 	/*
151 	 * Request to load a raw file?
152 	 */
153 	if (dofile) {
154 		if ((argc != 2) || (typestr == NULL) || (*typestr == 0)) {
155 			command_errmsg = "invalid load type";
156 			return (CMD_CRIT);
157 		}
158 
159 #ifdef LOADER_VERIEXEC
160 		if (strncmp(typestr, "manifest", 8) == 0) {
161 			if (dflag > 0)
162 				ve_debug_set(dflag);
163 			return (load_manifest(argv[1], prefix, skip, NULL));
164 		}
165 #ifdef LOADER_VERIEXEC_PASS_MANIFEST
166 		if (strncmp(typestr, "pass_manifest", 13) == 0) {
167 			if (dflag > 0)
168 				ve_debug_set(dflag);
169 		    return (pass_manifest(argv[1], prefix));
170 		}
171 #endif
172 #endif
173 
174 		fp = file_findfile(argv[1], typestr);
175 		if (fp) {
176 			snprintf(command_errbuf, sizeof(command_errbuf),
177 			  "warning: file '%s' already loaded", argv[1]);
178 			return (CMD_WARN);
179 		}
180 
181 		if (file_loadraw(argv[1], typestr, 1) != NULL)
182 			return (CMD_OK);
183 
184 		/* Failing to load mfs_root is never going to end well! */
185 		if (strcmp("mfs_root", typestr) == 0)
186 			return (CMD_FATAL);
187 
188 		return (CMD_ERROR);
189 	}
190 	/*
191 	 * Do we have explicit KLD load ?
192 	 */
193 	if (dokld || file_havepath(argv[1])) {
194 		error = mod_loadkld(argv[1], argc - 2, argv + 2);
195 		if (error == EEXIST) {
196 			snprintf(command_errbuf, sizeof(command_errbuf),
197 			  "warning: KLD '%s' already loaded", argv[1]);
198 			return (CMD_WARN);
199 		}
200 
201 		return (error == 0 ? CMD_OK : CMD_CRIT);
202 	}
203 	/*
204 	 * Looks like a request for a module.
205 	 */
206 	error = mod_load(argv[1], NULL, argc - 2, argv + 2);
207 	if (error == EEXIST) {
208 		snprintf(command_errbuf, sizeof(command_errbuf),
209 		  "warning: module '%s' already loaded", argv[1]);
210 		return (CMD_WARN);
211 	}
212 
213 	return (error == 0 ? CMD_OK : CMD_CRIT);
214 }
215 
216 #ifdef LOADER_GELI_SUPPORT
217 COMMAND_SET(load_geli, "load_geli", "load a geli key", command_load_geli);
218 
219 static int
220 command_load_geli(int argc, char *argv[])
221 {
222 	char	typestr[80];
223 	char	*cp;
224 	int		ch, num;
225 
226 	if (argc < 3) {
227 		command_errmsg = "usage is [-n key#] <prov> <file>";
228 		return(CMD_ERROR);
229 	}
230 
231 	num = 0;
232 	optind = 1;
233 	optreset = 1;
234 	while ((ch = getopt(argc, argv, "n:")) != -1) {
235 		switch(ch) {
236 		case 'n':
237 			num = strtol(optarg, &cp, 0);
238 			if (cp == optarg) {
239 				snprintf(command_errbuf, sizeof(command_errbuf),
240 				  "bad key index '%s'", optarg);
241 				return(CMD_ERROR);
242 			}
243 			break;
244 		case '?':
245 		default:
246 			/* getopt has already reported an error */
247 			return(CMD_OK);
248 		}
249 	}
250 	argv += (optind - 1);
251 	argc -= (optind - 1);
252 	sprintf(typestr, "%s:geli_keyfile%d", argv[1], num);
253 	return (file_loadraw(argv[2], typestr, 1) ? CMD_OK : CMD_ERROR);
254 }
255 #endif
256 
257 void
258 unload(void)
259 {
260 	struct preloaded_file *fp;
261 
262 	while (preloaded_files != NULL) {
263 		fp = preloaded_files;
264 		preloaded_files = preloaded_files->f_next;
265 		file_discard(fp);
266 	}
267 	loadaddr = 0;
268 	unsetenv("kernelname");
269 }
270 
271 COMMAND_SET(unload, "unload", "unload all modules", command_unload);
272 
273 static int
274 command_unload(int argc, char *argv[])
275 {
276 	unload();
277 	return(CMD_OK);
278 }
279 
280 COMMAND_SET(lsmod, "lsmod", "list loaded modules", command_lsmod);
281 
282 static int
283 command_lsmod(int argc, char *argv[])
284 {
285 	struct preloaded_file	*fp;
286 	struct kernel_module	*mp;
287 	struct file_metadata	*md;
288 	char			lbuf[80];
289 	int				ch, verbose, ret = 0;
290 
291 	verbose = 0;
292 	optind = 1;
293 	optreset = 1;
294 	while ((ch = getopt(argc, argv, "v")) != -1) {
295 		switch(ch) {
296 		case 'v':
297 			verbose = 1;
298 			break;
299 		case '?':
300 		default:
301 			/* getopt has already reported an error */
302 			return(CMD_OK);
303 		}
304 	}
305 
306 	pager_open();
307 	for (fp = preloaded_files; fp; fp = fp->f_next) {
308 		snprintf(lbuf, sizeof(lbuf), " %p: ", (void *) fp->f_addr);
309 		pager_output(lbuf);
310 		pager_output(fp->f_name);
311 		snprintf(lbuf, sizeof(lbuf), " (%s, 0x%lx)\n", fp->f_type,
312 		  (long)fp->f_size);
313 		if (pager_output(lbuf))
314 			break;
315 		if (fp->f_args != NULL) {
316 			pager_output("    args: ");
317 			pager_output(fp->f_args);
318 			if (pager_output("\n"))
319 				break;
320 		}
321 		if (fp->f_modules) {
322 			pager_output("  modules: ");
323 			for (mp = fp->f_modules; mp; mp = mp->m_next) {
324 				snprintf(lbuf, sizeof(lbuf), "%s.%d ", mp->m_name,
325 				  mp->m_version);
326 				pager_output(lbuf);
327 			}
328 			if (pager_output("\n"))
329 				break;
330 		}
331 		if (verbose) {
332 			/* XXX could add some formatting smarts here to display some better */
333 			for (md = fp->f_metadata; md != NULL; md = md->md_next) {
334 				snprintf(lbuf, sizeof(lbuf), "      0x%04x, 0x%lx\n",
335 				  md->md_type, (long) md->md_size);
336 				if (pager_output(lbuf))
337 					break;
338 			}
339 		}
340 		if (ret)
341 			break;
342 	}
343 	pager_close();
344 	return(CMD_OK);
345 }
346 
347 /*
348  * File level interface, functions file_*
349  */
350 int
351 file_load(char *filename, vm_offset_t dest, struct preloaded_file **result)
352 {
353 	static int last_file_format = 0;
354 	struct preloaded_file *fp;
355 	int error;
356 	int i;
357 
358 	if (archsw.arch_loadaddr != NULL)
359 		dest = archsw.arch_loadaddr(LOAD_RAW, filename, dest);
360 
361 	error = EFTYPE;
362 	for (i = last_file_format, fp = NULL;
363 	     file_formats[i] && fp == NULL; i++) {
364 		error = (file_formats[i]->l_load)(filename, dest, &fp);
365 		if (error == 0) {
366 			fp->f_loader = last_file_format = i; /* remember the loader */
367 			*result = fp;
368 			break;
369 		} else if (last_file_format == i && i != 0) {
370 			/* Restart from the beginning */
371 			i = -1;
372 			last_file_format = 0;
373 			fp = NULL;
374 			continue;
375 		}
376 		if (error == EFTYPE)
377 			continue;		/* Unknown to this handler? */
378 		if (error) {
379 			snprintf(command_errbuf, sizeof(command_errbuf),
380 			  "can't load file '%s': %s", filename, strerror(error));
381 			break;
382 		}
383 	}
384 	return (error);
385 }
386 
387 static int
388 file_load_dependencies(struct preloaded_file *base_file)
389 {
390 	struct file_metadata *md;
391 	struct preloaded_file *fp;
392 	struct mod_depend *verinfo;
393 	struct kernel_module *mp;
394 	char *dmodname;
395 	int error;
396 
397 	md = file_findmetadata(base_file, MODINFOMD_DEPLIST);
398 	if (md == NULL)
399 		return (0);
400 	error = 0;
401 	do {
402 		verinfo = (struct mod_depend*)md->md_data;
403 		dmodname = (char *)(verinfo + 1);
404 		if (file_findmodule(NULL, dmodname, verinfo) == NULL) {
405 			printf("loading required module '%s'\n", dmodname);
406 			error = mod_load(dmodname, verinfo, 0, NULL);
407 			if (error)
408 				break;
409 			/*
410 			 * If module loaded via kld name which isn't listed
411 			 * in the linker.hints file, we should check if it have
412 			 * required version.
413 			 */
414 			mp = file_findmodule(NULL, dmodname, verinfo);
415 			if (mp == NULL) {
416 				snprintf(command_errbuf, sizeof(command_errbuf),
417 				  "module '%s' exists but with wrong version", dmodname);
418 				error = ENOENT;
419 				break;
420 			}
421 		}
422 		md = metadata_next(md, MODINFOMD_DEPLIST);
423 	} while (md);
424 	if (!error)
425 		return (0);
426 	/* Load failed; discard everything */
427 	while (base_file != NULL) {
428 		fp = base_file;
429 		base_file = base_file->f_next;
430 		file_discard(fp);
431 	}
432 	return (error);
433 }
434 
435 /*
436  * We've been asked to load (fname) as (type), so just suck it in,
437  * no arguments or anything.
438  */
439 struct preloaded_file *
440 file_loadraw(const char *fname, char *type, int insert)
441 {
442 	struct preloaded_file	*fp;
443 	char			*name;
444 	int				fd, got;
445 	vm_offset_t			laddr;
446 
447 	/* We can't load first */
448 	if ((file_findfile(NULL, NULL)) == NULL) {
449 		command_errmsg = "can't load file before kernel";
450 		return(NULL);
451 	}
452 
453 	/* locate the file on the load path */
454 	name = file_search(fname, NULL);
455 	if (name == NULL) {
456 		snprintf(command_errbuf, sizeof(command_errbuf),
457 		  "can't find '%s'", fname);
458 		return(NULL);
459 	}
460 
461 	if ((fd = open(name, O_RDONLY)) < 0) {
462 		snprintf(command_errbuf, sizeof(command_errbuf),
463 		  "can't open '%s': %s", name, strerror(errno));
464 		free(name);
465 		return(NULL);
466 	}
467 
468 #ifdef LOADER_VERIEXEC
469 	if (verify_file(fd, name, 0, VE_MUST) < 0) {
470 		sprintf(command_errbuf, "can't verify '%s'", name);
471 		free(name);
472 		close(fd);
473 		return(NULL);
474 	}
475 #endif
476 
477 	if (archsw.arch_loadaddr != NULL)
478 		loadaddr = archsw.arch_loadaddr(LOAD_RAW, name, loadaddr);
479 
480 	printf("%s ", name);
481 
482 	laddr = loadaddr;
483 	for (;;) {
484 		/* read in 4k chunks; size is not really important */
485 		got = archsw.arch_readin(fd, laddr, 4096);
486 		if (got == 0)				/* end of file */
487 			break;
488 		if (got < 0) {				/* error */
489 			snprintf(command_errbuf, sizeof(command_errbuf),
490 			  "error reading '%s': %s", name, strerror(errno));
491 			free(name);
492 			close(fd);
493 			return(NULL);
494 		}
495 		laddr += got;
496 	}
497 
498 	printf("size=%#jx\n", (uintmax_t)(laddr - loadaddr));
499 
500 	/* Looks OK so far; create & populate control structure */
501 	fp = file_alloc();
502 	fp->f_name = strdup(name);
503 	fp->f_type = strdup(type);
504 	fp->f_args = NULL;
505 	fp->f_metadata = NULL;
506 	fp->f_loader = -1;
507 	fp->f_addr = loadaddr;
508 	fp->f_size = laddr - loadaddr;
509 
510 	/* recognise space consumption */
511 	loadaddr = laddr;
512 
513 	/* Add to the list of loaded files */
514 	if (insert != 0)
515 		file_insert_tail(fp);
516 	close(fd);
517 	return(fp);
518 }
519 
520 /*
521  * Load the module (name), pass it (argc),(argv), add container file
522  * to the list of loaded files.
523  * If module is already loaded just assign new argc/argv.
524  */
525 int
526 mod_load(char *modname, struct mod_depend *verinfo, int argc, char *argv[])
527 {
528 	struct kernel_module	*mp;
529 	int				err;
530 	char			*filename;
531 
532 	if (file_havepath(modname)) {
533 		printf("Warning: mod_load() called instead of mod_loadkld() for module '%s'\n", modname);
534 		return (mod_loadkld(modname, argc, argv));
535 	}
536 	/* see if module is already loaded */
537 	mp = file_findmodule(NULL, modname, verinfo);
538 	if (mp) {
539 #ifdef moduleargs
540 		free(mp->m_args);
541 		mp->m_args = unargv(argc, argv);
542 #endif
543 		snprintf(command_errbuf, sizeof(command_errbuf),
544 		  "warning: module '%s' already loaded", mp->m_name);
545 		return (0);
546 	}
547 	/* locate file with the module on the search path */
548 	filename = mod_searchmodule(modname, verinfo);
549 	if (filename == NULL) {
550 		snprintf(command_errbuf, sizeof(command_errbuf),
551 		  "can't find '%s'", modname);
552 		return (ENOENT);
553 	}
554 	err = mod_loadkld(filename, argc, argv);
555 	return (err);
556 }
557 
558 /*
559  * Load specified KLD. If path is omitted, then try to locate it via
560  * search path.
561  */
562 int
563 mod_loadkld(const char *kldname, int argc, char *argv[])
564 {
565 	struct preloaded_file	*fp;
566 	int			err;
567 	char			*filename;
568 	vm_offset_t		loadaddr_saved;
569 
570 	/*
571 	 * Get fully qualified KLD name
572 	 */
573 	filename = file_search(kldname, kld_ext_list);
574 	if (filename == NULL) {
575 		snprintf(command_errbuf, sizeof(command_errbuf),
576 		  "can't find '%s'", kldname);
577 		return (ENOENT);
578 	}
579 	/*
580 	 * Check if KLD already loaded
581 	 */
582 	fp = file_findfile(filename, NULL);
583 	if (fp) {
584 		snprintf(command_errbuf, sizeof(command_errbuf),
585 		  "warning: KLD '%s' already loaded", filename);
586 		free(filename);
587 		return (0);
588 	}
589 
590 	do {
591 		err = file_load(filename, loadaddr, &fp);
592 		if (err)
593 			break;
594 		fp->f_args = unargv(argc, argv);
595 		loadaddr_saved = loadaddr;
596 		loadaddr = fp->f_addr + fp->f_size;
597 		file_insert_tail(fp);	/* Add to the list of loaded files */
598 		if (file_load_dependencies(fp) != 0) {
599 			err = ENOENT;
600 			file_remove(fp);
601 			loadaddr = loadaddr_saved;
602 			fp = NULL;
603 			break;
604 		}
605 	} while(0);
606 	if (err == EFTYPE) {
607 		snprintf(command_errbuf, sizeof(command_errbuf),
608 		  "don't know how to load module '%s'", filename);
609 	}
610 	if (err && fp)
611 		file_discard(fp);
612 	free(filename);
613 	return (err);
614 }
615 
616 /*
617  * Find a file matching (name) and (type).
618  * NULL may be passed as a wildcard to either.
619  */
620 struct preloaded_file *
621 file_findfile(const char *name, const char *type)
622 {
623 	struct preloaded_file *fp;
624 
625 	for (fp = preloaded_files; fp != NULL; fp = fp->f_next) {
626 		if (((name == NULL) || !strcmp(name, fp->f_name)) &&
627 		  ((type == NULL) || !strcmp(type, fp->f_type)))
628 			break;
629 	}
630 	return (fp);
631 }
632 
633 /*
634  * Find a module matching (name) inside of given file.
635  * NULL may be passed as a wildcard.
636  */
637 struct kernel_module *
638 file_findmodule(struct preloaded_file *fp, char *modname,
639 	struct mod_depend *verinfo)
640 {
641 	struct kernel_module *mp, *best;
642 	int bestver, mver;
643 
644 	if (fp == NULL) {
645 		for (fp = preloaded_files; fp; fp = fp->f_next) {
646 			mp = file_findmodule(fp, modname, verinfo);
647 			if (mp)
648 				return (mp);
649 		}
650 		return (NULL);
651 	}
652 	best = NULL;
653 	bestver = 0;
654 	for (mp = fp->f_modules; mp; mp = mp->m_next) {
655 		if (strcmp(modname, mp->m_name) == 0) {
656 			if (verinfo == NULL)
657 				return (mp);
658 			mver = mp->m_version;
659 			if (mver == verinfo->md_ver_preferred)
660 				return (mp);
661 			if (mver >= verinfo->md_ver_minimum &&
662 			  mver <= verinfo->md_ver_maximum &&
663 			  mver > bestver) {
664 				best = mp;
665 				bestver = mver;
666 			}
667 		}
668 	}
669 	return (best);
670 }
671 /*
672  * Make a copy of (size) bytes of data from (p), and associate them as
673  * metadata of (type) to the module (mp).
674  */
675 void
676 file_addmetadata(struct preloaded_file *fp, int type, size_t size, void *p)
677 {
678 	struct file_metadata	*md;
679 
680 	md = malloc(sizeof(struct file_metadata) - sizeof(md->md_data) + size);
681 	if (md != NULL) {
682 		md->md_size = size;
683 		md->md_type = type;
684 		bcopy(p, md->md_data, size);
685 		md->md_next = fp->f_metadata;
686 	}
687 	fp->f_metadata = md;
688 }
689 
690 /*
691  * Find a metadata object of (type) associated with the file (fp)
692  */
693 struct file_metadata *
694 file_findmetadata(struct preloaded_file *fp, int type)
695 {
696 	struct file_metadata *md;
697 
698 	for (md = fp->f_metadata; md != NULL; md = md->md_next)
699 		if (md->md_type == type)
700 			break;
701 	return(md);
702 }
703 
704 /*
705  * Remove all metadata from the file.
706  */
707 void
708 file_removemetadata(struct preloaded_file *fp)
709 {
710 	struct file_metadata *md, *next;
711 
712 	for (md = fp->f_metadata; md != NULL; md = next)
713 	{
714 		next = md->md_next;
715 		free(md);
716 	}
717 	fp->f_metadata = NULL;
718 }
719 
720 struct file_metadata *
721 metadata_next(struct file_metadata *md, int type)
722 {
723 
724 	if (md == NULL)
725 		return (NULL);
726 	while((md = md->md_next) != NULL)
727 		if (md->md_type == type)
728 			break;
729 	return (md);
730 }
731 
732 static char *emptyextlist[] = { "", NULL };
733 
734 /*
735  * Check if the given file is in place and return full path to it.
736  */
737 static char *
738 file_lookup(const char *path, const char *name, int namelen, char **extlist)
739 {
740 	struct stat	st;
741 	char	*result, *cp, **cpp;
742 	int		pathlen, extlen, len;
743 
744 	pathlen = strlen(path);
745 	extlen = 0;
746 	if (extlist == NULL)
747 		extlist = emptyextlist;
748 	for (cpp = extlist; *cpp; cpp++) {
749 		len = strlen(*cpp);
750 		if (len > extlen)
751 			extlen = len;
752 	}
753 	result = malloc(pathlen + namelen + extlen + 2);
754 	if (result == NULL)
755 		return (NULL);
756 	bcopy(path, result, pathlen);
757 	if (pathlen > 0 && result[pathlen - 1] != '/')
758 		result[pathlen++] = '/';
759 	cp = result + pathlen;
760 	bcopy(name, cp, namelen);
761 	cp += namelen;
762 	for (cpp = extlist; *cpp; cpp++) {
763 		strcpy(cp, *cpp);
764 		if (stat(result, &st) == 0 && S_ISREG(st.st_mode))
765 			return result;
766 	}
767 	free(result);
768 	return NULL;
769 }
770 
771 /*
772  * Check if file name have any qualifiers
773  */
774 static int
775 file_havepath(const char *name)
776 {
777 	const char		*cp;
778 
779 	archsw.arch_getdev(NULL, name, &cp);
780 	return (cp != name || strchr(name, '/') != NULL);
781 }
782 
783 /*
784  * Attempt to find the file (name) on the module searchpath.
785  * If (name) is qualified in any way, we simply check it and
786  * return it or NULL.  If it is not qualified, then we attempt
787  * to construct a path using entries in the environment variable
788  * module_path.
789  *
790  * The path we return a pointer to need never be freed, as we manage
791  * it internally.
792  */
793 static char *
794 file_search(const char *name, char **extlist)
795 {
796 	struct moduledir	*mdp;
797 	struct stat		sb;
798 	char		*result;
799 	int			namelen;
800 
801 	/* Don't look for nothing */
802 	if (name == NULL)
803 		return(NULL);
804 
805 	if (*name == 0)
806 		return(strdup(name));
807 
808 	if (file_havepath(name)) {
809 		/* Qualified, so just see if it exists */
810 		if (stat(name, &sb) == 0)
811 			return(strdup(name));
812 		return(NULL);
813 	}
814 	moduledir_rebuild();
815 	result = NULL;
816 	namelen = strlen(name);
817 	STAILQ_FOREACH(mdp, &moduledir_list, d_link) {
818 		result = file_lookup(mdp->d_path, name, namelen, extlist);
819 		if (result)
820 			break;
821 	}
822 	return(result);
823 }
824 
825 #define	INT_ALIGN(base, ptr)	ptr = \
826 	(base) + roundup2((ptr) - (base), sizeof(int))
827 
828 static char *
829 mod_search_hints(struct moduledir *mdp, const char *modname,
830 	struct mod_depend *verinfo)
831 {
832 	u_char	*cp, *recptr, *bufend, *best;
833 	char	*result;
834 	int		*intp, bestver, blen, clen, found, ival, modnamelen, reclen;
835 
836 	moduledir_readhints(mdp);
837 	modnamelen = strlen(modname);
838 	found = 0;
839 	result = NULL;
840 	bestver = 0;
841 	if (mdp->d_hints == NULL)
842 		goto bad;
843 	recptr = mdp->d_hints;
844 	bufend = recptr + mdp->d_hintsz;
845 	clen = blen = 0;
846 	best = cp = NULL;
847 	while (recptr < bufend && !found) {
848 		intp = (int*)recptr;
849 		reclen = *intp++;
850 		ival = *intp++;
851 		cp = (u_char*)intp;
852 		switch (ival) {
853 		case MDT_VERSION:
854 			clen = *cp++;
855 			if (clen != modnamelen || bcmp(cp, modname, clen) != 0)
856 				break;
857 			cp += clen;
858 			INT_ALIGN(mdp->d_hints, cp);
859 			ival = *(int*)cp;
860 			cp += sizeof(int);
861 			clen = *cp++;
862 			if (verinfo == NULL || ival == verinfo->md_ver_preferred) {
863 				found = 1;
864 				break;
865 			}
866 			if (ival >= verinfo->md_ver_minimum &&
867 			  ival <= verinfo->md_ver_maximum &&
868 			  ival > bestver) {
869 				bestver = ival;
870 				best = cp;
871 				blen = clen;
872 			}
873 			break;
874 		default:
875 			break;
876 		}
877 		recptr += reclen + sizeof(int);
878 	}
879 	/*
880 	 * Finally check if KLD is in the place
881 	 */
882 	if (found)
883 		result = file_lookup(mdp->d_path, (const char *)cp, clen, NULL);
884 	else if (best)
885 		result = file_lookup(mdp->d_path, (const char *)best, blen, NULL);
886 bad:
887 	/*
888 	 * If nothing found or hints is absent - fallback to the old way
889 	 * by using "kldname[.ko]" as module name.
890 	 */
891 	if (!found && !bestver && result == NULL)
892 		result = file_lookup(mdp->d_path, modname, modnamelen, kld_ext_list);
893 	return result;
894 }
895 
896 /*
897  * Attempt to locate the file containing the module (name)
898  */
899 static char *
900 mod_searchmodule(char *name, struct mod_depend *verinfo)
901 {
902 	struct	moduledir *mdp;
903 	char	*result;
904 
905 	moduledir_rebuild();
906 	/*
907 	 * Now we ready to lookup module in the given directories
908 	 */
909 	result = NULL;
910 	STAILQ_FOREACH(mdp, &moduledir_list, d_link) {
911 		result = mod_search_hints(mdp, name, verinfo);
912 		if (result)
913 			break;
914 	}
915 
916 	return(result);
917 }
918 
919 int
920 file_addmodule(struct preloaded_file *fp, char *modname, int version,
921 	struct kernel_module **newmp)
922 {
923 	struct kernel_module *mp;
924 	struct mod_depend mdepend;
925 
926 	bzero(&mdepend, sizeof(mdepend));
927 	mdepend.md_ver_preferred = version;
928 	mp = file_findmodule(fp, modname, &mdepend);
929 	if (mp)
930 		return (EEXIST);
931 	mp = calloc(1, sizeof(struct kernel_module));
932 	if (mp == NULL)
933 		return (ENOMEM);
934 	mp->m_name = strdup(modname);
935 	if (mp->m_name == NULL) {
936 		free(mp);
937 		return (ENOMEM);
938 	}
939 	mp->m_version = version;
940 	mp->m_fp = fp;
941 	mp->m_next = fp->f_modules;
942 	fp->f_modules = mp;
943 	if (newmp)
944 		*newmp = mp;
945 	return (0);
946 }
947 
948 /*
949  * Throw a file away
950  */
951 void
952 file_discard(struct preloaded_file *fp)
953 {
954 	struct file_metadata	*md, *md1;
955 	struct kernel_module	*mp, *mp1;
956 	if (fp == NULL)
957 		return;
958 	md = fp->f_metadata;
959 	while (md) {
960 		md1 = md;
961 		md = md->md_next;
962 		free(md1);
963 	}
964 	mp = fp->f_modules;
965 	while (mp) {
966 		free(mp->m_name);
967 		mp1 = mp;
968 		mp = mp->m_next;
969 		free(mp1);
970 	}
971 	free(fp->f_name);
972 	free(fp->f_type);
973 	free(fp->f_args);
974 	free(fp);
975 }
976 
977 /*
978  * Allocate a new file; must be used instead of malloc()
979  * to ensure safe initialisation.
980  */
981 struct preloaded_file *
982 file_alloc(void)
983 {
984 
985 	return (calloc(1, sizeof(struct preloaded_file)));
986 }
987 
988 /*
989  * Add a module to the chain
990  */
991 static void
992 file_insert_tail(struct preloaded_file *fp)
993 {
994 	struct preloaded_file	*cm;
995 
996 	/* Append to list of loaded file */
997 	fp->f_next = NULL;
998 	if (preloaded_files == NULL) {
999 		preloaded_files = fp;
1000 	} else {
1001 		for (cm = preloaded_files; cm->f_next != NULL; cm = cm->f_next)
1002 			;
1003 		cm->f_next = fp;
1004 	}
1005 }
1006 
1007 /*
1008  * Remove module from the chain
1009  */
1010 static void
1011 file_remove(struct preloaded_file *fp)
1012 {
1013 	struct preloaded_file   *cm;
1014 
1015 	if (preloaded_files == NULL)
1016 		return;
1017 
1018 	if (preloaded_files == fp) {
1019 		preloaded_files = fp->f_next;
1020 		return;
1021         }
1022         for (cm = preloaded_files; cm->f_next != NULL; cm = cm->f_next) {
1023 		if (cm->f_next == fp) {
1024 			cm->f_next = fp->f_next;
1025 			return;
1026 		}
1027 	}
1028 }
1029 
1030 static char *
1031 moduledir_fullpath(struct moduledir *mdp, const char *fname)
1032 {
1033 	char *cp;
1034 
1035 	cp = malloc(strlen(mdp->d_path) + strlen(fname) + 2);
1036 	if (cp == NULL)
1037 		return NULL;
1038 	strcpy(cp, mdp->d_path);
1039 	strcat(cp, "/");
1040 	strcat(cp, fname);
1041 	return (cp);
1042 }
1043 
1044 /*
1045  * Read linker.hints file into memory performing some sanity checks.
1046  */
1047 static void
1048 moduledir_readhints(struct moduledir *mdp)
1049 {
1050 	struct stat	st;
1051 	char	*path;
1052 	int		fd, size, version;
1053 
1054 	if (mdp->d_hints != NULL || (mdp->d_flags & MDIR_NOHINTS))
1055 		return;
1056 	path = moduledir_fullpath(mdp, "linker.hints");
1057 	if (stat(path, &st) != 0 ||
1058 	  st.st_size < (ssize_t)(sizeof(version) + sizeof(int)) ||
1059 	  st.st_size > LINKER_HINTS_MAX || (fd = open(path, O_RDONLY)) < 0) {
1060 		free(path);
1061 		mdp->d_flags |= MDIR_NOHINTS;
1062 		return;
1063 	}
1064 	free(path);
1065 	size = read(fd, &version, sizeof(version));
1066 	if (size != sizeof(version) || version != LINKER_HINTS_VERSION)
1067 		goto bad;
1068 	size = st.st_size - size;
1069 	mdp->d_hints = malloc(size);
1070 	if (mdp->d_hints == NULL)
1071 		goto bad;
1072 	if (read(fd, mdp->d_hints, size) != size)
1073 		goto bad;
1074 	mdp->d_hintsz = size;
1075 	close(fd);
1076 	return;
1077 bad:
1078 	close(fd);
1079 	free(mdp->d_hints);
1080 	mdp->d_hints = NULL;
1081 	mdp->d_flags |= MDIR_NOHINTS;
1082 	return;
1083 }
1084 
1085 /*
1086  * Extract directories from the ';' separated list, remove duplicates.
1087  */
1088 static void
1089 moduledir_rebuild(void)
1090 {
1091 	struct	moduledir *mdp, *mtmp;
1092 	const char	*path, *cp, *ep;
1093 	size_t	cplen;
1094 
1095 	path = getenv("module_path");
1096 	if (path == NULL)
1097 		path = default_searchpath;
1098 	/*
1099 	 * Rebuild list of module directories if it changed
1100 	 */
1101 	STAILQ_FOREACH(mdp, &moduledir_list, d_link)
1102 		mdp->d_flags |= MDIR_REMOVED;
1103 
1104 	for (ep = path; *ep != 0;  ep++) {
1105 		cp = ep;
1106 		for (; *ep != 0 && *ep != ';'; ep++)
1107 			;
1108 		/*
1109 		 * Ignore trailing slashes
1110 		 */
1111 		for (cplen = ep - cp; cplen > 1 && cp[cplen - 1] == '/'; cplen--)
1112 			;
1113 		STAILQ_FOREACH(mdp, &moduledir_list, d_link) {
1114 			if (strlen(mdp->d_path) != cplen ||	bcmp(cp, mdp->d_path, cplen) != 0)
1115 				continue;
1116 			mdp->d_flags &= ~MDIR_REMOVED;
1117 			break;
1118 		}
1119 		if (mdp == NULL) {
1120 			mdp = malloc(sizeof(*mdp) + cplen + 1);
1121 			if (mdp == NULL)
1122 				return;
1123 			mdp->d_path = (char*)(mdp + 1);
1124 			bcopy(cp, mdp->d_path, cplen);
1125 			mdp->d_path[cplen] = 0;
1126 			mdp->d_hints = NULL;
1127 			mdp->d_flags = 0;
1128 			STAILQ_INSERT_TAIL(&moduledir_list, mdp, d_link);
1129 		}
1130 		if (*ep == 0)
1131 			break;
1132 	}
1133 	/*
1134 	 * Delete unused directories if any
1135 	 */
1136 	mdp = STAILQ_FIRST(&moduledir_list);
1137 	while (mdp) {
1138 		if ((mdp->d_flags & MDIR_REMOVED) == 0) {
1139 			mdp = STAILQ_NEXT(mdp, d_link);
1140 		} else {
1141 			free(mdp->d_hints);
1142 			mtmp = mdp;
1143 			mdp = STAILQ_NEXT(mdp, d_link);
1144 			STAILQ_REMOVE(&moduledir_list, mtmp, moduledir, d_link);
1145 			free(mtmp);
1146 		}
1147 	}
1148 	return;
1149 }
1150