2a7c586c7b151c86a13c0954d9a73a65955ae78e
[dragonfly.git] / sys / kern / kern_linker.c
1 /*-
2  * Copyright (c) 1997 Doug Rabson
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  * $FreeBSD: src/sys/kern/kern_linker.c,v 1.41.2.3 2001/11/21 17:50:35 luigi Exp $
27  * $DragonFly: src/sys/kern/kern_linker.c,v 1.39 2007/11/19 18:49:06 swildner Exp $
28  */
29
30 #include "opt_ddb.h"
31
32 #include <sys/param.h>
33 #include <sys/kernel.h>
34 #include <sys/systm.h>
35 #include <sys/malloc.h>
36 #include <sys/sysproto.h>
37 #include <sys/sysent.h>
38 #include <sys/proc.h>
39 #include <sys/lock.h>
40 #include <sys/module.h>
41 #include <sys/linker.h>
42 #include <sys/fcntl.h>
43 #include <sys/libkern.h>
44 #include <sys/nlookup.h>
45 #include <sys/vnode.h>
46 #include <sys/sysctl.h>
47
48 #include <vm/vm_zone.h>
49
50 #ifdef _KERNEL_VIRTUAL
51 #include <dlfcn.h>
52 #endif
53
54 #ifdef KLD_DEBUG
55 int kld_debug = 0;
56 #endif
57
58 /* Metadata from the static kernel */
59 SET_DECLARE(modmetadata_set, struct mod_metadata);
60 MALLOC_DEFINE(M_LINKER, "kld", "kernel linker");
61
62 linker_file_t linker_current_file;
63 linker_file_t linker_kernel_file;
64
65 static struct lock lock;        /* lock for the file list */
66 static linker_class_list_t classes;
67 static linker_file_list_t linker_files;
68 static int next_file_id = 1;
69
70 static void
71 linker_init(void* arg)
72 {
73     lockinit(&lock, "klink", 0, 0);
74     TAILQ_INIT(&classes);
75     TAILQ_INIT(&linker_files);
76 }
77
78 SYSINIT(linker, SI_BOOT2_KLD, SI_ORDER_FIRST, linker_init, 0);
79
80 int
81 linker_add_class(const char* desc, void* priv,
82                  struct linker_class_ops* ops)
83 {
84     linker_class_t lc;
85
86     lc = kmalloc(sizeof(struct linker_class), M_LINKER, M_NOWAIT);
87     if (!lc)
88         return ENOMEM;
89     bzero(lc, sizeof(*lc));
90
91     lc->desc = desc;
92     lc->priv = priv;
93     lc->ops = ops;
94     TAILQ_INSERT_HEAD(&classes, lc, link);
95
96     return 0;
97 }
98
99 static int
100 linker_file_sysinit(linker_file_t lf)
101 {
102     struct sysinit** start, ** stop;
103     struct sysinit** sipp;
104     struct sysinit** xipp;
105     struct sysinit* save;
106     const moduledata_t *moddata;
107     int error;
108
109     KLD_DPF(FILE, ("linker_file_sysinit: calling SYSINITs for %s\n",
110                    lf->filename));
111
112     if (linker_file_lookup_set(lf, "sysinit_set", &start, &stop, NULL) != 0)
113         return 0; /* XXX is this correct ? No sysinit ? */
114
115     /* HACK ALERT! */
116     for (sipp = start; sipp < stop; sipp++) {
117         if ((*sipp)->func == module_register_init) {
118             moddata = (*sipp)->udata;
119             error = module_register(moddata, lf);
120             if (error) {
121                 kprintf("linker_file_sysinit \"%s\" failed to register! %d\n",
122                     lf->filename, error);
123                 return error;
124             }
125         }
126     }
127             
128     /*
129      * Perform a bubble sort of the system initialization objects by
130      * their subsystem (primary key) and order (secondary key).
131      *
132      * Since some things care about execution order, this is the
133      * operation which ensures continued function.
134      */
135     for (sipp = start; sipp < stop; sipp++) {
136         for (xipp = sipp + 1; xipp < stop; xipp++) {
137             if ((*sipp)->subsystem < (*xipp)->subsystem ||
138                  ((*sipp)->subsystem == (*xipp)->subsystem &&
139                   (*sipp)->order <= (*xipp)->order))
140                 continue;       /* skip*/
141             save = *sipp;
142             *sipp = *xipp;
143             *xipp = save;
144         }
145     }
146
147
148     /*
149      * Traverse the (now) ordered list of system initialization tasks.
150      * Perform each task, and continue on to the next task.
151      */
152     for (sipp = start; sipp < stop; sipp++) {
153         if ((*sipp)->subsystem == SI_SPECIAL_DUMMY)
154             continue;   /* skip dummy task(s)*/
155
156         /* Call function */
157         (*((*sipp)->func))((*sipp)->udata);
158     }
159     return 0; /* no errors */
160 }
161
162 static void
163 linker_file_sysuninit(linker_file_t lf)
164 {
165     struct sysinit** start, ** stop;
166     struct sysinit** sipp;
167     struct sysinit** xipp;
168     struct sysinit* save;
169
170     KLD_DPF(FILE, ("linker_file_sysuninit: calling SYSUNINITs for %s\n",
171                    lf->filename));
172
173     if (linker_file_lookup_set(lf, "sysuninit_set", &start, &stop, NULL) != 0)
174         return;
175
176     /*
177      * Perform a reverse bubble sort of the system initialization objects
178      * by their subsystem (primary key) and order (secondary key).
179      *
180      * Since some things care about execution order, this is the
181      * operation which ensures continued function.
182      */
183     for (sipp = start; sipp < stop; sipp++) {
184         for (xipp = sipp + 1; xipp < stop; xipp++) {
185             if ((*sipp)->subsystem > (*xipp)->subsystem ||
186                  ((*sipp)->subsystem == (*xipp)->subsystem &&
187                   (*sipp)->order >= (*xipp)->order))
188                 continue;       /* skip*/
189             save = *sipp;
190             *sipp = *xipp;
191             *xipp = save;
192         }
193     }
194
195
196     /*
197      * Traverse the (now) ordered list of system initialization tasks.
198      * Perform each task, and continue on to the next task.
199      */
200     for (sipp = start; sipp < stop; sipp++) {
201         if ((*sipp)->subsystem == SI_SPECIAL_DUMMY)
202             continue;   /* skip dummy task(s)*/
203
204         /* Call function */
205         (*((*sipp)->func))((*sipp)->udata);
206     }
207 }
208
209 static void
210 linker_file_register_sysctls(linker_file_t lf)
211 {
212     struct sysctl_oid **start, **stop, **oidp;
213
214     KLD_DPF(FILE, ("linker_file_register_sysctls: registering SYSCTLs for %s\n",
215                    lf->filename));
216
217     if (linker_file_lookup_set(lf, "sysctl_set", &start, &stop, NULL) != 0)
218         return;
219     for (oidp = start; oidp < stop; oidp++)
220         sysctl_register_oid(*oidp);
221 }
222
223 static void
224 linker_file_unregister_sysctls(linker_file_t lf)
225 {
226     struct sysctl_oid **start, **stop, **oidp;
227
228     KLD_DPF(FILE, ("linker_file_unregister_sysctls: registering SYSCTLs for %s\n",
229                    lf->filename));
230
231     if (linker_file_lookup_set(lf, "sysctl_set", &start, &stop, NULL) != 0)
232         return;
233     for (oidp = start; oidp < stop; oidp++)
234         sysctl_unregister_oid(*oidp);
235 }
236
237 int
238 linker_load_file(const char* filename, linker_file_t* result)
239 {
240     linker_class_t lc;
241     linker_file_t lf;
242     int foundfile, error = 0;
243     char *koname = NULL;
244
245     /* Refuse to load modules if securelevel raised */
246     if (securelevel > 0 || kernel_mem_readonly)
247         return EPERM; 
248
249     lf = linker_find_file_by_name(filename);
250     if (lf) {
251         KLD_DPF(FILE, ("linker_load_file: file %s is already loaded, incrementing refs\n", filename));
252         *result = lf;
253         lf->refs++;
254         goto out;
255     }
256     if (find_mod_metadata(filename)) {
257         if (linker_kernel_file)
258             ++linker_kernel_file->refs;
259         *result = linker_kernel_file;
260         goto out;
261     }
262
263     koname = kmalloc(strlen(filename) + 4, M_LINKER, M_WAITOK);
264     if (koname == NULL) {
265         error = ENOMEM;
266         goto out;
267     }
268     ksprintf(koname, "%s.ko", filename);
269     lf = NULL;
270     foundfile = 0;
271     for (lc = TAILQ_FIRST(&classes); lc; lc = TAILQ_NEXT(lc, link)) {
272         KLD_DPF(FILE, ("linker_load_file: trying to load %s as %s\n",
273                        filename, lc->desc));
274
275         error = lc->ops->load_file(koname, &lf);        /* First with .ko */
276         if (lf == NULL && error == ENOENT)
277             error = lc->ops->load_file(filename, &lf);  /* Then try without */
278         /*
279          * If we got something other than ENOENT, then it exists but we cannot
280          * load it for some other reason.
281          */
282         if (error != ENOENT)
283             foundfile = 1;
284         if (lf) {
285             linker_file_register_sysctls(lf);
286             error = linker_file_sysinit(lf);
287
288             *result = lf;
289             goto out;
290         }
291     }
292     /*
293      * Less than ideal, but tells the user whether it failed to load or
294      * the module was not found.
295      */
296     if (foundfile) {
297             /*
298              * Format not recognized or otherwise unloadable.
299              * When loading a module that is statically built into
300              * the kernel EEXIST percolates back up as the return
301              * value.  Preserve this so that apps can recognize this
302              * special case.
303              */
304             if (error != EEXIST)
305                     error = ENOEXEC;
306     } else {
307         error = ENOENT;         /* Nothing found */
308     }
309
310 out:
311     if (koname)
312         kfree(koname, M_LINKER);
313     return error;
314 }
315
316 linker_file_t
317 linker_find_file_by_name(const char* filename)
318 {
319     linker_file_t lf = 0;
320     char *koname;
321     int i;
322
323     for (i = strlen(filename); i > 0 && filename[i-1] != '/'; --i)
324         ;
325     filename += i;
326
327     koname = kmalloc(strlen(filename) + 4, M_LINKER, M_WAITOK);
328     if (koname == NULL)
329         goto out;
330     ksprintf(koname, "%s.ko", filename);
331
332     lockmgr(&lock, LK_SHARED);
333     for (lf = TAILQ_FIRST(&linker_files); lf; lf = TAILQ_NEXT(lf, link)) {
334         if (!strcmp(lf->filename, koname))
335             break;
336         if (!strcmp(lf->filename, filename))
337             break;
338     }
339     lockmgr(&lock, LK_RELEASE);
340
341 out:
342     if (koname)
343         kfree(koname, M_LINKER);
344     return lf;
345 }
346
347 linker_file_t
348 linker_find_file_by_id(int fileid)
349 {
350     linker_file_t lf = 0;
351
352     lockmgr(&lock, LK_SHARED);
353     for (lf = TAILQ_FIRST(&linker_files); lf; lf = TAILQ_NEXT(lf, link))
354         if (lf->id == fileid)
355             break;
356     lockmgr(&lock, LK_RELEASE);
357
358     return lf;
359 }
360
361 linker_file_t
362 linker_make_file(const char* pathname, void* priv, struct linker_file_ops* ops)
363 {
364     linker_file_t lf = 0;
365     int namelen;
366     const char *filename;
367
368     filename = rindex(pathname, '/');
369     if (filename && filename[1])
370         filename++;
371     else
372         filename = pathname;
373
374     KLD_DPF(FILE, ("linker_make_file: new file, filename=%s\n", filename));
375     lockmgr(&lock, LK_EXCLUSIVE);
376     namelen = strlen(filename) + 1;
377     lf = kmalloc(sizeof(struct linker_file) + namelen, M_LINKER, M_WAITOK);
378     if (!lf)
379         goto out;
380     bzero(lf, sizeof(*lf));
381
382     lf->refs = 1;
383     lf->userrefs = 0;
384     lf->flags = 0;
385     lf->filename = (char*) (lf + 1);
386     strcpy(lf->filename, filename);
387     lf->id = next_file_id++;
388     lf->ndeps = 0;
389     lf->deps = NULL;
390     STAILQ_INIT(&lf->common);
391     TAILQ_INIT(&lf->modules);
392
393     lf->priv = priv;
394     lf->ops = ops;
395     TAILQ_INSERT_TAIL(&linker_files, lf, link);
396
397 out:
398     lockmgr(&lock, LK_RELEASE);
399     return lf;
400 }
401
402 int
403 linker_file_unload(linker_file_t file)
404 {
405     module_t mod, next;
406     struct common_symbol* cp;
407     int error = 0;
408     int i;
409
410     /* Refuse to unload modules if securelevel raised */
411     if (securelevel > 0 || kernel_mem_readonly)
412         return EPERM; 
413
414     KLD_DPF(FILE, ("linker_file_unload: lf->refs=%d\n", file->refs));
415     lockmgr(&lock, LK_EXCLUSIVE);
416     if (file->refs == 1) {
417         KLD_DPF(FILE, ("linker_file_unload: file is unloading, informing modules\n"));
418         /*
419          * Temporarily bump file->refs to prevent recursive unloading
420          */
421         ++file->refs;
422
423         /*
424          * Inform any modules associated with this file.
425          */
426         mod = TAILQ_FIRST(&file->modules);
427         while (mod) {
428             /*
429              * Give the module a chance to veto the unload.  Note that the
430              * act of unloading the module may cause other modules in the
431              * same file list to be unloaded recursively.
432              */
433             if ((error = module_unload(mod)) != 0) {
434                 KLD_DPF(FILE, ("linker_file_unload: module %x vetoes unload\n",
435                                mod));
436                 lockmgr(&lock, LK_RELEASE);
437                 file->refs--;
438                 goto out;
439             }
440
441             /*
442              * Recursive relationships may prevent the release from
443              * immediately removing the module, or may remove other
444              * modules in the list.
445              */
446             next = module_getfnext(mod);
447             module_release(mod);
448             mod = next;
449         }
450
451         /*
452          * Since we intend to destroy the file structure, we expect all
453          * modules to have been removed by now.
454          */
455         for (mod = TAILQ_FIRST(&file->modules); 
456              mod; 
457              mod = module_getfnext(mod)
458         ) {
459             kprintf("linker_file_unload: module %p still has refs!\n", mod);
460         }
461         --file->refs;
462     }
463
464     file->refs--;
465     if (file->refs > 0) {
466         lockmgr(&lock, LK_RELEASE);
467         goto out;
468     }
469
470     /* Don't try to run SYSUNINITs if we are unloaded due to a link error */
471     if (file->flags & LINKER_FILE_LINKED) {
472         linker_file_sysuninit(file);
473         linker_file_unregister_sysctls(file);
474     }
475
476     TAILQ_REMOVE(&linker_files, file, link);
477     lockmgr(&lock, LK_RELEASE);
478
479     for (i = 0; i < file->ndeps; i++)
480         linker_file_unload(file->deps[i]);
481     kfree(file->deps, M_LINKER);
482
483     for (cp = STAILQ_FIRST(&file->common); cp;
484          cp = STAILQ_FIRST(&file->common)) {
485         STAILQ_REMOVE(&file->common, cp, common_symbol, link);
486         kfree(cp, M_LINKER);
487     }
488
489     file->ops->unload(file);
490     kfree(file, M_LINKER);
491
492 out:
493     return error;
494 }
495
496 int
497 linker_file_add_dependancy(linker_file_t file, linker_file_t dep)
498 {
499     linker_file_t* newdeps;
500
501     newdeps = kmalloc((file->ndeps + 1) * sizeof(linker_file_t*),
502                      M_LINKER, M_WAITOK);
503     if (newdeps == NULL)
504         return ENOMEM;
505     bzero(newdeps, (file->ndeps + 1) * sizeof(linker_file_t*));
506
507     if (file->deps) {
508         bcopy(file->deps, newdeps, file->ndeps * sizeof(linker_file_t*));
509         kfree(file->deps, M_LINKER);
510     }
511     file->deps = newdeps;
512     file->deps[file->ndeps] = dep;
513     file->ndeps++;
514
515     return 0;
516 }
517
518 /*
519  * Locate a linker set and its contents.
520  * This is a helper function to avoid linker_if.h exposure elsewhere.
521  * Note: firstp and lastp are really void ***
522  */
523 int
524 linker_file_lookup_set(linker_file_t file, const char *name,
525                       void *firstp, void *lastp, int *countp)
526 {
527     return file->ops->lookup_set(file, name, firstp, lastp, countp);
528 }
529
530 int
531 linker_file_lookup_symbol(linker_file_t file, const char* name, int deps, caddr_t *raddr)
532 {
533     c_linker_sym_t sym;
534     linker_symval_t symval;
535     linker_file_t lf;
536     size_t common_size = 0;
537     int i;
538
539     KLD_DPF(SYM, ("linker_file_lookup_symbol: file=%x, name=%s, deps=%d\n",
540                   file, name, deps));
541
542     if (file->ops->lookup_symbol(file, name, &sym) == 0) {
543         file->ops->symbol_values(file, sym, &symval);
544
545         /*
546          * XXX Assume a common symbol if its value is 0 and it has a non-zero
547          * size, otherwise it could be an absolute symbol with a value of 0.
548          */
549         if (symval.value == 0 && symval.size != 0) {
550             /*
551              * For commons, first look them up in the dependancies and
552              * only allocate space if not found there.
553              */
554             common_size = symval.size;
555         } else {
556             KLD_DPF(SYM, ("linker_file_lookup_symbol: symbol.value=%x\n", symval.value));
557             *raddr = symval.value;
558             return 0;
559         }
560     }
561     if (deps) {
562         for (i = 0; i < file->ndeps; i++) {
563             if (linker_file_lookup_symbol(file->deps[i], name, 0, raddr) == 0) {
564                 KLD_DPF(SYM, ("linker_file_lookup_symbol: deps value=%x\n", *raddr));
565                 return 0;
566             }
567         }
568
569         /* If we have not found it in the dependencies, search globally */
570         for (lf = TAILQ_FIRST(&linker_files); lf; lf = TAILQ_NEXT(lf, link)) {
571             /* But skip the current file if it's on the list */
572             if (lf == file)
573                 continue;
574             /* And skip the files we searched above */
575             for (i = 0; i < file->ndeps; i++)
576                 if (lf == file->deps[i])
577                     break;
578             if (i < file->ndeps)
579                 continue;
580             if (linker_file_lookup_symbol(lf, name, 0, raddr) == 0) {
581                 KLD_DPF(SYM, ("linker_file_lookup_symbol: global value=%x\n", *raddr));
582                 return 0;
583             }
584         }
585     }
586
587     if (common_size > 0) {
588         /*
589          * This is a common symbol which was not found in the
590          * dependancies.  We maintain a simple common symbol table in
591          * the file object.
592          */
593         struct common_symbol* cp;
594
595         for (cp = STAILQ_FIRST(&file->common); cp;
596              cp = STAILQ_NEXT(cp, link))
597             if (!strcmp(cp->name, name)) {
598                 KLD_DPF(SYM, ("linker_file_lookup_symbol: old common value=%x\n", cp->address));
599                 *raddr = cp->address;
600                 return 0;
601             }
602
603         /*
604          * Round the symbol size up to align.
605          */
606         common_size = (common_size + sizeof(int) - 1) & -sizeof(int);
607         cp = kmalloc(sizeof(struct common_symbol)
608                     + common_size
609                     + strlen(name) + 1,
610                     M_LINKER, M_WAITOK);
611         if (!cp) {
612             KLD_DPF(SYM, ("linker_file_lookup_symbol: nomem\n"));
613             return ENOMEM;
614         }
615         bzero(cp, sizeof(struct common_symbol) + common_size + strlen(name)+ 1);
616
617         cp->address = (caddr_t) (cp + 1);
618         cp->name = cp->address + common_size;
619         strcpy(cp->name, name);
620         bzero(cp->address, common_size);
621         STAILQ_INSERT_TAIL(&file->common, cp, link);
622
623         KLD_DPF(SYM, ("linker_file_lookup_symbol: new common value=%x\n", cp->address));
624         *raddr = cp->address;
625         return 0;
626     }
627
628 #ifdef _KERNEL_VIRTUAL
629     *raddr = dlsym(RTLD_NEXT, name);
630     if (*raddr != NULL) {
631         KLD_DPF(SYM, ("linker_file_lookup_symbol: found dlsym=%x\n", *raddr));
632         return 0;
633     }
634 #endif
635
636     KLD_DPF(SYM, ("linker_file_lookup_symbol: fail\n"));
637     return ENOENT;
638 }
639
640 #ifdef DDB
641 /*
642  * DDB Helpers.  DDB has to look across multiple files with their own
643  * symbol tables and string tables.
644  *
645  * Note that we do not obey list locking protocols here.  We really don't
646  * need DDB to hang because somebody's got the lock held.  We'll take the
647  * chance that the files list is inconsistant instead.
648  */
649
650 int
651 linker_ddb_lookup(const char *symstr, c_linker_sym_t *sym)
652 {
653     linker_file_t lf;
654
655     for (lf = TAILQ_FIRST(&linker_files); lf; lf = TAILQ_NEXT(lf, link)) {
656         if (lf->ops->lookup_symbol(lf, symstr, sym) == 0)
657             return 0;
658     }
659     return ENOENT;
660 }
661
662 int
663 linker_ddb_search_symbol(caddr_t value, c_linker_sym_t *sym, long *diffp)
664 {
665     linker_file_t lf;
666     u_long off = (uintptr_t)value;
667     u_long diff, bestdiff;
668     c_linker_sym_t best;
669     c_linker_sym_t es;
670
671     best = 0;
672     bestdiff = off;
673     for (lf = TAILQ_FIRST(&linker_files); lf; lf = TAILQ_NEXT(lf, link)) {
674         if (lf->ops->search_symbol(lf, value, &es, &diff) != 0)
675             continue;
676         if (es != 0 && diff < bestdiff) {
677             best = es;
678             bestdiff = diff;
679         }
680         if (bestdiff == 0)
681             break;
682     }
683     if (best) {
684         *sym = best;
685         *diffp = bestdiff;
686         return 0;
687     } else {
688         *sym = 0;
689         *diffp = off;
690         return ENOENT;
691     }
692 }
693
694 int
695 linker_ddb_symbol_values(c_linker_sym_t sym, linker_symval_t *symval)
696 {
697     linker_file_t lf;
698
699     for (lf = TAILQ_FIRST(&linker_files); lf; lf = TAILQ_NEXT(lf, link)) {
700         if (lf->ops->symbol_values(lf, sym, symval) == 0)
701             return 0;
702     }
703     return ENOENT;
704 }
705
706 #endif
707
708 /*
709  * Syscalls.
710  */
711
712 int
713 sys_kldload(struct kldload_args *uap)
714 {
715     struct thread *td = curthread;
716     char* filename = NULL, *modulename;
717     linker_file_t lf;
718     int error = 0;
719
720     uap->sysmsg_result = -1;
721
722     if (securelevel > 0 || kernel_mem_readonly) /* redundant, but that's OK */
723         return EPERM;
724
725     if ((error = suser(td)) != 0)
726         return error;
727
728     filename = kmalloc(MAXPATHLEN, M_TEMP, M_WAITOK);
729     if ((error = copyinstr(uap->file, filename, MAXPATHLEN, NULL)) != 0)
730         goto out;
731
732     /* Can't load more than one module with the same name */
733     modulename = rindex(filename, '/');
734     if (modulename == NULL)
735         modulename = filename;
736     else
737         modulename++;
738     if (linker_find_file_by_name(modulename)) {
739         error = EEXIST;
740         goto out;
741     }
742
743     if ((error = linker_load_file(filename, &lf)) != 0)
744         goto out;
745
746     lf->userrefs++;
747     uap->sysmsg_result = lf->id;
748
749 out:
750     if (filename)
751         kfree(filename, M_TEMP);
752     return error;
753 }
754
755 int
756 sys_kldunload(struct kldunload_args *uap)
757 {
758     struct thread *td = curthread;
759     linker_file_t lf;
760     int error = 0;
761
762     if (securelevel > 0 || kernel_mem_readonly) /* redundant, but that's OK */
763         return EPERM;
764
765     if ((error = suser(td)) != 0)
766         return error;
767
768     lf = linker_find_file_by_id(uap->fileid);
769     if (lf) {
770         KLD_DPF(FILE, ("kldunload: lf->userrefs=%d\n", lf->userrefs));
771         if (lf->userrefs == 0) {
772             kprintf("linkerunload: attempt to unload file that was loaded by the kernel\n");
773             error = EBUSY;
774             goto out;
775         }
776         lf->userrefs--;
777         error = linker_file_unload(lf);
778         if (error)
779             lf->userrefs++;
780     } else
781         error = ENOENT;
782
783 out:
784     return error;
785 }
786
787 int
788 sys_kldfind(struct kldfind_args *uap)
789 {
790     char *filename = NULL, *modulename;
791     linker_file_t lf;
792     int error = 0;
793
794     uap->sysmsg_result = -1;
795
796     filename = kmalloc(MAXPATHLEN, M_TEMP, M_WAITOK);
797     if ((error = copyinstr(uap->file, filename, MAXPATHLEN, NULL)) != 0)
798         goto out;
799
800     modulename = rindex(filename, '/');
801     if (modulename == NULL)
802         modulename = filename;
803
804     lf = linker_find_file_by_name(modulename);
805     if (lf)
806         uap->sysmsg_result = lf->id;
807     else
808         error = ENOENT;
809
810 out:
811     if (filename)
812         kfree(filename, M_TEMP);
813     return error;
814 }
815
816 int
817 sys_kldnext(struct kldnext_args *uap)
818 {
819     linker_file_t lf;
820     int error = 0;
821
822     if (uap->fileid == 0) {
823         if (TAILQ_FIRST(&linker_files))
824             uap->sysmsg_result = TAILQ_FIRST(&linker_files)->id;
825         else
826             uap->sysmsg_result = 0;
827         return 0;
828     }
829
830     lf = linker_find_file_by_id(uap->fileid);
831     if (lf) {
832         if (TAILQ_NEXT(lf, link))
833             uap->sysmsg_result = TAILQ_NEXT(lf, link)->id;
834         else
835             uap->sysmsg_result = 0;
836     } else
837         error = ENOENT;
838
839     return error;
840 }
841
842 int
843 sys_kldstat(struct kldstat_args *uap)
844 {
845     linker_file_t lf;
846     int error = 0;
847     int version;
848     struct kld_file_stat* stat;
849     int namelen;
850
851     lf = linker_find_file_by_id(uap->fileid);
852     if (!lf) {
853         error = ENOENT;
854         goto out;
855     }
856
857     stat = uap->stat;
858
859     /*
860      * Check the version of the user's structure.
861      */
862     if ((error = copyin(&stat->version, &version, sizeof(version))) != 0)
863         goto out;
864     if (version != sizeof(struct kld_file_stat)) {
865         error = EINVAL;
866         goto out;
867     }
868
869     namelen = strlen(lf->filename) + 1;
870     if (namelen > MAXPATHLEN)
871         namelen = MAXPATHLEN;
872     if ((error = copyout(lf->filename, &stat->name[0], namelen)) != 0)
873         goto out;
874     if ((error = copyout(&lf->refs, &stat->refs, sizeof(int))) != 0)
875         goto out;
876     if ((error = copyout(&lf->id, &stat->id, sizeof(int))) != 0)
877         goto out;
878     if ((error = copyout(&lf->address, &stat->address, sizeof(caddr_t))) != 0)
879         goto out;
880     if ((error = copyout(&lf->size, &stat->size, sizeof(size_t))) != 0)
881         goto out;
882
883     uap->sysmsg_result = 0;
884
885 out:
886     return error;
887 }
888
889 int
890 sys_kldfirstmod(struct kldfirstmod_args *uap)
891 {
892     linker_file_t lf;
893     int error = 0;
894
895     lf = linker_find_file_by_id(uap->fileid);
896     if (lf) {
897         if (TAILQ_FIRST(&lf->modules))
898             uap->sysmsg_result = module_getid(TAILQ_FIRST(&lf->modules));
899         else
900             uap->sysmsg_result = 0;
901     } else
902         error = ENOENT;
903
904     return error;
905 }
906
907 int
908 sys_kldsym(struct kldsym_args *uap)
909 {
910     char *symstr = NULL;
911     c_linker_sym_t sym;
912     linker_symval_t symval;
913     linker_file_t lf;
914     struct kld_sym_lookup lookup;
915     int error = 0;
916
917     if ((error = copyin(uap->data, &lookup, sizeof(lookup))) != 0)
918         goto out;
919     if (lookup.version != sizeof(lookup) || uap->cmd != KLDSYM_LOOKUP) {
920         error = EINVAL;
921         goto out;
922     }
923
924     symstr = kmalloc(MAXPATHLEN, M_TEMP, M_WAITOK);
925     if ((error = copyinstr(lookup.symname, symstr, MAXPATHLEN, NULL)) != 0)
926         goto out;
927
928     if (uap->fileid != 0) {
929         lf = linker_find_file_by_id(uap->fileid);
930         if (lf == NULL) {
931             error = ENOENT;
932             goto out;
933         }
934         if (lf->ops->lookup_symbol(lf, symstr, &sym) == 0 &&
935             lf->ops->symbol_values(lf, sym, &symval) == 0) {
936             lookup.symvalue = (uintptr_t)symval.value;
937             lookup.symsize = symval.size;
938             error = copyout(&lookup, uap->data, sizeof(lookup));
939         } else
940             error = ENOENT;
941     } else {
942         for (lf = TAILQ_FIRST(&linker_files); lf; lf = TAILQ_NEXT(lf, link)) {
943             if (lf->ops->lookup_symbol(lf, symstr, &sym) == 0 &&
944                 lf->ops->symbol_values(lf, sym, &symval) == 0) {
945                 lookup.symvalue = (uintptr_t)symval.value;
946                 lookup.symsize = symval.size;
947                 error = copyout(&lookup, uap->data, sizeof(lookup));
948                 break;
949             }
950         }
951         if (!lf)
952             error = ENOENT;
953     }
954 out:
955     if (symstr)
956         kfree(symstr, M_TEMP);
957     return error;
958 }
959
960 /*
961  * Look for module metadata in the static kernel
962  */
963 struct mod_metadata *
964 find_mod_metadata(const char *modname)
965 {
966     int len;
967     struct mod_metadata **mdp;
968     struct mod_metadata *mdt;
969
970     /*
971      * Strip path prefixes and any dot extension.  MDT_MODULE names
972      * are just the module name without a path or ".ko".
973      */
974     for (len = strlen(modname) - 1; len >= 0; --len) {
975         if (modname[len] == '/')
976             break;
977     }
978     modname += len + 1;
979     for (len = 0; modname[len] && modname[len] != '.'; ++len)
980         ;
981
982     /*
983      * Look for the module declaration
984      */
985     SET_FOREACH(mdp, modmetadata_set) {
986         mdt = *mdp;
987         if (mdt->md_type != MDT_MODULE)
988             continue;
989         if (strlen(mdt->md_cval) == len &&
990             strncmp(mdt->md_cval, modname, len) == 0) {
991             return(mdt);
992         }
993     }
994     return(NULL);
995 }
996
997 /*
998  * Preloaded module support
999  */
1000 static void
1001 linker_preload(void* arg)
1002 {
1003     caddr_t             modptr;
1004     char                *modname;
1005     char                *modtype;
1006     linker_file_t       lf;
1007     linker_class_t      lc;
1008     int                 error;
1009     struct sysinit      **sipp;
1010     const moduledata_t  *moddata;
1011     struct sysinit      **si_start, **si_stop;
1012
1013     modptr = NULL;
1014     while ((modptr = preload_search_next_name(modptr)) != NULL) {
1015         modname = (char *)preload_search_info(modptr, MODINFO_NAME);
1016         modtype = (char *)preload_search_info(modptr, MODINFO_TYPE);
1017         if (modname == NULL) {
1018             kprintf("Preloaded module at %p does not have a name!\n", modptr);
1019             continue;
1020         }
1021         if (modtype == NULL) {
1022             kprintf("Preloaded module at %p does not have a type!\n", modptr);
1023             continue;
1024         }
1025
1026         /*
1027          * This is a hack at the moment, but what's in FreeBSD-5 is even 
1028          * worse so I'd rather the hack.
1029          */
1030         kprintf("Preloaded %s \"%s\" at %p", modtype, modname, modptr);
1031         if (find_mod_metadata(modname)) {
1032             kprintf(" (ignored, already in static kernel)\n");
1033             continue;
1034         }
1035         kprintf(".\n");
1036
1037         lf = linker_find_file_by_name(modname);
1038         if (lf) {
1039             lf->refs++;
1040             lf->userrefs++;
1041             continue;
1042         }
1043         lf = NULL;
1044         for (lc = TAILQ_FIRST(&classes); lc; lc = TAILQ_NEXT(lc, link)) {
1045             error = lc->ops->load_file(modname, &lf);
1046             if (error) {
1047                 lf = NULL;
1048                 break;
1049             }
1050         }
1051         if (lf) {
1052             lf->userrefs++;
1053
1054             if (linker_file_lookup_set(lf, "sysinit_set", &si_start, &si_stop, NULL) == 0) {
1055                 /* HACK ALERT!
1056                  * This is to set the sysinit moduledata so that the module
1057                  * can attach itself to the correct containing file.
1058                  * The sysinit could be run at *any* time.
1059                  */
1060                 for (sipp = si_start; sipp < si_stop; sipp++) {
1061                     if ((*sipp)->func == module_register_init) {
1062                         moddata = (*sipp)->udata;
1063                         error = module_register(moddata, lf);
1064                         if (error)
1065                             kprintf("Preloaded %s \"%s\" failed to register: %d\n",
1066                                 modtype, modname, error);
1067                     }
1068                 }
1069                 sysinit_add(si_start, si_stop);
1070             }
1071             linker_file_register_sysctls(lf);
1072         }
1073     }
1074 }
1075
1076 SYSINIT(preload, SI_BOOT2_KLD, SI_ORDER_MIDDLE, linker_preload, 0);
1077
1078 /*
1079  * Search for a not-loaded module by name.
1080  *
1081  * Modules may be found in the following locations:
1082  *
1083  * - preloaded (result is just the module name)
1084  * - on disk (result is full path to module)
1085  *
1086  * If the module name is qualified in any way (contains path, etc.)
1087  * the we simply return a copy of it.
1088  *
1089  * The search path can be manipulated via sysctl.  Note that we use the ';'
1090  * character as a separator to be consistent with the bootloader.
1091  */
1092
1093 static char linker_path[MAXPATHLEN] = "/;/boot;/modules";
1094
1095 SYSCTL_STRING(_kern, OID_AUTO, module_path, CTLFLAG_RW, linker_path,
1096               sizeof(linker_path), "module load search path");
1097 TUNABLE_STR("module_path", linker_path, sizeof(linker_path));
1098
1099 static char *
1100 linker_strdup(const char *str)
1101 {
1102     char        *result;
1103
1104     if ((result = kmalloc((strlen(str) + 1), M_LINKER, M_WAITOK)) != NULL)
1105         strcpy(result, str);
1106     return(result);
1107 }
1108
1109 char *
1110 linker_search_path(const char *name)
1111 {
1112     struct nlookupdata  nd;
1113     char                *cp, *ep, *result;
1114     size_t              name_len, prefix_len;
1115     int                 sep;
1116     int                 error;
1117     enum vtype          type;
1118
1119     /* qualified at all? */
1120     if (index(name, '/'))
1121         return(linker_strdup(name));
1122
1123     /* traverse the linker path */
1124     cp = linker_path;
1125     name_len = strlen(name);
1126     for (;;) {
1127
1128         /* find the end of this component */
1129         for (ep = cp; (*ep != 0) && (*ep != ';'); ep++)
1130             ;
1131         prefix_len = ep - cp;
1132         /* if this component doesn't end with a slash, add one */
1133         if (ep == cp || *(ep - 1) != '/')
1134             sep = 1;
1135         else
1136             sep = 0;
1137
1138         /*
1139          * +2 : possible separator, plus terminator.
1140          */
1141         result = kmalloc(prefix_len + name_len + 2, M_LINKER, M_WAITOK);
1142
1143         strncpy(result, cp, prefix_len);
1144         if (sep)
1145             result[prefix_len++] = '/';
1146         strcpy(result + prefix_len, name);
1147
1148         /*
1149          * Attempt to open the file, and return the path if we succeed and it's
1150          * a regular file.
1151          */
1152         error = nlookup_init(&nd, result, UIO_SYSSPACE, NLC_FOLLOW|NLC_LOCKVP);
1153         if (error == 0)
1154             error = vn_open(&nd, NULL, FREAD, 0);
1155         if (error == 0) {
1156             type = nd.nl_open_vp->v_type;
1157             if (type == VREG) {
1158                 nlookup_done(&nd);
1159                 return (result);
1160             }
1161         }
1162         nlookup_done(&nd);
1163         kfree(result, M_LINKER);
1164
1165         if (*ep == 0)
1166             break;
1167         cp = ep + 1;
1168     }
1169     return(NULL);
1170 }