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