1 /* $NetBSD: subr_kobj.c,v 1.33 2009/01/08 01:03:24 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.33 2009/01/08 01:03:24 pooka 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 /* 749 * Notify MD code that a module has been loaded. 750 * 751 * Most architectures use this opportunity to flush their caches. 752 */ 753 if (error == 0) { 754 error = kobj_machdep(ko, (void *)ko->ko_address, ko->ko_size, 755 true); 756 if (error != 0) { 757 kobj_error("machine dependent init failed"); 758 } 759 ko->ko_loaded = true; 760 } 761 762 /* If there was an error, destroy the whole object. */ 763 if (error != 0) { 764 kobj_unload(ko); 765 } 766 767 return error; 768 } 769 770 /* 771 * kobj_find_section: 772 * 773 * Given a section name, search the loaded object and return 774 * virtual address if present and loaded. 775 */ 776 int 777 kobj_find_section(kobj_t ko, const char *name, void **addr, size_t *size) 778 { 779 int i; 780 781 KASSERT(ko->ko_progtab != NULL); 782 783 for (i = 0; i < ko->ko_nprogtab; i++) { 784 if (strcmp(ko->ko_progtab[i].name, name) == 0) { 785 if (addr != NULL) { 786 *addr = ko->ko_progtab[i].addr; 787 } 788 if (size != NULL) { 789 *size = ko->ko_progtab[i].size; 790 } 791 return 0; 792 } 793 } 794 795 return ENOENT; 796 } 797 798 /* 799 * kobj_jettison: 800 * 801 * Release object data not needed after performing relocations. 802 */ 803 static void 804 kobj_jettison(kobj_t ko) 805 { 806 int i; 807 808 for (i = 0; i < ko->ko_nrel; i++) { 809 if (ko->ko_reltab[i].rel) { 810 kobj_free(ko, ko->ko_reltab[i].rel, 811 ko->ko_reltab[i].size); 812 } 813 } 814 for (i = 0; i < ko->ko_nrela; i++) { 815 if (ko->ko_relatab[i].rela) { 816 kobj_free(ko, ko->ko_relatab[i].rela, 817 ko->ko_relatab[i].size); 818 } 819 } 820 if (ko->ko_reltab != NULL) { 821 kobj_free(ko, ko->ko_reltab, ko->ko_nrel * 822 sizeof(*ko->ko_reltab)); 823 ko->ko_reltab = NULL; 824 ko->ko_nrel = 0; 825 } 826 if (ko->ko_relatab != NULL) { 827 kobj_free(ko, ko->ko_relatab, ko->ko_nrela * 828 sizeof(*ko->ko_relatab)); 829 ko->ko_relatab = NULL; 830 ko->ko_nrela = 0; 831 } 832 if (ko->ko_shdr != NULL) { 833 kobj_free(ko, ko->ko_shdr, ko->ko_shdrsz); 834 ko->ko_shdr = NULL; 835 } 836 } 837 838 /* 839 * kobj_sym_lookup: 840 * 841 * Symbol lookup function to be used when the symbol index 842 * is known (ie during relocation). 843 */ 844 uintptr_t 845 kobj_sym_lookup(kobj_t ko, uintptr_t symidx) 846 { 847 const Elf_Sym *sym; 848 const char *symbol; 849 850 /* Don't even try to lookup the symbol if the index is bogus. */ 851 if (symidx >= ko->ko_symcnt) 852 return 0; 853 854 sym = ko->ko_symtab + symidx; 855 856 /* Quick answer if there is a definition included. */ 857 if (sym->st_shndx != SHN_UNDEF) { 858 return (uintptr_t)sym->st_value; 859 } 860 861 /* If we get here, then it is undefined and needs a lookup. */ 862 switch (ELF_ST_BIND(sym->st_info)) { 863 case STB_LOCAL: 864 /* Local, but undefined? huh? */ 865 kobj_error("local symbol undefined"); 866 return 0; 867 868 case STB_GLOBAL: 869 /* Relative to Data or Function name */ 870 symbol = ko->ko_strtab + sym->st_name; 871 872 /* Force a lookup failure if the symbol name is bogus. */ 873 if (*symbol == 0) { 874 kobj_error("bad symbol name"); 875 return 0; 876 } 877 878 return (uintptr_t)sym->st_value; 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_checksyms: 909 * 910 * Scan symbol table for duplicates or resolve references to 911 * exernal symbols. 912 */ 913 static int 914 kobj_checksyms(kobj_t ko, bool undefined) 915 { 916 unsigned long rval; 917 Elf_Sym *sym, *ms; 918 const char *name; 919 int error; 920 921 error = 0; 922 923 for (ms = (sym = ko->ko_symtab) + ko->ko_symcnt; sym < ms; sym++) { 924 /* Check validity of the symbol. */ 925 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL || 926 sym->st_name == 0) 927 continue; 928 if (undefined != (sym->st_shndx == SHN_UNDEF)) { 929 continue; 930 } 931 932 /* 933 * Look it up. Don't need to lock, as it is known that 934 * the symbol tables aren't going to change (we hold 935 * module_lock). 936 */ 937 name = ko->ko_strtab + sym->st_name; 938 if (ksyms_getval_unlocked(NULL, name, &rval, 939 KSYMS_EXTERN) != 0) { 940 if (undefined) { 941 kobj_error("symbol `%s' not found", name); 942 error = ENOEXEC; 943 } 944 continue; 945 } 946 947 /* Save values of undefined globals. */ 948 if (undefined) { 949 sym->st_value = (Elf_Addr)rval; 950 continue; 951 } 952 953 /* Check (and complain) about differing values. */ 954 if (sym->st_value == rval) { 955 continue; 956 } 957 if (strcmp(name, "_bss_start") == 0 || 958 strcmp(name, "__bss_start") == 0 || 959 strcmp(name, "_bss_end__") == 0 || 960 strcmp(name, "__bss_end__") == 0 || 961 strcmp(name, "_edata") == 0 || 962 strcmp(name, "_end") == 0 || 963 strcmp(name, "__end") == 0 || 964 strcmp(name, "__end__") == 0 || 965 strncmp(name, "__start_link_set_", 17) == 0 || 966 strncmp(name, "__stop_link_set_", 16)) { 967 continue; 968 } 969 kobj_error("global symbol `%s' redefined\n", name); 970 error = ENOEXEC; 971 } 972 973 return error; 974 } 975 976 /* 977 * kobj_relocate: 978 * 979 * Resolve relocations for the loaded object. 980 */ 981 static int 982 kobj_relocate(kobj_t ko, bool local) 983 { 984 const Elf_Rel *rellim; 985 const Elf_Rel *rel; 986 const Elf_Rela *relalim; 987 const Elf_Rela *rela; 988 const Elf_Sym *sym; 989 uintptr_t base; 990 int i, error; 991 uintptr_t symidx; 992 993 /* 994 * Perform relocations without addend if there are any. 995 */ 996 for (i = 0; i < ko->ko_nrel; i++) { 997 rel = ko->ko_reltab[i].rel; 998 if (rel == NULL) { 999 continue; 1000 } 1001 rellim = rel + ko->ko_reltab[i].nrel; 1002 base = kobj_findbase(ko, ko->ko_reltab[i].sec); 1003 if (base == 0) { 1004 panic("lost base for e_reltab"); 1005 } 1006 for (; rel < rellim; rel++) { 1007 symidx = ELF_R_SYM(rel->r_info); 1008 if (symidx >= ko->ko_symcnt) { 1009 continue; 1010 } 1011 sym = ko->ko_symtab + symidx; 1012 if (local != (ELF_ST_BIND(sym->st_info) == STB_LOCAL)) { 1013 continue; 1014 } 1015 error = kobj_reloc(ko, base, rel, false, local); 1016 if (error != 0) { 1017 return ENOENT; 1018 } 1019 } 1020 } 1021 1022 /* 1023 * Perform relocations with addend if there are any. 1024 */ 1025 for (i = 0; i < ko->ko_nrela; i++) { 1026 rela = ko->ko_relatab[i].rela; 1027 if (rela == NULL) { 1028 continue; 1029 } 1030 relalim = rela + ko->ko_relatab[i].nrela; 1031 base = kobj_findbase(ko, ko->ko_relatab[i].sec); 1032 if (base == 0) { 1033 panic("lost base for e_relatab"); 1034 } 1035 for (; rela < relalim; rela++) { 1036 symidx = ELF_R_SYM(rela->r_info); 1037 if (symidx >= ko->ko_symcnt) { 1038 continue; 1039 } 1040 sym = ko->ko_symtab + symidx; 1041 if (local != (ELF_ST_BIND(sym->st_info) == STB_LOCAL)) { 1042 continue; 1043 } 1044 error = kobj_reloc(ko, base, rela, true, local); 1045 if (error != 0) { 1046 return ENOENT; 1047 } 1048 } 1049 } 1050 1051 return 0; 1052 } 1053 1054 /* 1055 * kobj_error: 1056 * 1057 * Utility function: log an error. 1058 */ 1059 static void 1060 kobj_error(const char *fmt, ...) 1061 { 1062 va_list ap; 1063 1064 va_start(ap, fmt); 1065 printf("WARNING: linker error: "); 1066 vprintf(fmt, ap); 1067 printf("\n"); 1068 va_end(ap); 1069 } 1070 1071 /* 1072 * kobj_read: 1073 * 1074 * Utility function: read from the object. 1075 */ 1076 static int 1077 kobj_read(kobj_t ko, void **basep, size_t size, off_t off) 1078 { 1079 size_t resid; 1080 void *base; 1081 int error; 1082 1083 KASSERT(ko->ko_source != NULL); 1084 1085 switch (ko->ko_type) { 1086 case KT_VNODE: 1087 base = kmem_alloc(size, KM_SLEEP); 1088 if (base == NULL) { 1089 error = ENOMEM; 1090 break; 1091 } 1092 error = vn_rdwr(UIO_READ, ko->ko_source, base, size, off, 1093 UIO_SYSSPACE, IO_NODELOCKED, curlwp->l_cred, &resid, 1094 curlwp); 1095 if (error == 0 && resid != 0) { 1096 error = EINVAL; 1097 } 1098 if (error != 0) { 1099 kmem_free(base, size); 1100 base = NULL; 1101 } 1102 break; 1103 case KT_MEMORY: 1104 if (ko->ko_memsize != -1 && off + size > ko->ko_memsize) { 1105 kobj_error("kobj_read: preloaded object short"); 1106 error = EINVAL; 1107 base = NULL; 1108 } else { 1109 base = (uint8_t *)ko->ko_source + off; 1110 error = 0; 1111 } 1112 break; 1113 default: 1114 panic("kobj_read: invalid type"); 1115 } 1116 1117 *basep = base; 1118 return error; 1119 } 1120 1121 /* 1122 * kobj_read_bits: 1123 * 1124 * Utility function: load a section from the object. 1125 */ 1126 static int 1127 kobj_read_bits(kobj_t ko, void *base, size_t size, off_t off) 1128 { 1129 size_t resid; 1130 int error; 1131 1132 KASSERT(ko->ko_source != NULL); 1133 1134 switch (ko->ko_type) { 1135 case KT_VNODE: 1136 KASSERT((uintptr_t)base >= (uintptr_t)ko->ko_address); 1137 KASSERT((uintptr_t)base + size <= 1138 (uintptr_t)ko->ko_address + ko->ko_size); 1139 error = vn_rdwr(UIO_READ, ko->ko_source, base, size, off, 1140 UIO_SYSSPACE, IO_NODELOCKED, curlwp->l_cred, &resid, 1141 curlwp); 1142 if (error == 0 && resid != 0) { 1143 error = EINVAL; 1144 } 1145 break; 1146 case KT_MEMORY: 1147 if (ko->ko_memsize != -1 && off + size > ko->ko_memsize) { 1148 kobj_error("kobj_read_bits: preloaded object short"); 1149 error = EINVAL; 1150 } else if ((uint8_t *)base != (uint8_t *)ko->ko_source + off) { 1151 kobj_error("kobj_read_bits: object not aligned"); 1152 kobj_error("source=%p base=%p off=%d size=%zd", 1153 ko->ko_source, base, (int)off, size); 1154 error = EINVAL; 1155 } else { 1156 /* Nothing to do. Loading in-situ. */ 1157 error = 0; 1158 } 1159 break; 1160 default: 1161 panic("kobj_read: invalid type"); 1162 } 1163 1164 return error; 1165 } 1166 1167 /* 1168 * kobj_free: 1169 * 1170 * Utility function: free memory if it was allocated from the heap. 1171 */ 1172 static void 1173 kobj_free(kobj_t ko, void *base, size_t size) 1174 { 1175 1176 if (ko->ko_type != KT_MEMORY) 1177 kmem_free(base, size); 1178 } 1179 1180 #else /* MODULAR */ 1181 1182 int 1183 kobj_load_file(kobj_t *kop, const char *name, const char *base, bool autoload) 1184 { 1185 1186 return ENOSYS; 1187 } 1188 1189 int 1190 kobj_load_mem(kobj_t *kop, void *base, ssize_t size) 1191 { 1192 1193 return ENOSYS; 1194 } 1195 1196 void 1197 kobj_unload(kobj_t ko) 1198 { 1199 1200 panic("not modular"); 1201 } 1202 1203 void 1204 kobj_stat(kobj_t ko, vaddr_t *base, size_t *size) 1205 { 1206 1207 panic("not modular"); 1208 } 1209 1210 int 1211 kobj_affix(kobj_t ko, const char *name) 1212 { 1213 1214 panic("not modular"); 1215 } 1216 1217 int 1218 kobj_find_section(kobj_t ko, const char *name, void **addr, size_t *size) 1219 { 1220 1221 panic("not modular"); 1222 } 1223 1224 #endif /* MODULAR */ 1225