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