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