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