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