1 /* $NetBSD: subr_kobj.c,v 1.38 2009/05/26 08:34:23 jnemeth 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.38 2009/05/26 08:34:23 jnemeth 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 void 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 } 636 637 /* 638 * kobj_affix: 639 * 640 * Set an object's name and perform global relocs. May only be 641 * called after the module and any requisite modules are loaded. 642 */ 643 int 644 kobj_affix(kobj_t ko, const char *name) 645 { 646 int error; 647 648 KASSERT(ko->ko_ksyms == false); 649 KASSERT(ko->ko_loaded == false); 650 651 strlcpy(ko->ko_name, name, sizeof(ko->ko_name)); 652 653 /* Cache addresses of undefined symbols. */ 654 error = kobj_checksyms(ko, true); 655 656 /* Now do global relocations. */ 657 if (error == 0) 658 error = kobj_relocate(ko, false); 659 660 /* 661 * Now that we know the name, register the symbol table. 662 * Do after global relocations because ksyms will pack 663 * the table. 664 */ 665 if (error == 0) { 666 ksyms_modload(ko->ko_name, ko->ko_symtab, ko->ko_symcnt * 667 sizeof(Elf_Sym), ko->ko_strtab, ko->ko_strtabsz); 668 ko->ko_ksyms = true; 669 } 670 671 /* Jettison unneeded memory post-link. */ 672 kobj_jettison(ko); 673 674 /* 675 * Notify MD code that a module has been loaded. 676 * 677 * Most architectures use this opportunity to flush their caches. 678 */ 679 if (error == 0) { 680 error = kobj_machdep(ko, (void *)ko->ko_address, ko->ko_size, 681 true); 682 if (error != 0) { 683 kobj_error("machine dependent init failed"); 684 } 685 ko->ko_loaded = true; 686 } 687 688 /* If there was an error, destroy the whole object. */ 689 if (error != 0) { 690 kobj_unload(ko); 691 } 692 693 return error; 694 } 695 696 /* 697 * kobj_find_section: 698 * 699 * Given a section name, search the loaded object and return 700 * virtual address if present and loaded. 701 */ 702 int 703 kobj_find_section(kobj_t ko, const char *name, void **addr, size_t *size) 704 { 705 int i; 706 707 KASSERT(ko->ko_progtab != NULL); 708 709 for (i = 0; i < ko->ko_nprogtab; i++) { 710 if (strcmp(ko->ko_progtab[i].name, name) == 0) { 711 if (addr != NULL) { 712 *addr = ko->ko_progtab[i].addr; 713 } 714 if (size != NULL) { 715 *size = ko->ko_progtab[i].size; 716 } 717 return 0; 718 } 719 } 720 721 return ENOENT; 722 } 723 724 /* 725 * kobj_jettison: 726 * 727 * Release object data not needed after performing relocations. 728 */ 729 static void 730 kobj_jettison(kobj_t ko) 731 { 732 int i; 733 734 if (ko->ko_reltab != NULL) { 735 for (i = 0; i < ko->ko_nrel; i++) { 736 if (ko->ko_reltab[i].rel) { 737 kobj_free(ko, ko->ko_reltab[i].rel, 738 ko->ko_reltab[i].size); 739 } 740 } 741 kobj_free(ko, ko->ko_reltab, ko->ko_nrel * 742 sizeof(*ko->ko_reltab)); 743 ko->ko_reltab = NULL; 744 ko->ko_nrel = 0; 745 } 746 if (ko->ko_relatab != NULL) { 747 for (i = 0; i < ko->ko_nrela; i++) { 748 if (ko->ko_relatab[i].rela) { 749 kobj_free(ko, ko->ko_relatab[i].rela, 750 ko->ko_relatab[i].size); 751 } 752 } 753 kobj_free(ko, ko->ko_relatab, ko->ko_nrela * 754 sizeof(*ko->ko_relatab)); 755 ko->ko_relatab = NULL; 756 ko->ko_nrela = 0; 757 } 758 if (ko->ko_shdr != NULL) { 759 kobj_free(ko, ko->ko_shdr, ko->ko_shdrsz); 760 ko->ko_shdr = NULL; 761 } 762 } 763 764 /* 765 * kobj_sym_lookup: 766 * 767 * Symbol lookup function to be used when the symbol index 768 * is known (ie during relocation). 769 */ 770 uintptr_t 771 kobj_sym_lookup(kobj_t ko, uintptr_t symidx) 772 { 773 const Elf_Sym *sym; 774 const char *symbol; 775 776 /* Don't even try to lookup the symbol if the index is bogus. */ 777 if (symidx >= ko->ko_symcnt) 778 return 0; 779 780 sym = ko->ko_symtab + symidx; 781 782 /* Quick answer if there is a definition included. */ 783 if (sym->st_shndx != SHN_UNDEF) { 784 return (uintptr_t)sym->st_value; 785 } 786 787 /* If we get here, then it is undefined and needs a lookup. */ 788 switch (ELF_ST_BIND(sym->st_info)) { 789 case STB_LOCAL: 790 /* Local, but undefined? huh? */ 791 kobj_error("local symbol undefined"); 792 return 0; 793 794 case STB_GLOBAL: 795 /* Relative to Data or Function name */ 796 symbol = ko->ko_strtab + sym->st_name; 797 798 /* Force a lookup failure if the symbol name is bogus. */ 799 if (*symbol == 0) { 800 kobj_error("bad symbol name"); 801 return 0; 802 } 803 804 return (uintptr_t)sym->st_value; 805 806 case STB_WEAK: 807 kobj_error("weak symbols not supported\n"); 808 return 0; 809 810 default: 811 return 0; 812 } 813 } 814 815 /* 816 * kobj_findbase: 817 * 818 * Return base address of the given section. 819 */ 820 static uintptr_t 821 kobj_findbase(kobj_t ko, int sec) 822 { 823 int i; 824 825 for (i = 0; i < ko->ko_nprogtab; i++) { 826 if (sec == ko->ko_progtab[i].sec) { 827 return (uintptr_t)ko->ko_progtab[i].addr; 828 } 829 } 830 return 0; 831 } 832 833 /* 834 * kobj_checksyms: 835 * 836 * Scan symbol table for duplicates or resolve references to 837 * exernal symbols. 838 */ 839 static int 840 kobj_checksyms(kobj_t ko, bool undefined) 841 { 842 unsigned long rval; 843 Elf_Sym *sym, *ms; 844 const char *name; 845 int error; 846 847 error = 0; 848 849 for (ms = (sym = ko->ko_symtab) + ko->ko_symcnt; sym < ms; sym++) { 850 /* Check validity of the symbol. */ 851 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL || 852 sym->st_name == 0) 853 continue; 854 if (undefined != (sym->st_shndx == SHN_UNDEF)) { 855 continue; 856 } 857 858 /* 859 * Look it up. Don't need to lock, as it is known that 860 * the symbol tables aren't going to change (we hold 861 * module_lock). 862 */ 863 name = ko->ko_strtab + sym->st_name; 864 if (ksyms_getval_unlocked(NULL, name, &rval, 865 KSYMS_EXTERN) != 0) { 866 if (undefined) { 867 kobj_error("symbol `%s' not found", name); 868 error = ENOEXEC; 869 } 870 continue; 871 } 872 873 /* Save values of undefined globals. */ 874 if (undefined) { 875 sym->st_value = (Elf_Addr)rval; 876 continue; 877 } 878 879 /* Check (and complain) about differing values. */ 880 if (sym->st_value == rval) { 881 continue; 882 } 883 if (strcmp(name, "_bss_start") == 0 || 884 strcmp(name, "__bss_start") == 0 || 885 strcmp(name, "_bss_end__") == 0 || 886 strcmp(name, "__bss_end__") == 0 || 887 strcmp(name, "_edata") == 0 || 888 strcmp(name, "_end") == 0 || 889 strcmp(name, "__end") == 0 || 890 strcmp(name, "__end__") == 0 || 891 strncmp(name, "__start_link_set_", 17) == 0 || 892 strncmp(name, "__stop_link_set_", 16)) { 893 continue; 894 } 895 kobj_error("global symbol `%s' redefined\n", name); 896 error = ENOEXEC; 897 } 898 899 return error; 900 } 901 902 /* 903 * kobj_relocate: 904 * 905 * Resolve relocations for the loaded object. 906 */ 907 static int 908 kobj_relocate(kobj_t ko, bool local) 909 { 910 const Elf_Rel *rellim; 911 const Elf_Rel *rel; 912 const Elf_Rela *relalim; 913 const Elf_Rela *rela; 914 const Elf_Sym *sym; 915 uintptr_t base; 916 int i, error; 917 uintptr_t symidx; 918 919 /* 920 * Perform relocations without addend if there are any. 921 */ 922 for (i = 0; i < ko->ko_nrel; i++) { 923 rel = ko->ko_reltab[i].rel; 924 if (rel == NULL) { 925 continue; 926 } 927 rellim = rel + ko->ko_reltab[i].nrel; 928 base = kobj_findbase(ko, ko->ko_reltab[i].sec); 929 if (base == 0) { 930 panic("lost base for e_reltab"); 931 } 932 for (; rel < rellim; rel++) { 933 symidx = ELF_R_SYM(rel->r_info); 934 if (symidx >= ko->ko_symcnt) { 935 continue; 936 } 937 sym = ko->ko_symtab + symidx; 938 if (local != (ELF_ST_BIND(sym->st_info) == STB_LOCAL)) { 939 continue; 940 } 941 error = kobj_reloc(ko, base, rel, false, local); 942 if (error != 0) { 943 return ENOENT; 944 } 945 } 946 } 947 948 /* 949 * Perform relocations with addend if there are any. 950 */ 951 for (i = 0; i < ko->ko_nrela; i++) { 952 rela = ko->ko_relatab[i].rela; 953 if (rela == NULL) { 954 continue; 955 } 956 relalim = rela + ko->ko_relatab[i].nrela; 957 base = kobj_findbase(ko, ko->ko_relatab[i].sec); 958 if (base == 0) { 959 panic("lost base for e_relatab"); 960 } 961 for (; rela < relalim; rela++) { 962 symidx = ELF_R_SYM(rela->r_info); 963 if (symidx >= ko->ko_symcnt) { 964 continue; 965 } 966 sym = ko->ko_symtab + symidx; 967 if (local != (ELF_ST_BIND(sym->st_info) == STB_LOCAL)) { 968 continue; 969 } 970 error = kobj_reloc(ko, base, rela, true, local); 971 if (error != 0) { 972 return ENOENT; 973 } 974 } 975 } 976 977 return 0; 978 } 979 980 /* 981 * kobj_error: 982 * 983 * Utility function: log an error. 984 */ 985 static void 986 kobj_error(const char *fmt, ...) 987 { 988 va_list ap; 989 990 va_start(ap, fmt); 991 printf("WARNING: linker error: "); 992 vprintf(fmt, ap); 993 printf("\n"); 994 va_end(ap); 995 } 996 997 /* 998 * kobj_read: 999 * 1000 * Utility function: read from the object. 1001 */ 1002 static int 1003 kobj_read(kobj_t ko, void **basep, size_t size, off_t off) 1004 { 1005 size_t resid; 1006 void *base; 1007 int error; 1008 1009 KASSERT(ko->ko_source != NULL); 1010 1011 switch (ko->ko_type) { 1012 case KT_VNODE: 1013 base = kmem_alloc(size, KM_SLEEP); 1014 if (base == NULL) { 1015 error = ENOMEM; 1016 break; 1017 } 1018 error = vn_rdwr(UIO_READ, ko->ko_source, base, size, off, 1019 UIO_SYSSPACE, IO_NODELOCKED, curlwp->l_cred, &resid, 1020 curlwp); 1021 if (error == 0 && resid != 0) { 1022 error = EINVAL; 1023 } 1024 if (error != 0) { 1025 kmem_free(base, size); 1026 base = NULL; 1027 } 1028 break; 1029 case KT_MEMORY: 1030 if (ko->ko_memsize != -1 && off + size > ko->ko_memsize) { 1031 kobj_error("kobj_read: preloaded object short"); 1032 error = EINVAL; 1033 base = NULL; 1034 } else { 1035 base = (uint8_t *)ko->ko_source + off; 1036 error = 0; 1037 } 1038 break; 1039 default: 1040 panic("kobj_read: invalid type"); 1041 } 1042 1043 *basep = base; 1044 return error; 1045 } 1046 1047 /* 1048 * kobj_read_bits: 1049 * 1050 * Utility function: load a section from the object. 1051 */ 1052 static int 1053 kobj_read_bits(kobj_t ko, void *base, size_t size, off_t off) 1054 { 1055 size_t resid; 1056 int error; 1057 1058 KASSERT(ko->ko_source != NULL); 1059 1060 switch (ko->ko_type) { 1061 case KT_VNODE: 1062 KASSERT((uintptr_t)base >= (uintptr_t)ko->ko_address); 1063 KASSERT((uintptr_t)base + size <= 1064 (uintptr_t)ko->ko_address + ko->ko_size); 1065 error = vn_rdwr(UIO_READ, ko->ko_source, base, size, off, 1066 UIO_SYSSPACE, IO_NODELOCKED, curlwp->l_cred, &resid, 1067 curlwp); 1068 if (error == 0 && resid != 0) { 1069 error = EINVAL; 1070 } 1071 break; 1072 case KT_MEMORY: 1073 if (ko->ko_memsize != -1 && off + size > ko->ko_memsize) { 1074 kobj_error("kobj_read_bits: preloaded object short"); 1075 error = EINVAL; 1076 } else if ((uint8_t *)base != (uint8_t *)ko->ko_source + off) { 1077 kobj_error("kobj_read_bits: object not aligned"); 1078 kobj_error("source=%p base=%p off=%d size=%zd", 1079 ko->ko_source, base, (int)off, size); 1080 error = EINVAL; 1081 } else { 1082 /* Nothing to do. Loading in-situ. */ 1083 error = 0; 1084 } 1085 break; 1086 default: 1087 panic("kobj_read: invalid type"); 1088 } 1089 1090 return error; 1091 } 1092 1093 /* 1094 * kobj_free: 1095 * 1096 * Utility function: free memory if it was allocated from the heap. 1097 */ 1098 static void 1099 kobj_free(kobj_t ko, void *base, size_t size) 1100 { 1101 1102 if (ko->ko_type != KT_MEMORY) 1103 kmem_free(base, size); 1104 } 1105 1106 #else /* MODULAR */ 1107 1108 int 1109 kobj_load_file(kobj_t *kop, const char *name, const bool nochroot) 1110 { 1111 1112 return ENOSYS; 1113 } 1114 1115 int 1116 kobj_load_mem(kobj_t *kop, void *base, ssize_t size) 1117 { 1118 1119 return ENOSYS; 1120 } 1121 1122 void 1123 kobj_unload(kobj_t ko) 1124 { 1125 1126 panic("not modular"); 1127 } 1128 1129 void 1130 kobj_stat(kobj_t ko, vaddr_t *base, size_t *size) 1131 { 1132 1133 panic("not modular"); 1134 } 1135 1136 int 1137 kobj_affix(kobj_t ko, const char *name) 1138 { 1139 1140 panic("not modular"); 1141 } 1142 1143 int 1144 kobj_find_section(kobj_t ko, const char *name, void **addr, size_t *size) 1145 { 1146 1147 panic("not modular"); 1148 } 1149 1150 #endif /* MODULAR */ 1151