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