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