FreeBSD/Linux Kernel Cross Reference
sys/kern/subr_kobj.c
1 /* $NetBSD: subr_kobj.c,v 1.24.4.2 2009/06/17 20:20:54 bouyer Exp $ */
2
3 /*-
4 * Copyright (c) 2008 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 /*-
30 * Copyright (c) 1998-2000 Doug Rabson
31 * Copyright (c) 2004 Peter Wemm
32 * All rights reserved.
33 *
34 * Redistribution and use in source and binary forms, with or without
35 * modification, are permitted provided that the following conditions
36 * are met:
37 * 1. Redistributions of source code must retain the above copyright
38 * notice, this list of conditions and the following disclaimer.
39 * 2. Redistributions in binary form must reproduce the above copyright
40 * notice, this list of conditions and the following disclaimer in the
41 * documentation and/or other materials provided with the distribution.
42 *
43 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
44 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
45 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
46 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
47 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
48 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
49 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
50 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
51 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
52 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
53 * SUCH DAMAGE.
54 */
55
56 /*
57 * Kernel loader for ELF objects.
58 *
59 * TODO: adjust kmem_alloc() calls to avoid needless fragmentation.
60 */
61
62 #include "opt_modular.h"
63
64 #include <sys/cdefs.h>
65 __KERNEL_RCSID(0, "$NetBSD: subr_kobj.c,v 1.24.4.2 2009/06/17 20:20:54 bouyer Exp $");
66
67 #define ELFSIZE ARCH_ELFSIZE
68
69 #include <sys/systm.h>
70 #include <sys/kobj.h>
71 #include <sys/errno.h>
72
73 #ifdef MODULAR
74
75 #include <sys/param.h>
76 #include <sys/kernel.h>
77 #include <sys/kmem.h>
78 #include <sys/proc.h>
79 #include <sys/namei.h>
80 #include <sys/vnode.h>
81 #include <sys/fcntl.h>
82 #include <sys/ksyms.h>
83 #include <sys/lkm.h>
84 #include <sys/exec.h>
85 #include <sys/exec_elf.h>
86
87 #include <machine/stdarg.h>
88
89 #include <uvm/uvm_extern.h>
90
91
92 typedef struct {
93 void *addr;
94 Elf_Off size;
95 int flags;
96 int sec; /* Original section */
97 const char *name;
98 } progent_t;
99
100 typedef struct {
101 Elf_Rel *rel;
102 int nrel;
103 int sec;
104 size_t size;
105 } relent_t;
106
107 typedef struct {
108 Elf_Rela *rela;
109 int nrela;
110 int sec;
111 size_t size;
112 } relaent_t;
113
114 typedef enum kobjtype {
115 KT_UNSET,
116 KT_VNODE,
117 KT_MEMORY
118 } kobjtype_t;
119
120 struct kobj {
121 char ko_name[MAXLKMNAME];
122 kobjtype_t ko_type;
123 void *ko_source;
124 ssize_t ko_memsize;
125 vaddr_t ko_address; /* Relocation address */
126 Elf_Shdr *ko_shdr;
127 progent_t *ko_progtab;
128 relaent_t *ko_relatab;
129 relent_t *ko_reltab;
130 Elf_Sym *ko_symtab; /* Symbol table */
131 char *ko_strtab; /* String table */
132 char *ko_shstrtab; /* Section name string table */
133 size_t ko_size; /* Size of text/data/bss */
134 size_t ko_symcnt; /* Number of symbols */
135 size_t ko_strtabsz; /* Number of bytes in string table */
136 size_t ko_shstrtabsz; /* Number of bytes in scn str table */
137 size_t ko_shdrsz;
138 int ko_nrel;
139 int ko_nrela;
140 int ko_nprogtab;
141 bool ko_ksyms;
142 bool ko_loaded;
143 };
144
145 static int kobj_relocate(kobj_t, bool);
146 static int kobj_checkdup(kobj_t);
147 static void kobj_error(const char *, ...);
148 static int kobj_read(kobj_t, void **, size_t, off_t);
149 static int kobj_read_bits(kobj_t, void *, size_t, off_t);
150 static void kobj_jettison(kobj_t);
151 static void kobj_free(kobj_t, void *, size_t);
152 static void kobj_close(kobj_t);
153 static int kobj_load(kobj_t);
154
155 extern struct vm_map *lkm_map;
156
157 /*
158 * kobj_load_file:
159 *
160 * Load an object located in the file system.
161 */
162 int
163 kobj_load_file(kobj_t *kop, const char *filename, const char *base,
164 bool autoload)
165 {
166 struct nameidata nd;
167 kauth_cred_t cred;
168 char *path;
169 int error;
170 kobj_t ko;
171
172 cred = kauth_cred_get();
173
174 ko = kmem_zalloc(sizeof(*ko), KM_SLEEP);
175 if (ko == NULL) {
176 return ENOMEM;
177 }
178
179 if (autoload) {
180 error = ENOENT;
181 } else {
182 NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, filename);
183 error = vn_open(&nd, FREAD, 0);
184 }
185 if (error != 0) {
186 if (error != ENOENT) {
187 goto out;
188 }
189 path = PNBUF_GET();
190 snprintf(path, MAXPATHLEN - 1, "%s/%s/%s.kmod", base,
191 filename, filename);
192 NDINIT(&nd, LOOKUP, FOLLOW | NOCHROOT, UIO_SYSSPACE, path);
193 error = vn_open(&nd, FREAD, 0);
194 if (error != 0) {
195 strlcat(path, ".o", MAXPATHLEN);
196 NDINIT(&nd, LOOKUP, FOLLOW | NOCHROOT, UIO_SYSSPACE,
197 path);
198 error = vn_open(&nd, FREAD, 0);
199 }
200 PNBUF_PUT(path);
201 if (error != 0) {
202 goto out;
203 }
204 }
205
206 out:
207 if (error != 0) {
208 kmem_free(ko, sizeof(*ko));
209 return error;
210 }
211
212 ko->ko_type = KT_VNODE;
213 ko->ko_source = nd.ni_vp;
214 *kop = ko;
215 return kobj_load(ko);
216 }
217
218 /*
219 * kobj_load_mem:
220 *
221 * Load an object already resident in memory. If size is not -1,
222 * the complete size of the object is known.
223 */
224 int
225 kobj_load_mem(kobj_t *kop, void *base, ssize_t size)
226 {
227 kobj_t ko;
228
229 ko = kmem_zalloc(sizeof(*ko), KM_SLEEP);
230 if (ko == NULL) {
231 return ENOMEM;
232 }
233
234 ko->ko_type = KT_MEMORY;
235 ko->ko_source = base;
236 ko->ko_memsize = size;
237 *kop = ko;
238 return kobj_load(ko);
239 }
240
241 /*
242 * kobj_close:
243 *
244 * Close an open ELF object.
245 */
246 static void
247 kobj_close(kobj_t ko)
248 {
249
250 if (ko->ko_source == NULL) {
251 return;
252 }
253
254 switch (ko->ko_type) {
255 case KT_VNODE:
256 VOP_UNLOCK(ko->ko_source, 0);
257 vn_close(ko->ko_source, FREAD, kauth_cred_get());
258 break;
259 case KT_MEMORY:
260 /* nothing */
261 break;
262 default:
263 panic("kobj_close: unknown type");
264 break;
265 }
266
267 ko->ko_source = NULL;
268 }
269
270 /*
271 * kobj_load:
272 *
273 * Load an ELF object and prepare to link into the running kernel
274 * image.
275 */
276 static int
277 kobj_load(kobj_t ko)
278 {
279 Elf_Ehdr *hdr;
280 Elf_Shdr *shdr;
281 Elf_Sym *es;
282 vaddr_t mapbase;
283 size_t mapsize;
284 int error;
285 int symtabindex;
286 int symstrindex;
287 int nsym;
288 int pb, rl, ra;
289 int alignmask;
290 int i, j;
291 void *addr;
292
293 KASSERT(ko->ko_type != KT_UNSET);
294 KASSERT(ko->ko_source != NULL);
295
296 shdr = NULL;
297 mapsize = 0;
298 error = 0;
299 hdr = NULL;
300
301 /*
302 * Read the elf header from the file.
303 */
304 error = kobj_read(ko, (void **)&hdr, sizeof(*hdr), 0);
305 if (error != 0)
306 goto out;
307 if (memcmp(hdr->e_ident, ELFMAG, SELFMAG) != 0) {
308 kobj_error("not an ELF object");
309 error = ENOEXEC;
310 goto out;
311 }
312
313 if (hdr->e_ident[EI_VERSION] != EV_CURRENT ||
314 hdr->e_version != EV_CURRENT) {
315 kobj_error("unsupported file version");
316 error = ENOEXEC;
317 goto out;
318 }
319 if (hdr->e_type != ET_REL) {
320 kobj_error("unsupported file type");
321 error = ENOEXEC;
322 goto out;
323 }
324 switch (hdr->e_machine) {
325 #if ELFSIZE == 32
326 ELF32_MACHDEP_ID_CASES
327 #else
328 ELF64_MACHDEP_ID_CASES
329 #endif
330 default:
331 kobj_error("unsupported machine");
332 error = ENOEXEC;
333 goto out;
334 }
335
336 ko->ko_nprogtab = 0;
337 ko->ko_shdr = 0;
338 ko->ko_nrel = 0;
339 ko->ko_nrela = 0;
340
341 /*
342 * Allocate and read in the section header.
343 */
344 ko->ko_shdrsz = hdr->e_shnum * hdr->e_shentsize;
345 if (ko->ko_shdrsz == 0 || hdr->e_shoff == 0 ||
346 hdr->e_shentsize != sizeof(Elf_Shdr)) {
347 error = ENOEXEC;
348 goto out;
349 }
350 error = kobj_read(ko, (void **)&shdr, ko->ko_shdrsz, hdr->e_shoff);
351 if (error != 0) {
352 goto out;
353 }
354 ko->ko_shdr = shdr;
355
356 /*
357 * Scan the section header for information and table sizing.
358 */
359 nsym = 0;
360 symtabindex = -1;
361 symstrindex = -1;
362 for (i = 0; i < hdr->e_shnum; i++) {
363 switch (shdr[i].sh_type) {
364 case SHT_PROGBITS:
365 case SHT_NOBITS:
366 ko->ko_nprogtab++;
367 break;
368 case SHT_SYMTAB:
369 nsym++;
370 symtabindex = i;
371 symstrindex = shdr[i].sh_link;
372 break;
373 case SHT_REL:
374 ko->ko_nrel++;
375 break;
376 case SHT_RELA:
377 ko->ko_nrela++;
378 break;
379 case SHT_STRTAB:
380 break;
381 }
382 }
383 if (ko->ko_nprogtab == 0) {
384 kobj_error("file has no contents");
385 error = ENOEXEC;
386 goto out;
387 }
388 if (nsym != 1) {
389 /* Only allow one symbol table for now */
390 kobj_error("file has no valid symbol table");
391 error = ENOEXEC;
392 goto out;
393 }
394 if (symstrindex < 0 || symstrindex > hdr->e_shnum ||
395 shdr[symstrindex].sh_type != SHT_STRTAB) {
396 kobj_error("file has invalid symbol strings");
397 error = ENOEXEC;
398 goto out;
399 }
400
401 /*
402 * Allocate space for tracking the load chunks.
403 */
404 if (ko->ko_nprogtab != 0) {
405 ko->ko_progtab = kmem_zalloc(ko->ko_nprogtab *
406 sizeof(*ko->ko_progtab), KM_SLEEP);
407 if (ko->ko_progtab == NULL) {
408 error = ENOMEM;
409 goto out;
410 }
411 }
412 if (ko->ko_nrel != 0) {
413 ko->ko_reltab = kmem_zalloc(ko->ko_nrel *
414 sizeof(*ko->ko_reltab), KM_SLEEP);
415 if (ko->ko_reltab == NULL) {
416 error = ENOMEM;
417 goto out;
418 }
419 }
420 if (ko->ko_nrela != 0) {
421 ko->ko_relatab = kmem_zalloc(ko->ko_nrela *
422 sizeof(*ko->ko_relatab), KM_SLEEP);
423 if (ko->ko_relatab == NULL) {
424 error = ENOMEM;
425 goto out;
426 }
427 }
428 if (symtabindex == -1) {
429 kobj_error("lost symbol table index");
430 goto out;
431 }
432
433 /*
434 * Allocate space for and load the symbol table.
435 */
436 ko->ko_symcnt = shdr[symtabindex].sh_size / sizeof(Elf_Sym);
437 if (ko->ko_symcnt == 0) {
438 kobj_error("no symbol table");
439 goto out;
440 }
441 error = kobj_read(ko, (void **)&ko->ko_symtab,
442 ko->ko_symcnt * sizeof(Elf_Sym),
443 shdr[symtabindex].sh_offset);
444 if (error != 0) {
445 goto out;
446 }
447
448 /*
449 * Allocate space for and load the symbol strings.
450 */
451 ko->ko_strtabsz = shdr[symstrindex].sh_size;
452 if (ko->ko_strtabsz == 0) {
453 kobj_error("no symbol strings");
454 goto out;
455 }
456 error = kobj_read(ko, (void *)&ko->ko_strtab, ko->ko_strtabsz,
457 shdr[symstrindex].sh_offset);
458 if (error != 0) {
459 goto out;
460 }
461
462 /*
463 * Do we have a string table for the section names?
464 */
465 if (hdr->e_shstrndx != 0 && shdr[hdr->e_shstrndx].sh_size != 0 &&
466 shdr[hdr->e_shstrndx].sh_type == SHT_STRTAB) {
467 ko->ko_shstrtabsz = shdr[hdr->e_shstrndx].sh_size;
468 error = kobj_read(ko, (void *)&ko->ko_shstrtab,
469 shdr[hdr->e_shstrndx].sh_size,
470 shdr[hdr->e_shstrndx].sh_offset);
471 if (error != 0) {
472 goto out;
473 }
474 }
475
476 /*
477 * Size up code/data(progbits) and bss(nobits).
478 */
479 alignmask = 0;
480 mapbase = 0;
481 for (i = 0; i < hdr->e_shnum; i++) {
482 switch (shdr[i].sh_type) {
483 case SHT_PROGBITS:
484 case SHT_NOBITS:
485 if (mapbase == 0)
486 mapbase = shdr[i].sh_offset;
487 alignmask = shdr[i].sh_addralign - 1;
488 mapsize += alignmask;
489 mapsize &= ~alignmask;
490 mapsize += shdr[i].sh_size;
491 break;
492 }
493 }
494
495 /*
496 * We know how much space we need for the text/data/bss/etc.
497 * This stuff needs to be in a single chunk so that profiling etc
498 * can get the bounds and gdb can associate offsets with modules.
499 */
500 if (mapsize == 0) {
501 kobj_error("no text/data/bss");
502 goto out;
503 }
504 if (ko->ko_type == KT_MEMORY) {
505 mapbase += (vaddr_t)ko->ko_source;
506 } else {
507 mapbase = uvm_km_alloc(lkm_map, round_page(mapsize),
508 0, UVM_KMF_WIRED | UVM_KMF_EXEC);
509 if (mapbase == 0) {
510 error = ENOMEM;
511 goto out;
512 }
513 }
514 ko->ko_address = mapbase;
515 ko->ko_size = mapsize;
516
517 /*
518 * Now load code/data(progbits), zero bss(nobits), allocate space
519 * for and load relocs
520 */
521 pb = 0;
522 rl = 0;
523 ra = 0;
524 alignmask = 0;
525 for (i = 0; i < hdr->e_shnum; i++) {
526 switch (shdr[i].sh_type) {
527 case SHT_PROGBITS:
528 case SHT_NOBITS:
529 alignmask = shdr[i].sh_addralign - 1;
530 if (ko->ko_type == KT_MEMORY) {
531 addr = (void *)(shdr[i].sh_offset +
532 (vaddr_t)ko->ko_source);
533 if (((vaddr_t)addr & alignmask) != 0) {
534 kobj_error("section %d not aligned\n",
535 i);
536 goto out;
537 }
538 } else {
539 mapbase += alignmask;
540 mapbase &= ~alignmask;
541 addr = (void *)mapbase;
542 mapbase += shdr[i].sh_size;
543 }
544 ko->ko_progtab[pb].addr = addr;
545 if (shdr[i].sh_type == SHT_PROGBITS) {
546 ko->ko_progtab[pb].name = "<<PROGBITS>>";
547 error = kobj_read_bits(ko, addr,
548 shdr[i].sh_size, shdr[i].sh_offset);
549 if (error != 0) {
550 goto out;
551 }
552 } else if (ko->ko_type == KT_MEMORY &&
553 shdr[i].sh_size != 0) {
554 kobj_error("non-loadable BSS section in "
555 "pre-loaded module");
556 error = EINVAL;
557 goto out;
558 } else {
559 ko->ko_progtab[pb].name = "<<NOBITS>>";
560 memset(addr, 0, shdr[i].sh_size);
561 }
562 ko->ko_progtab[pb].size = shdr[i].sh_size;
563 ko->ko_progtab[pb].sec = i;
564 if (ko->ko_shstrtab != NULL && shdr[i].sh_name != 0) {
565 ko->ko_progtab[pb].name =
566 ko->ko_shstrtab + shdr[i].sh_name;
567 }
568
569 /* Update all symbol values with the offset. */
570 for (j = 0; j < ko->ko_symcnt; j++) {
571 es = &ko->ko_symtab[j];
572 if (es->st_shndx != i) {
573 continue;
574 }
575 es->st_value += (Elf_Addr)addr;
576 }
577 pb++;
578 break;
579 case SHT_REL:
580 ko->ko_reltab[rl].size = shdr[i].sh_size;
581 ko->ko_reltab[rl].size -=
582 shdr[i].sh_size % sizeof(Elf_Rel);
583 if (ko->ko_reltab[rl].size != 0) {
584 ko->ko_reltab[rl].nrel =
585 shdr[i].sh_size / sizeof(Elf_Rel);
586 ko->ko_reltab[rl].sec = shdr[i].sh_info;
587 error = kobj_read(ko,
588 (void **)&ko->ko_reltab[rl].rel,
589 ko->ko_reltab[rl].size,
590 shdr[i].sh_offset);
591 if (error != 0) {
592 goto out;
593 }
594 }
595 rl++;
596 break;
597 case SHT_RELA:
598 ko->ko_relatab[ra].size = shdr[i].sh_size;
599 ko->ko_relatab[ra].size -=
600 shdr[i].sh_size % sizeof(Elf_Rela);
601 if (ko->ko_relatab[ra].size != 0) {
602 ko->ko_relatab[ra].nrela =
603 shdr[i].sh_size / sizeof(Elf_Rela);
604 ko->ko_relatab[ra].sec = shdr[i].sh_info;
605 error = kobj_read(ko,
606 (void **)&ko->ko_relatab[ra].rela,
607 shdr[i].sh_size,
608 shdr[i].sh_offset);
609 if (error != 0) {
610 goto out;
611 }
612 }
613 ra++;
614 break;
615 default:
616 break;
617 }
618 }
619 if (pb != ko->ko_nprogtab) {
620 panic("lost progbits");
621 }
622 if (rl != ko->ko_nrel) {
623 panic("lost rel");
624 }
625 if (ra != ko->ko_nrela) {
626 panic("lost rela");
627 }
628 if (ko->ko_type != KT_MEMORY && mapbase != ko->ko_address + mapsize) {
629 panic("mapbase 0x%lx != address %lx + mapsize %ld (0x%lx)\n",
630 (long)mapbase, (long)ko->ko_address, (long)mapsize,
631 (long)ko->ko_address + mapsize);
632 }
633
634 /*
635 * Perform local relocations only. Relocations relating to global
636 * symbols will be done by kobj_affix().
637 */
638 error = kobj_checkdup(ko);
639 if (error == 0) {
640 error = kobj_relocate(ko, true);
641 }
642 out:
643 if (hdr != NULL) {
644 kobj_free(ko, hdr, sizeof(*hdr));
645 }
646 kobj_close(ko);
647 if (error != 0) {
648 kobj_unload(ko);
649 }
650
651 return error;
652 }
653
654 /*
655 * kobj_unload:
656 *
657 * Unload an object previously loaded by kobj_load().
658 */
659 void
660 kobj_unload(kobj_t ko)
661 {
662 int error;
663
664 kobj_close(ko);
665 kobj_jettison(ko);
666
667 /*
668 * Notify MD code that a module has been unloaded.
669 */
670 if (ko->ko_loaded) {
671 error = kobj_machdep(ko, (void *)ko->ko_address, ko->ko_size,
672 false);
673 if (error != 0) {
674 kobj_error("machine dependent deinit failed");
675 }
676 }
677 if (ko->ko_address != 0 && ko->ko_type != KT_MEMORY) {
678 uvm_km_free(lkm_map, ko->ko_address, round_page(ko->ko_size),
679 UVM_KMF_WIRED);
680 }
681 if (ko->ko_ksyms == true) {
682 ksyms_modunload(ko->ko_name);
683 }
684 if (ko->ko_symtab != NULL) {
685 kobj_free(ko, ko->ko_symtab, ko->ko_symcnt * sizeof(Elf_Sym));
686 }
687 if (ko->ko_strtab != NULL) {
688 kobj_free(ko, ko->ko_strtab, ko->ko_strtabsz);
689 }
690 if (ko->ko_progtab != NULL) {
691 kobj_free(ko, ko->ko_progtab, ko->ko_nprogtab *
692 sizeof(*ko->ko_progtab));
693 ko->ko_progtab = NULL;
694 }
695 if (ko->ko_shstrtab) {
696 kobj_free(ko, ko->ko_shstrtab, ko->ko_shstrtabsz);
697 ko->ko_shstrtab = NULL;
698 }
699
700 kmem_free(ko, sizeof(*ko));
701 }
702
703 /*
704 * kobj_stat:
705 *
706 * Return size and load address of an object.
707 */
708 void
709 kobj_stat(kobj_t ko, vaddr_t *address, size_t *size)
710 {
711
712 if (address != NULL) {
713 *address = ko->ko_address;
714 }
715 if (size != NULL) {
716 *size = ko->ko_size;
717 }
718 }
719
720 /*
721 * kobj_affix:
722 *
723 * Set an object's name and perform global relocs. May only be
724 * called after the module and any requisite modules are loaded.
725 */
726 int
727 kobj_affix(kobj_t ko, const char *name)
728 {
729 int error;
730
731 KASSERT(ko->ko_ksyms == false);
732 KASSERT(ko->ko_loaded == false);
733
734 strlcpy(ko->ko_name, name, sizeof(ko->ko_name));
735
736 /* Now do global relocations. */
737 error = kobj_relocate(ko, false);
738
739 /*
740 * Now that we know the name, register the symbol table.
741 * Do after global relocations because ksyms will pack it.
742 */
743 ksyms_modload(ko->ko_name, ko->ko_symtab, ko->ko_symcnt *
744 sizeof(Elf_Sym), ko->ko_strtab, ko->ko_strtabsz);
745 ko->ko_ksyms = true;
746
747 /* Jettison unneeded memory post-link. */
748 kobj_jettison(ko);
749
750 /* Notify MD code that a module has been loaded. */
751 if (error == 0) {
752 error = kobj_machdep(ko, (void *)ko->ko_address, ko->ko_size,
753 true);
754 if (error != 0) {
755 kobj_error("machine dependent init failed");
756 }
757 ko->ko_loaded = true;
758 }
759
760 /* If there was an error, destroy the whole object. */
761 if (error != 0) {
762 kobj_unload(ko);
763 }
764
765 return error;
766 }
767
768 /*
769 * kobj_find_section:
770 *
771 * Given a section name, search the loaded object and return
772 * virtual address if present and loaded.
773 */
774 int
775 kobj_find_section(kobj_t ko, const char *name, void **addr, size_t *size)
776 {
777 int i;
778
779 KASSERT(ko->ko_progtab != NULL);
780
781 for (i = 0; i < ko->ko_nprogtab; i++) {
782 if (strcmp(ko->ko_progtab[i].name, name) == 0) {
783 if (addr != NULL) {
784 *addr = ko->ko_progtab[i].addr;
785 }
786 if (size != NULL) {
787 *size = ko->ko_progtab[i].size;
788 }
789 return 0;
790 }
791 }
792
793 return ENOENT;
794 }
795
796 /*
797 * kobj_jettison:
798 *
799 * Release object data not needed after performing relocations.
800 */
801 static void
802 kobj_jettison(kobj_t ko)
803 {
804 int i;
805
806 if (ko->ko_reltab != NULL) {
807 for (i = 0; i < ko->ko_nrel; i++) {
808 if (ko->ko_reltab[i].rel) {
809 kobj_free(ko, ko->ko_reltab[i].rel,
810 ko->ko_reltab[i].size);
811 }
812 }
813 kobj_free(ko, ko->ko_reltab, ko->ko_nrel *
814 sizeof(*ko->ko_reltab));
815 ko->ko_reltab = NULL;
816 ko->ko_nrel = 0;
817 }
818 if (ko->ko_relatab != NULL) {
819 for (i = 0; i < ko->ko_nrela; i++) {
820 if (ko->ko_relatab[i].rela) {
821 kobj_free(ko, ko->ko_relatab[i].rela,
822 ko->ko_relatab[i].size);
823 }
824 }
825 kobj_free(ko, ko->ko_relatab, ko->ko_nrela *
826 sizeof(*ko->ko_relatab));
827 ko->ko_relatab = NULL;
828 ko->ko_nrela = 0;
829 }
830 if (ko->ko_shdr != NULL) {
831 kobj_free(ko, ko->ko_shdr, ko->ko_shdrsz);
832 ko->ko_shdr = NULL;
833 }
834 }
835
836 /*
837 * kobj_sym_lookup:
838 *
839 * Symbol lookup function to be used when the symbol index
840 * is known (ie during relocation).
841 */
842 uintptr_t
843 kobj_sym_lookup(kobj_t ko, uintptr_t symidx)
844 {
845 const Elf_Sym *sym;
846 const char *symbol;
847 int error;
848 u_long addr;
849
850 /* Don't even try to lookup the symbol if the index is bogus. */
851 if (symidx >= ko->ko_symcnt)
852 return 0;
853
854 sym = ko->ko_symtab + symidx;
855
856 /* Quick answer if there is a definition included. */
857 if (sym->st_shndx != SHN_UNDEF) {
858 return sym->st_value;
859 }
860
861 /* If we get here, then it is undefined and needs a lookup. */
862 switch (ELF_ST_BIND(sym->st_info)) {
863 case STB_LOCAL:
864 /* Local, but undefined? huh? */
865 kobj_error("local symbol undefined");
866 return 0;
867
868 case STB_GLOBAL:
869 /* Relative to Data or Function name */
870 symbol = ko->ko_strtab + sym->st_name;
871
872 /* Force a lookup failure if the symbol name is bogus. */
873 if (*symbol == 0) {
874 kobj_error("bad symbol name");
875 return 0;
876 }
877
878 /*
879 * Don't need to lock, as it is known that the symbol
880 * tables aren't going to change (we hold module_lock).
881 */
882 error = ksyms_getval(NULL, symbol, &addr, KSYMS_ANY);
883 if (error != 0) {
884 kobj_error("symbol `%s' not found", symbol);
885 return (uintptr_t)0;
886 }
887 return (uintptr_t)addr;
888
889 case STB_WEAK:
890 kobj_error("weak symbols not supported\n");
891 return 0;
892
893 default:
894 return 0;
895 }
896 }
897
898 /*
899 * kobj_findbase:
900 *
901 * Return base address of the given section.
902 */
903 static uintptr_t
904 kobj_findbase(kobj_t ko, int sec)
905 {
906 int i;
907
908 for (i = 0; i < ko->ko_nprogtab; i++) {
909 if (sec == ko->ko_progtab[i].sec) {
910 return (uintptr_t)ko->ko_progtab[i].addr;
911 }
912 }
913 return 0;
914 }
915
916 /*
917 * kobj_checkdup:
918 *
919 * Scan symbol table for duplicates.
920 */
921 static int
922 kobj_checkdup(kobj_t ko)
923 {
924 unsigned long rval;
925 Elf_Sym *sym, *ms;
926 const char *name;
927 bool dup;
928
929 dup = false;
930 for (ms = (sym = ko->ko_symtab) + ko->ko_symcnt; sym < ms; sym++) {
931 /* Check validity of the symbol. */
932 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL ||
933 sym->st_name == 0)
934 continue;
935
936 /* Check if the symbol already exists */
937 name = ko->ko_strtab + sym->st_name;
938 if (ksyms_getval(NULL, name, &rval, KSYMS_EXTERN) != 0) {
939 continue;
940 }
941
942 /* Check (and complain) about differing values */
943 if (sym->st_value == rval || sym->st_shndx == SHN_UNDEF) {
944 continue;
945 }
946 if (strcmp(name, "_bss_start") == 0 ||
947 strcmp(name, "__bss_start") == 0 ||
948 strcmp(name, "_bss_end__") == 0 ||
949 strcmp(name, "__bss_end__") == 0 ||
950 strcmp(name, "_edata") == 0 ||
951 strcmp(name, "_end") == 0 ||
952 strcmp(name, "__end") == 0 ||
953 strcmp(name, "__end__") == 0 ||
954 strncmp(name, "__start_link_set_", 17) == 0 ||
955 strncmp(name, "__stop_link_set_", 16)) {
956 continue;
957 }
958 kobj_error("global symbol `%s' redefined\n", name);
959 dup = true;
960 }
961
962 return dup ? EEXIST : 0;
963 }
964
965 /*
966 * kobj_relocate:
967 *
968 * Resolve relocations for the loaded object.
969 */
970 static int
971 kobj_relocate(kobj_t ko, bool local)
972 {
973 const Elf_Rel *rellim;
974 const Elf_Rel *rel;
975 const Elf_Rela *relalim;
976 const Elf_Rela *rela;
977 const Elf_Sym *sym;
978 uintptr_t base;
979 int i, error;
980 uintptr_t symidx;
981
982 /*
983 * Perform relocations without addend if there are any.
984 */
985 for (i = 0; i < ko->ko_nrel; i++) {
986 rel = ko->ko_reltab[i].rel;
987 if (rel == NULL) {
988 continue;
989 }
990 rellim = rel + ko->ko_reltab[i].nrel;
991 base = kobj_findbase(ko, ko->ko_reltab[i].sec);
992 if (base == 0) {
993 panic("lost base for e_reltab");
994 }
995 for (; rel < rellim; rel++) {
996 symidx = ELF_R_SYM(rel->r_info);
997 if (symidx >= ko->ko_symcnt) {
998 continue;
999 }
1000 sym = ko->ko_symtab + symidx;
1001 if (local != (ELF_ST_BIND(sym->st_info) == STB_LOCAL)) {
1002 continue;
1003 }
1004 error = kobj_reloc(ko, base, rel, false, local);
1005 if (error != 0) {
1006 return ENOENT;
1007 }
1008 }
1009 }
1010
1011 /*
1012 * Perform relocations with addend if there are any.
1013 */
1014 for (i = 0; i < ko->ko_nrela; i++) {
1015 rela = ko->ko_relatab[i].rela;
1016 if (rela == NULL) {
1017 continue;
1018 }
1019 relalim = rela + ko->ko_relatab[i].nrela;
1020 base = kobj_findbase(ko, ko->ko_relatab[i].sec);
1021 if (base == 0) {
1022 panic("lost base for e_relatab");
1023 }
1024 for (; rela < relalim; rela++) {
1025 symidx = ELF_R_SYM(rela->r_info);
1026 if (symidx >= ko->ko_symcnt) {
1027 continue;
1028 }
1029 sym = ko->ko_symtab + symidx;
1030 if (local != (ELF_ST_BIND(sym->st_info) == STB_LOCAL)) {
1031 continue;
1032 }
1033 error = kobj_reloc(ko, base, rela, true, local);
1034 if (error != 0) {
1035 return ENOENT;
1036 }
1037 }
1038 }
1039
1040 return 0;
1041 }
1042
1043 /*
1044 * kobj_error:
1045 *
1046 * Utility function: log an error.
1047 */
1048 static void
1049 kobj_error(const char *fmt, ...)
1050 {
1051 va_list ap;
1052
1053 va_start(ap, fmt);
1054 printf("WARNING: linker error: ");
1055 vprintf(fmt, ap);
1056 printf("\n");
1057 va_end(ap);
1058 }
1059
1060 /*
1061 * kobj_read:
1062 *
1063 * Utility function: read from the object.
1064 */
1065 static int
1066 kobj_read(kobj_t ko, void **basep, size_t size, off_t off)
1067 {
1068 size_t resid;
1069 void *base;
1070 int error;
1071
1072 KASSERT(ko->ko_source != NULL);
1073
1074 switch (ko->ko_type) {
1075 case KT_VNODE:
1076 base = kmem_alloc(size, KM_SLEEP);
1077 if (base == NULL) {
1078 error = ENOMEM;
1079 break;
1080 }
1081 error = vn_rdwr(UIO_READ, ko->ko_source, base, size, off,
1082 UIO_SYSSPACE, IO_NODELOCKED, curlwp->l_cred, &resid,
1083 curlwp);
1084 if (error == 0 && resid != 0) {
1085 error = EINVAL;
1086 }
1087 if (error != 0) {
1088 kmem_free(base, size);
1089 base = NULL;
1090 }
1091 break;
1092 case KT_MEMORY:
1093 if (ko->ko_memsize != -1 && off + size > ko->ko_memsize) {
1094 kobj_error("kobj_read: preloaded object short");
1095 error = EINVAL;
1096 base = NULL;
1097 } else {
1098 base = (uint8_t *)ko->ko_source + off;
1099 error = 0;
1100 }
1101 break;
1102 default:
1103 panic("kobj_read: invalid type");
1104 }
1105
1106 *basep = base;
1107 return error;
1108 }
1109
1110 /*
1111 * kobj_read_bits:
1112 *
1113 * Utility function: load a section from the object.
1114 */
1115 static int
1116 kobj_read_bits(kobj_t ko, void *base, size_t size, off_t off)
1117 {
1118 size_t resid;
1119 int error;
1120
1121 KASSERT(ko->ko_source != NULL);
1122
1123 switch (ko->ko_type) {
1124 case KT_VNODE:
1125 KASSERT((uintptr_t)base >= (uintptr_t)ko->ko_address);
1126 KASSERT((uintptr_t)base + size <=
1127 (uintptr_t)ko->ko_address + ko->ko_size);
1128 error = vn_rdwr(UIO_READ, ko->ko_source, base, size, off,
1129 UIO_SYSSPACE, IO_NODELOCKED, curlwp->l_cred, &resid,
1130 curlwp);
1131 if (error == 0 && resid != 0) {
1132 error = EINVAL;
1133 }
1134 break;
1135 case KT_MEMORY:
1136 if (ko->ko_memsize != -1 && off + size > ko->ko_memsize) {
1137 kobj_error("kobj_read_bits: preloaded object short");
1138 error = EINVAL;
1139 } else if ((uint8_t *)base != (uint8_t *)ko->ko_source + off) {
1140 kobj_error("kobj_read_bits: object not aligned");
1141 kobj_error("source=%p base=%p off=%d size=%zd",
1142 ko->ko_source, base, (int)off, size);
1143 error = EINVAL;
1144 } else {
1145 /* Nothing to do. Loading in-situ. */
1146 error = 0;
1147 }
1148 break;
1149 default:
1150 panic("kobj_read: invalid type");
1151 }
1152
1153 return error;
1154 }
1155
1156 /*
1157 * kobj_free:
1158 *
1159 * Utility function: free memory if it was allocated from the heap.
1160 */
1161 static void
1162 kobj_free(kobj_t ko, void *base, size_t size)
1163 {
1164
1165 if (ko->ko_type != KT_MEMORY)
1166 kmem_free(base, size);
1167 }
1168
1169 #else /* MODULAR */
1170
1171 int
1172 kobj_load_file(kobj_t *kop, const char *name, const char *base, bool autoload)
1173 {
1174
1175 return ENOSYS;
1176 }
1177
1178 int
1179 kobj_load_mem(kobj_t *kop, void *base, ssize_t size)
1180 {
1181
1182 return ENOSYS;
1183 }
1184
1185 void
1186 kobj_unload(kobj_t ko)
1187 {
1188
1189 panic("not modular");
1190 }
1191
1192 void
1193 kobj_stat(kobj_t ko, vaddr_t *base, size_t *size)
1194 {
1195
1196 panic("not modular");
1197 }
1198
1199 int
1200 kobj_affix(kobj_t ko, const char *name)
1201 {
1202
1203 panic("not modular");
1204 }
1205
1206 int
1207 kobj_find_section(kobj_t ko, const char *name, void **addr, size_t *size)
1208 {
1209
1210 panic("not modular");
1211 }
1212
1213 #endif /* MODULAR */
Cache object: d176327d99fa9b44773acaae941371dd
|