1 /* $NetBSD: subr_kobj.c,v 1.41 2010/04/26 22:58:53 pooka 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.41 2010/04/26 22:58:53 pooka 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 #else 204 ELF64_MACHDEP_ID_CASES 205 #endif 206 default: 207 kobj_error("unsupported machine"); 208 error = ENOEXEC; 209 goto out; 210 } 211 212 ko->ko_nprogtab = 0; 213 ko->ko_shdr = 0; 214 ko->ko_nrel = 0; 215 ko->ko_nrela = 0; 216 217 /* 218 * Allocate and read in the section header. 219 */ 220 ko->ko_shdrsz = hdr->e_shnum * hdr->e_shentsize; 221 if (ko->ko_shdrsz == 0 || hdr->e_shoff == 0 || 222 hdr->e_shentsize != sizeof(Elf_Shdr)) { 223 error = ENOEXEC; 224 goto out; 225 } 226 error = ko->ko_read(ko, (void **)&shdr, ko->ko_shdrsz, hdr->e_shoff, 227 true); 228 if (error != 0) { 229 goto out; 230 } 231 ko->ko_shdr = shdr; 232 233 /* 234 * Scan the section header for information and table sizing. 235 */ 236 nsym = 0; 237 symtabindex = -1; 238 symstrindex = -1; 239 for (i = 0; i < hdr->e_shnum; i++) { 240 switch (shdr[i].sh_type) { 241 case SHT_PROGBITS: 242 case SHT_NOBITS: 243 ko->ko_nprogtab++; 244 break; 245 case SHT_SYMTAB: 246 nsym++; 247 symtabindex = i; 248 symstrindex = shdr[i].sh_link; 249 break; 250 case SHT_REL: 251 ko->ko_nrel++; 252 break; 253 case SHT_RELA: 254 ko->ko_nrela++; 255 break; 256 case SHT_STRTAB: 257 break; 258 } 259 } 260 if (ko->ko_nprogtab == 0) { 261 kobj_error("file has no contents"); 262 error = ENOEXEC; 263 goto out; 264 } 265 if (nsym != 1) { 266 /* Only allow one symbol table for now */ 267 kobj_error("file has no valid symbol table"); 268 error = ENOEXEC; 269 goto out; 270 } 271 if (symstrindex < 0 || symstrindex > hdr->e_shnum || 272 shdr[symstrindex].sh_type != SHT_STRTAB) { 273 kobj_error("file has invalid symbol strings"); 274 error = ENOEXEC; 275 goto out; 276 } 277 278 /* 279 * Allocate space for tracking the load chunks. 280 */ 281 if (ko->ko_nprogtab != 0) { 282 ko->ko_progtab = kmem_zalloc(ko->ko_nprogtab * 283 sizeof(*ko->ko_progtab), KM_SLEEP); 284 if (ko->ko_progtab == NULL) { 285 error = ENOMEM; 286 goto out; 287 } 288 } 289 if (ko->ko_nrel != 0) { 290 ko->ko_reltab = kmem_zalloc(ko->ko_nrel * 291 sizeof(*ko->ko_reltab), KM_SLEEP); 292 if (ko->ko_reltab == NULL) { 293 error = ENOMEM; 294 goto out; 295 } 296 } 297 if (ko->ko_nrela != 0) { 298 ko->ko_relatab = kmem_zalloc(ko->ko_nrela * 299 sizeof(*ko->ko_relatab), KM_SLEEP); 300 if (ko->ko_relatab == NULL) { 301 error = ENOMEM; 302 goto out; 303 } 304 } 305 if (symtabindex == -1) { 306 kobj_error("lost symbol table index"); 307 goto out; 308 } 309 310 /* 311 * Allocate space for and load the symbol table. 312 */ 313 ko->ko_symcnt = shdr[symtabindex].sh_size / sizeof(Elf_Sym); 314 if (ko->ko_symcnt == 0) { 315 kobj_error("no symbol table"); 316 goto out; 317 } 318 error = ko->ko_read(ko, (void **)&ko->ko_symtab, 319 ko->ko_symcnt * sizeof(Elf_Sym), 320 shdr[symtabindex].sh_offset, true); 321 if (error != 0) { 322 goto out; 323 } 324 325 /* 326 * Allocate space for and load the symbol strings. 327 */ 328 ko->ko_strtabsz = shdr[symstrindex].sh_size; 329 if (ko->ko_strtabsz == 0) { 330 kobj_error("no symbol strings"); 331 goto out; 332 } 333 error = ko->ko_read(ko, (void *)&ko->ko_strtab, ko->ko_strtabsz, 334 shdr[symstrindex].sh_offset, true); 335 if (error != 0) { 336 goto out; 337 } 338 339 /* 340 * Adjust module symbol namespace, if necessary (e.g. with rump) 341 */ 342 error = kobj_renamespace(ko->ko_symtab, ko->ko_symcnt, 343 &ko->ko_strtab, &ko->ko_strtabsz); 344 if (error != 0) { 345 goto out; 346 } 347 348 /* 349 * Do we have a string table for the section names? 350 */ 351 if (hdr->e_shstrndx != 0 && shdr[hdr->e_shstrndx].sh_size != 0 && 352 shdr[hdr->e_shstrndx].sh_type == SHT_STRTAB) { 353 ko->ko_shstrtabsz = shdr[hdr->e_shstrndx].sh_size; 354 error = ko->ko_read(ko, (void **)&ko->ko_shstrtab, 355 shdr[hdr->e_shstrndx].sh_size, 356 shdr[hdr->e_shstrndx].sh_offset, true); 357 if (error != 0) { 358 goto out; 359 } 360 } 361 362 /* 363 * Size up code/data(progbits) and bss(nobits). 364 */ 365 alignmask = 0; 366 mapbase = 0; 367 for (i = 0; i < hdr->e_shnum; i++) { 368 switch (shdr[i].sh_type) { 369 case SHT_PROGBITS: 370 case SHT_NOBITS: 371 if (mapbase == 0) 372 mapbase = shdr[i].sh_offset; 373 alignmask = shdr[i].sh_addralign - 1; 374 mapsize += alignmask; 375 mapsize &= ~alignmask; 376 mapsize += shdr[i].sh_size; 377 break; 378 } 379 } 380 381 /* 382 * We know how much space we need for the text/data/bss/etc. 383 * This stuff needs to be in a single chunk so that profiling etc 384 * can get the bounds and gdb can associate offsets with modules. 385 */ 386 if (mapsize == 0) { 387 kobj_error("no text/data/bss"); 388 goto out; 389 } 390 if (ko->ko_type == KT_MEMORY) { 391 mapbase += (vaddr_t)ko->ko_source; 392 } else { 393 mapbase = uvm_km_alloc(module_map, round_page(mapsize), 394 0, UVM_KMF_WIRED | UVM_KMF_EXEC); 395 if (mapbase == 0) { 396 error = ENOMEM; 397 goto out; 398 } 399 } 400 ko->ko_address = mapbase; 401 ko->ko_size = mapsize; 402 403 /* 404 * Now load code/data(progbits), zero bss(nobits), allocate space 405 * for and load relocs 406 */ 407 pb = 0; 408 rl = 0; 409 ra = 0; 410 alignmask = 0; 411 for (i = 0; i < hdr->e_shnum; i++) { 412 switch (shdr[i].sh_type) { 413 case SHT_PROGBITS: 414 case SHT_NOBITS: 415 alignmask = shdr[i].sh_addralign - 1; 416 if (ko->ko_type == KT_MEMORY) { 417 addr = (void *)(shdr[i].sh_offset + 418 (vaddr_t)ko->ko_source); 419 if (((vaddr_t)addr & alignmask) != 0) { 420 kobj_error("section %d not aligned\n", 421 i); 422 goto out; 423 } 424 } else { 425 mapbase += alignmask; 426 mapbase &= ~alignmask; 427 addr = (void *)mapbase; 428 mapbase += shdr[i].sh_size; 429 } 430 ko->ko_progtab[pb].addr = addr; 431 if (shdr[i].sh_type == SHT_PROGBITS) { 432 ko->ko_progtab[pb].name = "<<PROGBITS>>"; 433 error = ko->ko_read(ko, &addr, 434 shdr[i].sh_size, shdr[i].sh_offset, false); 435 if (error != 0) { 436 goto out; 437 } 438 } else if (ko->ko_type == KT_MEMORY && 439 shdr[i].sh_size != 0) { 440 kobj_error("non-loadable BSS section in " 441 "pre-loaded module"); 442 error = EINVAL; 443 goto out; 444 } else { 445 ko->ko_progtab[pb].name = "<<NOBITS>>"; 446 memset(addr, 0, shdr[i].sh_size); 447 } 448 ko->ko_progtab[pb].size = shdr[i].sh_size; 449 ko->ko_progtab[pb].sec = i; 450 if (ko->ko_shstrtab != NULL && shdr[i].sh_name != 0) { 451 ko->ko_progtab[pb].name = 452 ko->ko_shstrtab + shdr[i].sh_name; 453 } 454 455 /* Update all symbol values with the offset. */ 456 for (j = 0; j < ko->ko_symcnt; j++) { 457 es = &ko->ko_symtab[j]; 458 if (es->st_shndx != i) { 459 continue; 460 } 461 es->st_value += (Elf_Addr)addr; 462 } 463 pb++; 464 break; 465 case SHT_REL: 466 ko->ko_reltab[rl].size = shdr[i].sh_size; 467 ko->ko_reltab[rl].size -= 468 shdr[i].sh_size % sizeof(Elf_Rel); 469 if (ko->ko_reltab[rl].size != 0) { 470 ko->ko_reltab[rl].nrel = 471 shdr[i].sh_size / sizeof(Elf_Rel); 472 ko->ko_reltab[rl].sec = shdr[i].sh_info; 473 error = ko->ko_read(ko, 474 (void **)&ko->ko_reltab[rl].rel, 475 ko->ko_reltab[rl].size, 476 shdr[i].sh_offset, true); 477 if (error != 0) { 478 goto out; 479 } 480 } 481 rl++; 482 break; 483 case SHT_RELA: 484 ko->ko_relatab[ra].size = shdr[i].sh_size; 485 ko->ko_relatab[ra].size -= 486 shdr[i].sh_size % sizeof(Elf_Rela); 487 if (ko->ko_relatab[ra].size != 0) { 488 ko->ko_relatab[ra].nrela = 489 shdr[i].sh_size / sizeof(Elf_Rela); 490 ko->ko_relatab[ra].sec = shdr[i].sh_info; 491 error = ko->ko_read(ko, 492 (void **)&ko->ko_relatab[ra].rela, 493 shdr[i].sh_size, 494 shdr[i].sh_offset, true); 495 if (error != 0) { 496 goto out; 497 } 498 } 499 ra++; 500 break; 501 default: 502 break; 503 } 504 } 505 if (pb != ko->ko_nprogtab) { 506 panic("lost progbits"); 507 } 508 if (rl != ko->ko_nrel) { 509 panic("lost rel"); 510 } 511 if (ra != ko->ko_nrela) { 512 panic("lost rela"); 513 } 514 if (ko->ko_type != KT_MEMORY && mapbase != ko->ko_address + mapsize) { 515 panic("mapbase 0x%lx != address %lx + mapsize %ld (0x%lx)\n", 516 (long)mapbase, (long)ko->ko_address, (long)mapsize, 517 (long)ko->ko_address + mapsize); 518 } 519 520 /* 521 * Perform local relocations only. Relocations relating to global 522 * symbols will be done by kobj_affix(). 523 */ 524 error = kobj_checksyms(ko, false); 525 if (error == 0) { 526 error = kobj_relocate(ko, true); 527 } 528 out: 529 if (hdr != NULL) { 530 kobj_free(ko, hdr, sizeof(*hdr)); 531 } 532 kobj_close(ko); 533 if (error != 0) { 534 kobj_unload(ko); 535 } 536 537 return error; 538 } 539 540 /* 541 * kobj_unload: 542 * 543 * Unload an object previously loaded by kobj_load(). 544 */ 545 void 546 kobj_unload(kobj_t ko) 547 { 548 int error; 549 550 kobj_close(ko); 551 kobj_jettison(ko); 552 553 /* 554 * Notify MD code that a module has been unloaded. 555 */ 556 if (ko->ko_loaded) { 557 error = kobj_machdep(ko, (void *)ko->ko_address, ko->ko_size, 558 false); 559 if (error != 0) { 560 kobj_error("machine dependent deinit failed"); 561 } 562 } 563 if (ko->ko_address != 0 && ko->ko_type != KT_MEMORY) { 564 uvm_km_free(module_map, ko->ko_address, round_page(ko->ko_size), 565 UVM_KMF_WIRED); 566 } 567 if (ko->ko_ksyms == true) { 568 ksyms_modunload(ko->ko_name); 569 } 570 if (ko->ko_symtab != NULL) { 571 kobj_free(ko, ko->ko_symtab, ko->ko_symcnt * sizeof(Elf_Sym)); 572 } 573 if (ko->ko_strtab != NULL) { 574 kobj_free(ko, ko->ko_strtab, ko->ko_strtabsz); 575 } 576 if (ko->ko_progtab != NULL) { 577 kobj_free(ko, ko->ko_progtab, ko->ko_nprogtab * 578 sizeof(*ko->ko_progtab)); 579 ko->ko_progtab = NULL; 580 } 581 if (ko->ko_shstrtab) { 582 kobj_free(ko, ko->ko_shstrtab, ko->ko_shstrtabsz); 583 ko->ko_shstrtab = NULL; 584 } 585 586 kmem_free(ko, sizeof(*ko)); 587 } 588 589 /* 590 * kobj_stat: 591 * 592 * Return size and load address of an object. 593 */ 594 int 595 kobj_stat(kobj_t ko, vaddr_t *address, size_t *size) 596 { 597 598 if (address != NULL) { 599 *address = ko->ko_address; 600 } 601 if (size != NULL) { 602 *size = ko->ko_size; 603 } 604 return 0; 605 } 606 607 /* 608 * kobj_affix: 609 * 610 * Set an object's name and perform global relocs. May only be 611 * called after the module and any requisite modules are loaded. 612 */ 613 int 614 kobj_affix(kobj_t ko, const char *name) 615 { 616 int error; 617 618 KASSERT(ko->ko_ksyms == false); 619 KASSERT(ko->ko_loaded == false); 620 621 strlcpy(ko->ko_name, name, sizeof(ko->ko_name)); 622 623 /* Cache addresses of undefined symbols. */ 624 error = kobj_checksyms(ko, true); 625 626 /* Now do global relocations. */ 627 if (error == 0) 628 error = kobj_relocate(ko, false); 629 630 /* 631 * Now that we know the name, register the symbol table. 632 * Do after global relocations because ksyms will pack 633 * the table. 634 */ 635 if (error == 0) { 636 ksyms_modload(ko->ko_name, ko->ko_symtab, ko->ko_symcnt * 637 sizeof(Elf_Sym), ko->ko_strtab, ko->ko_strtabsz); 638 ko->ko_ksyms = true; 639 } 640 641 /* Jettison unneeded memory post-link. */ 642 kobj_jettison(ko); 643 644 /* 645 * Notify MD code that a module has been loaded. 646 * 647 * Most architectures use this opportunity to flush their caches. 648 */ 649 if (error == 0) { 650 error = kobj_machdep(ko, (void *)ko->ko_address, ko->ko_size, 651 true); 652 if (error != 0) { 653 kobj_error("machine dependent init failed"); 654 } 655 ko->ko_loaded = true; 656 } 657 658 /* If there was an error, destroy the whole object. */ 659 if (error != 0) { 660 kobj_unload(ko); 661 } 662 663 return error; 664 } 665 666 /* 667 * kobj_find_section: 668 * 669 * Given a section name, search the loaded object and return 670 * virtual address if present and loaded. 671 */ 672 int 673 kobj_find_section(kobj_t ko, const char *name, void **addr, size_t *size) 674 { 675 int i; 676 677 KASSERT(ko->ko_progtab != NULL); 678 679 for (i = 0; i < ko->ko_nprogtab; i++) { 680 if (strcmp(ko->ko_progtab[i].name, name) == 0) { 681 if (addr != NULL) { 682 *addr = ko->ko_progtab[i].addr; 683 } 684 if (size != NULL) { 685 *size = ko->ko_progtab[i].size; 686 } 687 return 0; 688 } 689 } 690 691 return ENOENT; 692 } 693 694 /* 695 * kobj_jettison: 696 * 697 * Release object data not needed after performing relocations. 698 */ 699 static void 700 kobj_jettison(kobj_t ko) 701 { 702 int i; 703 704 if (ko->ko_reltab != NULL) { 705 for (i = 0; i < ko->ko_nrel; i++) { 706 if (ko->ko_reltab[i].rel) { 707 kobj_free(ko, ko->ko_reltab[i].rel, 708 ko->ko_reltab[i].size); 709 } 710 } 711 kobj_free(ko, ko->ko_reltab, ko->ko_nrel * 712 sizeof(*ko->ko_reltab)); 713 ko->ko_reltab = NULL; 714 ko->ko_nrel = 0; 715 } 716 if (ko->ko_relatab != NULL) { 717 for (i = 0; i < ko->ko_nrela; i++) { 718 if (ko->ko_relatab[i].rela) { 719 kobj_free(ko, ko->ko_relatab[i].rela, 720 ko->ko_relatab[i].size); 721 } 722 } 723 kobj_free(ko, ko->ko_relatab, ko->ko_nrela * 724 sizeof(*ko->ko_relatab)); 725 ko->ko_relatab = NULL; 726 ko->ko_nrela = 0; 727 } 728 if (ko->ko_shdr != NULL) { 729 kobj_free(ko, ko->ko_shdr, ko->ko_shdrsz); 730 ko->ko_shdr = NULL; 731 } 732 } 733 734 /* 735 * kobj_sym_lookup: 736 * 737 * Symbol lookup function to be used when the symbol index 738 * is known (ie during relocation). 739 */ 740 uintptr_t 741 kobj_sym_lookup(kobj_t ko, uintptr_t symidx) 742 { 743 const Elf_Sym *sym; 744 const char *symbol; 745 746 /* Don't even try to lookup the symbol if the index is bogus. */ 747 if (symidx >= ko->ko_symcnt) 748 return 0; 749 750 sym = ko->ko_symtab + symidx; 751 752 /* Quick answer if there is a definition included. */ 753 if (sym->st_shndx != SHN_UNDEF) { 754 return (uintptr_t)sym->st_value; 755 } 756 757 /* If we get here, then it is undefined and needs a lookup. */ 758 switch (ELF_ST_BIND(sym->st_info)) { 759 case STB_LOCAL: 760 /* Local, but undefined? huh? */ 761 kobj_error("local symbol undefined"); 762 return 0; 763 764 case STB_GLOBAL: 765 /* Relative to Data or Function name */ 766 symbol = ko->ko_strtab + sym->st_name; 767 768 /* Force a lookup failure if the symbol name is bogus. */ 769 if (*symbol == 0) { 770 kobj_error("bad symbol name"); 771 return 0; 772 } 773 774 return (uintptr_t)sym->st_value; 775 776 case STB_WEAK: 777 kobj_error("weak symbols not supported\n"); 778 return 0; 779 780 default: 781 return 0; 782 } 783 } 784 785 /* 786 * kobj_findbase: 787 * 788 * Return base address of the given section. 789 */ 790 static uintptr_t 791 kobj_findbase(kobj_t ko, int sec) 792 { 793 int i; 794 795 for (i = 0; i < ko->ko_nprogtab; i++) { 796 if (sec == ko->ko_progtab[i].sec) { 797 return (uintptr_t)ko->ko_progtab[i].addr; 798 } 799 } 800 return 0; 801 } 802 803 /* 804 * kobj_checksyms: 805 * 806 * Scan symbol table for duplicates or resolve references to 807 * exernal symbols. 808 */ 809 static int 810 kobj_checksyms(kobj_t ko, bool undefined) 811 { 812 unsigned long rval; 813 Elf_Sym *sym, *ms; 814 const char *name; 815 int error; 816 817 error = 0; 818 819 for (ms = (sym = ko->ko_symtab) + ko->ko_symcnt; sym < ms; sym++) { 820 /* Check validity of the symbol. */ 821 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL || 822 sym->st_name == 0) 823 continue; 824 if (undefined != (sym->st_shndx == SHN_UNDEF)) { 825 continue; 826 } 827 828 /* 829 * Look it up. Don't need to lock, as it is known that 830 * the symbol tables aren't going to change (we hold 831 * module_lock). 832 */ 833 name = ko->ko_strtab + sym->st_name; 834 if (ksyms_getval_unlocked(NULL, name, &rval, 835 KSYMS_EXTERN) != 0) { 836 if (undefined) { 837 kobj_error("symbol `%s' not found", name); 838 error = ENOEXEC; 839 } 840 continue; 841 } 842 843 /* Save values of undefined globals. */ 844 if (undefined) { 845 sym->st_value = (Elf_Addr)rval; 846 continue; 847 } 848 849 /* Check (and complain) about differing values. */ 850 if (sym->st_value == rval) { 851 continue; 852 } 853 if (strcmp(name, "_bss_start") == 0 || 854 strcmp(name, "__bss_start") == 0 || 855 strcmp(name, "_bss_end__") == 0 || 856 strcmp(name, "__bss_end__") == 0 || 857 strcmp(name, "_edata") == 0 || 858 strcmp(name, "_end") == 0 || 859 strcmp(name, "__end") == 0 || 860 strcmp(name, "__end__") == 0 || 861 strncmp(name, "__start_link_set_", 17) == 0 || 862 strncmp(name, "__stop_link_set_", 16)) { 863 continue; 864 } 865 kobj_error("global symbol `%s' redefined\n", name); 866 error = ENOEXEC; 867 } 868 869 return error; 870 } 871 872 /* 873 * kobj_relocate: 874 * 875 * Resolve relocations for the loaded object. 876 */ 877 static int 878 kobj_relocate(kobj_t ko, bool local) 879 { 880 const Elf_Rel *rellim; 881 const Elf_Rel *rel; 882 const Elf_Rela *relalim; 883 const Elf_Rela *rela; 884 const Elf_Sym *sym; 885 uintptr_t base; 886 int i, error; 887 uintptr_t symidx; 888 889 /* 890 * Perform relocations without addend if there are any. 891 */ 892 for (i = 0; i < ko->ko_nrel; i++) { 893 rel = ko->ko_reltab[i].rel; 894 if (rel == NULL) { 895 continue; 896 } 897 rellim = rel + ko->ko_reltab[i].nrel; 898 base = kobj_findbase(ko, ko->ko_reltab[i].sec); 899 if (base == 0) { 900 panic("lost base for e_reltab"); 901 } 902 for (; rel < rellim; rel++) { 903 symidx = ELF_R_SYM(rel->r_info); 904 if (symidx >= ko->ko_symcnt) { 905 continue; 906 } 907 sym = ko->ko_symtab + symidx; 908 if (local != (ELF_ST_BIND(sym->st_info) == STB_LOCAL)) { 909 continue; 910 } 911 error = kobj_reloc(ko, base, rel, false, local); 912 if (error != 0) { 913 return ENOENT; 914 } 915 } 916 } 917 918 /* 919 * Perform relocations with addend if there are any. 920 */ 921 for (i = 0; i < ko->ko_nrela; i++) { 922 rela = ko->ko_relatab[i].rela; 923 if (rela == NULL) { 924 continue; 925 } 926 relalim = rela + ko->ko_relatab[i].nrela; 927 base = kobj_findbase(ko, ko->ko_relatab[i].sec); 928 if (base == 0) { 929 panic("lost base for e_relatab"); 930 } 931 for (; rela < relalim; rela++) { 932 symidx = ELF_R_SYM(rela->r_info); 933 if (symidx >= ko->ko_symcnt) { 934 continue; 935 } 936 sym = ko->ko_symtab + symidx; 937 if (local != (ELF_ST_BIND(sym->st_info) == STB_LOCAL)) { 938 continue; 939 } 940 error = kobj_reloc(ko, base, rela, true, local); 941 if (error != 0) { 942 return ENOENT; 943 } 944 } 945 } 946 947 return 0; 948 } 949 950 /* 951 * kobj_error: 952 * 953 * Utility function: log an error. 954 */ 955 static void 956 kobj_error(const char *fmt, ...) 957 { 958 va_list ap; 959 960 va_start(ap, fmt); 961 printf("WARNING: linker error: "); 962 vprintf(fmt, ap); 963 printf("\n"); 964 va_end(ap); 965 } 966 967 static int 968 kobj_read_mem(kobj_t ko, void **basep, size_t size, off_t off, 969 bool allocate) 970 { 971 void *base = *basep; 972 int error; 973 974 if (ko->ko_memsize != -1 && off + size > ko->ko_memsize) { 975 kobj_error("kobj_read_mem: preloaded object short"); 976 error = EINVAL; 977 base = NULL; 978 } else if (allocate) { 979 base = (uint8_t *)ko->ko_source + off; 980 error = 0; 981 } else if ((uint8_t *)base != (uint8_t *)ko->ko_source + off) { 982 kobj_error("kobj_read_mem: object not aligned"); 983 kobj_error("source=%p base=%p off=%d size=%zd", 984 ko->ko_source, base, (int)off, size); 985 error = EINVAL; 986 } else { 987 /* Nothing to do. Loading in-situ. */ 988 error = 0; 989 } 990 991 if (allocate) 992 *basep = base; 993 994 return error; 995 } 996 997 /* 998 * kobj_free: 999 * 1000 * Utility function: free memory if it was allocated from the heap. 1001 */ 1002 static void 1003 kobj_free(kobj_t ko, void *base, size_t size) 1004 { 1005 1006 if (ko->ko_type != KT_MEMORY) 1007 kmem_free(base, size); 1008 } 1009 1010 #else /* MODULAR */ 1011 1012 int 1013 kobj_load_mem(kobj_t *kop, void *base, ssize_t size) 1014 { 1015 1016 return ENOSYS; 1017 } 1018 1019 void 1020 kobj_unload(kobj_t ko) 1021 { 1022 1023 panic("not modular"); 1024 } 1025 1026 int 1027 kobj_stat(kobj_t ko, vaddr_t *base, size_t *size) 1028 { 1029 1030 return ENOSYS; 1031 } 1032 1033 int 1034 kobj_affix(kobj_t ko, const char *name) 1035 { 1036 1037 panic("not modular"); 1038 } 1039 1040 int 1041 kobj_find_section(kobj_t ko, const char *name, void **addr, size_t *size) 1042 { 1043 1044 panic("not modular"); 1045 } 1046 1047 #endif /* MODULAR */ 1048