1 /*-
2 * Copyright (c) 1997-2000 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
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD: src/sys/kern/kern_linker.c,v 1.158 2008/05/23 07:08:59 jb Exp $");
29
30 #include "opt_ddb.h"
31 #include "opt_hwpmc_hooks.h"
32 #include "opt_mac.h"
33
34 #include <sys/param.h>
35 #include <sys/kernel.h>
36 #include <sys/systm.h>
37 #include <sys/malloc.h>
38 #include <sys/sysproto.h>
39 #include <sys/sysent.h>
40 #include <sys/priv.h>
41 #include <sys/proc.h>
42 #include <sys/lock.h>
43 #include <sys/mutex.h>
44 #include <sys/sx.h>
45 #include <sys/module.h>
46 #include <sys/mount.h>
47 #include <sys/linker.h>
48 #include <sys/fcntl.h>
49 #include <sys/libkern.h>
50 #include <sys/namei.h>
51 #include <sys/vnode.h>
52 #include <sys/syscallsubr.h>
53 #include <sys/sysctl.h>
54
55 #include <security/mac/mac_framework.h>
56
57 #include "linker_if.h"
58
59 #ifdef HWPMC_HOOKS
60 #include <sys/pmckern.h>
61 #endif
62
63 #ifdef KLD_DEBUG
64 int kld_debug = 0;
65 #endif
66
67 #define KLD_LOCK() sx_xlock(&kld_sx)
68 #define KLD_UNLOCK() sx_xunlock(&kld_sx)
69 #define KLD_LOCKED() sx_xlocked(&kld_sx)
70 #define KLD_LOCK_ASSERT() do { \
71 if (!cold) \
72 sx_assert(&kld_sx, SX_XLOCKED); \
73 } while (0)
74
75 /*
76 * static char *linker_search_path(const char *name, struct mod_depend
77 * *verinfo);
78 */
79 static const char *linker_basename(const char *path);
80
81 /*
82 * Find a currently loaded file given its filename.
83 */
84 static linker_file_t linker_find_file_by_name(const char* _filename);
85
86 /*
87 * Find a currently loaded file given its file id.
88 */
89 static linker_file_t linker_find_file_by_id(int _fileid);
90
91 /* Metadata from the static kernel */
92 SET_DECLARE(modmetadata_set, struct mod_metadata);
93
94 MALLOC_DEFINE(M_LINKER, "linker", "kernel linker");
95
96 linker_file_t linker_kernel_file;
97
98 static struct sx kld_sx; /* kernel linker lock */
99
100 /*
101 * Load counter used by clients to determine if a linker file has been
102 * re-loaded. This counter is incremented for each file load.
103 */
104 static int loadcnt;
105
106 static linker_class_list_t classes;
107 static linker_file_list_t linker_files;
108 static int next_file_id = 1;
109 static int linker_no_more_classes = 0;
110
111 #define LINKER_GET_NEXT_FILE_ID(a) do { \
112 linker_file_t lftmp; \
113 \
114 KLD_LOCK_ASSERT(); \
115 retry: \
116 TAILQ_FOREACH(lftmp, &linker_files, link) { \
117 if (next_file_id == lftmp->id) { \
118 next_file_id++; \
119 goto retry; \
120 } \
121 } \
122 (a) = next_file_id; \
123 } while(0)
124
125
126 /* XXX wrong name; we're looking at version provision tags here, not modules */
127 typedef TAILQ_HEAD(, modlist) modlisthead_t;
128 struct modlist {
129 TAILQ_ENTRY(modlist) link; /* chain together all modules */
130 linker_file_t container;
131 const char *name;
132 int version;
133 };
134 typedef struct modlist *modlist_t;
135 static modlisthead_t found_modules;
136
137 static int linker_file_add_dependency(linker_file_t file,
138 linker_file_t dep);
139 static caddr_t linker_file_lookup_symbol_internal(linker_file_t file,
140 const char* name, int deps);
141 static int linker_load_module(const char *kldname,
142 const char *modname, struct linker_file *parent,
143 struct mod_depend *verinfo, struct linker_file **lfpp);
144 static modlist_t modlist_lookup2(const char *name, struct mod_depend *verinfo);
145
146 static char *
147 linker_strdup(const char *str)
148 {
149 char *result;
150
151 if ((result = malloc((strlen(str) + 1), M_LINKER, M_WAITOK)) != NULL)
152 strcpy(result, str);
153 return (result);
154 }
155
156 static void
157 linker_init(void *arg)
158 {
159
160 sx_init(&kld_sx, "kernel linker");
161 TAILQ_INIT(&classes);
162 TAILQ_INIT(&linker_files);
163 }
164
165 SYSINIT(linker, SI_SUB_KLD, SI_ORDER_FIRST, linker_init, 0);
166
167 static void
168 linker_stop_class_add(void *arg)
169 {
170
171 linker_no_more_classes = 1;
172 }
173
174 SYSINIT(linker_class, SI_SUB_KLD, SI_ORDER_ANY, linker_stop_class_add, NULL);
175
176 int
177 linker_add_class(linker_class_t lc)
178 {
179
180 /*
181 * We disallow any class registration past SI_ORDER_ANY
182 * of SI_SUB_KLD. We bump the reference count to keep the
183 * ops from being freed.
184 */
185 if (linker_no_more_classes == 1)
186 return (EPERM);
187 kobj_class_compile((kobj_class_t) lc);
188 ((kobj_class_t)lc)->refs++; /* XXX: kobj_mtx */
189 TAILQ_INSERT_TAIL(&classes, lc, link);
190 return (0);
191 }
192
193 static void
194 linker_file_sysinit(linker_file_t lf)
195 {
196 struct sysinit **start, **stop, **sipp, **xipp, *save;
197
198 KLD_DPF(FILE, ("linker_file_sysinit: calling SYSINITs for %s\n",
199 lf->filename));
200
201 if (linker_file_lookup_set(lf, "sysinit_set", &start, &stop, NULL) != 0)
202 return;
203 /*
204 * Perform a bubble sort of the system initialization objects by
205 * their subsystem (primary key) and order (secondary key).
206 *
207 * Since some things care about execution order, this is the operation
208 * which ensures continued function.
209 */
210 for (sipp = start; sipp < stop; sipp++) {
211 for (xipp = sipp + 1; xipp < stop; xipp++) {
212 if ((*sipp)->subsystem < (*xipp)->subsystem ||
213 ((*sipp)->subsystem == (*xipp)->subsystem &&
214 (*sipp)->order <= (*xipp)->order))
215 continue; /* skip */
216 save = *sipp;
217 *sipp = *xipp;
218 *xipp = save;
219 }
220 }
221
222 /*
223 * Traverse the (now) ordered list of system initialization tasks.
224 * Perform each task, and continue on to the next task.
225 */
226 mtx_lock(&Giant);
227 for (sipp = start; sipp < stop; sipp++) {
228 if ((*sipp)->subsystem == SI_SUB_DUMMY)
229 continue; /* skip dummy task(s) */
230
231 /* Call function */
232 (*((*sipp)->func)) ((*sipp)->udata);
233 }
234 mtx_unlock(&Giant);
235 }
236
237 static void
238 linker_file_sysuninit(linker_file_t lf)
239 {
240 struct sysinit **start, **stop, **sipp, **xipp, *save;
241
242 KLD_DPF(FILE, ("linker_file_sysuninit: calling SYSUNINITs for %s\n",
243 lf->filename));
244
245 if (linker_file_lookup_set(lf, "sysuninit_set", &start, &stop,
246 NULL) != 0)
247 return;
248
249 /*
250 * Perform a reverse bubble sort of the system initialization objects
251 * by their subsystem (primary key) and order (secondary key).
252 *
253 * Since some things care about execution order, this is the operation
254 * which ensures continued function.
255 */
256 for (sipp = start; sipp < stop; sipp++) {
257 for (xipp = sipp + 1; xipp < stop; xipp++) {
258 if ((*sipp)->subsystem > (*xipp)->subsystem ||
259 ((*sipp)->subsystem == (*xipp)->subsystem &&
260 (*sipp)->order >= (*xipp)->order))
261 continue; /* skip */
262 save = *sipp;
263 *sipp = *xipp;
264 *xipp = save;
265 }
266 }
267
268 /*
269 * Traverse the (now) ordered list of system initialization tasks.
270 * Perform each task, and continue on to the next task.
271 */
272 mtx_lock(&Giant);
273 for (sipp = start; sipp < stop; sipp++) {
274 if ((*sipp)->subsystem == SI_SUB_DUMMY)
275 continue; /* skip dummy task(s) */
276
277 /* Call function */
278 (*((*sipp)->func)) ((*sipp)->udata);
279 }
280 mtx_unlock(&Giant);
281 }
282
283 static void
284 linker_file_register_sysctls(linker_file_t lf)
285 {
286 struct sysctl_oid **start, **stop, **oidp;
287
288 KLD_DPF(FILE,
289 ("linker_file_register_sysctls: registering SYSCTLs for %s\n",
290 lf->filename));
291
292 if (linker_file_lookup_set(lf, "sysctl_set", &start, &stop, NULL) != 0)
293 return;
294
295 mtx_lock(&Giant);
296 for (oidp = start; oidp < stop; oidp++)
297 sysctl_register_oid(*oidp);
298 mtx_unlock(&Giant);
299 }
300
301 static void
302 linker_file_unregister_sysctls(linker_file_t lf)
303 {
304 struct sysctl_oid **start, **stop, **oidp;
305
306 KLD_DPF(FILE, ("linker_file_unregister_sysctls: registering SYSCTLs"
307 " for %s\n", lf->filename));
308
309 if (linker_file_lookup_set(lf, "sysctl_set", &start, &stop, NULL) != 0)
310 return;
311
312 mtx_lock(&Giant);
313 for (oidp = start; oidp < stop; oidp++)
314 sysctl_unregister_oid(*oidp);
315 mtx_unlock(&Giant);
316 }
317
318 static int
319 linker_file_register_modules(linker_file_t lf)
320 {
321 struct mod_metadata **start, **stop, **mdp;
322 const moduledata_t *moddata;
323 int first_error, error;
324
325 KLD_DPF(FILE, ("linker_file_register_modules: registering modules"
326 " in %s\n", lf->filename));
327
328 if (linker_file_lookup_set(lf, "modmetadata_set", &start,
329 &stop, NULL) != 0) {
330 /*
331 * This fallback should be unnecessary, but if we get booted
332 * from boot2 instead of loader and we are missing our
333 * metadata then we have to try the best we can.
334 */
335 if (lf == linker_kernel_file) {
336 start = SET_BEGIN(modmetadata_set);
337 stop = SET_LIMIT(modmetadata_set);
338 } else
339 return (0);
340 }
341 first_error = 0;
342 for (mdp = start; mdp < stop; mdp++) {
343 if ((*mdp)->md_type != MDT_MODULE)
344 continue;
345 moddata = (*mdp)->md_data;
346 KLD_DPF(FILE, ("Registering module %s in %s\n",
347 moddata->name, lf->filename));
348 error = module_register(moddata, lf);
349 if (error) {
350 printf("Module %s failed to register: %d\n",
351 moddata->name, error);
352 if (first_error == 0)
353 first_error = error;
354 }
355 }
356 return (first_error);
357 }
358
359 static void
360 linker_init_kernel_modules(void)
361 {
362
363 linker_file_register_modules(linker_kernel_file);
364 }
365
366 SYSINIT(linker_kernel, SI_SUB_KLD, SI_ORDER_ANY, linker_init_kernel_modules,
367 0);
368
369 static int
370 linker_load_file(const char *filename, linker_file_t *result)
371 {
372 linker_class_t lc;
373 linker_file_t lf;
374 int foundfile, error;
375
376 /* Refuse to load modules if securelevel raised */
377 if (securelevel > 0)
378 return (EPERM);
379
380 KLD_LOCK_ASSERT();
381 lf = linker_find_file_by_name(filename);
382 if (lf) {
383 KLD_DPF(FILE, ("linker_load_file: file %s is already loaded,"
384 " incrementing refs\n", filename));
385 *result = lf;
386 lf->refs++;
387 return (0);
388 }
389 foundfile = 0;
390 error = 0;
391
392 /*
393 * We do not need to protect (lock) classes here because there is
394 * no class registration past startup (SI_SUB_KLD, SI_ORDER_ANY)
395 * and there is no class deregistration mechanism at this time.
396 */
397 TAILQ_FOREACH(lc, &classes, link) {
398 KLD_DPF(FILE, ("linker_load_file: trying to load %s\n",
399 filename));
400 error = LINKER_LOAD_FILE(lc, filename, &lf);
401 /*
402 * If we got something other than ENOENT, then it exists but
403 * we cannot load it for some other reason.
404 */
405 if (error != ENOENT)
406 foundfile = 1;
407 if (lf) {
408 error = linker_file_register_modules(lf);
409 if (error == EEXIST) {
410 linker_file_unload(lf, LINKER_UNLOAD_FORCE);
411 return (error);
412 }
413 KLD_UNLOCK();
414 linker_file_register_sysctls(lf);
415 linker_file_sysinit(lf);
416 KLD_LOCK();
417 lf->flags |= LINKER_FILE_LINKED;
418 *result = lf;
419 return (0);
420 }
421 }
422 /*
423 * Less than ideal, but tells the user whether it failed to load or
424 * the module was not found.
425 */
426 if (foundfile) {
427 /*
428 * Format not recognized or otherwise unloadable.
429 * When loading a module that is statically built into
430 * the kernel EEXIST percolates back up as the return
431 * value. Preserve this so that apps like sysinstall
432 * can recognize this special case and not post bogus
433 * dialog boxes.
434 */
435 if (error != EEXIST)
436 error = ENOEXEC;
437 } else
438 error = ENOENT; /* Nothing found */
439 return (error);
440 }
441
442 int
443 linker_reference_module(const char *modname, struct mod_depend *verinfo,
444 linker_file_t *result)
445 {
446 modlist_t mod;
447 int error;
448
449 KLD_LOCK();
450 if ((mod = modlist_lookup2(modname, verinfo)) != NULL) {
451 *result = mod->container;
452 (*result)->refs++;
453 KLD_UNLOCK();
454 return (0);
455 }
456
457 error = linker_load_module(NULL, modname, NULL, verinfo, result);
458 KLD_UNLOCK();
459 return (error);
460 }
461
462 int
463 linker_release_module(const char *modname, struct mod_depend *verinfo,
464 linker_file_t lf)
465 {
466 modlist_t mod;
467 int error;
468
469 KLD_LOCK();
470 if (lf == NULL) {
471 KASSERT(modname != NULL,
472 ("linker_release_module: no file or name"));
473 mod = modlist_lookup2(modname, verinfo);
474 if (mod == NULL) {
475 KLD_UNLOCK();
476 return (ESRCH);
477 }
478 lf = mod->container;
479 } else
480 KASSERT(modname == NULL && verinfo == NULL,
481 ("linker_release_module: both file and name"));
482 error = linker_file_unload(lf, LINKER_UNLOAD_NORMAL);
483 KLD_UNLOCK();
484 return (error);
485 }
486
487 static linker_file_t
488 linker_find_file_by_name(const char *filename)
489 {
490 linker_file_t lf;
491 char *koname;
492
493 koname = malloc(strlen(filename) + 4, M_LINKER, M_WAITOK);
494 sprintf(koname, "%s.ko", filename);
495
496 KLD_LOCK_ASSERT();
497 TAILQ_FOREACH(lf, &linker_files, link) {
498 if (strcmp(lf->filename, koname) == 0)
499 break;
500 if (strcmp(lf->filename, filename) == 0)
501 break;
502 }
503 free(koname, M_LINKER);
504 return (lf);
505 }
506
507 static linker_file_t
508 linker_find_file_by_id(int fileid)
509 {
510 linker_file_t lf;
511
512 KLD_LOCK_ASSERT();
513 TAILQ_FOREACH(lf, &linker_files, link)
514 if (lf->id == fileid && lf->flags & LINKER_FILE_LINKED)
515 break;
516 return (lf);
517 }
518
519 int
520 linker_file_foreach(linker_predicate_t *predicate, void *context)
521 {
522 linker_file_t lf;
523 int retval = 0;
524
525 KLD_LOCK();
526 TAILQ_FOREACH(lf, &linker_files, link) {
527 retval = predicate(lf, context);
528 if (retval != 0)
529 break;
530 }
531 KLD_UNLOCK();
532 return (retval);
533 }
534
535 linker_file_t
536 linker_make_file(const char *pathname, linker_class_t lc)
537 {
538 linker_file_t lf;
539 const char *filename;
540
541 KLD_LOCK_ASSERT();
542 filename = linker_basename(pathname);
543
544 KLD_DPF(FILE, ("linker_make_file: new file, filename='%s' for pathname='%s'\n", filename, pathname));
545 lf = (linker_file_t)kobj_create((kobj_class_t)lc, M_LINKER, M_WAITOK);
546 if (lf == NULL)
547 return (NULL);
548 lf->refs = 1;
549 lf->userrefs = 0;
550 lf->flags = 0;
551 lf->filename = linker_strdup(filename);
552 lf->pathname = linker_strdup(pathname);
553 LINKER_GET_NEXT_FILE_ID(lf->id);
554 lf->ndeps = 0;
555 lf->deps = NULL;
556 lf->loadcnt = ++loadcnt;
557 lf->sdt_probes = NULL;
558 lf->sdt_nprobes = 0;
559 STAILQ_INIT(&lf->common);
560 TAILQ_INIT(&lf->modules);
561 TAILQ_INSERT_TAIL(&linker_files, lf, link);
562 return (lf);
563 }
564
565 int
566 linker_file_unload(linker_file_t file, int flags)
567 {
568 module_t mod, next;
569 modlist_t ml, nextml;
570 struct common_symbol *cp;
571 int error, i;
572
573 /* Refuse to unload modules if securelevel raised. */
574 if (securelevel > 0)
575 return (EPERM);
576
577 KLD_LOCK_ASSERT();
578 KLD_DPF(FILE, ("linker_file_unload: lf->refs=%d\n", file->refs));
579
580 /* Easy case of just dropping a reference. */
581 if (file->refs > 1) {
582 file->refs--;
583 return (0);
584 }
585
586 KLD_DPF(FILE, ("linker_file_unload: file is unloading,"
587 " informing modules\n"));
588
589 /*
590 * Inform any modules associated with this file.
591 */
592 MOD_XLOCK;
593 for (mod = TAILQ_FIRST(&file->modules); mod; mod = next) {
594 next = module_getfnext(mod);
595 MOD_XUNLOCK;
596
597 /*
598 * Give the module a chance to veto the unload.
599 */
600 if ((error = module_unload(mod, flags)) != 0) {
601 KLD_DPF(FILE, ("linker_file_unload: module %p"
602 " vetoes unload\n", mod));
603 return (error);
604 }
605 MOD_XLOCK;
606 module_release(mod);
607 }
608 MOD_XUNLOCK;
609
610 TAILQ_FOREACH_SAFE(ml, &found_modules, link, nextml) {
611 if (ml->container == file) {
612 TAILQ_REMOVE(&found_modules, ml, link);
613 free(ml, M_LINKER);
614 }
615 }
616
617 /*
618 * Don't try to run SYSUNINITs if we are unloaded due to a
619 * link error.
620 */
621 if (file->flags & LINKER_FILE_LINKED) {
622 linker_file_sysuninit(file);
623 linker_file_unregister_sysctls(file);
624 }
625 TAILQ_REMOVE(&linker_files, file, link);
626
627 if (file->deps) {
628 for (i = 0; i < file->ndeps; i++)
629 linker_file_unload(file->deps[i], flags);
630 free(file->deps, M_LINKER);
631 file->deps = NULL;
632 }
633 while ((cp = STAILQ_FIRST(&file->common)) != NULL) {
634 STAILQ_REMOVE_HEAD(&file->common, link);
635 free(cp, M_LINKER);
636 }
637
638 LINKER_UNLOAD(file);
639 if (file->filename) {
640 free(file->filename, M_LINKER);
641 file->filename = NULL;
642 }
643 if (file->pathname) {
644 free(file->pathname, M_LINKER);
645 file->pathname = NULL;
646 }
647 kobj_delete((kobj_t) file, M_LINKER);
648 return (0);
649 }
650
651 int
652 linker_ctf_get(linker_file_t file, linker_ctf_t *lc)
653 {
654 return (LINKER_CTF_GET(file, lc));
655 }
656
657 static int
658 linker_file_add_dependency(linker_file_t file, linker_file_t dep)
659 {
660 linker_file_t *newdeps;
661
662 KLD_LOCK_ASSERT();
663 newdeps = malloc((file->ndeps + 1) * sizeof(linker_file_t *),
664 M_LINKER, M_WAITOK | M_ZERO);
665 if (newdeps == NULL)
666 return (ENOMEM);
667
668 if (file->deps) {
669 bcopy(file->deps, newdeps,
670 file->ndeps * sizeof(linker_file_t *));
671 free(file->deps, M_LINKER);
672 }
673 file->deps = newdeps;
674 file->deps[file->ndeps] = dep;
675 file->ndeps++;
676 return (0);
677 }
678
679 /*
680 * Locate a linker set and its contents. This is a helper function to avoid
681 * linker_if.h exposure elsewhere. Note: firstp and lastp are really void **.
682 * This function is used in this file so we can avoid having lots of (void **)
683 * casts.
684 */
685 int
686 linker_file_lookup_set(linker_file_t file, const char *name,
687 void *firstp, void *lastp, int *countp)
688 {
689 int error, locked;
690
691 locked = KLD_LOCKED();
692 if (!locked)
693 KLD_LOCK();
694 error = LINKER_LOOKUP_SET(file, name, firstp, lastp, countp);
695 if (!locked)
696 KLD_UNLOCK();
697 return (error);
698 }
699
700 /*
701 * List all functions in a file.
702 */
703 int
704 linker_file_function_listall(linker_file_t lf,
705 linker_function_nameval_callback_t callback_func, void *arg)
706 {
707 return (LINKER_EACH_FUNCTION_NAMEVAL(lf, callback_func, arg));
708 }
709
710 caddr_t
711 linker_file_lookup_symbol(linker_file_t file, const char *name, int deps)
712 {
713 caddr_t sym;
714 int locked;
715
716 locked = KLD_LOCKED();
717 if (!locked)
718 KLD_LOCK();
719 sym = linker_file_lookup_symbol_internal(file, name, deps);
720 if (!locked)
721 KLD_UNLOCK();
722 return (sym);
723 }
724
725 static caddr_t
726 linker_file_lookup_symbol_internal(linker_file_t file, const char *name,
727 int deps)
728 {
729 c_linker_sym_t sym;
730 linker_symval_t symval;
731 caddr_t address;
732 size_t common_size = 0;
733 int i;
734
735 KLD_LOCK_ASSERT();
736 KLD_DPF(SYM, ("linker_file_lookup_symbol: file=%p, name=%s, deps=%d\n",
737 file, name, deps));
738
739 if (LINKER_LOOKUP_SYMBOL(file, name, &sym) == 0) {
740 LINKER_SYMBOL_VALUES(file, sym, &symval);
741 if (symval.value == 0)
742 /*
743 * For commons, first look them up in the
744 * dependencies and only allocate space if not found
745 * there.
746 */
747 common_size = symval.size;
748 else {
749 KLD_DPF(SYM, ("linker_file_lookup_symbol: symbol"
750 ".value=%p\n", symval.value));
751 return (symval.value);
752 }
753 }
754 if (deps) {
755 for (i = 0; i < file->ndeps; i++) {
756 address = linker_file_lookup_symbol_internal(
757 file->deps[i], name, 0);
758 if (address) {
759 KLD_DPF(SYM, ("linker_file_lookup_symbol:"
760 " deps value=%p\n", address));
761 return (address);
762 }
763 }
764 }
765 if (common_size > 0) {
766 /*
767 * This is a common symbol which was not found in the
768 * dependencies. We maintain a simple common symbol table in
769 * the file object.
770 */
771 struct common_symbol *cp;
772
773 STAILQ_FOREACH(cp, &file->common, link) {
774 if (strcmp(cp->name, name) == 0) {
775 KLD_DPF(SYM, ("linker_file_lookup_symbol:"
776 " old common value=%p\n", cp->address));
777 return (cp->address);
778 }
779 }
780 /*
781 * Round the symbol size up to align.
782 */
783 common_size = (common_size + sizeof(int) - 1) & -sizeof(int);
784 cp = malloc(sizeof(struct common_symbol)
785 + common_size + strlen(name) + 1, M_LINKER,
786 M_WAITOK | M_ZERO);
787 cp->address = (caddr_t)(cp + 1);
788 cp->name = cp->address + common_size;
789 strcpy(cp->name, name);
790 bzero(cp->address, common_size);
791 STAILQ_INSERT_TAIL(&file->common, cp, link);
792
793 KLD_DPF(SYM, ("linker_file_lookup_symbol: new common"
794 " value=%p\n", cp->address));
795 return (cp->address);
796 }
797 KLD_DPF(SYM, ("linker_file_lookup_symbol: fail\n"));
798 return (0);
799 }
800
801 /*
802 * Both DDB and stack(9) rely on the kernel linker to provide forward and
803 * backward lookup of symbols. However, DDB and sometimes stack(9) need to
804 * do this in a lockfree manner. We provide a set of internal helper
805 * routines to perform these operations without locks, and then wrappers that
806 * optionally lock.
807 *
808 * linker_debug_lookup() is ifdef DDB as currently it's only used by DDB.
809 */
810 #ifdef DDB
811 static int
812 linker_debug_lookup(const char *symstr, c_linker_sym_t *sym)
813 {
814 linker_file_t lf;
815
816 TAILQ_FOREACH(lf, &linker_files, link) {
817 if (LINKER_LOOKUP_SYMBOL(lf, symstr, sym) == 0)
818 return (0);
819 }
820 return (ENOENT);
821 }
822 #endif
823
824 static int
825 linker_debug_search_symbol(caddr_t value, c_linker_sym_t *sym, long *diffp)
826 {
827 linker_file_t lf;
828 c_linker_sym_t best, es;
829 u_long diff, bestdiff, off;
830
831 best = 0;
832 off = (uintptr_t)value;
833 bestdiff = off;
834 TAILQ_FOREACH(lf, &linker_files, link) {
835 if (LINKER_SEARCH_SYMBOL(lf, value, &es, &diff) != 0)
836 continue;
837 if (es != 0 && diff < bestdiff) {
838 best = es;
839 bestdiff = diff;
840 }
841 if (bestdiff == 0)
842 break;
843 }
844 if (best) {
845 *sym = best;
846 *diffp = bestdiff;
847 return (0);
848 } else {
849 *sym = 0;
850 *diffp = off;
851 return (ENOENT);
852 }
853 }
854
855 static int
856 linker_debug_symbol_values(c_linker_sym_t sym, linker_symval_t *symval)
857 {
858 linker_file_t lf;
859
860 TAILQ_FOREACH(lf, &linker_files, link) {
861 if (LINKER_SYMBOL_VALUES(lf, sym, symval) == 0)
862 return (0);
863 }
864 return (ENOENT);
865 }
866
867 static int
868 linker_debug_search_symbol_name(caddr_t value, char *buf, u_int buflen,
869 long *offset)
870 {
871 linker_symval_t symval;
872 c_linker_sym_t sym;
873 int error;
874
875 *offset = 0;
876 error = linker_debug_search_symbol(value, &sym, offset);
877 if (error)
878 return (error);
879 error = linker_debug_symbol_values(sym, &symval);
880 if (error)
881 return (error);
882 strlcpy(buf, symval.name, buflen);
883 return (0);
884 }
885
886 #ifdef DDB
887 /*
888 * DDB Helpers. DDB has to look across multiple files with their own symbol
889 * tables and string tables.
890 *
891 * Note that we do not obey list locking protocols here. We really don't need
892 * DDB to hang because somebody's got the lock held. We'll take the chance
893 * that the files list is inconsistant instead.
894 */
895 int
896 linker_ddb_lookup(const char *symstr, c_linker_sym_t *sym)
897 {
898
899 return (linker_debug_lookup(symstr, sym));
900 }
901
902 int
903 linker_ddb_search_symbol(caddr_t value, c_linker_sym_t *sym, long *diffp)
904 {
905
906 return (linker_debug_search_symbol(value, sym, diffp));
907 }
908
909 int
910 linker_ddb_symbol_values(c_linker_sym_t sym, linker_symval_t *symval)
911 {
912
913 return (linker_debug_symbol_values(sym, symval));
914 }
915
916 int
917 linker_ddb_search_symbol_name(caddr_t value, char *buf, u_int buflen,
918 long *offset)
919 {
920
921 return (linker_debug_search_symbol_name(value, buf, buflen, offset));
922 }
923 #endif
924
925 /*
926 * stack(9) helper for non-debugging environemnts. Unlike DDB helpers, we do
927 * obey locking protocols, and offer a significantly less complex interface.
928 */
929 int
930 linker_search_symbol_name(caddr_t value, char *buf, u_int buflen,
931 long *offset)
932 {
933 int error;
934
935 KLD_LOCK();
936 error = linker_debug_search_symbol_name(value, buf, buflen, offset);
937 KLD_UNLOCK();
938 return (error);
939 }
940
941 /*
942 * Syscalls.
943 */
944 int
945 kern_kldload(struct thread *td, const char *file, int *fileid)
946 {
947 #ifdef HWPMC_HOOKS
948 struct pmckern_map_in pkm;
949 #endif
950 const char *kldname, *modname;
951 linker_file_t lf;
952 int error;
953
954 if ((error = securelevel_gt(td->td_ucred, 0)) != 0)
955 return (error);
956
957 if ((error = priv_check(td, PRIV_KLD_LOAD)) != 0)
958 return (error);
959
960 /*
961 * If file does not contain a qualified name or any dot in it
962 * (kldname.ko, or kldname.ver.ko) treat it as an interface
963 * name.
964 */
965 if (index(file, '/') || index(file, '.')) {
966 kldname = file;
967 modname = NULL;
968 } else {
969 kldname = NULL;
970 modname = file;
971 }
972
973 KLD_LOCK();
974 error = linker_load_module(kldname, modname, NULL, NULL, &lf);
975 if (error)
976 goto unlock;
977 #ifdef HWPMC_HOOKS
978 pkm.pm_file = lf->filename;
979 pkm.pm_address = (uintptr_t) lf->address;
980 PMC_CALL_HOOK(td, PMC_FN_KLD_LOAD, (void *) &pkm);
981 #endif
982 lf->userrefs++;
983 if (fileid != NULL)
984 *fileid = lf->id;
985 unlock:
986 KLD_UNLOCK();
987 return (error);
988 }
989
990 int
991 kldload(struct thread *td, struct kldload_args *uap)
992 {
993 char *pathname = NULL;
994 int error, fileid;
995
996 td->td_retval[0] = -1;
997
998 pathname = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
999 error = copyinstr(uap->file, pathname, MAXPATHLEN, NULL);
1000 if (error == 0) {
1001 error = kern_kldload(td, pathname, &fileid);
1002 if (error == 0)
1003 td->td_retval[0] = fileid;
1004 }
1005 free(pathname, M_TEMP);
1006 return (error);
1007 }
1008
1009 int
1010 kern_kldunload(struct thread *td, int fileid, int flags)
1011 {
1012 #ifdef HWPMC_HOOKS
1013 struct pmckern_map_out pkm;
1014 #endif
1015 linker_file_t lf;
1016 int error = 0;
1017
1018 if ((error = securelevel_gt(td->td_ucred, 0)) != 0)
1019 return (error);
1020
|