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