27 */
28
29#include "opt_ddb.h"
30
31#include <sys/param.h>
32#include <sys/kernel.h>
33#include <sys/systm.h>
34#include <sys/malloc.h>
35#include <sys/sysproto.h>
36#include <sys/sysent.h>
37#include <sys/proc.h>
38#include <sys/lock.h>
39#include <sys/mutex.h>
40#include <sys/sx.h>
41#include <sys/module.h>
42#include <sys/linker.h>
43#include <sys/fcntl.h>
44#include <sys/libkern.h>
45#include <sys/namei.h>
46#include <sys/vnode.h>
47#include <sys/sysctl.h>
48
49#include "linker_if.h"
50
51#ifdef KLD_DEBUG
52int kld_debug = 0;
53#endif
54
55/*
56 * static char *linker_search_path(const char *name, struct mod_depend
57 * *verinfo);
58 */
59static const char *linker_basename(const char *path);
60static int linker_load_module(const char *kldname, const char *modname,
61 struct linker_file *parent, struct mod_depend *verinfo,
62 struct linker_file **lfpp);
63
64/* Metadata from the static kernel */
65SET_DECLARE(modmetadata_set, struct mod_metadata);
66
67MALLOC_DEFINE(M_LINKER, "linker", "kernel linker");
68
69linker_file_t linker_kernel_file;
70
71static struct lock lock; /* lock for the file list */
72static linker_class_list_t classes;
73static linker_file_list_t linker_files;
74static int next_file_id = 1;
75
76#define LINKER_GET_NEXT_FILE_ID(a) do { \
77 linker_file_t lftmp; \
78 \
79retry: \
80 TAILQ_FOREACH(lftmp, &linker_files, link) { \
81 if (next_file_id == lftmp->id) { \
82 next_file_id++; \
83 goto retry; \
84 } \
85 } \
86 (a) = next_file_id; \
87} while(0)
88
89
90/* XXX wrong name; we're looking at version provision tags here, not modules */
91typedef TAILQ_HEAD(, modlist) modlisthead_t;
92struct modlist {
93 TAILQ_ENTRY(modlist) link; /* chain together all modules */
94 linker_file_t container;
95 const char *name;
96 int version;
97};
98typedef struct modlist *modlist_t;
99static modlisthead_t found_modules;
100
101static char *
102linker_strdup(const char *str)
103{
104 char *result;
105
106 if ((result = malloc((strlen(str) + 1), M_LINKER, M_WAITOK)) != NULL)
107 strcpy(result, str);
108 return (result);
109}
110
111static void
112linker_init(void *arg)
113{
114
115 lockinit(&lock, PVM, "klink", 0, 0);
116 TAILQ_INIT(&classes);
117 TAILQ_INIT(&linker_files);
118}
119
120SYSINIT(linker, SI_SUB_KLD, SI_ORDER_FIRST, linker_init, 0)
121
122int
123linker_add_class(linker_class_t lc)
124{
125
126 kobj_class_compile((kobj_class_t) lc);
127 TAILQ_INSERT_TAIL(&classes, lc, link);
128 return (0);
129}
130
131static void
132linker_file_sysinit(linker_file_t lf)
133{
134 struct sysinit **start, **stop, **sipp, **xipp, *save;
135
136 KLD_DPF(FILE, ("linker_file_sysinit: calling SYSINITs for %s\n",
137 lf->filename));
138
139 if (linker_file_lookup_set(lf, "sysinit_set", &start, &stop, NULL) != 0)
140 return;
141 /*
142 * Perform a bubble sort of the system initialization objects by
143 * their subsystem (primary key) and order (secondary key).
144 *
145 * Since some things care about execution order, this is the operation
146 * which ensures continued function.
147 */
148 for (sipp = start; sipp < stop; sipp++) {
149 for (xipp = sipp + 1; xipp < stop; xipp++) {
150 if ((*sipp)->subsystem < (*xipp)->subsystem ||
151 ((*sipp)->subsystem == (*xipp)->subsystem &&
152 (*sipp)->order <= (*xipp)->order))
153 continue; /* skip */
154 save = *sipp;
155 *sipp = *xipp;
156 *xipp = save;
157 }
158 }
159
160 /*
161 * Traverse the (now) ordered list of system initialization tasks.
162 * Perform each task, and continue on to the next task.
163 */
164 for (sipp = start; sipp < stop; sipp++) {
165 if ((*sipp)->subsystem == SI_SUB_DUMMY)
166 continue; /* skip dummy task(s) */
167
168 /* Call function */
169 (*((*sipp)->func)) ((*sipp)->udata);
170 }
171}
172
173static void
174linker_file_sysuninit(linker_file_t lf)
175{
176 struct sysinit **start, **stop, **sipp, **xipp, *save;
177
178 KLD_DPF(FILE, ("linker_file_sysuninit: calling SYSUNINITs for %s\n",
179 lf->filename));
180
181 if (linker_file_lookup_set(lf, "sysuninit_set", &start, &stop,
182 NULL) != 0)
183 return;
184
185 /*
186 * Perform a reverse bubble sort of the system initialization objects
187 * by their subsystem (primary key) and order (secondary key).
188 *
189 * Since some things care about execution order, this is the operation
190 * which ensures continued function.
191 */
192 for (sipp = start; sipp < stop; sipp++) {
193 for (xipp = sipp + 1; xipp < stop; xipp++) {
194 if ((*sipp)->subsystem > (*xipp)->subsystem ||
195 ((*sipp)->subsystem == (*xipp)->subsystem &&
196 (*sipp)->order >= (*xipp)->order))
197 continue; /* skip */
198 save = *sipp;
199 *sipp = *xipp;
200 *xipp = save;
201 }
202 }
203
204 /*
205 * Traverse the (now) ordered list of system initialization tasks.
206 * Perform each task, and continue on to the next task.
207 */
208 for (sipp = start; sipp < stop; sipp++) {
209 if ((*sipp)->subsystem == SI_SUB_DUMMY)
210 continue; /* skip dummy task(s) */
211
212 /* Call function */
213 (*((*sipp)->func)) ((*sipp)->udata);
214 }
215}
216
217static void
218linker_file_register_sysctls(linker_file_t lf)
219{
220 struct sysctl_oid **start, **stop, **oidp;
221
222 KLD_DPF(FILE,
223 ("linker_file_register_sysctls: registering SYSCTLs for %s\n",
224 lf->filename));
225
226 if (linker_file_lookup_set(lf, "sysctl_set", &start, &stop, NULL) != 0)
227 return;
228
229 for (oidp = start; oidp < stop; oidp++)
230 sysctl_register_oid(*oidp);
231}
232
233static void
234linker_file_unregister_sysctls(linker_file_t lf)
235{
236 struct sysctl_oid **start, **stop, **oidp;
237
238 KLD_DPF(FILE, ("linker_file_unregister_sysctls: registering SYSCTLs"
239 " for %s\n", lf->filename));
240
241 if (linker_file_lookup_set(lf, "sysctl_set", &start, &stop, NULL) != 0)
242 return;
243
244 for (oidp = start; oidp < stop; oidp++)
245 sysctl_unregister_oid(*oidp);
246}
247
248static int
249linker_file_register_modules(linker_file_t lf)
250{
251 struct mod_metadata **start, **stop, **mdp;
252 const moduledata_t *moddata;
253 int error;
254
255 KLD_DPF(FILE, ("linker_file_register_modules: registering modules"
256 " in %s\n", lf->filename));
257
258 if (linker_file_lookup_set(lf, "modmetadata_set", &start,
259 &stop, 0) != 0) {
260 /*
261 * This fallback should be unnecessary, but if we get booted
262 * from boot2 instead of loader and we are missing our
263 * metadata then we have to try the best we can.
264 */
265 if (lf == linker_kernel_file) {
266 start = SET_BEGIN(modmetadata_set);
267 stop = SET_LIMIT(modmetadata_set);
268 } else
269 return (0);
270 }
271 for (mdp = start; mdp < stop; mdp++) {
272 if ((*mdp)->md_type != MDT_MODULE)
273 continue;
274 moddata = (*mdp)->md_data;
275 KLD_DPF(FILE, ("Registering module %s in %s\n",
276 moddata->name, lf->filename));
277 error = module_register(moddata, lf);
278 if (error)
279 printf("Module %s failed to register: %d\n",
280 moddata->name, error);
281 }
282 return (0);
283}
284
285static void
286linker_init_kernel_modules(void)
287{
288
289 linker_file_register_modules(linker_kernel_file);
290}
291
292SYSINIT(linker_kernel, SI_SUB_KLD, SI_ORDER_ANY, linker_init_kernel_modules, 0)
293
294int
295linker_load_file(const char *filename, linker_file_t *result)
296{
297 linker_class_t lc;
298 linker_file_t lf;
299 int foundfile, error = 0;
300
301 /* Refuse to load modules if securelevel raised */
302 if (securelevel > 0)
303 return (EPERM);
304
305 lf = linker_find_file_by_name(filename);
306 if (lf) {
307 KLD_DPF(FILE, ("linker_load_file: file %s is already loaded,"
308 " incrementing refs\n", filename));
309 *result = lf;
310 lf->refs++;
311 goto out;
312 }
313 lf = NULL;
314 foundfile = 0;
315 TAILQ_FOREACH(lc, &classes, link) {
316 KLD_DPF(FILE, ("linker_load_file: trying to load %s\n",
317 filename));
318 error = LINKER_LOAD_FILE(lc, filename, &lf);
319 /*
320 * If we got something other than ENOENT, then it exists but
321 * we cannot load it for some other reason.
322 */
323 if (error != ENOENT)
324 foundfile = 1;
325 if (lf) {
326 linker_file_register_modules(lf);
327 linker_file_register_sysctls(lf);
328 linker_file_sysinit(lf);
329 lf->flags |= LINKER_FILE_LINKED;
330 *result = lf;
331 error = 0;
332 goto out;
333 }
334 }
335 /*
336 * Less than ideal, but tells the user whether it failed to load or
337 * the module was not found.
338 */
339 if (foundfile)
340 /* Format not recognized (or unloadable). */
341 error = ENOEXEC;
342 else
343 error = ENOENT; /* Nothing found */
344out:
345 return (error);
346}
347
348/* XXX: function parameters are incomplete */
349int
350linker_reference_module(const char *modname, linker_file_t *result)
351{
352 return (linker_load_module(NULL, modname, NULL, NULL, result));
353}
354
355linker_file_t
356linker_find_file_by_name(const char *filename)
357{
358 linker_file_t lf = 0;
359 char *koname;
360
361 koname = malloc(strlen(filename) + 4, M_LINKER, M_WAITOK);
362 if (koname == NULL)
363 goto out;
364 sprintf(koname, "%s.ko", filename);
365
366 lockmgr(&lock, LK_SHARED, 0, curthread);
367 TAILQ_FOREACH(lf, &linker_files, link) {
368 if (strcmp(lf->filename, koname) == 0)
369 break;
370 if (strcmp(lf->filename, filename) == 0)
371 break;
372 }
373 lockmgr(&lock, LK_RELEASE, 0, curthread);
374out:
375 if (koname)
376 free(koname, M_LINKER);
377 return (lf);
378}
379
380linker_file_t
381linker_find_file_by_id(int fileid)
382{
383 linker_file_t lf = 0;
384
385 lockmgr(&lock, LK_SHARED, 0, curthread);
386 TAILQ_FOREACH(lf, &linker_files, link)
387 if (lf->id == fileid)
388 break;
389 lockmgr(&lock, LK_RELEASE, 0, curthread);
390 return (lf);
391}
392
393linker_file_t
394linker_make_file(const char *pathname, linker_class_t lc)
395{
396 linker_file_t lf;
397 const char *filename;
398
399 lf = NULL;
400 filename = linker_basename(pathname);
401
402 KLD_DPF(FILE, ("linker_make_file: new file, filename=%s\n", filename));
403 lockmgr(&lock, LK_EXCLUSIVE, 0, curthread);
404 lf = (linker_file_t)kobj_create((kobj_class_t)lc, M_LINKER, M_WAITOK);
405 if (lf == NULL)
406 goto out;
407 lf->refs = 1;
408 lf->userrefs = 0;
409 lf->flags = 0;
410 lf->filename = linker_strdup(filename);
411 LINKER_GET_NEXT_FILE_ID(lf->id);
412 lf->ndeps = 0;
413 lf->deps = NULL;
414 STAILQ_INIT(&lf->common);
415 TAILQ_INIT(&lf->modules);
416 TAILQ_INSERT_TAIL(&linker_files, lf, link);
417out:
418 lockmgr(&lock, LK_RELEASE, 0, curthread);
419 return (lf);
420}
421
422int
423linker_file_unload(linker_file_t file)
424{
425 module_t mod, next;
426 modlist_t ml, nextml;
427 struct common_symbol *cp;
428 int error, i;
429
430 error = 0;
431
432 /* Refuse to unload modules if securelevel raised. */
433 if (securelevel > 0)
434 return (EPERM);
435
436 KLD_DPF(FILE, ("linker_file_unload: lf->refs=%d\n", file->refs));
437 lockmgr(&lock, LK_EXCLUSIVE, 0, curthread);
438 if (file->refs == 1) {
439 KLD_DPF(FILE, ("linker_file_unload: file is unloading,"
440 " informing modules\n"));
441
442 /*
443 * Inform any modules associated with this file.
444 */
445 MOD_XLOCK;
446 for (mod = TAILQ_FIRST(&file->modules); mod; mod = next) {
447 next = module_getfnext(mod);
448 MOD_XUNLOCK;
449
450 /*
451 * Give the module a chance to veto the unload.
452 */
453 if ((error = module_unload(mod)) != 0) {
454 KLD_DPF(FILE, ("linker_file_unload: module %x"
455 " vetoes unload\n", mod));
456 lockmgr(&lock, LK_RELEASE, 0, curthread);
457 goto out;
458 } else
459 MOD_XLOCK;
460 module_release(mod);
461 }
462 MOD_XUNLOCK;
463 }
464 file->refs--;
465 if (file->refs > 0) {
466 lockmgr(&lock, LK_RELEASE, 0, curthread);
467 goto out;
468 }
469 for (ml = TAILQ_FIRST(&found_modules); ml; ml = nextml) {
470 nextml = TAILQ_NEXT(ml, link);
471 if (ml->container == file)
472 TAILQ_REMOVE(&found_modules, ml, link);
473 }
474
475 /*
476 * Don't try to run SYSUNINITs if we are unloaded due to a
477 * link error.
478 */
479 if (file->flags & LINKER_FILE_LINKED) {
480 linker_file_sysuninit(file);
481 linker_file_unregister_sysctls(file);
482 }
483 TAILQ_REMOVE(&linker_files, file, link);
484 lockmgr(&lock, LK_RELEASE, 0, curthread);
485
486 if (file->deps) {
487 for (i = 0; i < file->ndeps; i++)
488 linker_file_unload(file->deps[i]);
489 free(file->deps, M_LINKER);
490 file->deps = NULL;
491 }
492 for (cp = STAILQ_FIRST(&file->common); cp;
493 cp = STAILQ_FIRST(&file->common)) {
494 STAILQ_REMOVE(&file->common, cp, common_symbol, link);
495 free(cp, M_LINKER);
496 }
497
498 LINKER_UNLOAD(file);
499 if (file->filename) {
500 free(file->filename, M_LINKER);
501 file->filename = NULL;
502 }
503 kobj_delete((kobj_t) file, M_LINKER);
504out:
505 return (error);
506}
507
508int
509linker_file_add_dependency(linker_file_t file, linker_file_t dep)
510{
511 linker_file_t *newdeps;
512
513 newdeps = malloc((file->ndeps + 1) * sizeof(linker_file_t *),
514 M_LINKER, M_WAITOK | M_ZERO);
515 if (newdeps == NULL)
516 return (ENOMEM);
517
518 if (file->deps) {
519 bcopy(file->deps, newdeps,
520 file->ndeps * sizeof(linker_file_t *));
521 free(file->deps, M_LINKER);
522 }
523 file->deps = newdeps;
524 file->deps[file->ndeps] = dep;
525 file->ndeps++;
526 return (0);
527}
528
529/*
530 * Locate a linker set and its contents. This is a helper function to avoid
531 * linker_if.h exposure elsewhere. Note: firstp and lastp are really void ***
532 */
533int
534linker_file_lookup_set(linker_file_t file, const char *name,
535 void *firstp, void *lastp, int *countp)
536{
537
538 return (LINKER_LOOKUP_SET(file, name, firstp, lastp, countp));
539}
540
541caddr_t
542linker_file_lookup_symbol(linker_file_t file, const char *name, int deps)
543{
544 c_linker_sym_t sym;
545 linker_symval_t symval;
546 caddr_t address;
547 size_t common_size = 0;
548 int i;
549
550 KLD_DPF(SYM, ("linker_file_lookup_symbol: file=%x, name=%s, deps=%d\n",
551 file, name, deps));
552
553 if (LINKER_LOOKUP_SYMBOL(file, name, &sym) == 0) {
554 LINKER_SYMBOL_VALUES(file, sym, &symval);
555 if (symval.value == 0)
556 /*
557 * For commons, first look them up in the
558 * dependencies and only allocate space if not found
559 * there.
560 */
561 common_size = symval.size;
562 else {
563 KLD_DPF(SYM, ("linker_file_lookup_symbol: symbol"
564 ".value=%x\n", symval.value));
565 return (symval.value);
566 }
567 }
568 if (deps) {
569 for (i = 0; i < file->ndeps; i++) {
570 address = linker_file_lookup_symbol(file->deps[i],
571 name, 0);
572 if (address) {
573 KLD_DPF(SYM, ("linker_file_lookup_symbol:"
574 " deps value=%x\n", address));
575 return (address);
576 }
577 }
578 }
579 if (common_size > 0) {
580 /*
581 * This is a common symbol which was not found in the
582 * dependencies. We maintain a simple common symbol table in
583 * the file object.
584 */
585 struct common_symbol *cp;
586
587 STAILQ_FOREACH(cp, &file->common, link) {
588 if (strcmp(cp->name, name) == 0) {
589 KLD_DPF(SYM, ("linker_file_lookup_symbol:"
590 " old common value=%x\n", cp->address));
591 return (cp->address);
592 }
593 }
594 /*
595 * Round the symbol size up to align.
596 */
597 common_size = (common_size + sizeof(int) - 1) & -sizeof(int);
598 cp = malloc(sizeof(struct common_symbol)
599 + common_size + strlen(name) + 1, M_LINKER,
600 M_WAITOK | M_ZERO);
601 if (cp == NULL) {
602 KLD_DPF(SYM, ("linker_file_lookup_symbol: nomem\n"));
603 return (0);
604 }
605 cp->address = (caddr_t)(cp + 1);
606 cp->name = cp->address + common_size;
607 strcpy(cp->name, name);
608 bzero(cp->address, common_size);
609 STAILQ_INSERT_TAIL(&file->common, cp, link);
610
611 KLD_DPF(SYM, ("linker_file_lookup_symbol: new common"
612 " value=%x\n", cp->address));
613 return (cp->address);
614 }
615 KLD_DPF(SYM, ("linker_file_lookup_symbol: fail\n"));
616 return (0);
617}
618
619#ifdef DDB
620/*
621 * DDB Helpers. DDB has to look across multiple files with their own symbol
622 * tables and string tables.
623 *
624 * Note that we do not obey list locking protocols here. We really don't need
625 * DDB to hang because somebody's got the lock held. We'll take the chance
626 * that the files list is inconsistant instead.
627 */
628
629int
630linker_ddb_lookup(const char *symstr, c_linker_sym_t *sym)
631{
632 linker_file_t lf;
633
634 TAILQ_FOREACH(lf, &linker_files, link) {
635 if (LINKER_LOOKUP_SYMBOL(lf, symstr, sym) == 0)
636 return (0);
637 }
638 return (ENOENT);
639}
640
641int
642linker_ddb_search_symbol(caddr_t value, c_linker_sym_t *sym, long *diffp)
643{
644 linker_file_t lf;
645 c_linker_sym_t best, es;
646 u_long diff, bestdiff, off;
647
648 best = 0;
649 off = (uintptr_t)value;
650 bestdiff = off;
651 TAILQ_FOREACH(lf, &linker_files, link) {
652 if (LINKER_SEARCH_SYMBOL(lf, value, &es, &diff) != 0)
653 continue;
654 if (es != 0 && diff < bestdiff) {
655 best = es;
656 bestdiff = diff;
657 }
658 if (bestdiff == 0)
659 break;
660 }
661 if (best) {
662 *sym = best;
663 *diffp = bestdiff;
664 return (0);
665 } else {
666 *sym = 0;
667 *diffp = off;
668 return (ENOENT);
669 }
670}
671
672int
673linker_ddb_symbol_values(c_linker_sym_t sym, linker_symval_t *symval)
674{
675 linker_file_t lf;
676
677 TAILQ_FOREACH(lf, &linker_files, link) {
678 if (LINKER_SYMBOL_VALUES(lf, sym, symval) == 0)
679 return (0);
680 }
681 return (ENOENT);
682}
683#endif
684
685/*
686 * Syscalls.
687 */
688/*
689 * MPSAFE
690 */
691int
692kldload(struct thread *td, struct kldload_args *uap)
693{
694 char *kldname, *modname;
695 char *pathname = NULL;
696 linker_file_t lf;
697 int error = 0;
698
699 td->td_retval[0] = -1;
700
| 27 */
28
29#include "opt_ddb.h"
30
31#include <sys/param.h>
32#include <sys/kernel.h>
33#include <sys/systm.h>
34#include <sys/malloc.h>
35#include <sys/sysproto.h>
36#include <sys/sysent.h>
37#include <sys/proc.h>
38#include <sys/lock.h>
39#include <sys/mutex.h>
40#include <sys/sx.h>
41#include <sys/module.h>
42#include <sys/linker.h>
43#include <sys/fcntl.h>
44#include <sys/libkern.h>
45#include <sys/namei.h>
46#include <sys/vnode.h>
47#include <sys/sysctl.h>
48
49#include "linker_if.h"
50
51#ifdef KLD_DEBUG
52int kld_debug = 0;
53#endif
54
55/*
56 * static char *linker_search_path(const char *name, struct mod_depend
57 * *verinfo);
58 */
59static const char *linker_basename(const char *path);
60static int linker_load_module(const char *kldname, const char *modname,
61 struct linker_file *parent, struct mod_depend *verinfo,
62 struct linker_file **lfpp);
63
64/* Metadata from the static kernel */
65SET_DECLARE(modmetadata_set, struct mod_metadata);
66
67MALLOC_DEFINE(M_LINKER, "linker", "kernel linker");
68
69linker_file_t linker_kernel_file;
70
71static struct lock lock; /* lock for the file list */
72static linker_class_list_t classes;
73static linker_file_list_t linker_files;
74static int next_file_id = 1;
75
76#define LINKER_GET_NEXT_FILE_ID(a) do { \
77 linker_file_t lftmp; \
78 \
79retry: \
80 TAILQ_FOREACH(lftmp, &linker_files, link) { \
81 if (next_file_id == lftmp->id) { \
82 next_file_id++; \
83 goto retry; \
84 } \
85 } \
86 (a) = next_file_id; \
87} while(0)
88
89
90/* XXX wrong name; we're looking at version provision tags here, not modules */
91typedef TAILQ_HEAD(, modlist) modlisthead_t;
92struct modlist {
93 TAILQ_ENTRY(modlist) link; /* chain together all modules */
94 linker_file_t container;
95 const char *name;
96 int version;
97};
98typedef struct modlist *modlist_t;
99static modlisthead_t found_modules;
100
101static char *
102linker_strdup(const char *str)
103{
104 char *result;
105
106 if ((result = malloc((strlen(str) + 1), M_LINKER, M_WAITOK)) != NULL)
107 strcpy(result, str);
108 return (result);
109}
110
111static void
112linker_init(void *arg)
113{
114
115 lockinit(&lock, PVM, "klink", 0, 0);
116 TAILQ_INIT(&classes);
117 TAILQ_INIT(&linker_files);
118}
119
120SYSINIT(linker, SI_SUB_KLD, SI_ORDER_FIRST, linker_init, 0)
121
122int
123linker_add_class(linker_class_t lc)
124{
125
126 kobj_class_compile((kobj_class_t) lc);
127 TAILQ_INSERT_TAIL(&classes, lc, link);
128 return (0);
129}
130
131static void
132linker_file_sysinit(linker_file_t lf)
133{
134 struct sysinit **start, **stop, **sipp, **xipp, *save;
135
136 KLD_DPF(FILE, ("linker_file_sysinit: calling SYSINITs for %s\n",
137 lf->filename));
138
139 if (linker_file_lookup_set(lf, "sysinit_set", &start, &stop, NULL) != 0)
140 return;
141 /*
142 * Perform a bubble sort of the system initialization objects by
143 * their subsystem (primary key) and order (secondary key).
144 *
145 * Since some things care about execution order, this is the operation
146 * which ensures continued function.
147 */
148 for (sipp = start; sipp < stop; sipp++) {
149 for (xipp = sipp + 1; xipp < stop; xipp++) {
150 if ((*sipp)->subsystem < (*xipp)->subsystem ||
151 ((*sipp)->subsystem == (*xipp)->subsystem &&
152 (*sipp)->order <= (*xipp)->order))
153 continue; /* skip */
154 save = *sipp;
155 *sipp = *xipp;
156 *xipp = save;
157 }
158 }
159
160 /*
161 * Traverse the (now) ordered list of system initialization tasks.
162 * Perform each task, and continue on to the next task.
163 */
164 for (sipp = start; sipp < stop; sipp++) {
165 if ((*sipp)->subsystem == SI_SUB_DUMMY)
166 continue; /* skip dummy task(s) */
167
168 /* Call function */
169 (*((*sipp)->func)) ((*sipp)->udata);
170 }
171}
172
173static void
174linker_file_sysuninit(linker_file_t lf)
175{
176 struct sysinit **start, **stop, **sipp, **xipp, *save;
177
178 KLD_DPF(FILE, ("linker_file_sysuninit: calling SYSUNINITs for %s\n",
179 lf->filename));
180
181 if (linker_file_lookup_set(lf, "sysuninit_set", &start, &stop,
182 NULL) != 0)
183 return;
184
185 /*
186 * Perform a reverse bubble sort of the system initialization objects
187 * by their subsystem (primary key) and order (secondary key).
188 *
189 * Since some things care about execution order, this is the operation
190 * which ensures continued function.
191 */
192 for (sipp = start; sipp < stop; sipp++) {
193 for (xipp = sipp + 1; xipp < stop; xipp++) {
194 if ((*sipp)->subsystem > (*xipp)->subsystem ||
195 ((*sipp)->subsystem == (*xipp)->subsystem &&
196 (*sipp)->order >= (*xipp)->order))
197 continue; /* skip */
198 save = *sipp;
199 *sipp = *xipp;
200 *xipp = save;
201 }
202 }
203
204 /*
205 * Traverse the (now) ordered list of system initialization tasks.
206 * Perform each task, and continue on to the next task.
207 */
208 for (sipp = start; sipp < stop; sipp++) {
209 if ((*sipp)->subsystem == SI_SUB_DUMMY)
210 continue; /* skip dummy task(s) */
211
212 /* Call function */
213 (*((*sipp)->func)) ((*sipp)->udata);
214 }
215}
216
217static void
218linker_file_register_sysctls(linker_file_t lf)
219{
220 struct sysctl_oid **start, **stop, **oidp;
221
222 KLD_DPF(FILE,
223 ("linker_file_register_sysctls: registering SYSCTLs for %s\n",
224 lf->filename));
225
226 if (linker_file_lookup_set(lf, "sysctl_set", &start, &stop, NULL) != 0)
227 return;
228
229 for (oidp = start; oidp < stop; oidp++)
230 sysctl_register_oid(*oidp);
231}
232
233static void
234linker_file_unregister_sysctls(linker_file_t lf)
235{
236 struct sysctl_oid **start, **stop, **oidp;
237
238 KLD_DPF(FILE, ("linker_file_unregister_sysctls: registering SYSCTLs"
239 " for %s\n", lf->filename));
240
241 if (linker_file_lookup_set(lf, "sysctl_set", &start, &stop, NULL) != 0)
242 return;
243
244 for (oidp = start; oidp < stop; oidp++)
245 sysctl_unregister_oid(*oidp);
246}
247
248static int
249linker_file_register_modules(linker_file_t lf)
250{
251 struct mod_metadata **start, **stop, **mdp;
252 const moduledata_t *moddata;
253 int error;
254
255 KLD_DPF(FILE, ("linker_file_register_modules: registering modules"
256 " in %s\n", lf->filename));
257
258 if (linker_file_lookup_set(lf, "modmetadata_set", &start,
259 &stop, 0) != 0) {
260 /*
261 * This fallback should be unnecessary, but if we get booted
262 * from boot2 instead of loader and we are missing our
263 * metadata then we have to try the best we can.
264 */
265 if (lf == linker_kernel_file) {
266 start = SET_BEGIN(modmetadata_set);
267 stop = SET_LIMIT(modmetadata_set);
268 } else
269 return (0);
270 }
271 for (mdp = start; mdp < stop; mdp++) {
272 if ((*mdp)->md_type != MDT_MODULE)
273 continue;
274 moddata = (*mdp)->md_data;
275 KLD_DPF(FILE, ("Registering module %s in %s\n",
276 moddata->name, lf->filename));
277 error = module_register(moddata, lf);
278 if (error)
279 printf("Module %s failed to register: %d\n",
280 moddata->name, error);
281 }
282 return (0);
283}
284
285static void
286linker_init_kernel_modules(void)
287{
288
289 linker_file_register_modules(linker_kernel_file);
290}
291
292SYSINIT(linker_kernel, SI_SUB_KLD, SI_ORDER_ANY, linker_init_kernel_modules, 0)
293
294int
295linker_load_file(const char *filename, linker_file_t *result)
296{
297 linker_class_t lc;
298 linker_file_t lf;
299 int foundfile, error = 0;
300
301 /* Refuse to load modules if securelevel raised */
302 if (securelevel > 0)
303 return (EPERM);
304
305 lf = linker_find_file_by_name(filename);
306 if (lf) {
307 KLD_DPF(FILE, ("linker_load_file: file %s is already loaded,"
308 " incrementing refs\n", filename));
309 *result = lf;
310 lf->refs++;
311 goto out;
312 }
313 lf = NULL;
314 foundfile = 0;
315 TAILQ_FOREACH(lc, &classes, link) {
316 KLD_DPF(FILE, ("linker_load_file: trying to load %s\n",
317 filename));
318 error = LINKER_LOAD_FILE(lc, filename, &lf);
319 /*
320 * If we got something other than ENOENT, then it exists but
321 * we cannot load it for some other reason.
322 */
323 if (error != ENOENT)
324 foundfile = 1;
325 if (lf) {
326 linker_file_register_modules(lf);
327 linker_file_register_sysctls(lf);
328 linker_file_sysinit(lf);
329 lf->flags |= LINKER_FILE_LINKED;
330 *result = lf;
331 error = 0;
332 goto out;
333 }
334 }
335 /*
336 * Less than ideal, but tells the user whether it failed to load or
337 * the module was not found.
338 */
339 if (foundfile)
340 /* Format not recognized (or unloadable). */
341 error = ENOEXEC;
342 else
343 error = ENOENT; /* Nothing found */
344out:
345 return (error);
346}
347
348/* XXX: function parameters are incomplete */
349int
350linker_reference_module(const char *modname, linker_file_t *result)
351{
352 return (linker_load_module(NULL, modname, NULL, NULL, result));
353}
354
355linker_file_t
356linker_find_file_by_name(const char *filename)
357{
358 linker_file_t lf = 0;
359 char *koname;
360
361 koname = malloc(strlen(filename) + 4, M_LINKER, M_WAITOK);
362 if (koname == NULL)
363 goto out;
364 sprintf(koname, "%s.ko", filename);
365
366 lockmgr(&lock, LK_SHARED, 0, curthread);
367 TAILQ_FOREACH(lf, &linker_files, link) {
368 if (strcmp(lf->filename, koname) == 0)
369 break;
370 if (strcmp(lf->filename, filename) == 0)
371 break;
372 }
373 lockmgr(&lock, LK_RELEASE, 0, curthread);
374out:
375 if (koname)
376 free(koname, M_LINKER);
377 return (lf);
378}
379
380linker_file_t
381linker_find_file_by_id(int fileid)
382{
383 linker_file_t lf = 0;
384
385 lockmgr(&lock, LK_SHARED, 0, curthread);
386 TAILQ_FOREACH(lf, &linker_files, link)
387 if (lf->id == fileid)
388 break;
389 lockmgr(&lock, LK_RELEASE, 0, curthread);
390 return (lf);
391}
392
393linker_file_t
394linker_make_file(const char *pathname, linker_class_t lc)
395{
396 linker_file_t lf;
397 const char *filename;
398
399 lf = NULL;
400 filename = linker_basename(pathname);
401
402 KLD_DPF(FILE, ("linker_make_file: new file, filename=%s\n", filename));
403 lockmgr(&lock, LK_EXCLUSIVE, 0, curthread);
404 lf = (linker_file_t)kobj_create((kobj_class_t)lc, M_LINKER, M_WAITOK);
405 if (lf == NULL)
406 goto out;
407 lf->refs = 1;
408 lf->userrefs = 0;
409 lf->flags = 0;
410 lf->filename = linker_strdup(filename);
411 LINKER_GET_NEXT_FILE_ID(lf->id);
412 lf->ndeps = 0;
413 lf->deps = NULL;
414 STAILQ_INIT(&lf->common);
415 TAILQ_INIT(&lf->modules);
416 TAILQ_INSERT_TAIL(&linker_files, lf, link);
417out:
418 lockmgr(&lock, LK_RELEASE, 0, curthread);
419 return (lf);
420}
421
422int
423linker_file_unload(linker_file_t file)
424{
425 module_t mod, next;
426 modlist_t ml, nextml;
427 struct common_symbol *cp;
428 int error, i;
429
430 error = 0;
431
432 /* Refuse to unload modules if securelevel raised. */
433 if (securelevel > 0)
434 return (EPERM);
435
436 KLD_DPF(FILE, ("linker_file_unload: lf->refs=%d\n", file->refs));
437 lockmgr(&lock, LK_EXCLUSIVE, 0, curthread);
438 if (file->refs == 1) {
439 KLD_DPF(FILE, ("linker_file_unload: file is unloading,"
440 " informing modules\n"));
441
442 /*
443 * Inform any modules associated with this file.
444 */
445 MOD_XLOCK;
446 for (mod = TAILQ_FIRST(&file->modules); mod; mod = next) {
447 next = module_getfnext(mod);
448 MOD_XUNLOCK;
449
450 /*
451 * Give the module a chance to veto the unload.
452 */
453 if ((error = module_unload(mod)) != 0) {
454 KLD_DPF(FILE, ("linker_file_unload: module %x"
455 " vetoes unload\n", mod));
456 lockmgr(&lock, LK_RELEASE, 0, curthread);
457 goto out;
458 } else
459 MOD_XLOCK;
460 module_release(mod);
461 }
462 MOD_XUNLOCK;
463 }
464 file->refs--;
465 if (file->refs > 0) {
466 lockmgr(&lock, LK_RELEASE, 0, curthread);
467 goto out;
468 }
469 for (ml = TAILQ_FIRST(&found_modules); ml; ml = nextml) {
470 nextml = TAILQ_NEXT(ml, link);
471 if (ml->container == file)
472 TAILQ_REMOVE(&found_modules, ml, link);
473 }
474
475 /*
476 * Don't try to run SYSUNINITs if we are unloaded due to a
477 * link error.
478 */
479 if (file->flags & LINKER_FILE_LINKED) {
480 linker_file_sysuninit(file);
481 linker_file_unregister_sysctls(file);
482 }
483 TAILQ_REMOVE(&linker_files, file, link);
484 lockmgr(&lock, LK_RELEASE, 0, curthread);
485
486 if (file->deps) {
487 for (i = 0; i < file->ndeps; i++)
488 linker_file_unload(file->deps[i]);
489 free(file->deps, M_LINKER);
490 file->deps = NULL;
491 }
492 for (cp = STAILQ_FIRST(&file->common); cp;
493 cp = STAILQ_FIRST(&file->common)) {
494 STAILQ_REMOVE(&file->common, cp, common_symbol, link);
495 free(cp, M_LINKER);
496 }
497
498 LINKER_UNLOAD(file);
499 if (file->filename) {
500 free(file->filename, M_LINKER);
501 file->filename = NULL;
502 }
503 kobj_delete((kobj_t) file, M_LINKER);
504out:
505 return (error);
506}
507
508int
509linker_file_add_dependency(linker_file_t file, linker_file_t dep)
510{
511 linker_file_t *newdeps;
512
513 newdeps = malloc((file->ndeps + 1) * sizeof(linker_file_t *),
514 M_LINKER, M_WAITOK | M_ZERO);
515 if (newdeps == NULL)
516 return (ENOMEM);
517
518 if (file->deps) {
519 bcopy(file->deps, newdeps,
520 file->ndeps * sizeof(linker_file_t *));
521 free(file->deps, M_LINKER);
522 }
523 file->deps = newdeps;
524 file->deps[file->ndeps] = dep;
525 file->ndeps++;
526 return (0);
527}
528
529/*
530 * Locate a linker set and its contents. This is a helper function to avoid
531 * linker_if.h exposure elsewhere. Note: firstp and lastp are really void ***
532 */
533int
534linker_file_lookup_set(linker_file_t file, const char *name,
535 void *firstp, void *lastp, int *countp)
536{
537
538 return (LINKER_LOOKUP_SET(file, name, firstp, lastp, countp));
539}
540
541caddr_t
542linker_file_lookup_symbol(linker_file_t file, const char *name, int deps)
543{
544 c_linker_sym_t sym;
545 linker_symval_t symval;
546 caddr_t address;
547 size_t common_size = 0;
548 int i;
549
550 KLD_DPF(SYM, ("linker_file_lookup_symbol: file=%x, name=%s, deps=%d\n",
551 file, name, deps));
552
553 if (LINKER_LOOKUP_SYMBOL(file, name, &sym) == 0) {
554 LINKER_SYMBOL_VALUES(file, sym, &symval);
555 if (symval.value == 0)
556 /*
557 * For commons, first look them up in the
558 * dependencies and only allocate space if not found
559 * there.
560 */
561 common_size = symval.size;
562 else {
563 KLD_DPF(SYM, ("linker_file_lookup_symbol: symbol"
564 ".value=%x\n", symval.value));
565 return (symval.value);
566 }
567 }
568 if (deps) {
569 for (i = 0; i < file->ndeps; i++) {
570 address = linker_file_lookup_symbol(file->deps[i],
571 name, 0);
572 if (address) {
573 KLD_DPF(SYM, ("linker_file_lookup_symbol:"
574 " deps value=%x\n", address));
575 return (address);
576 }
577 }
578 }
579 if (common_size > 0) {
580 /*
581 * This is a common symbol which was not found in the
582 * dependencies. We maintain a simple common symbol table in
583 * the file object.
584 */
585 struct common_symbol *cp;
586
587 STAILQ_FOREACH(cp, &file->common, link) {
588 if (strcmp(cp->name, name) == 0) {
589 KLD_DPF(SYM, ("linker_file_lookup_symbol:"
590 " old common value=%x\n", cp->address));
591 return (cp->address);
592 }
593 }
594 /*
595 * Round the symbol size up to align.
596 */
597 common_size = (common_size + sizeof(int) - 1) & -sizeof(int);
598 cp = malloc(sizeof(struct common_symbol)
599 + common_size + strlen(name) + 1, M_LINKER,
600 M_WAITOK | M_ZERO);
601 if (cp == NULL) {
602 KLD_DPF(SYM, ("linker_file_lookup_symbol: nomem\n"));
603 return (0);
604 }
605 cp->address = (caddr_t)(cp + 1);
606 cp->name = cp->address + common_size;
607 strcpy(cp->name, name);
608 bzero(cp->address, common_size);
609 STAILQ_INSERT_TAIL(&file->common, cp, link);
610
611 KLD_DPF(SYM, ("linker_file_lookup_symbol: new common"
612 " value=%x\n", cp->address));
613 return (cp->address);
614 }
615 KLD_DPF(SYM, ("linker_file_lookup_symbol: fail\n"));
616 return (0);
617}
618
619#ifdef DDB
620/*
621 * DDB Helpers. DDB has to look across multiple files with their own symbol
622 * tables and string tables.
623 *
624 * Note that we do not obey list locking protocols here. We really don't need
625 * DDB to hang because somebody's got the lock held. We'll take the chance
626 * that the files list is inconsistant instead.
627 */
628
629int
630linker_ddb_lookup(const char *symstr, c_linker_sym_t *sym)
631{
632 linker_file_t lf;
633
634 TAILQ_FOREACH(lf, &linker_files, link) {
635 if (LINKER_LOOKUP_SYMBOL(lf, symstr, sym) == 0)
636 return (0);
637 }
638 return (ENOENT);
639}
640
641int
642linker_ddb_search_symbol(caddr_t value, c_linker_sym_t *sym, long *diffp)
643{
644 linker_file_t lf;
645 c_linker_sym_t best, es;
646 u_long diff, bestdiff, off;
647
648 best = 0;
649 off = (uintptr_t)value;
650 bestdiff = off;
651 TAILQ_FOREACH(lf, &linker_files, link) {
652 if (LINKER_SEARCH_SYMBOL(lf, value, &es, &diff) != 0)
653 continue;
654 if (es != 0 && diff < bestdiff) {
655 best = es;
656 bestdiff = diff;
657 }
658 if (bestdiff == 0)
659 break;
660 }
661 if (best) {
662 *sym = best;
663 *diffp = bestdiff;
664 return (0);
665 } else {
666 *sym = 0;
667 *diffp = off;
668 return (ENOENT);
669 }
670}
671
672int
673linker_ddb_symbol_values(c_linker_sym_t sym, linker_symval_t *symval)
674{
675 linker_file_t lf;
676
677 TAILQ_FOREACH(lf, &linker_files, link) {
678 if (LINKER_SYMBOL_VALUES(lf, sym, symval) == 0)
679 return (0);
680 }
681 return (ENOENT);
682}
683#endif
684
685/*
686 * Syscalls.
687 */
688/*
689 * MPSAFE
690 */
691int
692kldload(struct thread *td, struct kldload_args *uap)
693{
694 char *kldname, *modname;
695 char *pathname = NULL;
696 linker_file_t lf;
697 int error = 0;
698
699 td->td_retval[0] = -1;
700
|
753 if ((error = suser_xxx(td->td_ucred, NULL, 0)) != 0)
754 goto out;
755
756 lf = linker_find_file_by_id(SCARG(uap, fileid));
757 if (lf) {
758 KLD_DPF(FILE, ("kldunload: lf->userrefs=%d\n", lf->userrefs));
759 if (lf->userrefs == 0) {
760 printf("kldunload: attempt to unload file that was"
761 " loaded by the kernel\n");
762 error = EBUSY;
763 goto out;
764 }
765 lf->userrefs--;
766 error = linker_file_unload(lf);
767 if (error)
768 lf->userrefs++;
769 } else
770 error = ENOENT;
771out:
772 mtx_unlock(&Giant);
773 return (error);
774}
775
776/*
777 * MPSAFE
778 */
779int
780kldfind(struct thread *td, struct kldfind_args *uap)
781{
782 char *pathname;
783 const char *filename;
784 linker_file_t lf;
785 int error = 0;
786
787 mtx_lock(&Giant);
788 td->td_retval[0] = -1;
789
790 pathname = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
791 if ((error = copyinstr(SCARG(uap, file), pathname, MAXPATHLEN,
792 NULL)) != 0)
793 goto out;
794
795 filename = linker_basename(pathname);
796 lf = linker_find_file_by_name(filename);
797 if (lf)
798 td->td_retval[0] = lf->id;
799 else
800 error = ENOENT;
801out:
802 if (pathname)
803 free(pathname, M_TEMP);
804 mtx_unlock(&Giant);
805 return (error);
806}
807
808/*
809 * MPSAFE
810 */
811int
812kldnext(struct thread *td, struct kldnext_args *uap)
813{
814 linker_file_t lf;
815 int error = 0;
816
817 mtx_lock(&Giant);
818
819 if (SCARG(uap, fileid) == 0) {
820 if (TAILQ_FIRST(&linker_files))
821 td->td_retval[0] = TAILQ_FIRST(&linker_files)->id;
822 else
823 td->td_retval[0] = 0;
824 goto out;
825 }
826 lf = linker_find_file_by_id(SCARG(uap, fileid));
827 if (lf) {
828 if (TAILQ_NEXT(lf, link))
829 td->td_retval[0] = TAILQ_NEXT(lf, link)->id;
830 else
831 td->td_retval[0] = 0;
832 } else
833 error = ENOENT;
834out:
835 mtx_unlock(&Giant);
836 return (error);
837}
838
839/*
840 * MPSAFE
841 */
842int
843kldstat(struct thread *td, struct kldstat_args *uap)
844{
845 linker_file_t lf;
846 int error = 0;
847 int namelen, version;
848 struct kld_file_stat *stat;
849
850 mtx_lock(&Giant);
851
852 lf = linker_find_file_by_id(SCARG(uap, fileid));
853 if (lf == NULL) {
854 error = ENOENT;
855 goto out;
856 }
857 stat = SCARG(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 namelen = strlen(lf->filename) + 1;
869 if (namelen > MAXPATHLEN)
870 namelen = MAXPATHLEN;
871 if ((error = copyout(lf->filename, &stat->name[0], namelen)) != 0)
872 goto out;
873 if ((error = copyout(&lf->refs, &stat->refs, sizeof(int))) != 0)
874 goto out;
875 if ((error = copyout(&lf->id, &stat->id, sizeof(int))) != 0)
876 goto out;
877 if ((error = copyout(&lf->address, &stat->address,
878 sizeof(caddr_t))) != 0)
879 goto out;
880 if ((error = copyout(&lf->size, &stat->size, sizeof(size_t))) != 0)
881 goto out;
882
883 td->td_retval[0] = 0;
884out:
885 mtx_unlock(&Giant);
886 return (error);
887}
888
889/*
890 * MPSAFE
891 */
892int
893kldfirstmod(struct thread *td, struct kldfirstmod_args *uap)
894{
895 linker_file_t lf;
896 module_t mp;
897 int error = 0;
898
899 mtx_lock(&Giant);
900 lf = linker_find_file_by_id(SCARG(uap, fileid));
901 if (lf) {
902 MOD_SLOCK;
903 mp = TAILQ_FIRST(&lf->modules);
904 if (mp != NULL)
905 td->td_retval[0] = module_getid(mp);
906 else
907 td->td_retval[0] = 0;
908 MOD_SUNLOCK;
909 } else
910 error = ENOENT;
911 mtx_unlock(&Giant);
912 return (error);
913}
914
915/*
916 * MPSAFE
917 */
918int
919kldsym(struct thread *td, struct kldsym_args *uap)
920{
921 char *symstr = NULL;
922 c_linker_sym_t sym;
923 linker_symval_t symval;
924 linker_file_t lf;
925 struct kld_sym_lookup lookup;
926 int error = 0;
927
928 mtx_lock(&Giant);
929
930 if ((error = copyin(SCARG(uap, data), &lookup, sizeof(lookup))) != 0)
931 goto out;
932 if (lookup.version != sizeof(lookup) ||
933 SCARG(uap, cmd) != KLDSYM_LOOKUP) {
934 error = EINVAL;
935 goto out;
936 }
937 symstr = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
938 if ((error = copyinstr(lookup.symname, symstr, MAXPATHLEN, NULL)) != 0)
939 goto out;
940 if (SCARG(uap, fileid) != 0) {
941 lf = linker_find_file_by_id(SCARG(uap, fileid));
942 if (lf == NULL) {
943 error = ENOENT;
944 goto out;
945 }
946 if (LINKER_LOOKUP_SYMBOL(lf, symstr, &sym) == 0 &&
947 LINKER_SYMBOL_VALUES(lf, sym, &symval) == 0) {
948 lookup.symvalue = (uintptr_t) symval.value;
949 lookup.symsize = symval.size;
950 error = copyout(&lookup, SCARG(uap, data),
951 sizeof(lookup));
952 } else
953 error = ENOENT;
954 } else {
955 TAILQ_FOREACH(lf, &linker_files, link) {
956 if (LINKER_LOOKUP_SYMBOL(lf, symstr, &sym) == 0 &&
957 LINKER_SYMBOL_VALUES(lf, sym, &symval) == 0) {
958 lookup.symvalue = (uintptr_t)symval.value;
959 lookup.symsize = symval.size;
960 error = copyout(&lookup, SCARG(uap, data),
961 sizeof(lookup));
962 break;
963 }
964 }
965 if (lf == NULL)
966 error = ENOENT;
967 }
968out:
969 if (symstr)
970 free(symstr, M_TEMP);
971 mtx_unlock(&Giant);
972 return (error);
973}
974
975/*
976 * Preloaded module support
977 */
978
979static modlist_t
980modlist_lookup(const char *name, int ver)
981{
982 modlist_t mod;
983
984 TAILQ_FOREACH(mod, &found_modules, link) {
985 if (strcmp(mod->name, name) == 0 &&
986 (ver == 0 || mod->version == ver))
987 return (mod);
988 }
989 return (NULL);
990}
991
992static modlist_t
993modlist_lookup2(const char *name, struct mod_depend *verinfo)
994{
995 modlist_t mod, bestmod;
996 int ver;
997
998 if (verinfo == NULL)
999 return (modlist_lookup(name, 0));
1000 bestmod = NULL;
1001 for (mod = TAILQ_FIRST(&found_modules); mod;
1002 mod = TAILQ_NEXT(mod, link)) {
1003 if (strcmp(mod->name, name) != 0)
1004 continue;
1005 ver = mod->version;
1006 if (ver == verinfo->md_ver_preferred)
1007 return (mod);
1008 if (ver >= verinfo->md_ver_minimum &&
1009 ver <= verinfo->md_ver_maximum &&
1010 ver > bestmod->version)
1011 bestmod = mod;
1012 }
1013 return (bestmod);
1014}
1015
1016static modlist_t
1017modlist_newmodule(const char *modname, int version, linker_file_t container)
1018{
1019 modlist_t mod;
1020
1021 mod = malloc(sizeof(struct modlist), M_LINKER, M_NOWAIT | M_ZERO);
1022 if (mod == NULL)
1023 panic("no memory for module list");
1024 mod->container = container;
1025 mod->name = modname;
1026 mod->version = version;
1027 TAILQ_INSERT_TAIL(&found_modules, mod, link);
1028 return (mod);
1029}
1030
1031/*
1032 * This routine is cheap and nasty but will work for data pointers.
1033 */
1034static void *
1035linker_reloc_ptr(linker_file_t lf, const void *offset)
1036{
1037 return (lf->address + (uintptr_t)offset);
1038}
1039
1040/*
1041 * Dereference MDT_VERSION metadata into module name and version
1042 */
1043static void
1044linker_mdt_version(linker_file_t lf, struct mod_metadata *mp,
1045 const char **modname, int *version)
1046{
1047 struct mod_version *mvp;
1048
1049 if (modname)
1050 *modname = linker_reloc_ptr(lf, mp->md_cval);
1051 if (version) {
1052 mvp = linker_reloc_ptr(lf, mp->md_data);
1053 *version = mvp->mv_version;
1054 }
1055}
1056
1057/*
1058 * Dereference MDT_DEPEND metadata into module name and mod_depend structure
1059 */
1060static void
1061linker_mdt_depend(linker_file_t lf, struct mod_metadata *mp,
1062 const char **modname, struct mod_depend **verinfo)
1063{
1064
1065 if (modname)
1066 *modname = linker_reloc_ptr(lf, mp->md_cval);
1067 if (verinfo)
1068 *verinfo = linker_reloc_ptr(lf, mp->md_data);
1069}
1070
1071static void
1072linker_addmodules(linker_file_t lf, struct mod_metadata **start,
1073 struct mod_metadata **stop, int preload)
1074{
1075 struct mod_metadata *mp, **mdp;
1076 const char *modname;
1077 int ver;
1078
1079 for (mdp = start; mdp < stop; mdp++) {
1080 if (preload)
1081 mp = *mdp;
1082 else
1083 mp = linker_reloc_ptr(lf, *mdp);
1084 if (mp->md_type != MDT_VERSION)
1085 continue;
1086 if (preload) {
1087 modname = mp->md_cval;
1088 ver = ((struct mod_version *)mp->md_data)->mv_version;
1089 } else
1090 linker_mdt_version(lf, mp, &modname, &ver);
1091 if (modlist_lookup(modname, ver) != NULL) {
1092 printf("module %s already present!\n", modname);
1093 /* XXX what can we do? this is a build error. :-( */
1094 continue;
1095 }
1096 modlist_newmodule(modname, ver, lf);
1097 }
1098}
1099
1100static void
1101linker_preload(void *arg)
1102{
1103 caddr_t modptr;
1104 const char *modname, *nmodname;
1105 char *modtype;
1106 linker_file_t lf;
1107 linker_class_t lc;
1108 int error;
1109 linker_file_list_t loaded_files;
1110 linker_file_list_t depended_files;
1111 struct mod_metadata *mp, *nmp;
1112 struct mod_metadata **start, **stop, **mdp, **nmdp;
1113 struct mod_depend *verinfo;
1114 int nver;
1115 int resolves;
1116 modlist_t mod;
1117 struct sysinit **si_start, **si_stop;
1118
1119 TAILQ_INIT(&loaded_files);
1120 TAILQ_INIT(&depended_files);
1121 TAILQ_INIT(&found_modules);
1122 error = 0;
1123
1124 modptr = NULL;
1125 while ((modptr = preload_search_next_name(modptr)) != NULL) {
1126 modname = (char *)preload_search_info(modptr, MODINFO_NAME);
1127 modtype = (char *)preload_search_info(modptr, MODINFO_TYPE);
1128 if (modname == NULL) {
1129 printf("Preloaded module at %p does not have a"
1130 " name!\n", modptr);
1131 continue;
1132 }
1133 if (modtype == NULL) {
1134 printf("Preloaded module at %p does not have a type!\n",
1135 modptr);
1136 continue;
1137 }
1138 printf("Preloaded %s \"%s\" at %p.\n", modtype, modname,
1139 modptr);
1140 lf = NULL;
1141 TAILQ_FOREACH(lc, &classes, link) {
1142 error = LINKER_LINK_PRELOAD(lc, modname, &lf);
1143 if (error) {
1144 lf = NULL;
1145 break;
1146 }
1147 }
1148 if (lf)
1149 TAILQ_INSERT_TAIL(&loaded_files, lf, loaded);
1150 }
1151
1152 /*
1153 * First get a list of stuff in the kernel.
1154 */
1155 if (linker_file_lookup_set(linker_kernel_file, MDT_SETNAME, &start,
1156 &stop, NULL) == 0)
1157 linker_addmodules(linker_kernel_file, start, stop, 1);
1158
1159 /*
1160 * this is a once-off kinky bubble sort resolve relocation dependency
1161 * requirements
1162 */
1163restart:
1164 TAILQ_FOREACH(lf, &loaded_files, loaded) {
1165 error = linker_file_lookup_set(lf, MDT_SETNAME, &start,
1166 &stop, NULL);
1167 /*
1168 * First, look to see if we would successfully link with this
1169 * stuff.
1170 */
1171 resolves = 1; /* unless we know otherwise */
1172 if (!error) {
1173 for (mdp = start; mdp < stop; mdp++) {
1174 mp = linker_reloc_ptr(lf, *mdp);
1175 if (mp->md_type != MDT_DEPEND)
1176 continue;
1177 linker_mdt_depend(lf, mp, &modname, &verinfo);
1178 for (nmdp = start; nmdp < stop; nmdp++) {
1179 nmp = linker_reloc_ptr(lf, *nmdp);
1180 if (nmp->md_type != MDT_VERSION)
1181 continue;
1182 linker_mdt_version(lf, nmp, &nmodname,
1183 NULL);
1184 nmodname = linker_reloc_ptr(lf,
1185 nmp->md_cval);
1186 if (strcmp(modname, nmodname) == 0)
1187 break;
1188 }
1189 if (nmdp < stop) /* it's a self reference */
1190 continue;
1191
1192 /*
1193 * ok, the module isn't here yet, we
1194 * are not finished
1195 */
1196 if (modlist_lookup2(modname, verinfo) == NULL)
1197 resolves = 0;
1198 }
1199 }
1200 /*
1201 * OK, if we found our modules, we can link. So, "provide"
1202 * the modules inside and add it to the end of the link order
1203 * list.
1204 */
1205 if (resolves) {
1206 if (!error) {
1207 for (mdp = start; mdp < stop; mdp++) {
1208 mp = linker_reloc_ptr(lf, *mdp);
1209 if (mp->md_type != MDT_VERSION)
1210 continue;
1211 linker_mdt_version(lf, mp,
1212 &modname, &nver);
1213 if (modlist_lookup(modname,
1214 nver) != NULL) {
1215 printf("module %s already"
1216 " present!\n", modname);
1217 linker_file_unload(lf);
1218 TAILQ_REMOVE(&loaded_files,
1219 lf, loaded);
1220 /* we changed tailq next ptr */
1221 goto restart;
1222 }
1223 modlist_newmodule(modname, nver, lf);
1224 }
1225 }
1226 TAILQ_REMOVE(&loaded_files, lf, loaded);
1227 TAILQ_INSERT_TAIL(&depended_files, lf, loaded);
1228 /*
1229 * Since we provided modules, we need to restart the
1230 * sort so that the previous files that depend on us
1231 * have a chance. Also, we've busted the tailq next
1232 * pointer with the REMOVE.
1233 */
1234 goto restart;
1235 }
1236 }
1237
1238 /*
1239 * At this point, we check to see what could not be resolved..
1240 */
1241 TAILQ_FOREACH(lf, &loaded_files, loaded) {
1242 printf("KLD file %s is missing dependencies\n", lf->filename);
1243 linker_file_unload(lf);
1244 TAILQ_REMOVE(&loaded_files, lf, loaded);
1245 }
1246
1247 /*
1248 * We made it. Finish off the linking in the order we determined.
1249 */
1250 TAILQ_FOREACH(lf, &depended_files, loaded) {
1251 if (linker_kernel_file) {
1252 linker_kernel_file->refs++;
1253 error = linker_file_add_dependency(lf,
1254 linker_kernel_file);
1255 if (error)
1256 panic("cannot add dependency");
1257 }
1258 lf->userrefs++; /* so we can (try to) kldunload it */
1259 error = linker_file_lookup_set(lf, MDT_SETNAME, &start,
1260 &stop, NULL);
1261 if (!error) {
1262 for (mdp = start; mdp < stop; mdp++) {
1263 mp = linker_reloc_ptr(lf, *mdp);
1264 if (mp->md_type != MDT_DEPEND)
1265 continue;
1266 linker_mdt_depend(lf, mp, &modname, &verinfo);
1267 mod = modlist_lookup2(modname, verinfo);
1268 mod->container->refs++;
1269 error = linker_file_add_dependency(lf,
1270 mod->container);
1271 if (error)
1272 panic("cannot add dependency");
1273 }
1274 }
1275 /*
1276 * Now do relocation etc using the symbol search paths
1277 * established by the dependencies
1278 */
1279 error = LINKER_LINK_PRELOAD_FINISH(lf);
1280 if (error) {
1281 printf("KLD file %s - could not finalize loading\n",
1282 lf->filename);
1283 linker_file_unload(lf);
1284 continue;
1285 }
1286 linker_file_register_modules(lf);
1287 if (linker_file_lookup_set(lf, "sysinit_set", &si_start,
1288 &si_stop, NULL) == 0)
1289 sysinit_add(si_start, si_stop);
1290 linker_file_register_sysctls(lf);
1291 lf->flags |= LINKER_FILE_LINKED;
1292 }
1293 /* woohoo! we made it! */
1294}
1295
1296SYSINIT(preload, SI_SUB_KLD, SI_ORDER_MIDDLE, linker_preload, 0)
1297
1298/*
1299 * Search for a not-loaded module by name.
1300 *
1301 * Modules may be found in the following locations:
1302 *
1303 * - preloaded (result is just the module name) - on disk (result is full path
1304 * to module)
1305 *
1306 * If the module name is qualified in any way (contains path, etc.) the we
1307 * simply return a copy of it.
1308 *
1309 * The search path can be manipulated via sysctl. Note that we use the ';'
1310 * character as a separator to be consistent with the bootloader.
1311 */
1312
1313static char linker_hintfile[] = "linker.hints";
1314static char linker_path[MAXPATHLEN] = "/boot/kernel;/boot/modules;/modules";
1315
1316SYSCTL_STRING(_kern, OID_AUTO, module_path, CTLFLAG_RW, linker_path,
1317 sizeof(linker_path), "module load search path");
1318
1319TUNABLE_STR("module_path", linker_path, sizeof(linker_path));
1320
1321static char *linker_ext_list[] = {
1322 "",
1323 ".ko",
1324 NULL
1325};
1326
1327/*
1328 * Check if file actually exists either with or without extension listed in
1329 * the linker_ext_list. (probably should be generic for the rest of the
1330 * kernel)
1331 */
1332static char *
1333linker_lookup_file(const char *path, int pathlen, const char *name,
1334 int namelen, struct vattr *vap)
1335{
1336 struct nameidata nd;
1337 struct thread *td = curthread; /* XXX */
1338 char *result, **cpp, *sep;
1339 int error, len, extlen, reclen, flags;
1340 enum vtype type;
1341
1342 extlen = 0;
1343 for (cpp = linker_ext_list; *cpp; cpp++) {
1344 len = strlen(*cpp);
1345 if (len > extlen)
1346 extlen = len;
1347 }
1348 extlen++; /* trailing '\0' */
1349 sep = (path[pathlen - 1] != '/') ? "/" : "";
1350
1351 reclen = pathlen + strlen(sep) + namelen + extlen + 1;
1352 result = malloc(reclen, M_LINKER, M_WAITOK);
1353 for (cpp = linker_ext_list; *cpp; cpp++) {
1354 snprintf(result, reclen, "%.*s%s%.*s%s", pathlen, path, sep,
1355 namelen, name, *cpp);
1356 /*
1357 * Attempt to open the file, and return the path if
1358 * we succeed and it's a regular file.
1359 */
1360 NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, result, td);
1361 flags = FREAD;
1362 error = vn_open(&nd, &flags, 0);
1363 if (error == 0) {
1364 NDFREE(&nd, NDF_ONLY_PNBUF);
1365 type = nd.ni_vp->v_type;
1366 if (vap)
1367 VOP_GETATTR(nd.ni_vp, vap, td->td_ucred, td);
1368 VOP_UNLOCK(nd.ni_vp, 0, td);
1369 vn_close(nd.ni_vp, FREAD, td->td_ucred, td);
1370 if (type == VREG)
1371 return (result);
1372 }
1373 }
1374 free(result, M_LINKER);
1375 return (NULL);
1376}
1377
1378#define INT_ALIGN(base, ptr) ptr = \
1379 (base) + (((ptr) - (base) + sizeof(int) - 1) & ~(sizeof(int) - 1))
1380
1381/*
1382 * Lookup KLD which contains requested module in the "linker.hints" file. If
1383 * version specification is available, then try to find the best KLD.
1384 * Otherwise just find the latest one.
1385 *
1386 * XXX: Vnode locking here is hosed; lock should be held for calls to
1387 * VOP_GETATTR() and vn_rdwr().
1388 */
1389static char *
1390linker_hints_lookup(const char *path, int pathlen, const char *modname,
1391 int modnamelen, struct mod_depend *verinfo)
1392{
1393 struct thread *td = curthread; /* XXX */
1394 struct ucred *cred = td ? td->td_ucred : NULL;
1395 struct nameidata nd;
1396 struct vattr vattr, mattr;
1397 u_char *hints = NULL;
1398 u_char *cp, *recptr, *bufend, *result, *best, *pathbuf, *sep;
1399 int error, ival, bestver, *intp, reclen, found, flags, clen, blen;
1400
1401 result = NULL;
1402 bestver = found = 0;
1403
1404 sep = (path[pathlen - 1] != '/') ? "/" : "";
1405 reclen = imax(modnamelen, strlen(linker_hintfile)) + pathlen +
1406 strlen(sep) + 1;
1407 pathbuf = malloc(reclen, M_LINKER, M_WAITOK);
1408 snprintf(pathbuf, reclen, "%.*s%s%s", pathlen, path, sep,
1409 linker_hintfile);
1410
1411 NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_SYSSPACE, pathbuf, td);
1412 flags = FREAD;
1413 error = vn_open(&nd, &flags, 0);
1414 if (error)
1415 goto bad;
1416 NDFREE(&nd, NDF_ONLY_PNBUF);
1417 VOP_UNLOCK(nd.ni_vp, 0, td);
1418 if (nd.ni_vp->v_type != VREG)
1419 goto bad;
1420 best = cp = NULL;
1421 error = VOP_GETATTR(nd.ni_vp, &vattr, cred, td);
1422 if (error)
1423 goto bad;
1424 /*
1425 * XXX: we need to limit this number to some reasonable value
1426 */
1427 if (vattr.va_size > 100 * 1024) {
1428 printf("hints file too large %ld\n", (long)vattr.va_size);
1429 goto bad;
1430 }
1431 hints = malloc(vattr.va_size, M_TEMP, M_WAITOK);
1432 if (hints == NULL)
1433 goto bad;
1434 error = vn_rdwr(UIO_READ, nd.ni_vp, (caddr_t)hints, vattr.va_size, 0,
1435 UIO_SYSSPACE, IO_NODELOCKED, cred, &reclen, td);
1436 if (error)
1437 goto bad;
1438 vn_close(nd.ni_vp, FREAD, cred, td);
1439 nd.ni_vp = NULL;
1440 if (reclen != 0) {
1441 printf("can't read %d\n", reclen);
1442 goto bad;
1443 }
1444 intp = (int *)hints;
1445 ival = *intp++;
1446 if (ival != LINKER_HINTS_VERSION) {
1447 printf("hints file version mismatch %d\n", ival);
1448 goto bad;
1449 }
1450 bufend = hints + vattr.va_size;
1451 recptr = (u_char *)intp;
1452 clen = blen = 0;
1453 while (recptr < bufend && !found) {
1454 intp = (int *)recptr;
1455 reclen = *intp++;
1456 ival = *intp++;
1457 cp = (char *)intp;
1458 switch (ival) {
1459 case MDT_VERSION:
1460 clen = *cp++;
1461 if (clen != modnamelen || bcmp(cp, modname, clen) != 0)
1462 break;
1463 cp += clen;
1464 INT_ALIGN(hints, cp);
1465 ival = *(int *)cp;
1466 cp += sizeof(int);
1467 clen = *cp++;
1468 if (verinfo == NULL ||
1469 ival == verinfo->md_ver_preferred) {
1470 found = 1;
1471 break;
1472 }
1473 if (ival >= verinfo->md_ver_minimum &&
1474 ival <= verinfo->md_ver_maximum &&
1475 ival > bestver) {
1476 bestver = ival;
1477 best = cp;
1478 blen = clen;
1479 }
1480 break;
1481 default:
1482 break;
1483 }
1484 recptr += reclen + sizeof(int);
1485 }
1486 /*
1487 * Finally check if KLD is in the place
1488 */
1489 if (found)
1490 result = linker_lookup_file(path, pathlen, cp, clen, &mattr);
1491 else if (best)
1492 result = linker_lookup_file(path, pathlen, best, blen, &mattr);
1493
1494 /*
1495 * KLD is newer than hints file. What we should do now?
1496 */
1497 if (result && timespeccmp(&mattr.va_mtime, &vattr.va_mtime, >))
1498 printf("warning: KLD '%s' is newer than the linker.hints"
1499 " file\n", result);
1500bad:
1501 if (hints)
1502 free(hints, M_TEMP);
1503 if (nd.ni_vp != NULL)
1504 vn_close(nd.ni_vp, FREAD, cred, td);
1505 /*
1506 * If nothing found or hints is absent - fallback to the old
1507 * way by using "kldname[.ko]" as module name.
1508 */
1509 if (!found && !bestver && result == NULL)
1510 result = linker_lookup_file(path, pathlen, modname,
1511 modnamelen, NULL);
1512 return (result);
1513}
1514
1515/*
1516 * Lookup KLD which contains requested module in the all directories.
1517 */
1518static char *
1519linker_search_module(const char *modname, int modnamelen,
1520 struct mod_depend *verinfo)
1521{
1522 char *cp, *ep, *result;
1523
1524 /*
1525 * traverse the linker path
1526 */
1527 for (cp = linker_path; *cp; cp = ep + 1) {
1528 /* find the end of this component */
1529 for (ep = cp; (*ep != 0) && (*ep != ';'); ep++);
1530 result = linker_hints_lookup(cp, ep - cp, modname,
1531 modnamelen, verinfo);
1532 if (result != NULL)
1533 return (result);
1534 if (*ep == 0)
1535 break;
1536 }
1537 return (NULL);
1538}
1539
1540/*
1541 * Search for module in all directories listed in the linker_path.
1542 */
1543static char *
1544linker_search_kld(const char *name)
1545{
1546 char *cp, *ep, *result, **cpp;
1547 int extlen, len;
1548
1549 /* qualified at all? */
1550 if (index(name, '/'))
1551 return (linker_strdup(name));
1552
1553 extlen = 0;
1554 for (cpp = linker_ext_list; *cpp; cpp++) {
1555 len = strlen(*cpp);
1556 if (len > extlen)
1557 extlen = len;
1558 }
1559 extlen++; /* trailing '\0' */
1560
1561 /* traverse the linker path */
1562 len = strlen(name);
1563 for (ep = linker_path; *ep; ep++) {
1564 cp = ep;
1565 /* find the end of this component */
1566 for (; *ep != 0 && *ep != ';'; ep++);
1567 result = linker_lookup_file(cp, ep - cp, name, len, NULL);
1568 if (result != NULL)
1569 return (result);
1570 }
1571 return (NULL);
1572}
1573
1574static const char *
1575linker_basename(const char *path)
1576{
1577 const char *filename;
1578
1579 filename = rindex(path, '/');
1580 if (filename == NULL)
1581 return path;
1582 if (filename[1])
1583 filename++;
1584 return (filename);
1585}
1586
1587/*
1588 * Find a file which contains given module and load it, if "parent" is not
1589 * NULL, register a reference to it.
1590 */
1591static int
1592linker_load_module(const char *kldname, const char *modname,
1593 struct linker_file *parent, struct mod_depend *verinfo,
1594 struct linker_file **lfpp)
1595{
1596 linker_file_t lfdep;
1597 const char *filename;
1598 char *pathname;
1599 int error;
1600
1601 if (modname == NULL) {
1602 /*
1603 * We have to load KLD
1604 */
1605 KASSERT(verinfo == NULL, ("linker_load_module: verinfo"
1606 " is not NULL"));
1607 pathname = linker_search_kld(kldname);
1608 } else {
1609 if (modlist_lookup2(modname, verinfo) != NULL)
1610 return (EEXIST);
1611 if (kldname == NULL)
1612 /*
1613 * Need to find a KLD with required module
1614 */
1615 pathname = linker_search_module(modname,
1616 strlen(modname), verinfo);
1617 else
1618 pathname = linker_strdup(kldname);
1619 }
1620 if (pathname == NULL)
1621 return (ENOENT);
1622
1623 /*
1624 * Can't load more than one file with the same basename XXX:
1625 * Actually it should be possible to have multiple KLDs with
1626 * the same basename but different path because they can
1627 * provide different versions of the same modules.
1628 */
1629 filename = linker_basename(pathname);
1630 if (linker_find_file_by_name(filename)) {
1631 error = EEXIST;
1632 goto out;
1633 }
1634 do {
1635 error = linker_load_file(pathname, &lfdep);
1636 if (error)
1637 break;
1638 if (modname && verinfo &&
1639 modlist_lookup2(modname, verinfo) == NULL) {
1640 linker_file_unload(lfdep);
1641 error = ENOENT;
1642 break;
1643 }
1644 if (parent) {
1645 error = linker_file_add_dependency(parent, lfdep);
1646 if (error)
1647 break;
1648 }
1649 if (lfpp)
1650 *lfpp = lfdep;
1651 } while (0);
1652out:
1653 if (pathname)
1654 free(pathname, M_LINKER);
1655 return (error);
1656}
1657
1658/*
1659 * This routine is responsible for finding dependencies of userland initiated
1660 * kldload(2)'s of files.
1661 */
1662int
1663linker_load_dependencies(linker_file_t lf)
1664{
1665 linker_file_t lfdep;
1666 struct mod_metadata **start, **stop, **mdp, **nmdp;
1667 struct mod_metadata *mp, *nmp;
1668 struct mod_depend *verinfo;
1669 modlist_t mod;
1670 const char *modname, *nmodname;
1671 int ver, error = 0, count;
1672
1673 /*
1674 * All files are dependant on /kernel.
1675 */
1676 if (linker_kernel_file) {
1677 linker_kernel_file->refs++;
1678 error = linker_file_add_dependency(lf, linker_kernel_file);
1679 if (error)
1680 return (error);
1681 }
1682 if (linker_file_lookup_set(lf, MDT_SETNAME, &start, &stop,
1683 &count) != 0)
1684 return (0);
1685 for (mdp = start; mdp < stop; mdp++) {
1686 mp = linker_reloc_ptr(lf, *mdp);
1687 if (mp->md_type != MDT_VERSION)
1688 continue;
1689 linker_mdt_version(lf, mp, &modname, &ver);
1690 mod = modlist_lookup(modname, ver);
1691 if (mod != NULL) {
1692 printf("interface %s.%d already present in the KLD"
1693 " '%s'!\n", modname, ver,
1694 mod->container->filename);
1695 return (EEXIST);
1696 }
1697 }
1698
1699 for (mdp = start; mdp < stop; mdp++) {
1700 mp = linker_reloc_ptr(lf, *mdp);
1701 if (mp->md_type != MDT_DEPEND)
1702 continue;
1703 linker_mdt_depend(lf, mp, &modname, &verinfo);
1704 nmodname = NULL;
1705 for (nmdp = start; nmdp < stop; nmdp++) {
1706 nmp = linker_reloc_ptr(lf, *nmdp);
1707 if (nmp->md_type != MDT_VERSION)
1708 continue;
1709 nmodname = linker_reloc_ptr(lf, nmp->md_cval);
1710 if (strcmp(modname, nmodname) == 0)
1711 break;
1712 }
1713 if (nmdp < stop)/* early exit, it's a self reference */
1714 continue;
1715 mod = modlist_lookup2(modname, verinfo);
1716 if (mod) { /* woohoo, it's loaded already */
1717 lfdep = mod->container;
1718 lfdep->refs++;
1719 error = linker_file_add_dependency(lf, lfdep);
1720 if (error)
1721 break;
1722 continue;
1723 }
1724 error = linker_load_module(NULL, modname, lf, verinfo, NULL);
1725 if (error) {
1726 printf("KLD %s: depends on %s - not available\n",
1727 lf->filename, modname);
1728 break;
1729 }
1730 }
1731
1732 if (error)
1733 return (error);
1734 linker_addmodules(lf, start, stop, 0);
1735 return (error);
1736}
1737
1738static int
1739sysctl_kern_function_list_iterate(const char *name, void *opaque)
1740{
1741 struct sysctl_req *req;
1742
1743 req = opaque;
1744 return (SYSCTL_OUT(req, name, strlen(name) + 1));
1745}
1746
1747/*
1748 * Export a nul-separated, double-nul-terminated list of all function names
1749 * in the kernel.
1750 */
1751static int
1752sysctl_kern_function_list(SYSCTL_HANDLER_ARGS)
1753{
1754 linker_file_t lf;
1755 int error;
1756
1757 TAILQ_FOREACH(lf, &linker_files, link) {
1758 error = LINKER_EACH_FUNCTION_NAME(lf,
1759 sysctl_kern_function_list_iterate, req);
1760 if (error)
1761 return (error);
1762 }
1763 return (SYSCTL_OUT(req, "", 1));
1764}
1765
1766SYSCTL_PROC(_kern, OID_AUTO, function_list, CTLFLAG_RD,
1767 NULL, 0, sysctl_kern_function_list, "", "kernel function list");
| 753 if ((error = suser_xxx(td->td_ucred, NULL, 0)) != 0)
754 goto out;
755
756 lf = linker_find_file_by_id(SCARG(uap, fileid));
757 if (lf) {
758 KLD_DPF(FILE, ("kldunload: lf->userrefs=%d\n", lf->userrefs));
759 if (lf->userrefs == 0) {
760 printf("kldunload: attempt to unload file that was"
761 " loaded by the kernel\n");
762 error = EBUSY;
763 goto out;
764 }
765 lf->userrefs--;
766 error = linker_file_unload(lf);
767 if (error)
768 lf->userrefs++;
769 } else
770 error = ENOENT;
771out:
772 mtx_unlock(&Giant);
773 return (error);
774}
775
776/*
777 * MPSAFE
778 */
779int
780kldfind(struct thread *td, struct kldfind_args *uap)
781{
782 char *pathname;
783 const char *filename;
784 linker_file_t lf;
785 int error = 0;
786
787 mtx_lock(&Giant);
788 td->td_retval[0] = -1;
789
790 pathname = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
791 if ((error = copyinstr(SCARG(uap, file), pathname, MAXPATHLEN,
792 NULL)) != 0)
793 goto out;
794
795 filename = linker_basename(pathname);
796 lf = linker_find_file_by_name(filename);
797 if (lf)
798 td->td_retval[0] = lf->id;
799 else
800 error = ENOENT;
801out:
802 if (pathname)
803 free(pathname, M_TEMP);
804 mtx_unlock(&Giant);
805 return (error);
806}
807
808/*
809 * MPSAFE
810 */
811int
812kldnext(struct thread *td, struct kldnext_args *uap)
813{
814 linker_file_t lf;
815 int error = 0;
816
817 mtx_lock(&Giant);
818
819 if (SCARG(uap, fileid) == 0) {
820 if (TAILQ_FIRST(&linker_files))
821 td->td_retval[0] = TAILQ_FIRST(&linker_files)->id;
822 else
823 td->td_retval[0] = 0;
824 goto out;
825 }
826 lf = linker_find_file_by_id(SCARG(uap, fileid));
827 if (lf) {
828 if (TAILQ_NEXT(lf, link))
829 td->td_retval[0] = TAILQ_NEXT(lf, link)->id;
830 else
831 td->td_retval[0] = 0;
832 } else
833 error = ENOENT;
834out:
835 mtx_unlock(&Giant);
836 return (error);
837}
838
839/*
840 * MPSAFE
841 */
842int
843kldstat(struct thread *td, struct kldstat_args *uap)
844{
845 linker_file_t lf;
846 int error = 0;
847 int namelen, version;
848 struct kld_file_stat *stat;
849
850 mtx_lock(&Giant);
851
852 lf = linker_find_file_by_id(SCARG(uap, fileid));
853 if (lf == NULL) {
854 error = ENOENT;
855 goto out;
856 }
857 stat = SCARG(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 namelen = strlen(lf->filename) + 1;
869 if (namelen > MAXPATHLEN)
870 namelen = MAXPATHLEN;
871 if ((error = copyout(lf->filename, &stat->name[0], namelen)) != 0)
872 goto out;
873 if ((error = copyout(&lf->refs, &stat->refs, sizeof(int))) != 0)
874 goto out;
875 if ((error = copyout(&lf->id, &stat->id, sizeof(int))) != 0)
876 goto out;
877 if ((error = copyout(&lf->address, &stat->address,
878 sizeof(caddr_t))) != 0)
879 goto out;
880 if ((error = copyout(&lf->size, &stat->size, sizeof(size_t))) != 0)
881 goto out;
882
883 td->td_retval[0] = 0;
884out:
885 mtx_unlock(&Giant);
886 return (error);
887}
888
889/*
890 * MPSAFE
891 */
892int
893kldfirstmod(struct thread *td, struct kldfirstmod_args *uap)
894{
895 linker_file_t lf;
896 module_t mp;
897 int error = 0;
898
899 mtx_lock(&Giant);
900 lf = linker_find_file_by_id(SCARG(uap, fileid));
901 if (lf) {
902 MOD_SLOCK;
903 mp = TAILQ_FIRST(&lf->modules);
904 if (mp != NULL)
905 td->td_retval[0] = module_getid(mp);
906 else
907 td->td_retval[0] = 0;
908 MOD_SUNLOCK;
909 } else
910 error = ENOENT;
911 mtx_unlock(&Giant);
912 return (error);
913}
914
915/*
916 * MPSAFE
917 */
918int
919kldsym(struct thread *td, struct kldsym_args *uap)
920{
921 char *symstr = NULL;
922 c_linker_sym_t sym;
923 linker_symval_t symval;
924 linker_file_t lf;
925 struct kld_sym_lookup lookup;
926 int error = 0;
927
928 mtx_lock(&Giant);
929
930 if ((error = copyin(SCARG(uap, data), &lookup, sizeof(lookup))) != 0)
931 goto out;
932 if (lookup.version != sizeof(lookup) ||
933 SCARG(uap, cmd) != KLDSYM_LOOKUP) {
934 error = EINVAL;
935 goto out;
936 }
937 symstr = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
938 if ((error = copyinstr(lookup.symname, symstr, MAXPATHLEN, NULL)) != 0)
939 goto out;
940 if (SCARG(uap, fileid) != 0) {
941 lf = linker_find_file_by_id(SCARG(uap, fileid));
942 if (lf == NULL) {
943 error = ENOENT;
944 goto out;
945 }
946 if (LINKER_LOOKUP_SYMBOL(lf, symstr, &sym) == 0 &&
947 LINKER_SYMBOL_VALUES(lf, sym, &symval) == 0) {
948 lookup.symvalue = (uintptr_t) symval.value;
949 lookup.symsize = symval.size;
950 error = copyout(&lookup, SCARG(uap, data),
951 sizeof(lookup));
952 } else
953 error = ENOENT;
954 } else {
955 TAILQ_FOREACH(lf, &linker_files, link) {
956 if (LINKER_LOOKUP_SYMBOL(lf, symstr, &sym) == 0 &&
957 LINKER_SYMBOL_VALUES(lf, sym, &symval) == 0) {
958 lookup.symvalue = (uintptr_t)symval.value;
959 lookup.symsize = symval.size;
960 error = copyout(&lookup, SCARG(uap, data),
961 sizeof(lookup));
962 break;
963 }
964 }
965 if (lf == NULL)
966 error = ENOENT;
967 }
968out:
969 if (symstr)
970 free(symstr, M_TEMP);
971 mtx_unlock(&Giant);
972 return (error);
973}
974
975/*
976 * Preloaded module support
977 */
978
979static modlist_t
980modlist_lookup(const char *name, int ver)
981{
982 modlist_t mod;
983
984 TAILQ_FOREACH(mod, &found_modules, link) {
985 if (strcmp(mod->name, name) == 0 &&
986 (ver == 0 || mod->version == ver))
987 return (mod);
988 }
989 return (NULL);
990}
991
992static modlist_t
993modlist_lookup2(const char *name, struct mod_depend *verinfo)
994{
995 modlist_t mod, bestmod;
996 int ver;
997
998 if (verinfo == NULL)
999 return (modlist_lookup(name, 0));
1000 bestmod = NULL;
1001 for (mod = TAILQ_FIRST(&found_modules); mod;
1002 mod = TAILQ_NEXT(mod, link)) {
1003 if (strcmp(mod->name, name) != 0)
1004 continue;
1005 ver = mod->version;
1006 if (ver == verinfo->md_ver_preferred)
1007 return (mod);
1008 if (ver >= verinfo->md_ver_minimum &&
1009 ver <= verinfo->md_ver_maximum &&
1010 ver > bestmod->version)
1011 bestmod = mod;
1012 }
1013 return (bestmod);
1014}
1015
1016static modlist_t
1017modlist_newmodule(const char *modname, int version, linker_file_t container)
1018{
1019 modlist_t mod;
1020
1021 mod = malloc(sizeof(struct modlist), M_LINKER, M_NOWAIT | M_ZERO);
1022 if (mod == NULL)
1023 panic("no memory for module list");
1024 mod->container = container;
1025 mod->name = modname;
1026 mod->version = version;
1027 TAILQ_INSERT_TAIL(&found_modules, mod, link);
1028 return (mod);
1029}
1030
1031/*
1032 * This routine is cheap and nasty but will work for data pointers.
1033 */
1034static void *
1035linker_reloc_ptr(linker_file_t lf, const void *offset)
1036{
1037 return (lf->address + (uintptr_t)offset);
1038}
1039
1040/*
1041 * Dereference MDT_VERSION metadata into module name and version
1042 */
1043static void
1044linker_mdt_version(linker_file_t lf, struct mod_metadata *mp,
1045 const char **modname, int *version)
1046{
1047 struct mod_version *mvp;
1048
1049 if (modname)
1050 *modname = linker_reloc_ptr(lf, mp->md_cval);
1051 if (version) {
1052 mvp = linker_reloc_ptr(lf, mp->md_data);
1053 *version = mvp->mv_version;
1054 }
1055}
1056
1057/*
1058 * Dereference MDT_DEPEND metadata into module name and mod_depend structure
1059 */
1060static void
1061linker_mdt_depend(linker_file_t lf, struct mod_metadata *mp,
1062 const char **modname, struct mod_depend **verinfo)
1063{
1064
1065 if (modname)
1066 *modname = linker_reloc_ptr(lf, mp->md_cval);
1067 if (verinfo)
1068 *verinfo = linker_reloc_ptr(lf, mp->md_data);
1069}
1070
1071static void
1072linker_addmodules(linker_file_t lf, struct mod_metadata **start,
1073 struct mod_metadata **stop, int preload)
1074{
1075 struct mod_metadata *mp, **mdp;
1076 const char *modname;
1077 int ver;
1078
1079 for (mdp = start; mdp < stop; mdp++) {
1080 if (preload)
1081 mp = *mdp;
1082 else
1083 mp = linker_reloc_ptr(lf, *mdp);
1084 if (mp->md_type != MDT_VERSION)
1085 continue;
1086 if (preload) {
1087 modname = mp->md_cval;
1088 ver = ((struct mod_version *)mp->md_data)->mv_version;
1089 } else
1090 linker_mdt_version(lf, mp, &modname, &ver);
1091 if (modlist_lookup(modname, ver) != NULL) {
1092 printf("module %s already present!\n", modname);
1093 /* XXX what can we do? this is a build error. :-( */
1094 continue;
1095 }
1096 modlist_newmodule(modname, ver, lf);
1097 }
1098}
1099
1100static void
1101linker_preload(void *arg)
1102{
1103 caddr_t modptr;
1104 const char *modname, *nmodname;
1105 char *modtype;
1106 linker_file_t lf;
1107 linker_class_t lc;
1108 int error;
1109 linker_file_list_t loaded_files;
1110 linker_file_list_t depended_files;
1111 struct mod_metadata *mp, *nmp;
1112 struct mod_metadata **start, **stop, **mdp, **nmdp;
1113 struct mod_depend *verinfo;
1114 int nver;
1115 int resolves;
1116 modlist_t mod;
1117 struct sysinit **si_start, **si_stop;
1118
1119 TAILQ_INIT(&loaded_files);
1120 TAILQ_INIT(&depended_files);
1121 TAILQ_INIT(&found_modules);
1122 error = 0;
1123
1124 modptr = NULL;
1125 while ((modptr = preload_search_next_name(modptr)) != NULL) {
1126 modname = (char *)preload_search_info(modptr, MODINFO_NAME);
1127 modtype = (char *)preload_search_info(modptr, MODINFO_TYPE);
1128 if (modname == NULL) {
1129 printf("Preloaded module at %p does not have a"
1130 " name!\n", modptr);
1131 continue;
1132 }
1133 if (modtype == NULL) {
1134 printf("Preloaded module at %p does not have a type!\n",
1135 modptr);
1136 continue;
1137 }
1138 printf("Preloaded %s \"%s\" at %p.\n", modtype, modname,
1139 modptr);
1140 lf = NULL;
1141 TAILQ_FOREACH(lc, &classes, link) {
1142 error = LINKER_LINK_PRELOAD(lc, modname, &lf);
1143 if (error) {
1144 lf = NULL;
1145 break;
1146 }
1147 }
1148 if (lf)
1149 TAILQ_INSERT_TAIL(&loaded_files, lf, loaded);
1150 }
1151
1152 /*
1153 * First get a list of stuff in the kernel.
1154 */
1155 if (linker_file_lookup_set(linker_kernel_file, MDT_SETNAME, &start,
1156 &stop, NULL) == 0)
1157 linker_addmodules(linker_kernel_file, start, stop, 1);
1158
1159 /*
1160 * this is a once-off kinky bubble sort resolve relocation dependency
1161 * requirements
1162 */
1163restart:
1164 TAILQ_FOREACH(lf, &loaded_files, loaded) {
1165 error = linker_file_lookup_set(lf, MDT_SETNAME, &start,
1166 &stop, NULL);
1167 /*
1168 * First, look to see if we would successfully link with this
1169 * stuff.
1170 */
1171 resolves = 1; /* unless we know otherwise */
1172 if (!error) {
1173 for (mdp = start; mdp < stop; mdp++) {
1174 mp = linker_reloc_ptr(lf, *mdp);
1175 if (mp->md_type != MDT_DEPEND)
1176 continue;
1177 linker_mdt_depend(lf, mp, &modname, &verinfo);
1178 for (nmdp = start; nmdp < stop; nmdp++) {
1179 nmp = linker_reloc_ptr(lf, *nmdp);
1180 if (nmp->md_type != MDT_VERSION)
1181 continue;
1182 linker_mdt_version(lf, nmp, &nmodname,
1183 NULL);
1184 nmodname = linker_reloc_ptr(lf,
1185 nmp->md_cval);
1186 if (strcmp(modname, nmodname) == 0)
1187 break;
1188 }
1189 if (nmdp < stop) /* it's a self reference */
1190 continue;
1191
1192 /*
1193 * ok, the module isn't here yet, we
1194 * are not finished
1195 */
1196 if (modlist_lookup2(modname, verinfo) == NULL)
1197 resolves = 0;
1198 }
1199 }
1200 /*
1201 * OK, if we found our modules, we can link. So, "provide"
1202 * the modules inside and add it to the end of the link order
1203 * list.
1204 */
1205 if (resolves) {
1206 if (!error) {
1207 for (mdp = start; mdp < stop; mdp++) {
1208 mp = linker_reloc_ptr(lf, *mdp);
1209 if (mp->md_type != MDT_VERSION)
1210 continue;
1211 linker_mdt_version(lf, mp,
1212 &modname, &nver);
1213 if (modlist_lookup(modname,
1214 nver) != NULL) {
1215 printf("module %s already"
1216 " present!\n", modname);
1217 linker_file_unload(lf);
1218 TAILQ_REMOVE(&loaded_files,
1219 lf, loaded);
1220 /* we changed tailq next ptr */
1221 goto restart;
1222 }
1223 modlist_newmodule(modname, nver, lf);
1224 }
1225 }
1226 TAILQ_REMOVE(&loaded_files, lf, loaded);
1227 TAILQ_INSERT_TAIL(&depended_files, lf, loaded);
1228 /*
1229 * Since we provided modules, we need to restart the
1230 * sort so that the previous files that depend on us
1231 * have a chance. Also, we've busted the tailq next
1232 * pointer with the REMOVE.
1233 */
1234 goto restart;
1235 }
1236 }
1237
1238 /*
1239 * At this point, we check to see what could not be resolved..
1240 */
1241 TAILQ_FOREACH(lf, &loaded_files, loaded) {
1242 printf("KLD file %s is missing dependencies\n", lf->filename);
1243 linker_file_unload(lf);
1244 TAILQ_REMOVE(&loaded_files, lf, loaded);
1245 }
1246
1247 /*
1248 * We made it. Finish off the linking in the order we determined.
1249 */
1250 TAILQ_FOREACH(lf, &depended_files, loaded) {
1251 if (linker_kernel_file) {
1252 linker_kernel_file->refs++;
1253 error = linker_file_add_dependency(lf,
1254 linker_kernel_file);
1255 if (error)
1256 panic("cannot add dependency");
1257 }
1258 lf->userrefs++; /* so we can (try to) kldunload it */
1259 error = linker_file_lookup_set(lf, MDT_SETNAME, &start,
1260 &stop, NULL);
1261 if (!error) {
1262 for (mdp = start; mdp < stop; mdp++) {
1263 mp = linker_reloc_ptr(lf, *mdp);
1264 if (mp->md_type != MDT_DEPEND)
1265 continue;
1266 linker_mdt_depend(lf, mp, &modname, &verinfo);
1267 mod = modlist_lookup2(modname, verinfo);
1268 mod->container->refs++;
1269 error = linker_file_add_dependency(lf,
1270 mod->container);
1271 if (error)
1272 panic("cannot add dependency");
1273 }
1274 }
1275 /*
1276 * Now do relocation etc using the symbol search paths
1277 * established by the dependencies
1278 */
1279 error = LINKER_LINK_PRELOAD_FINISH(lf);
1280 if (error) {
1281 printf("KLD file %s - could not finalize loading\n",
1282 lf->filename);
1283 linker_file_unload(lf);
1284 continue;
1285 }
1286 linker_file_register_modules(lf);
1287 if (linker_file_lookup_set(lf, "sysinit_set", &si_start,
1288 &si_stop, NULL) == 0)
1289 sysinit_add(si_start, si_stop);
1290 linker_file_register_sysctls(lf);
1291 lf->flags |= LINKER_FILE_LINKED;
1292 }
1293 /* woohoo! we made it! */
1294}
1295
1296SYSINIT(preload, SI_SUB_KLD, SI_ORDER_MIDDLE, linker_preload, 0)
1297
1298/*
1299 * Search for a not-loaded module by name.
1300 *
1301 * Modules may be found in the following locations:
1302 *
1303 * - preloaded (result is just the module name) - on disk (result is full path
1304 * to module)
1305 *
1306 * If the module name is qualified in any way (contains path, etc.) the we
1307 * simply return a copy of it.
1308 *
1309 * The search path can be manipulated via sysctl. Note that we use the ';'
1310 * character as a separator to be consistent with the bootloader.
1311 */
1312
1313static char linker_hintfile[] = "linker.hints";
1314static char linker_path[MAXPATHLEN] = "/boot/kernel;/boot/modules;/modules";
1315
1316SYSCTL_STRING(_kern, OID_AUTO, module_path, CTLFLAG_RW, linker_path,
1317 sizeof(linker_path), "module load search path");
1318
1319TUNABLE_STR("module_path", linker_path, sizeof(linker_path));
1320
1321static char *linker_ext_list[] = {
1322 "",
1323 ".ko",
1324 NULL
1325};
1326
1327/*
1328 * Check if file actually exists either with or without extension listed in
1329 * the linker_ext_list. (probably should be generic for the rest of the
1330 * kernel)
1331 */
1332static char *
1333linker_lookup_file(const char *path, int pathlen, const char *name,
1334 int namelen, struct vattr *vap)
1335{
1336 struct nameidata nd;
1337 struct thread *td = curthread; /* XXX */
1338 char *result, **cpp, *sep;
1339 int error, len, extlen, reclen, flags;
1340 enum vtype type;
1341
1342 extlen = 0;
1343 for (cpp = linker_ext_list; *cpp; cpp++) {
1344 len = strlen(*cpp);
1345 if (len > extlen)
1346 extlen = len;
1347 }
1348 extlen++; /* trailing '\0' */
1349 sep = (path[pathlen - 1] != '/') ? "/" : "";
1350
1351 reclen = pathlen + strlen(sep) + namelen + extlen + 1;
1352 result = malloc(reclen, M_LINKER, M_WAITOK);
1353 for (cpp = linker_ext_list; *cpp; cpp++) {
1354 snprintf(result, reclen, "%.*s%s%.*s%s", pathlen, path, sep,
1355 namelen, name, *cpp);
1356 /*
1357 * Attempt to open the file, and return the path if
1358 * we succeed and it's a regular file.
1359 */
1360 NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, result, td);
1361 flags = FREAD;
1362 error = vn_open(&nd, &flags, 0);
1363 if (error == 0) {
1364 NDFREE(&nd, NDF_ONLY_PNBUF);
1365 type = nd.ni_vp->v_type;
1366 if (vap)
1367 VOP_GETATTR(nd.ni_vp, vap, td->td_ucred, td);
1368 VOP_UNLOCK(nd.ni_vp, 0, td);
1369 vn_close(nd.ni_vp, FREAD, td->td_ucred, td);
1370 if (type == VREG)
1371 return (result);
1372 }
1373 }
1374 free(result, M_LINKER);
1375 return (NULL);
1376}
1377
1378#define INT_ALIGN(base, ptr) ptr = \
1379 (base) + (((ptr) - (base) + sizeof(int) - 1) & ~(sizeof(int) - 1))
1380
1381/*
1382 * Lookup KLD which contains requested module in the "linker.hints" file. If
1383 * version specification is available, then try to find the best KLD.
1384 * Otherwise just find the latest one.
1385 *
1386 * XXX: Vnode locking here is hosed; lock should be held for calls to
1387 * VOP_GETATTR() and vn_rdwr().
1388 */
1389static char *
1390linker_hints_lookup(const char *path, int pathlen, const char *modname,
1391 int modnamelen, struct mod_depend *verinfo)
1392{
1393 struct thread *td = curthread; /* XXX */
1394 struct ucred *cred = td ? td->td_ucred : NULL;
1395 struct nameidata nd;
1396 struct vattr vattr, mattr;
1397 u_char *hints = NULL;
1398 u_char *cp, *recptr, *bufend, *result, *best, *pathbuf, *sep;
1399 int error, ival, bestver, *intp, reclen, found, flags, clen, blen;
1400
1401 result = NULL;
1402 bestver = found = 0;
1403
1404 sep = (path[pathlen - 1] != '/') ? "/" : "";
1405 reclen = imax(modnamelen, strlen(linker_hintfile)) + pathlen +
1406 strlen(sep) + 1;
1407 pathbuf = malloc(reclen, M_LINKER, M_WAITOK);
1408 snprintf(pathbuf, reclen, "%.*s%s%s", pathlen, path, sep,
1409 linker_hintfile);
1410
1411 NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_SYSSPACE, pathbuf, td);
1412 flags = FREAD;
1413 error = vn_open(&nd, &flags, 0);
1414 if (error)
1415 goto bad;
1416 NDFREE(&nd, NDF_ONLY_PNBUF);
1417 VOP_UNLOCK(nd.ni_vp, 0, td);
1418 if (nd.ni_vp->v_type != VREG)
1419 goto bad;
1420 best = cp = NULL;
1421 error = VOP_GETATTR(nd.ni_vp, &vattr, cred, td);
1422 if (error)
1423 goto bad;
1424 /*
1425 * XXX: we need to limit this number to some reasonable value
1426 */
1427 if (vattr.va_size > 100 * 1024) {
1428 printf("hints file too large %ld\n", (long)vattr.va_size);
1429 goto bad;
1430 }
1431 hints = malloc(vattr.va_size, M_TEMP, M_WAITOK);
1432 if (hints == NULL)
1433 goto bad;
1434 error = vn_rdwr(UIO_READ, nd.ni_vp, (caddr_t)hints, vattr.va_size, 0,
1435 UIO_SYSSPACE, IO_NODELOCKED, cred, &reclen, td);
1436 if (error)
1437 goto bad;
1438 vn_close(nd.ni_vp, FREAD, cred, td);
1439 nd.ni_vp = NULL;
1440 if (reclen != 0) {
1441 printf("can't read %d\n", reclen);
1442 goto bad;
1443 }
1444 intp = (int *)hints;
1445 ival = *intp++;
1446 if (ival != LINKER_HINTS_VERSION) {
1447 printf("hints file version mismatch %d\n", ival);
1448 goto bad;
1449 }
1450 bufend = hints + vattr.va_size;
1451 recptr = (u_char *)intp;
1452 clen = blen = 0;
1453 while (recptr < bufend && !found) {
1454 intp = (int *)recptr;
1455 reclen = *intp++;
1456 ival = *intp++;
1457 cp = (char *)intp;
1458 switch (ival) {
1459 case MDT_VERSION:
1460 clen = *cp++;
1461 if (clen != modnamelen || bcmp(cp, modname, clen) != 0)
1462 break;
1463 cp += clen;
1464 INT_ALIGN(hints, cp);
1465 ival = *(int *)cp;
1466 cp += sizeof(int);
1467 clen = *cp++;
1468 if (verinfo == NULL ||
1469 ival == verinfo->md_ver_preferred) {
1470 found = 1;
1471 break;
1472 }
1473 if (ival >= verinfo->md_ver_minimum &&
1474 ival <= verinfo->md_ver_maximum &&
1475 ival > bestver) {
1476 bestver = ival;
1477 best = cp;
1478 blen = clen;
1479 }
1480 break;
1481 default:
1482 break;
1483 }
1484 recptr += reclen + sizeof(int);
1485 }
1486 /*
1487 * Finally check if KLD is in the place
1488 */
1489 if (found)
1490 result = linker_lookup_file(path, pathlen, cp, clen, &mattr);
1491 else if (best)
1492 result = linker_lookup_file(path, pathlen, best, blen, &mattr);
1493
1494 /*
1495 * KLD is newer than hints file. What we should do now?
1496 */
1497 if (result && timespeccmp(&mattr.va_mtime, &vattr.va_mtime, >))
1498 printf("warning: KLD '%s' is newer than the linker.hints"
1499 " file\n", result);
1500bad:
1501 if (hints)
1502 free(hints, M_TEMP);
1503 if (nd.ni_vp != NULL)
1504 vn_close(nd.ni_vp, FREAD, cred, td);
1505 /*
1506 * If nothing found or hints is absent - fallback to the old
1507 * way by using "kldname[.ko]" as module name.
1508 */
1509 if (!found && !bestver && result == NULL)
1510 result = linker_lookup_file(path, pathlen, modname,
1511 modnamelen, NULL);
1512 return (result);
1513}
1514
1515/*
1516 * Lookup KLD which contains requested module in the all directories.
1517 */
1518static char *
1519linker_search_module(const char *modname, int modnamelen,
1520 struct mod_depend *verinfo)
1521{
1522 char *cp, *ep, *result;
1523
1524 /*
1525 * traverse the linker path
1526 */
1527 for (cp = linker_path; *cp; cp = ep + 1) {
1528 /* find the end of this component */
1529 for (ep = cp; (*ep != 0) && (*ep != ';'); ep++);
1530 result = linker_hints_lookup(cp, ep - cp, modname,
1531 modnamelen, verinfo);
1532 if (result != NULL)
1533 return (result);
1534 if (*ep == 0)
1535 break;
1536 }
1537 return (NULL);
1538}
1539
1540/*
1541 * Search for module in all directories listed in the linker_path.
1542 */
1543static char *
1544linker_search_kld(const char *name)
1545{
1546 char *cp, *ep, *result, **cpp;
1547 int extlen, len;
1548
1549 /* qualified at all? */
1550 if (index(name, '/'))
1551 return (linker_strdup(name));
1552
1553 extlen = 0;
1554 for (cpp = linker_ext_list; *cpp; cpp++) {
1555 len = strlen(*cpp);
1556 if (len > extlen)
1557 extlen = len;
1558 }
1559 extlen++; /* trailing '\0' */
1560
1561 /* traverse the linker path */
1562 len = strlen(name);
1563 for (ep = linker_path; *ep; ep++) {
1564 cp = ep;
1565 /* find the end of this component */
1566 for (; *ep != 0 && *ep != ';'; ep++);
1567 result = linker_lookup_file(cp, ep - cp, name, len, NULL);
1568 if (result != NULL)
1569 return (result);
1570 }
1571 return (NULL);
1572}
1573
1574static const char *
1575linker_basename(const char *path)
1576{
1577 const char *filename;
1578
1579 filename = rindex(path, '/');
1580 if (filename == NULL)
1581 return path;
1582 if (filename[1])
1583 filename++;
1584 return (filename);
1585}
1586
1587/*
1588 * Find a file which contains given module and load it, if "parent" is not
1589 * NULL, register a reference to it.
1590 */
1591static int
1592linker_load_module(const char *kldname, const char *modname,
1593 struct linker_file *parent, struct mod_depend *verinfo,
1594 struct linker_file **lfpp)
1595{
1596 linker_file_t lfdep;
1597 const char *filename;
1598 char *pathname;
1599 int error;
1600
1601 if (modname == NULL) {
1602 /*
1603 * We have to load KLD
1604 */
1605 KASSERT(verinfo == NULL, ("linker_load_module: verinfo"
1606 " is not NULL"));
1607 pathname = linker_search_kld(kldname);
1608 } else {
1609 if (modlist_lookup2(modname, verinfo) != NULL)
1610 return (EEXIST);
1611 if (kldname == NULL)
1612 /*
1613 * Need to find a KLD with required module
1614 */
1615 pathname = linker_search_module(modname,
1616 strlen(modname), verinfo);
1617 else
1618 pathname = linker_strdup(kldname);
1619 }
1620 if (pathname == NULL)
1621 return (ENOENT);
1622
1623 /*
1624 * Can't load more than one file with the same basename XXX:
1625 * Actually it should be possible to have multiple KLDs with
1626 * the same basename but different path because they can
1627 * provide different versions of the same modules.
1628 */
1629 filename = linker_basename(pathname);
1630 if (linker_find_file_by_name(filename)) {
1631 error = EEXIST;
1632 goto out;
1633 }
1634 do {
1635 error = linker_load_file(pathname, &lfdep);
1636 if (error)
1637 break;
1638 if (modname && verinfo &&
1639 modlist_lookup2(modname, verinfo) == NULL) {
1640 linker_file_unload(lfdep);
1641 error = ENOENT;
1642 break;
1643 }
1644 if (parent) {
1645 error = linker_file_add_dependency(parent, lfdep);
1646 if (error)
1647 break;
1648 }
1649 if (lfpp)
1650 *lfpp = lfdep;
1651 } while (0);
1652out:
1653 if (pathname)
1654 free(pathname, M_LINKER);
1655 return (error);
1656}
1657
1658/*
1659 * This routine is responsible for finding dependencies of userland initiated
1660 * kldload(2)'s of files.
1661 */
1662int
1663linker_load_dependencies(linker_file_t lf)
1664{
1665 linker_file_t lfdep;
1666 struct mod_metadata **start, **stop, **mdp, **nmdp;
1667 struct mod_metadata *mp, *nmp;
1668 struct mod_depend *verinfo;
1669 modlist_t mod;
1670 const char *modname, *nmodname;
1671 int ver, error = 0, count;
1672
1673 /*
1674 * All files are dependant on /kernel.
1675 */
1676 if (linker_kernel_file) {
1677 linker_kernel_file->refs++;
1678 error = linker_file_add_dependency(lf, linker_kernel_file);
1679 if (error)
1680 return (error);
1681 }
1682 if (linker_file_lookup_set(lf, MDT_SETNAME, &start, &stop,
1683 &count) != 0)
1684 return (0);
1685 for (mdp = start; mdp < stop; mdp++) {
1686 mp = linker_reloc_ptr(lf, *mdp);
1687 if (mp->md_type != MDT_VERSION)
1688 continue;
1689 linker_mdt_version(lf, mp, &modname, &ver);
1690 mod = modlist_lookup(modname, ver);
1691 if (mod != NULL) {
1692 printf("interface %s.%d already present in the KLD"
1693 " '%s'!\n", modname, ver,
1694 mod->container->filename);
1695 return (EEXIST);
1696 }
1697 }
1698
1699 for (mdp = start; mdp < stop; mdp++) {
1700 mp = linker_reloc_ptr(lf, *mdp);
1701 if (mp->md_type != MDT_DEPEND)
1702 continue;
1703 linker_mdt_depend(lf, mp, &modname, &verinfo);
1704 nmodname = NULL;
1705 for (nmdp = start; nmdp < stop; nmdp++) {
1706 nmp = linker_reloc_ptr(lf, *nmdp);
1707 if (nmp->md_type != MDT_VERSION)
1708 continue;
1709 nmodname = linker_reloc_ptr(lf, nmp->md_cval);
1710 if (strcmp(modname, nmodname) == 0)
1711 break;
1712 }
1713 if (nmdp < stop)/* early exit, it's a self reference */
1714 continue;
1715 mod = modlist_lookup2(modname, verinfo);
1716 if (mod) { /* woohoo, it's loaded already */
1717 lfdep = mod->container;
1718 lfdep->refs++;
1719 error = linker_file_add_dependency(lf, lfdep);
1720 if (error)
1721 break;
1722 continue;
1723 }
1724 error = linker_load_module(NULL, modname, lf, verinfo, NULL);
1725 if (error) {
1726 printf("KLD %s: depends on %s - not available\n",
1727 lf->filename, modname);
1728 break;
1729 }
1730 }
1731
1732 if (error)
1733 return (error);
1734 linker_addmodules(lf, start, stop, 0);
1735 return (error);
1736}
1737
1738static int
1739sysctl_kern_function_list_iterate(const char *name, void *opaque)
1740{
1741 struct sysctl_req *req;
1742
1743 req = opaque;
1744 return (SYSCTL_OUT(req, name, strlen(name) + 1));
1745}
1746
1747/*
1748 * Export a nul-separated, double-nul-terminated list of all function names
1749 * in the kernel.
1750 */
1751static int
1752sysctl_kern_function_list(SYSCTL_HANDLER_ARGS)
1753{
1754 linker_file_t lf;
1755 int error;
1756
1757 TAILQ_FOREACH(lf, &linker_files, link) {
1758 error = LINKER_EACH_FUNCTION_NAME(lf,
1759 sysctl_kern_function_list_iterate, req);
1760 if (error)
1761 return (error);
1762 }
1763 return (SYSCTL_OUT(req, "", 1));
1764}
1765
1766SYSCTL_PROC(_kern, OID_AUTO, function_list, CTLFLAG_RD,
1767 NULL, 0, sysctl_kern_function_list, "", "kernel function list");
|