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