kern_linker.c revision 74641
125537Sdfr/*-
259603Sdfr * Copyright (c) 1997-2000 Doug Rabson
325537Sdfr * All rights reserved.
425537Sdfr *
525537Sdfr * Redistribution and use in source and binary forms, with or without
625537Sdfr * modification, are permitted provided that the following conditions
725537Sdfr * are met:
825537Sdfr * 1. Redistributions of source code must retain the above copyright
925537Sdfr *    notice, this list of conditions and the following disclaimer.
1025537Sdfr * 2. Redistributions in binary form must reproduce the above copyright
1125537Sdfr *    notice, this list of conditions and the following disclaimer in the
1225537Sdfr *    documentation and/or other materials provided with the distribution.
1325537Sdfr *
1425537Sdfr * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
1525537Sdfr * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1625537Sdfr * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1725537Sdfr * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
1825537Sdfr * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
1925537Sdfr * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
2025537Sdfr * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
2125537Sdfr * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
2225537Sdfr * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
2325537Sdfr * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
2425537Sdfr * SUCH DAMAGE.
2525537Sdfr *
2650477Speter * $FreeBSD: head/sys/kern/kern_linker.c 74641 2001-03-22 07:55:33Z bp $
2725537Sdfr */
2825537Sdfr
2940159Speter#include "opt_ddb.h"
3040159Speter
3125537Sdfr#include <sys/param.h>
3225537Sdfr#include <sys/kernel.h>
3325537Sdfr#include <sys/systm.h>
3425537Sdfr#include <sys/malloc.h>
3525537Sdfr#include <sys/sysproto.h>
3625537Sdfr#include <sys/sysent.h>
3725537Sdfr#include <sys/proc.h>
3825537Sdfr#include <sys/lock.h>
3925537Sdfr#include <sys/module.h>
4025537Sdfr#include <sys/linker.h>
4140159Speter#include <sys/fcntl.h>
4240159Speter#include <sys/libkern.h>
4340159Speter#include <sys/namei.h>
4440159Speter#include <sys/vnode.h>
4540159Speter#include <sys/sysctl.h>
4625537Sdfr
4754655Seivind
4859603Sdfr#include "linker_if.h"
4959603Sdfr
5040961Speter#ifdef KLD_DEBUG
5140961Speterint kld_debug = 0;
5240961Speter#endif
5340961Speter
5459751Speterstatic char *linker_search_path(const char *name);
5559751Speterstatic const char *linker_basename(const char* path);
5659751Speter
5759751SpeterMALLOC_DEFINE(M_LINKER, "linker", "kernel linker");
5859751Speter
5940906Speterlinker_file_t linker_kernel_file;
6031324Sbde
6125537Sdfrstatic struct lock lock;	/* lock for the file list */
6225537Sdfrstatic linker_class_list_t classes;
6350068Sgrogstatic linker_file_list_t linker_files;
6425537Sdfrstatic int next_file_id = 1;
6525537Sdfr
6659751Speter/* XXX wrong name; we're looking at version provision tags here, not modules */
6760938Sjaketypedef TAILQ_HEAD(, modlist) modlisthead_t;
6859751Speterstruct modlist {
6960938Sjake    TAILQ_ENTRY(modlist) link;		/* chain together all modules */
7059751Speter    linker_file_t	container;
7159751Speter    const char		*name;
7259751Speter};
7359751Spetertypedef struct modlist	*modlist_t;
7459751Speterstatic modlisthead_t	found_modules;
7559751Speter
7659603Sdfrstatic char *
7759603Sdfrlinker_strdup(const char *str)
7859603Sdfr{
7959603Sdfr    char	*result;
8059603Sdfr
8159603Sdfr    if ((result = malloc((strlen(str) + 1), M_LINKER, M_WAITOK)) != NULL)
8259603Sdfr	strcpy(result, str);
8359603Sdfr    return(result);
8459603Sdfr}
8559603Sdfr
8625537Sdfrstatic void
8725537Sdfrlinker_init(void* arg)
8825537Sdfr{
8925537Sdfr    lockinit(&lock, PVM, "klink", 0, 0);
9025537Sdfr    TAILQ_INIT(&classes);
9150068Sgrog    TAILQ_INIT(&linker_files);
9225537Sdfr}
9325537Sdfr
9440159SpeterSYSINIT(linker, SI_SUB_KLD, SI_ORDER_FIRST, linker_init, 0);
9525537Sdfr
9625537Sdfrint
9759603Sdfrlinker_add_class(linker_class_t lc)
9825537Sdfr{
9959603Sdfr    kobj_class_compile((kobj_class_t) lc);
10059751Speter    TAILQ_INSERT_TAIL(&classes, lc, link);
10125537Sdfr    return 0;
10225537Sdfr}
10325537Sdfr
10425537Sdfrstatic void
10525537Sdfrlinker_file_sysinit(linker_file_t lf)
10625537Sdfr{
10725537Sdfr    struct linker_set* sysinits;
10825537Sdfr    struct sysinit** sipp;
10925537Sdfr    struct sysinit** xipp;
11025537Sdfr    struct sysinit* save;
11125537Sdfr
11225537Sdfr    KLD_DPF(FILE, ("linker_file_sysinit: calling SYSINITs for %s\n",
11325537Sdfr		   lf->filename));
11425537Sdfr
11525537Sdfr    sysinits = (struct linker_set*)
11625537Sdfr	linker_file_lookup_symbol(lf, "sysinit_set", 0);
11740159Speter
11840159Speter    KLD_DPF(FILE, ("linker_file_sysinit: SYSINITs %p\n", sysinits));
11925537Sdfr    if (!sysinits)
12025537Sdfr	return;
12125537Sdfr    /*
12225537Sdfr     * Perform a bubble sort of the system initialization objects by
12325537Sdfr     * their subsystem (primary key) and order (secondary key).
12425537Sdfr     *
12525537Sdfr     * Since some things care about execution order, this is the
12625537Sdfr     * operation which ensures continued function.
12725537Sdfr     */
12841055Speter    for (sipp = (struct sysinit **)sysinits->ls_items; *sipp; sipp++) {
12941055Speter	for (xipp = sipp + 1; *xipp; xipp++) {
13062860Sbp	    if ((*sipp)->subsystem < (*xipp)->subsystem ||
13141055Speter		 ((*sipp)->subsystem == (*xipp)->subsystem &&
13241055Speter		  (*sipp)->order <= (*xipp)->order))
13325537Sdfr		continue;	/* skip*/
13425537Sdfr	    save = *sipp;
13525537Sdfr	    *sipp = *xipp;
13625537Sdfr	    *xipp = save;
13725537Sdfr	}
13825537Sdfr    }
13925537Sdfr
14025537Sdfr
14125537Sdfr    /*
14225537Sdfr     * Traverse the (now) ordered list of system initialization tasks.
14325537Sdfr     * Perform each task, and continue on to the next task.
14425537Sdfr     */
14541055Speter    for (sipp = (struct sysinit **)sysinits->ls_items; *sipp; sipp++) {
14641055Speter	if ((*sipp)->subsystem == SI_SUB_DUMMY)
14725537Sdfr	    continue;	/* skip dummy task(s)*/
14825537Sdfr
14948391Speter	/* Call function */
15048391Speter	(*((*sipp)->func))((*sipp)->udata);
15125537Sdfr    }
15225537Sdfr}
15325537Sdfr
15441055Speterstatic void
15541055Speterlinker_file_sysuninit(linker_file_t lf)
15641055Speter{
15741055Speter    struct linker_set* sysuninits;
15841055Speter    struct sysinit** sipp;
15941055Speter    struct sysinit** xipp;
16041055Speter    struct sysinit* save;
16141055Speter
16241055Speter    KLD_DPF(FILE, ("linker_file_sysuninit: calling SYSUNINITs for %s\n",
16341055Speter		   lf->filename));
16441055Speter
16541055Speter    sysuninits = (struct linker_set*)
16641055Speter	linker_file_lookup_symbol(lf, "sysuninit_set", 0);
16741055Speter
16841055Speter    KLD_DPF(FILE, ("linker_file_sysuninit: SYSUNINITs %p\n", sysuninits));
16941055Speter    if (!sysuninits)
17041055Speter	return;
17141055Speter
17241055Speter    /*
17341055Speter     * Perform a reverse bubble sort of the system initialization objects
17441055Speter     * by their subsystem (primary key) and order (secondary key).
17541055Speter     *
17641055Speter     * Since some things care about execution order, this is the
17741055Speter     * operation which ensures continued function.
17841055Speter     */
17941055Speter    for (sipp = (struct sysinit **)sysuninits->ls_items; *sipp; sipp++) {
18041055Speter	for (xipp = sipp + 1; *xipp; xipp++) {
18162860Sbp	    if ((*sipp)->subsystem > (*xipp)->subsystem ||
18241055Speter		 ((*sipp)->subsystem == (*xipp)->subsystem &&
18341055Speter		  (*sipp)->order >= (*xipp)->order))
18441055Speter		continue;	/* skip*/
18541055Speter	    save = *sipp;
18641055Speter	    *sipp = *xipp;
18741055Speter	    *xipp = save;
18841055Speter	}
18941055Speter    }
19041055Speter
19141055Speter    /*
19241055Speter     * Traverse the (now) ordered list of system initialization tasks.
19341055Speter     * Perform each task, and continue on to the next task.
19441055Speter     */
19541055Speter    for (sipp = (struct sysinit **)sysuninits->ls_items; *sipp; sipp++) {
19641055Speter	if ((*sipp)->subsystem == SI_SUB_DUMMY)
19741055Speter	    continue;	/* skip dummy task(s)*/
19841055Speter
19948391Speter	/* Call function */
20048391Speter	(*((*sipp)->func))((*sipp)->udata);
20141055Speter    }
20241055Speter}
20341055Speter
20444078Sdfrstatic void
20544078Sdfrlinker_file_register_sysctls(linker_file_t lf)
20644078Sdfr{
20744078Sdfr    struct linker_set* sysctls;
20844078Sdfr
20944078Sdfr    KLD_DPF(FILE, ("linker_file_register_sysctls: registering SYSCTLs for %s\n",
21044078Sdfr		   lf->filename));
21144078Sdfr
21244078Sdfr    sysctls = (struct linker_set*)
21344078Sdfr	linker_file_lookup_symbol(lf, "sysctl_set", 0);
21444078Sdfr
21544078Sdfr    KLD_DPF(FILE, ("linker_file_register_sysctls: SYSCTLs %p\n", sysctls));
21644078Sdfr    if (!sysctls)
21744078Sdfr	return;
21844078Sdfr
21944078Sdfr    sysctl_register_set(sysctls);
22044078Sdfr}
22144078Sdfr
22244078Sdfrstatic void
22344078Sdfrlinker_file_unregister_sysctls(linker_file_t lf)
22444078Sdfr{
22544078Sdfr    struct linker_set* sysctls;
22644078Sdfr
22744078Sdfr    KLD_DPF(FILE, ("linker_file_unregister_sysctls: registering SYSCTLs for %s\n",
22844078Sdfr		   lf->filename));
22944078Sdfr
23044078Sdfr    sysctls = (struct linker_set*)
23144078Sdfr	linker_file_lookup_symbol(lf, "sysctl_set", 0);
23244078Sdfr
23344078Sdfr    KLD_DPF(FILE, ("linker_file_unregister_sysctls: SYSCTLs %p\n", sysctls));
23444078Sdfr    if (!sysctls)
23544078Sdfr	return;
23644078Sdfr
23744078Sdfr    sysctl_unregister_set(sysctls);
23844078Sdfr}
23944078Sdfr
24066630Sdfrextern struct linker_set modmetadata_set;
24166630Sdfr
24259751Speterstatic int
24359751Speterlinker_file_register_modules(linker_file_t lf)
24459751Speter{
24574639Sbp    int error;
24659751Speter    struct linker_set *modules;
24759751Speter    struct mod_metadata **mdpp;
24859751Speter    const moduledata_t *moddata;
24959751Speter
25059751Speter    KLD_DPF(FILE, ("linker_file_register_modules: registering modules in %s\n",
25159751Speter		   lf->filename));
25259751Speter
25359751Speter    modules = (struct linker_set*)
25459751Speter	linker_file_lookup_symbol(lf, "modmetadata_set", 0);
25566630Sdfr
25666630Sdfr    if (!modules && lf == linker_kernel_file)
25766630Sdfr	modules = &modmetadata_set;
25866630Sdfr
25974639Sbp    if (modules == NULL)
26074639Sbp	return 0;
26174639Sbp    for (mdpp = (struct mod_metadata**)modules->ls_items; *mdpp; mdpp++) {
26274639Sbp	if ((*mdpp)->md_type != MDT_MODULE)
26374639Sbp	    continue;
26474639Sbp	moddata = (*mdpp)->md_data;
26574639Sbp	KLD_DPF(FILE, ("Registering module %s in %s\n",
26674639Sbp             moddata->name, lf->filename));
26774639Sbp	if (module_lookupbyname(moddata->name) != NULL) {
26874639Sbp	    printf("Warning: module %s already exists\n", moddata->name);
26974639Sbp	    continue;	/* or return a error ? */
27059751Speter	}
27174639Sbp	error = module_register(moddata, lf);
27274639Sbp	if (error)
27374639Sbp	    printf("Module %s failed to register: %d\n", moddata->name, error);
27459751Speter    }
27574639Sbp    return 0;
27659751Speter}
27759751Speter
27859751Speterstatic void
27959751Speterlinker_init_kernel_modules(void)
28059751Speter{
28159751Speter    linker_file_register_modules(linker_kernel_file);
28259751Speter}
28359751Speter
28459751SpeterSYSINIT(linker_kernel, SI_SUB_KLD, SI_ORDER_ANY, linker_init_kernel_modules, 0);
28559751Speter
28625537Sdfrint
28725537Sdfrlinker_load_file(const char* filename, linker_file_t* result)
28825537Sdfr{
28925537Sdfr    linker_class_t lc;
29025537Sdfr    linker_file_t lf;
29142755Speter    int foundfile, error = 0;
29225537Sdfr
29362261Sarchie    /* Refuse to load modules if securelevel raised */
29462261Sarchie    if (securelevel > 0)
29562261Sarchie	return EPERM;
29662261Sarchie
29725537Sdfr    lf = linker_find_file_by_name(filename);
29825537Sdfr    if (lf) {
29925537Sdfr	KLD_DPF(FILE, ("linker_load_file: file %s is already loaded, incrementing refs\n", filename));
30025537Sdfr	*result = lf;
30125537Sdfr	lf->refs++;
30225537Sdfr	goto out;
30325537Sdfr    }
30425537Sdfr
30525537Sdfr    lf = NULL;
30642755Speter    foundfile = 0;
30771999Sphk    TAILQ_FOREACH(lc, &classes, link) {
30825537Sdfr	KLD_DPF(FILE, ("linker_load_file: trying to load %s as %s\n",
30925537Sdfr		       filename, lc->desc));
31059751Speter	error = LINKER_LOAD_FILE(lc, filename, &lf);
31142755Speter	/*
31242755Speter	 * If we got something other than ENOENT, then it exists but we cannot
31342755Speter	 * load it for some other reason.
31442755Speter	 */
31542755Speter	if (error != ENOENT)
31642755Speter	    foundfile = 1;
31725537Sdfr	if (lf) {
31859751Speter	    linker_file_register_modules(lf);
31944549Sdfr	    linker_file_register_sysctls(lf);
32025537Sdfr	    linker_file_sysinit(lf);
32159751Speter	    lf->flags |= LINKER_FILE_LINKED;
32225537Sdfr
32325537Sdfr	    *result = lf;
32440861Speter	    error = 0;
32525537Sdfr	    goto out;
32625537Sdfr	}
32725537Sdfr    }
32842755Speter    /*
32942755Speter     * Less than ideal, but tells the user whether it failed to load or
33042755Speter     * the module was not found.
33142755Speter     */
33242755Speter    if (foundfile)
33342755Speter	error = ENOEXEC;	/* Format not recognised (or unloadable) */
33442755Speter    else
33542755Speter	error = ENOENT;		/* Nothing found */
33625537Sdfr
33725537Sdfrout:
33825537Sdfr    return error;
33925537Sdfr}
34025537Sdfr
34125537Sdfrlinker_file_t
34225537Sdfrlinker_find_file_by_name(const char* filename)
34325537Sdfr{
34425537Sdfr    linker_file_t lf = 0;
34540861Speter    char *koname;
34625537Sdfr
34740861Speter    koname = malloc(strlen(filename) + 4, M_LINKER, M_WAITOK);
34840861Speter    if (koname == NULL)
34940861Speter	goto out;
35040861Speter    sprintf(koname, "%s.ko", filename);
35140861Speter
35225537Sdfr    lockmgr(&lock, LK_SHARED, 0, curproc);
35371999Sphk    TAILQ_FOREACH(lf, &linker_files, link) {
35440861Speter	if (!strcmp(lf->filename, koname))
35540861Speter	    break;
35625537Sdfr	if (!strcmp(lf->filename, filename))
35725537Sdfr	    break;
35840861Speter    }
35925537Sdfr    lockmgr(&lock, LK_RELEASE, 0, curproc);
36025537Sdfr
36140861Speterout:
36240861Speter    if (koname)
36340861Speter	free(koname, M_LINKER);
36425537Sdfr    return lf;
36525537Sdfr}
36625537Sdfr
36725537Sdfrlinker_file_t
36825537Sdfrlinker_find_file_by_id(int fileid)
36925537Sdfr{
37025537Sdfr    linker_file_t lf = 0;
37125537Sdfr
37225537Sdfr    lockmgr(&lock, LK_SHARED, 0, curproc);
37371999Sphk    TAILQ_FOREACH(lf, &linker_files, link)
37425537Sdfr	if (lf->id == fileid)
37525537Sdfr	    break;
37625537Sdfr    lockmgr(&lock, LK_RELEASE, 0, curproc);
37725537Sdfr
37825537Sdfr    return lf;
37925537Sdfr}
38025537Sdfr
38125537Sdfrlinker_file_t
38259603Sdfrlinker_make_file(const char* pathname, linker_class_t lc)
38325537Sdfr{
38425537Sdfr    linker_file_t lf = 0;
38540159Speter    const char *filename;
38625537Sdfr
38759751Speter    filename = linker_basename(pathname);
38840159Speter
38925537Sdfr    KLD_DPF(FILE, ("linker_make_file: new file, filename=%s\n", filename));
39045356Speter    lockmgr(&lock, LK_EXCLUSIVE, 0, curproc);
39159603Sdfr    lf = (linker_file_t) kobj_create((kobj_class_t) lc, M_LINKER, M_WAITOK);
39225537Sdfr    if (!lf)
39325537Sdfr	goto out;
39425537Sdfr
39525537Sdfr    lf->refs = 1;
39625537Sdfr    lf->userrefs = 0;
39743185Sdfr    lf->flags = 0;
39859603Sdfr    lf->filename = linker_strdup(filename);
39925537Sdfr    lf->id = next_file_id++;
40025537Sdfr    lf->ndeps = 0;
40125537Sdfr    lf->deps = NULL;
40225537Sdfr    STAILQ_INIT(&lf->common);
40325537Sdfr    TAILQ_INIT(&lf->modules);
40425537Sdfr
40550068Sgrog    TAILQ_INSERT_TAIL(&linker_files, lf, link);
40625537Sdfr
40725537Sdfrout:
40825537Sdfr    lockmgr(&lock, LK_RELEASE, 0, curproc);
40925537Sdfr    return lf;
41025537Sdfr}
41125537Sdfr
41225537Sdfrint
41325537Sdfrlinker_file_unload(linker_file_t file)
41425537Sdfr{
41525537Sdfr    module_t mod, next;
41659751Speter    modlist_t ml, nextml;
41725537Sdfr    struct common_symbol* cp;
41825537Sdfr    int error = 0;
41925537Sdfr    int i;
42025537Sdfr
42162261Sarchie    /* Refuse to unload modules if securelevel raised */
42262261Sarchie    if (securelevel > 0)
42362261Sarchie	return EPERM;
42462261Sarchie
42540159Speter    KLD_DPF(FILE, ("linker_file_unload: lf->refs=%d\n", file->refs));
42645356Speter    lockmgr(&lock, LK_EXCLUSIVE, 0, curproc);
42725537Sdfr    if (file->refs == 1) {
42825537Sdfr	KLD_DPF(FILE, ("linker_file_unload: file is unloading, informing modules\n"));
42925537Sdfr	/*
43025537Sdfr	 * Inform any modules associated with this file.
43125537Sdfr	 */
43225537Sdfr	for (mod = TAILQ_FIRST(&file->modules); mod; mod = next) {
43325537Sdfr	    next = module_getfnext(mod);
43425537Sdfr
43525537Sdfr	    /*
43625537Sdfr	     * Give the module a chance to veto the unload.
43725537Sdfr	     */
43843301Sdillon	    if ((error = module_unload(mod)) != 0) {
43925537Sdfr		KLD_DPF(FILE, ("linker_file_unload: module %x vetoes unload\n",
44025537Sdfr			       mod));
44125537Sdfr		lockmgr(&lock, LK_RELEASE, 0, curproc);
44225537Sdfr		goto out;
44325537Sdfr	    }
44425537Sdfr
44525537Sdfr	    module_release(mod);
44625537Sdfr	}
44725537Sdfr    }
44825537Sdfr
44925537Sdfr    file->refs--;
45025537Sdfr    if (file->refs > 0) {
45125537Sdfr	lockmgr(&lock, LK_RELEASE, 0, curproc);
45225537Sdfr	goto out;
45325537Sdfr    }
45425537Sdfr
45559751Speter    for (ml = TAILQ_FIRST(&found_modules); ml; ml = nextml) {
45659751Speter	nextml = TAILQ_NEXT(ml, link);
45759751Speter	if (ml->container == file) {
45859751Speter	    TAILQ_REMOVE(&found_modules, ml, link);
45959751Speter	}
46059751Speter    }
46159751Speter
46243185Sdfr    /* Don't try to run SYSUNINITs if we are unloaded due to a link error */
46344078Sdfr    if (file->flags & LINKER_FILE_LINKED) {
46443185Sdfr	linker_file_sysuninit(file);
46544078Sdfr	linker_file_unregister_sysctls(file);
46644078Sdfr    }
46741055Speter
46850068Sgrog    TAILQ_REMOVE(&linker_files, file, link);
46925537Sdfr    lockmgr(&lock, LK_RELEASE, 0, curproc);
47040159Speter
47159751Speter    if (file->deps) {
47259751Speter	for (i = 0; i < file->ndeps; i++)
47359751Speter	    linker_file_unload(file->deps[i]);
47459751Speter	free(file->deps, M_LINKER);
47559751Speter	file->deps = NULL;
47659751Speter    }
47725537Sdfr
47825537Sdfr    for (cp = STAILQ_FIRST(&file->common); cp;
47925537Sdfr	 cp = STAILQ_FIRST(&file->common)) {
48060938Sjake	STAILQ_REMOVE(&file->common, cp, common_symbol, link);
48125537Sdfr	free(cp, M_LINKER);
48225537Sdfr    }
48325537Sdfr
48459603Sdfr    LINKER_UNLOAD(file);
48559751Speter    if (file->filename) {
48659751Speter	free(file->filename, M_LINKER);
48759751Speter	file->filename = NULL;
48859751Speter    }
48959603Sdfr    kobj_delete((kobj_t) file, M_LINKER);
49025537Sdfr
49125537Sdfrout:
49225537Sdfr    return error;
49325537Sdfr}
49425537Sdfr
49525537Sdfrint
49625537Sdfrlinker_file_add_dependancy(linker_file_t file, linker_file_t dep)
49725537Sdfr{
49825537Sdfr    linker_file_t* newdeps;
49925537Sdfr
50025537Sdfr    newdeps = malloc((file->ndeps + 1) * sizeof(linker_file_t*),
50169781Sdwmalone		     M_LINKER, M_WAITOK | M_ZERO);
50225537Sdfr    if (newdeps == NULL)
50325537Sdfr	return ENOMEM;
50425537Sdfr
50525537Sdfr    if (file->deps) {
50625537Sdfr	bcopy(file->deps, newdeps, file->ndeps * sizeof(linker_file_t*));
50725537Sdfr	free(file->deps, M_LINKER);
50825537Sdfr    }
50925537Sdfr    file->deps = newdeps;
51025537Sdfr    file->deps[file->ndeps] = dep;
51125537Sdfr    file->ndeps++;
51225537Sdfr
51325537Sdfr    return 0;
51425537Sdfr}
51525537Sdfr
51625537Sdfrcaddr_t
51725537Sdfrlinker_file_lookup_symbol(linker_file_t file, const char* name, int deps)
51825537Sdfr{
51943309Sdillon    c_linker_sym_t sym;
52038275Sdfr    linker_symval_t symval;
52125537Sdfr    caddr_t address;
52225537Sdfr    size_t common_size = 0;
52325537Sdfr    int i;
52425537Sdfr
52540159Speter    KLD_DPF(SYM, ("linker_file_lookup_symbol: file=%x, name=%s, deps=%d\n",
52625537Sdfr		  file, name, deps));
52725537Sdfr
52859603Sdfr    if (LINKER_LOOKUP_SYMBOL(file, name, &sym) == 0) {
52959603Sdfr	LINKER_SYMBOL_VALUES(file, sym, &symval);
53038275Sdfr	if (symval.value == 0)
53125537Sdfr	    /*
53225537Sdfr	     * For commons, first look them up in the dependancies and
53325537Sdfr	     * only allocate space if not found there.
53425537Sdfr	     */
53538275Sdfr	    common_size = symval.size;
53640159Speter	else {
53740159Speter	    KLD_DPF(SYM, ("linker_file_lookup_symbol: symbol.value=%x\n", symval.value));
53838275Sdfr	    return symval.value;
53940159Speter	}
54038275Sdfr    }
54125537Sdfr
54242849Speter    if (deps) {
54325537Sdfr	for (i = 0; i < file->ndeps; i++) {
54425537Sdfr	    address = linker_file_lookup_symbol(file->deps[i], name, 0);
54540159Speter	    if (address) {
54640159Speter		KLD_DPF(SYM, ("linker_file_lookup_symbol: deps value=%x\n", address));
54725537Sdfr		return address;
54840159Speter	    }
54925537Sdfr	}
55042849Speter    }
55142849Speter
55225537Sdfr    if (common_size > 0) {
55325537Sdfr	/*
55425537Sdfr	 * This is a common symbol which was not found in the
55525537Sdfr	 * dependancies.  We maintain a simple common symbol table in
55625537Sdfr	 * the file object.
55725537Sdfr	 */
55825537Sdfr	struct common_symbol* cp;
55925537Sdfr
56072012Sphk	STAILQ_FOREACH(cp, &file->common, link)
56140159Speter	    if (!strcmp(cp->name, name)) {
56240159Speter		KLD_DPF(SYM, ("linker_file_lookup_symbol: old common value=%x\n", cp->address));
56325537Sdfr		return cp->address;
56440159Speter	    }
56525537Sdfr
56625537Sdfr	/*
56725537Sdfr	 * Round the symbol size up to align.
56825537Sdfr	 */
56925537Sdfr	common_size = (common_size + sizeof(int) - 1) & -sizeof(int);
57025537Sdfr	cp = malloc(sizeof(struct common_symbol)
57125537Sdfr		    + common_size
57225537Sdfr		    + strlen(name) + 1,
57369781Sdwmalone		    M_LINKER, M_WAITOK | M_ZERO);
57440159Speter	if (!cp) {
57540159Speter	    KLD_DPF(SYM, ("linker_file_lookup_symbol: nomem\n"));
57625537Sdfr	    return 0;
57740159Speter	}
57825537Sdfr
57925537Sdfr	cp->address = (caddr_t) (cp + 1);
58025537Sdfr	cp->name = cp->address + common_size;
58125537Sdfr	strcpy(cp->name, name);
58225537Sdfr	bzero(cp->address, common_size);
58325537Sdfr	STAILQ_INSERT_TAIL(&file->common, cp, link);
58425537Sdfr
58540159Speter	KLD_DPF(SYM, ("linker_file_lookup_symbol: new common value=%x\n", cp->address));
58625537Sdfr	return cp->address;
58725537Sdfr    }
58825537Sdfr
58940159Speter    KLD_DPF(SYM, ("linker_file_lookup_symbol: fail\n"));
59025537Sdfr    return 0;
59125537Sdfr}
59225537Sdfr
59340159Speter#ifdef DDB
59425537Sdfr/*
59540159Speter * DDB Helpers.  DDB has to look across multiple files with their own
59640159Speter * symbol tables and string tables.
59740159Speter *
59840159Speter * Note that we do not obey list locking protocols here.  We really don't
59940159Speter * need DDB to hang because somebody's got the lock held.  We'll take the
60040159Speter * chance that the files list is inconsistant instead.
60140159Speter */
60240159Speter
60340159Speterint
60443309Sdillonlinker_ddb_lookup(const char *symstr, c_linker_sym_t *sym)
60540159Speter{
60640159Speter    linker_file_t lf;
60740159Speter
60871999Sphk    TAILQ_FOREACH(lf, &linker_files, link) {
60959603Sdfr	if (LINKER_LOOKUP_SYMBOL(lf, symstr, sym) == 0)
61040159Speter	    return 0;
61140159Speter    }
61240159Speter    return ENOENT;
61340159Speter}
61440159Speter
61540159Speterint
61643309Sdillonlinker_ddb_search_symbol(caddr_t value, c_linker_sym_t *sym, long *diffp)
61740159Speter{
61840159Speter    linker_file_t lf;
61950272Sbde    u_long off = (uintptr_t)value;
62040159Speter    u_long diff, bestdiff;
62143309Sdillon    c_linker_sym_t best;
62243309Sdillon    c_linker_sym_t es;
62340159Speter
62440159Speter    best = 0;
62540159Speter    bestdiff = off;
62671999Sphk    TAILQ_FOREACH(lf, &linker_files, link) {
62759603Sdfr	if (LINKER_SEARCH_SYMBOL(lf, value, &es, &diff) != 0)
62840159Speter	    continue;
62940159Speter	if (es != 0 && diff < bestdiff) {
63040159Speter	    best = es;
63140159Speter	    bestdiff = diff;
63240159Speter	}
63340159Speter	if (bestdiff == 0)
63440159Speter	    break;
63540159Speter    }
63640159Speter    if (best) {
63740159Speter	*sym = best;
63840159Speter	*diffp = bestdiff;
63940159Speter	return 0;
64040159Speter    } else {
64140159Speter	*sym = 0;
64240159Speter	*diffp = off;
64340159Speter	return ENOENT;
64440159Speter    }
64540159Speter}
64640159Speter
64740159Speterint
64843309Sdillonlinker_ddb_symbol_values(c_linker_sym_t sym, linker_symval_t *symval)
64940159Speter{
65040159Speter    linker_file_t lf;
65140159Speter
65271999Sphk    TAILQ_FOREACH(lf, &linker_files, link) {
65359603Sdfr	if (LINKER_SYMBOL_VALUES(lf, sym, symval) == 0)
65440159Speter	    return 0;
65540159Speter    }
65640159Speter    return ENOENT;
65740159Speter}
65840159Speter
65940159Speter#endif
66040159Speter
66140159Speter/*
66225537Sdfr * Syscalls.
66325537Sdfr */
66425537Sdfr
66525537Sdfrint
66630994Sphkkldload(struct proc* p, struct kldload_args* uap)
66725537Sdfr{
66859751Speter    char* pathname, *realpath;
66959751Speter    const char *filename;
67025537Sdfr    linker_file_t lf;
67125537Sdfr    int error = 0;
67225537Sdfr
67330994Sphk    p->p_retval[0] = -1;
67425537Sdfr
67562261Sarchie    if (securelevel > 0)	/* redundant, but that's OK */
67625537Sdfr	return EPERM;
67725537Sdfr
67846112Sphk    if ((error = suser(p)) != 0)
67925537Sdfr	return error;
68025537Sdfr
68159751Speter    realpath = NULL;
68259751Speter    pathname = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
68359751Speter    if ((error = copyinstr(SCARG(uap, file), pathname, MAXPATHLEN, NULL)) != 0)
68425537Sdfr	goto out;
68525537Sdfr
68659751Speter    realpath = linker_search_path(pathname);
68759751Speter    if (realpath == NULL) {
68859751Speter	error = ENOENT;
68959751Speter	goto out;
69059751Speter    }
69159751Speter    /* Can't load more than one file with the same name */
69259751Speter    filename = linker_basename(realpath);
69359751Speter    if (linker_find_file_by_name(filename)) {
69442316Smsmith	error = EEXIST;
69542316Smsmith	goto out;
69642316Smsmith    }
69742316Smsmith
69859751Speter    if ((error = linker_load_file(realpath, &lf)) != 0)
69925537Sdfr	goto out;
70025537Sdfr
70125537Sdfr    lf->userrefs++;
70230994Sphk    p->p_retval[0] = lf->id;
70340159Speter
70425537Sdfrout:
70559751Speter    if (pathname)
70659751Speter	free(pathname, M_TEMP);
70759751Speter    if (realpath)
70859751Speter	free(realpath, M_LINKER);
70925537Sdfr    return error;
71025537Sdfr}
71125537Sdfr
71225537Sdfrint
71330994Sphkkldunload(struct proc* p, struct kldunload_args* uap)
71425537Sdfr{
71525537Sdfr    linker_file_t lf;
71625537Sdfr    int error = 0;
71725537Sdfr
71862261Sarchie    if (securelevel > 0)	/* redundant, but that's OK */
71925537Sdfr	return EPERM;
72025537Sdfr
72146112Sphk    if ((error = suser(p)) != 0)
72225537Sdfr	return error;
72325537Sdfr
72425537Sdfr    lf = linker_find_file_by_id(SCARG(uap, fileid));
72525537Sdfr    if (lf) {
72625537Sdfr	KLD_DPF(FILE, ("kldunload: lf->userrefs=%d\n", lf->userrefs));
72725537Sdfr	if (lf->userrefs == 0) {
72859751Speter	    printf("kldunload: attempt to unload file that was loaded by the kernel\n");
72925537Sdfr	    error = EBUSY;
73025537Sdfr	    goto out;
73125537Sdfr	}
73243084Speter	lf->userrefs--;
73342837Speter	error = linker_file_unload(lf);
73442837Speter	if (error)
73543084Speter	    lf->userrefs++;
73625537Sdfr    } else
73725537Sdfr	error = ENOENT;
73825537Sdfr
73925537Sdfrout:
74025537Sdfr    return error;
74125537Sdfr}
74225537Sdfr
74325537Sdfrint
74430994Sphkkldfind(struct proc* p, struct kldfind_args* uap)
74525537Sdfr{
74659751Speter    char* pathname;
74759751Speter    const char *filename;
74825537Sdfr    linker_file_t lf;
74925537Sdfr    int error = 0;
75025537Sdfr
75130994Sphk    p->p_retval[0] = -1;
75225537Sdfr
75359751Speter    pathname = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
75459751Speter    if ((error = copyinstr(SCARG(uap, file), pathname, MAXPATHLEN, NULL)) != 0)
75525537Sdfr	goto out;
75625537Sdfr
75759751Speter    filename = linker_basename(pathname);
75842316Smsmith
75959751Speter    lf = linker_find_file_by_name(filename);
76025537Sdfr    if (lf)
76130994Sphk	p->p_retval[0] = lf->id;
76225537Sdfr    else
76325537Sdfr	error = ENOENT;
76440159Speter
76525537Sdfrout:
76659751Speter    if (pathname)
76759751Speter	free(pathname, M_TEMP);
76825537Sdfr    return error;
76925537Sdfr}
77025537Sdfr
77125537Sdfrint
77230994Sphkkldnext(struct proc* p, struct kldnext_args* uap)
77325537Sdfr{
77425537Sdfr    linker_file_t lf;
77525537Sdfr    int error = 0;
77625537Sdfr
77725537Sdfr    if (SCARG(uap, fileid) == 0) {
77850068Sgrog	if (TAILQ_FIRST(&linker_files))
77950068Sgrog	    p->p_retval[0] = TAILQ_FIRST(&linker_files)->id;
78025537Sdfr	else
78130994Sphk	    p->p_retval[0] = 0;
78225537Sdfr	return 0;
78325537Sdfr    }
78440159Speter
78525537Sdfr    lf = linker_find_file_by_id(SCARG(uap, fileid));
78625537Sdfr    if (lf) {
78725537Sdfr	if (TAILQ_NEXT(lf, link))
78830994Sphk	    p->p_retval[0] = TAILQ_NEXT(lf, link)->id;
78925537Sdfr	else
79030994Sphk	    p->p_retval[0] = 0;
79125537Sdfr    } else
79225537Sdfr	error = ENOENT;
79325537Sdfr
79425537Sdfr    return error;
79525537Sdfr}
79625537Sdfr
79725537Sdfrint
79830994Sphkkldstat(struct proc* p, struct kldstat_args* uap)
79925537Sdfr{
80025537Sdfr    linker_file_t lf;
80125537Sdfr    int error = 0;
80225537Sdfr    int version;
80325537Sdfr    struct kld_file_stat* stat;
80425537Sdfr    int namelen;
80525537Sdfr
80625537Sdfr    lf = linker_find_file_by_id(SCARG(uap, fileid));
80725537Sdfr    if (!lf) {
80825537Sdfr	error = ENOENT;
80925537Sdfr	goto out;
81025537Sdfr    }
81125537Sdfr
81225537Sdfr    stat = SCARG(uap, stat);
81325537Sdfr
81425537Sdfr    /*
81525537Sdfr     * Check the version of the user's structure.
81625537Sdfr     */
81743301Sdillon    if ((error = copyin(&stat->version, &version, sizeof(version))) != 0)
81825537Sdfr	goto out;
81925537Sdfr    if (version != sizeof(struct kld_file_stat)) {
82025537Sdfr	error = EINVAL;
82125537Sdfr	goto out;
82225537Sdfr    }
82325537Sdfr
82425537Sdfr    namelen = strlen(lf->filename) + 1;
82525537Sdfr    if (namelen > MAXPATHLEN)
82625537Sdfr	namelen = MAXPATHLEN;
82743301Sdillon    if ((error = copyout(lf->filename, &stat->name[0], namelen)) != 0)
82825537Sdfr	goto out;
82943301Sdillon    if ((error = copyout(&lf->refs, &stat->refs, sizeof(int))) != 0)
83025537Sdfr	goto out;
83143301Sdillon    if ((error = copyout(&lf->id, &stat->id, sizeof(int))) != 0)
83225537Sdfr	goto out;
83343301Sdillon    if ((error = copyout(&lf->address, &stat->address, sizeof(caddr_t))) != 0)
83425537Sdfr	goto out;
83543301Sdillon    if ((error = copyout(&lf->size, &stat->size, sizeof(size_t))) != 0)
83625537Sdfr	goto out;
83725537Sdfr
83830994Sphk    p->p_retval[0] = 0;
83925537Sdfr
84025537Sdfrout:
84125537Sdfr    return error;
84225537Sdfr}
84325537Sdfr
84425537Sdfrint
84530994Sphkkldfirstmod(struct proc* p, struct kldfirstmod_args* uap)
84625537Sdfr{
84725537Sdfr    linker_file_t lf;
84825537Sdfr    int error = 0;
84925537Sdfr
85025537Sdfr    lf = linker_find_file_by_id(SCARG(uap, fileid));
85125537Sdfr    if (lf) {
85225537Sdfr	if (TAILQ_FIRST(&lf->modules))
85330994Sphk	    p->p_retval[0] = module_getid(TAILQ_FIRST(&lf->modules));
85425537Sdfr	else
85530994Sphk	    p->p_retval[0] = 0;
85625537Sdfr    } else
85725537Sdfr	error = ENOENT;
85825537Sdfr
85925537Sdfr    return error;
86025537Sdfr}
86140159Speter
86241090Speterint
86341090Speterkldsym(struct proc *p, struct kldsym_args *uap)
86441090Speter{
86541090Speter    char *symstr = NULL;
86643309Sdillon    c_linker_sym_t sym;
86741090Speter    linker_symval_t symval;
86841090Speter    linker_file_t lf;
86941090Speter    struct kld_sym_lookup lookup;
87041090Speter    int error = 0;
87141090Speter
87243301Sdillon    if ((error = copyin(SCARG(uap, data), &lookup, sizeof(lookup))) != 0)
87341090Speter	goto out;
87441090Speter    if (lookup.version != sizeof(lookup) || SCARG(uap, cmd) != KLDSYM_LOOKUP) {
87541090Speter	error = EINVAL;
87641090Speter	goto out;
87741090Speter    }
87841090Speter
87941090Speter    symstr = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
88043301Sdillon    if ((error = copyinstr(lookup.symname, symstr, MAXPATHLEN, NULL)) != 0)
88141090Speter	goto out;
88241090Speter
88341090Speter    if (SCARG(uap, fileid) != 0) {
88441090Speter	lf = linker_find_file_by_id(SCARG(uap, fileid));
88541090Speter	if (lf == NULL) {
88641090Speter	    error = ENOENT;
88741090Speter	    goto out;
88841090Speter	}
88959603Sdfr	if (LINKER_LOOKUP_SYMBOL(lf, symstr, &sym) == 0 &&
89059603Sdfr	    LINKER_SYMBOL_VALUES(lf, sym, &symval) == 0) {
89150272Sbde	    lookup.symvalue = (uintptr_t)symval.value;
89241090Speter	    lookup.symsize = symval.size;
89341090Speter	    error = copyout(&lookup, SCARG(uap, data), sizeof(lookup));
89441090Speter	} else
89541090Speter	    error = ENOENT;
89641090Speter    } else {
89771999Sphk	TAILQ_FOREACH(lf, &linker_files, link) {
89859603Sdfr	    if (LINKER_LOOKUP_SYMBOL(lf, symstr, &sym) == 0 &&
89959603Sdfr		LINKER_SYMBOL_VALUES(lf, sym, &symval) == 0) {
90050272Sbde		lookup.symvalue = (uintptr_t)symval.value;
90141090Speter		lookup.symsize = symval.size;
90241090Speter		error = copyout(&lookup, SCARG(uap, data), sizeof(lookup));
90341090Speter		break;
90441090Speter	    }
90541090Speter	}
90641090Speter	if (!lf)
90741090Speter	    error = ENOENT;
90841090Speter    }
90941090Speterout:
91041090Speter    if (symstr)
91141090Speter	free(symstr, M_TEMP);
91241090Speter    return error;
91341090Speter}
91441090Speter
91540159Speter/*
91640159Speter * Preloaded module support
91740159Speter */
91840159Speter
91959751Speterstatic modlist_t
92059751Spetermodlist_lookup(const char *name)
92159751Speter{
92259751Speter    modlist_t mod;
92359751Speter
92471999Sphk    TAILQ_FOREACH(mod, &found_modules, link) {
92559751Speter	if (!strcmp(mod->name, name))
92659751Speter	    return mod;
92759751Speter    }
92859751Speter    return NULL;
92959751Speter}
93059751Speter
93159751Speter/*
93259751Speter * This routine is cheap and nasty but will work for data pointers.
93359751Speter */
93459751Speterstatic void *
93559751Speterlinker_reloc_ptr(linker_file_t lf, void *offset)
93659751Speter{
93759751Speter	return lf->address + (uintptr_t)offset;
93859751Speter}
93959751Speter
94040159Speterstatic void
94140159Speterlinker_preload(void* arg)
94240159Speter{
94340159Speter    caddr_t		modptr;
94464143Speter    char		*modname, *nmodname;
94540162Speter    char		*modtype;
94640159Speter    linker_file_t	lf;
94740159Speter    linker_class_t	lc;
94874639Sbp    int			error;
94940159Speter    struct linker_set	*sysinits;
95059751Speter    linker_file_list_t	loaded_files;
95159751Speter    linker_file_list_t	depended_files;
95259751Speter    struct linker_set	*deps;
95364143Speter    struct mod_metadata	*mp, *nmp;
95464143Speter    int			i, j;
95559751Speter    int			resolves;
95659751Speter    modlist_t		mod;
95740159Speter
95859751Speter    TAILQ_INIT(&loaded_files);
95959751Speter    TAILQ_INIT(&depended_files);
96059751Speter    TAILQ_INIT(&found_modules);
96159751Speter    error = 0;
96259751Speter
96340159Speter    modptr = NULL;
96440159Speter    while ((modptr = preload_search_next_name(modptr)) != NULL) {
96540159Speter	modname = (char *)preload_search_info(modptr, MODINFO_NAME);
96640162Speter	modtype = (char *)preload_search_info(modptr, MODINFO_TYPE);
96740159Speter	if (modname == NULL) {
96840625Smsmith	    printf("Preloaded module at %p does not have a name!\n", modptr);
96940159Speter	    continue;
97040159Speter	}
97140162Speter	if (modtype == NULL) {
97240625Smsmith	    printf("Preloaded module at %p does not have a type!\n", modptr);
97340162Speter	    continue;
97440162Speter	}
97540625Smsmith	printf("Preloaded %s \"%s\" at %p.\n", modtype, modname, modptr);
97640159Speter	lf = NULL;
97771999Sphk	TAILQ_FOREACH(lc, &classes, link) {
97859751Speter	    error = LINKER_LINK_PRELOAD(lc, modname, &lf);
97940159Speter	    if (error) {
98040159Speter		lf = NULL;
98140159Speter		break;
98240159Speter	    }
98340159Speter	}
98459751Speter	if (lf)
98559751Speter	    TAILQ_INSERT_TAIL(&loaded_files, lf, loaded);
98659751Speter    }
98740159Speter
98859751Speter    /*
98959751Speter     * First get a list of stuff in the kernel.
99059751Speter     */
99159751Speter    deps = (struct linker_set*)
99259751Speter	linker_file_lookup_symbol(linker_kernel_file, MDT_SETNAME, 0);
99359751Speter    if (deps) {
99459751Speter	for (i = 0; i < deps->ls_length; i++) {
99559751Speter	    mp = deps->ls_items[i];
99659751Speter	    if (mp->md_type != MDT_VERSION)
99759751Speter		continue;
99859751Speter	    modname = mp->md_cval;
99959751Speter	    if (modlist_lookup(modname) != NULL) {
100059751Speter		printf("module %s already present!\n", modname);
100159751Speter		/* XXX what can we do? this is a build error. :-( */
100259751Speter		continue;
100359751Speter	    }
100469781Sdwmalone	    mod = malloc(sizeof(struct modlist), M_LINKER, M_NOWAIT|M_ZERO);
100559751Speter	    if (mod == NULL)
100659751Speter		panic("no memory for module list");
100759751Speter	    mod->container = linker_kernel_file;
100859751Speter	    mod->name = modname;
100959751Speter	    TAILQ_INSERT_TAIL(&found_modules, mod, link);
101059751Speter	}
101159751Speter    }
101259751Speter
101359751Speter    /*
101459751Speter     * this is a once-off kinky bubble sort
101559751Speter     * resolve relocation dependency requirements
101659751Speter     */
101759751Speterrestart:
101871999Sphk    TAILQ_FOREACH(lf, &loaded_files, loaded) {
101959751Speter	deps = (struct linker_set*)
102059751Speter	    linker_file_lookup_symbol(lf, MDT_SETNAME, 0);
102159751Speter	/*
102259751Speter	 * First, look to see if we would successfully link with this stuff.
102359751Speter	 */
102459751Speter	resolves = 1;	/* unless we know otherwise */
102559751Speter	if (deps) {
102659751Speter	    for (i = 0; i < deps->ls_length; i++) {
102759751Speter		mp = linker_reloc_ptr(lf, deps->ls_items[i]);
102859751Speter		if (mp->md_type != MDT_DEPEND)
102959751Speter		    continue;
103059751Speter		modname = linker_reloc_ptr(lf, mp->md_cval);
103164143Speter		for (j = 0; j < deps->ls_length; j++) {
103264143Speter		    nmp = linker_reloc_ptr(lf, deps->ls_items[j]);
103364143Speter		    if (nmp->md_type != MDT_VERSION)
103464143Speter			continue;
103564143Speter		    nmodname = linker_reloc_ptr(lf, nmp->md_cval);
103664143Speter		    if (strcmp(modname, nmodname) == 0)
103764143Speter			break;
103864143Speter		}
103964143Speter		if (j < deps->ls_length)	/* it's a self reference */
104064143Speter		    continue;
104159751Speter		if (modlist_lookup(modname) == NULL) {
104259751Speter		    /* ok, the module isn't here yet, we are not finished */
104359751Speter		    resolves = 0;
104459751Speter		}
104559751Speter	    }
104659751Speter	}
104759751Speter	/*
104859751Speter	 * OK, if we found our modules, we can link.  So, "provide" the
104959751Speter	 * modules inside and add it to the end of the link order list.
105059751Speter	 */
105159751Speter	if (resolves) {
105259751Speter	    if (deps) {
105359751Speter		for (i = 0; i < deps->ls_length; i++) {
105459751Speter		    mp = linker_reloc_ptr(lf, deps->ls_items[i]);
105559751Speter		    if (mp->md_type != MDT_VERSION)
105659751Speter			continue;
105759751Speter		    modname = linker_reloc_ptr(lf, mp->md_cval);
105859751Speter		    if (modlist_lookup(modname) != NULL) {
105959751Speter			printf("module %s already present!\n", modname);
106059751Speter			linker_file_unload(lf);
106159751Speter			TAILQ_REMOVE(&loaded_files, lf, loaded);
106259751Speter			goto restart;	/* we changed the tailq next ptr */
106340159Speter		    }
106469781Sdwmalone		    mod = malloc(sizeof(struct modlist), M_LINKER,
106569781Sdwmalone			M_NOWAIT|M_ZERO);
106659751Speter		    if (mod == NULL)
106759751Speter			panic("no memory for module list");
106859751Speter		    mod->container = lf;
106959751Speter		    mod->name = modname;
107059751Speter		    TAILQ_INSERT_TAIL(&found_modules, mod, link);
107140159Speter		}
107240159Speter	    }
107359751Speter	    TAILQ_REMOVE(&loaded_files, lf, loaded);
107459751Speter	    TAILQ_INSERT_TAIL(&depended_files, lf, loaded);
107559751Speter	    /*
107659751Speter	     * Since we provided modules, we need to restart the sort so
107759751Speter	     * that the previous files that depend on us have a chance.
107859751Speter	     * Also, we've busted the tailq next pointer with the REMOVE.
107959751Speter	     */
108059751Speter	    goto restart;
108140159Speter	}
108240159Speter    }
108359751Speter
108459751Speter    /*
108559751Speter     * At this point, we check to see what could not be resolved..
108659751Speter     */
108771999Sphk    TAILQ_FOREACH(lf, &loaded_files, loaded) {
108859751Speter	printf("KLD file %s is missing dependencies\n", lf->filename);
108959751Speter	linker_file_unload(lf);
109059751Speter	TAILQ_REMOVE(&loaded_files, lf, loaded);
109159751Speter    }
109259751Speter
109359751Speter    /*
109459751Speter     * We made it. Finish off the linking in the order we determined.
109559751Speter     */
109671999Sphk    TAILQ_FOREACH(lf, &depended_files, loaded) {
109759751Speter	if (linker_kernel_file) {
109859751Speter	    linker_kernel_file->refs++;
109959751Speter	    error = linker_file_add_dependancy(lf, linker_kernel_file);
110059751Speter	    if (error)
110159751Speter		panic("cannot add dependency");
110259751Speter	}
110359751Speter	lf->userrefs++;		/* so we can (try to) kldunload it */
110459751Speter	deps = (struct linker_set*)
110559751Speter	    linker_file_lookup_symbol(lf, MDT_SETNAME, 0);
110659751Speter	if (deps) {
110759751Speter	    for (i = 0; i < deps->ls_length; i++) {
110859751Speter		mp = linker_reloc_ptr(lf, deps->ls_items[i]);
110959751Speter		if (mp->md_type != MDT_DEPEND)
111059751Speter		    continue;
111159751Speter		modname = linker_reloc_ptr(lf, mp->md_cval);
111259751Speter		mod = modlist_lookup(modname);
111359751Speter		mod->container->refs++;
111459751Speter		error = linker_file_add_dependancy(lf, mod->container);
111559751Speter		if (error)
111659751Speter		    panic("cannot add dependency");
111759751Speter	    }
111859751Speter	}
111959751Speter
112059751Speter	/* Now do relocation etc using the symbol search paths established by the dependencies */
112159751Speter	error = LINKER_LINK_PRELOAD_FINISH(lf);
112259751Speter	if (error) {
112359751Speter	    printf("KLD file %s - could not finalize loading\n", lf->filename);
112459751Speter	    linker_file_unload(lf);
112559751Speter	    continue;
112659751Speter	}
112759751Speter
112874639Sbp	linker_file_register_modules(lf);
112959751Speter	sysinits = (struct linker_set*)
113059751Speter	    linker_file_lookup_symbol(lf, "sysinit_set", 0);
113159751Speter	if (sysinits)
113259751Speter	    sysinit_add((struct sysinit **)sysinits->ls_items);
113359751Speter	linker_file_register_sysctls(lf);
113459751Speter	lf->flags |= LINKER_FILE_LINKED;
113559751Speter    }
113659751Speter    /* woohoo! we made it! */
113740159Speter}
113840159Speter
113940159SpeterSYSINIT(preload, SI_SUB_KLD, SI_ORDER_MIDDLE, linker_preload, 0);
114040159Speter
114140159Speter/*
114240159Speter * Search for a not-loaded module by name.
114340159Speter *
114440159Speter * Modules may be found in the following locations:
114540159Speter *
114640159Speter * - preloaded (result is just the module name)
114740159Speter * - on disk (result is full path to module)
114840159Speter *
114940159Speter * If the module name is qualified in any way (contains path, etc.)
115040159Speter * the we simply return a copy of it.
115140159Speter *
115240159Speter * The search path can be manipulated via sysctl.  Note that we use the ';'
115340159Speter * character as a separator to be consistent with the bootloader.
115440159Speter */
115540159Speter
115670417Speterstatic char def_linker_path[] = "/boot/modules/;/modules/;/boot/kernel/";
115770417Speterstatic char linker_path[MAXPATHLEN] = "";
115840159Speter
115940159SpeterSYSCTL_STRING(_kern, OID_AUTO, module_path, CTLFLAG_RW, linker_path,
116040159Speter	      sizeof(linker_path), "module load search path");
116140159Speter
116270417SpeterTUNABLE_STR_DECL("module_path", def_linker_path, linker_path,
116370417Speter		 sizeof(linker_path));
116470417Speter
116559751Speterstatic char *linker_ext_list[] = {
116659751Speter	".ko",
116759751Speter	"",
116859751Speter	NULL
116959751Speter};
117059751Speter
117159751Speterstatic char *
117240159Speterlinker_search_path(const char *name)
117340159Speter{
117440159Speter    struct nameidata	nd;
117540159Speter    struct proc		*p = curproc;	/* XXX */
117659751Speter    char		*cp, *ep, *result, **cpp;
117762550Smckusick    int			error, extlen, len, flags;
117840159Speter    enum vtype		type;
117940159Speter
118040159Speter    /* qualified at all? */
118154411Speter    if (index(name, '/'))
118240159Speter	return(linker_strdup(name));
118340159Speter
118459751Speter    extlen = 0;
118559751Speter    for (cpp = linker_ext_list; *cpp; cpp++) {
118659751Speter	len = strlen(*cpp);
118759751Speter	if (len > extlen)
118859751Speter	    extlen = len;
118959751Speter    }
119059751Speter    extlen++;	/* trailing '\0' */
119159751Speter
119240159Speter    /* traverse the linker path */
119340159Speter    cp = linker_path;
119459751Speter    len = strlen(name);
119540159Speter    for (;;) {
119640159Speter
119740159Speter	/* find the end of this component */
119840159Speter	for (ep = cp; (*ep != 0) && (*ep != ';'); ep++)
119940159Speter	    ;
120070417Speter	result = malloc((len + (ep - cp) + extlen + 1), M_LINKER, M_WAITOK);
120140159Speter	if (result == NULL)	/* actually ENOMEM */
120240159Speter	    return(NULL);
120359751Speter	for (cpp = linker_ext_list; *cpp; cpp++) {
120459751Speter	    strncpy(result, cp, ep - cp);
120570417Speter	    strcpy(result + (ep - cp), "/");
120670417Speter	    strcat(result, name);
120759751Speter	    strcat(result, *cpp);
120859751Speter	    /*
120959751Speter	     * Attempt to open the file, and return the path if we succeed
121059751Speter	     * and it's a regular file.
121159751Speter	     */
121259751Speter	    NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, result, p);
121362550Smckusick	    flags = FREAD;
121462550Smckusick	    error = vn_open(&nd, &flags, 0);
121559751Speter	    if (error == 0) {
121659751Speter		NDFREE(&nd, NDF_ONLY_PNBUF);
121759751Speter		type = nd.ni_vp->v_type;
121859751Speter		VOP_UNLOCK(nd.ni_vp, 0, p);
121959751Speter		vn_close(nd.ni_vp, FREAD, p->p_ucred, p);
122059751Speter		if (type == VREG)
122159751Speter		    return(result);
122259751Speter	    }
122340159Speter	}
122440159Speter	free(result, M_LINKER);
122540159Speter
122640159Speter	if (*ep == 0)
122740159Speter	    break;
122840159Speter	cp = ep + 1;
122940159Speter    }
123040159Speter    return(NULL);
123140159Speter}
123259751Speter
123359751Speterstatic const char *
123459751Speterlinker_basename(const char* path)
123559751Speter{
123659751Speter    const char *filename;
123759751Speter
123859751Speter    filename = rindex(path, '/');
123959751Speter    if (filename == NULL)
124059751Speter	return path;
124159751Speter    if (filename[1])
124259751Speter	filename++;
124359751Speter    return filename;
124459751Speter}
124559751Speter
124659751Speter/*
124759751Speter * Find a file which contains given module and load it,
124859751Speter * if "parent" is not NULL, register a reference to it.
124959751Speter */
125059751Speterstatic int
125159751Speterlinker_load_module(const char *modname, struct linker_file *parent)
125259751Speter{
125359751Speter    linker_file_t lfdep;
125459751Speter    const char *filename;
125559751Speter    char *pathname;
125659751Speter    int error;
125759751Speter
125859751Speter    /*
125959751Speter     * There will be a system to look up or guess a file name from
126059751Speter     * a module name.
126159751Speter     * For now we just try to load a file with the same name.
126259751Speter     */
126359751Speter    pathname = linker_search_path(modname);
126459751Speter    if (pathname == NULL)
126559751Speter	return ENOENT;
126659751Speter
126759751Speter    /* Can't load more than one file with the same basename */
126859751Speter    filename = linker_basename(pathname);
126959751Speter    if (linker_find_file_by_name(filename)) {
127059751Speter	error = EEXIST;
127159751Speter	goto out;
127259751Speter    }
127359751Speter
127459751Speter    do {
127559751Speter	error = linker_load_file(pathname, &lfdep);
127659751Speter	if (error)
127759751Speter	    break;
127859751Speter	if (parent) {
127959751Speter	    error = linker_file_add_dependancy(parent, lfdep);
128059751Speter	    if (error)
128159751Speter		break;
128259751Speter	}
128359751Speter    } while(0);
128459751Speterout:
128559751Speter    if (pathname)
128659751Speter	free(pathname, M_LINKER);
128759751Speter    return error;
128859751Speter}
128959751Speter
129059751Speter/*
129159751Speter * This routine is responsible for finding dependencies of userland
129259751Speter * initiated kldload(2)'s of files.
129359751Speter */
129459751Speterint
129559751Speterlinker_load_dependancies(linker_file_t lf)
129659751Speter{
129759751Speter    linker_file_t lfdep;
129859751Speter    struct linker_set *deps;
129959751Speter    struct mod_metadata *mp, *nmp;
130059751Speter    modlist_t mod;
130159751Speter    char *modname, *nmodname;
130259751Speter    int i, j, error = 0;
130359751Speter
130459751Speter    /*
130559751Speter     * All files are dependant on /kernel.
130659751Speter     */
130759751Speter    if (linker_kernel_file) {
130859751Speter	linker_kernel_file->refs++;
130959751Speter	error = linker_file_add_dependancy(lf, linker_kernel_file);
131059751Speter	if (error)
131159751Speter	    return error;
131259751Speter    }
131359751Speter
131459751Speter    deps = (struct linker_set*)
131559751Speter	linker_file_lookup_symbol(lf, MDT_SETNAME, 0);
131674641Sbp    if (deps == NULL)
131774641Sbp	return 0;
131874641Sbp    for (i = 0; i < deps->ls_length; i++) {
131974641Sbp	mp = linker_reloc_ptr(lf, deps->ls_items[i]);
132074641Sbp	if (mp->md_type != MDT_VERSION)
132174641Sbp	    continue;
132274641Sbp	modname = linker_reloc_ptr(lf, mp->md_cval);
132374641Sbp	if (modlist_lookup(modname) != NULL) {
132474641Sbp	    printf("module %s already present!\n", modname);
132574641Sbp	    return EEXIST;
132659751Speter	}
132759751Speter    }
132874641Sbp    for (i = 0; i < deps->ls_length; i++) {
132974641Sbp	mp = linker_reloc_ptr(lf, deps->ls_items[i]);
133074641Sbp	if (mp->md_type != MDT_DEPEND)
133174641Sbp	    continue;
133274641Sbp	modname = linker_reloc_ptr(lf, mp->md_cval);
133374641Sbp	nmodname = NULL;
133474641Sbp	for (j = 0; j < deps->ls_length; j++) {
133574641Sbp	    nmp = linker_reloc_ptr(lf, deps->ls_items[j]);
133674641Sbp	    if (nmp->md_type != MDT_VERSION)
133759751Speter		continue;
133874641Sbp	    nmodname = linker_reloc_ptr(lf, nmp->md_cval);
133974641Sbp	    if (strcmp(modname, nmodname) == 0)
134059751Speter		break;
134159751Speter	}
134274641Sbp	if (j < deps->ls_length)	/* early exit, it's a self reference */
134374641Sbp	    continue;
134474641Sbp	mod = modlist_lookup(modname);
134574641Sbp	if (mod) {		/* woohoo, it's loaded already */
134674641Sbp	    lfdep = mod->container;
134774641Sbp	    lfdep->refs++;
134874641Sbp	    error = linker_file_add_dependancy(lf, lfdep);
134974641Sbp	    if (error)
135074641Sbp		break;
135174641Sbp	    continue;
135274641Sbp	}
135374641Sbp	error = linker_load_module(modname, lf);
135474641Sbp	if (error) {
135574641Sbp	    printf("KLD %s: depends on %s - not available\n",
135674641Sbp		lf->filename, modname);
135774641Sbp	    break;
135874641Sbp	}
135974641Sbp    }
136059751Speter
136174641Sbp    if (error)
136274641Sbp	return error;
136374641Sbp    for (i = 0; i < deps->ls_length; i++) {
136474641Sbp	mp = linker_reloc_ptr(lf, deps->ls_items[i]);
136574641Sbp	if (mp->md_type != MDT_VERSION)
136674641Sbp	    continue;
136774641Sbp	modname = linker_reloc_ptr(lf, mp->md_cval);
136874641Sbp	mod = malloc(sizeof(struct modlist), M_LINKER, M_NOWAIT|M_ZERO);
136974641Sbp	if (mod == NULL)
137074641Sbp	    panic("no memory for module list");
137174641Sbp	mod->container = lf;
137274641Sbp	mod->name = modname;
137374641Sbp	TAILQ_INSERT_TAIL(&found_modules, mod, link);
137459751Speter    }
137559751Speter    return error;
137659751Speter}
1377