1 /*- 2 * Copyright (c) 1998-2000 Doug Rabson 3 * Copyright (c) 2004 Peter Wemm 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 */ 27 28 #include <sys/cdefs.h> 29 __FBSDID("$FreeBSD$"); 30 31 #include "opt_ddb.h" 32 #include "opt_mac.h" 33 34 #include <sys/param.h> 35 #include <sys/systm.h> 36 #include <sys/kernel.h> 37 #include <sys/lock.h> 38 #include <sys/malloc.h> 39 #include <sys/mutex.h> 40 #include <sys/mount.h> 41 #include <sys/proc.h> 42 #include <sys/namei.h> 43 #include <sys/fcntl.h> 44 #include <sys/vnode.h> 45 #include <sys/linker.h> 46 47 #include <machine/elf.h> 48 49 #include <security/mac/mac_framework.h> 50 51 #include <vm/vm.h> 52 #include <vm/vm_param.h> 53 #include <vm/vm_object.h> 54 #include <vm/vm_kern.h> 55 #include <vm/vm_extern.h> 56 #include <vm/pmap.h> 57 #include <vm/vm_map.h> 58 59 #include <sys/link_elf.h> 60 61 #include "linker_if.h" 62 63 typedef struct { 64 void *addr; 65 Elf_Off size; 66 int flags; 67 int sec; /* Original section */ 68 char *name; 69 } Elf_progent; 70 71 typedef struct { 72 Elf_Rel *rel; 73 int nrel; 74 int sec; 75 } Elf_relent; 76 77 typedef struct { 78 Elf_Rela *rela; 79 int nrela; 80 int sec; 81 } Elf_relaent; 82 83 84 typedef struct elf_file { 85 struct linker_file lf; /* Common fields */ 86 87 int preloaded; 88 caddr_t address; /* Relocation address */ 89 vm_object_t object; /* VM object to hold file pages */ 90 Elf_Shdr *e_shdr; 91 92 Elf_progent *progtab; 93 int nprogtab; 94 95 Elf_relaent *relatab; 96 int nrela; 97 98 Elf_relent *reltab; 99 int nrel; 100 101 Elf_Sym *ddbsymtab; /* The symbol table we are using */ 102 long ddbsymcnt; /* Number of symbols */ 103 caddr_t ddbstrtab; /* String table */ 104 long ddbstrcnt; /* number of bytes in string table */ 105 106 caddr_t shstrtab; /* Section name string table */ 107 long shstrcnt; /* number of bytes in string table */ 108 109 } *elf_file_t; 110 111 static int link_elf_link_preload(linker_class_t cls, 112 const char *, linker_file_t *); 113 static int link_elf_link_preload_finish(linker_file_t); 114 static int link_elf_load_file(linker_class_t, const char *, linker_file_t *); 115 static int link_elf_lookup_symbol(linker_file_t, const char *, 116 c_linker_sym_t *); 117 static int link_elf_symbol_values(linker_file_t, c_linker_sym_t, 118 linker_symval_t *); 119 static int link_elf_search_symbol(linker_file_t, caddr_t value, 120 c_linker_sym_t *sym, long *diffp); 121 122 static void link_elf_unload_file(linker_file_t); 123 static int link_elf_lookup_set(linker_file_t, const char *, 124 void ***, void ***, int *); 125 static int link_elf_each_function_name(linker_file_t, 126 int (*)(const char *, void *), void *); 127 static void link_elf_reloc_local(linker_file_t); 128 129 static Elf_Addr elf_obj_lookup(linker_file_t lf, Elf_Size symidx, int deps); 130 131 static kobj_method_t link_elf_methods[] = { 132 KOBJMETHOD(linker_lookup_symbol, link_elf_lookup_symbol), 133 KOBJMETHOD(linker_symbol_values, link_elf_symbol_values), 134 KOBJMETHOD(linker_search_symbol, link_elf_search_symbol), 135 KOBJMETHOD(linker_unload, link_elf_unload_file), 136 KOBJMETHOD(linker_load_file, link_elf_load_file), 137 KOBJMETHOD(linker_link_preload, link_elf_link_preload), 138 KOBJMETHOD(linker_link_preload_finish, link_elf_link_preload_finish), 139 KOBJMETHOD(linker_lookup_set, link_elf_lookup_set), 140 KOBJMETHOD(linker_each_function_name, link_elf_each_function_name), 141 { 0, 0 } 142 }; 143 144 static struct linker_class link_elf_class = { 145 #if ELF_TARG_CLASS == ELFCLASS32 146 "elf32_obj", 147 #else 148 "elf64_obj", 149 #endif 150 link_elf_methods, sizeof(struct elf_file) 151 }; 152 153 static int relocate_file(elf_file_t ef); 154 155 static void 156 link_elf_error(const char *s) 157 { 158 printf("kldload: %s\n", s); 159 } 160 161 static void 162 link_elf_init(void *arg) 163 { 164 165 linker_add_class(&link_elf_class); 166 } 167 168 SYSINIT(link_elf_obj, SI_SUB_KLD, SI_ORDER_SECOND, link_elf_init, 0); 169 170 static int 171 link_elf_link_preload(linker_class_t cls, const char *filename, 172 linker_file_t *result) 173 { 174 Elf_Ehdr *hdr; 175 Elf_Shdr *shdr; 176 Elf_Sym *es; 177 void *modptr, *baseptr, *sizeptr; 178 char *type; 179 elf_file_t ef; 180 linker_file_t lf; 181 Elf_Addr off; 182 int error, i, j, pb, ra, rl, shstrindex, symstrindex, symtabindex; 183 184 /* Look to see if we have the file preloaded */ 185 modptr = preload_search_by_name(filename); 186 if (modptr == NULL) 187 return ENOENT; 188 189 type = (char *)preload_search_info(modptr, MODINFO_TYPE); 190 baseptr = preload_search_info(modptr, MODINFO_ADDR); 191 sizeptr = preload_search_info(modptr, MODINFO_SIZE); 192 hdr = (Elf_Ehdr *)preload_search_info(modptr, MODINFO_METADATA | 193 MODINFOMD_ELFHDR); 194 shdr = (Elf_Shdr *)preload_search_info(modptr, MODINFO_METADATA | 195 MODINFOMD_SHDR); 196 if (type == NULL || (strcmp(type, "elf" __XSTRING(__ELF_WORD_SIZE) 197 " obj module") != 0 && 198 strcmp(type, "elf obj module") != 0)) { 199 return (EFTYPE); 200 } 201 if (baseptr == NULL || sizeptr == NULL || hdr == NULL || 202 shdr == NULL) 203 return (EINVAL); 204 205 lf = linker_make_file(filename, &link_elf_class); 206 if (lf == NULL) 207 return (ENOMEM); 208 209 ef = (elf_file_t)lf; 210 ef->preloaded = 1; 211 ef->address = *(caddr_t *)baseptr; 212 lf->address = *(caddr_t *)baseptr; 213 lf->size = *(size_t *)sizeptr; 214 215 if (hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS || 216 hdr->e_ident[EI_DATA] != ELF_TARG_DATA || 217 hdr->e_ident[EI_VERSION] != EV_CURRENT || 218 hdr->e_version != EV_CURRENT || 219 hdr->e_type != ET_REL || 220 hdr->e_machine != ELF_TARG_MACH) { 221 error = EFTYPE; 222 goto out; 223 } 224 ef->e_shdr = shdr; 225 226 /* Scan the section header for information and table sizing. */ 227 symtabindex = -1; 228 symstrindex = -1; 229 for (i = 0; i < hdr->e_shnum; i++) { 230 switch (shdr[i].sh_type) { 231 case SHT_PROGBITS: 232 case SHT_NOBITS: 233 ef->nprogtab++; 234 break; 235 case SHT_SYMTAB: 236 symtabindex = i; 237 symstrindex = shdr[i].sh_link; 238 break; 239 case SHT_REL: 240 ef->nrel++; 241 break; 242 case SHT_RELA: 243 ef->nrela++; 244 break; 245 } 246 } 247 248 shstrindex = hdr->e_shstrndx; 249 if (ef->nprogtab == 0 || symstrindex < 0 || 250 symstrindex >= hdr->e_shnum || 251 shdr[symstrindex].sh_type != SHT_STRTAB || shstrindex == 0 || 252 shstrindex >= hdr->e_shnum || 253 shdr[shstrindex].sh_type != SHT_STRTAB) { 254 printf("%s: bad/missing section headers\n", filename); 255 error = ENOEXEC; 256 goto out; 257 } 258 259 /* Allocate space for tracking the load chunks */ 260 if (ef->nprogtab != 0) 261 ef->progtab = malloc(ef->nprogtab * sizeof(*ef->progtab), 262 M_LINKER, M_WAITOK | M_ZERO); 263 if (ef->nrel != 0) 264 ef->reltab = malloc(ef->nrel * sizeof(*ef->reltab), M_LINKER, 265 M_WAITOK | M_ZERO); 266 if (ef->nrela != 0) 267 ef->relatab = malloc(ef->nrela * sizeof(*ef->relatab), M_LINKER, 268 M_WAITOK | M_ZERO); 269 if ((ef->nprogtab != 0 && ef->progtab == NULL) || 270 (ef->nrel != 0 && ef->reltab == NULL) || 271 (ef->nrela != 0 && ef->relatab == NULL)) { 272 error = ENOMEM; 273 goto out; 274 } 275 276 /* XXX, relocate the sh_addr fields saved by the loader. */ 277 off = 0; 278 for (i = 0; i < hdr->e_shnum; i++) { 279 if (shdr[i].sh_addr != 0 && (off == 0 || shdr[i].sh_addr < off)) 280 off = shdr[i].sh_addr; 281 } 282 for (i = 0; i < hdr->e_shnum; i++) { 283 if (shdr[i].sh_addr != 0) 284 shdr[i].sh_addr = shdr[i].sh_addr - off + 285 (Elf_Addr)ef->address; 286 } 287 288 ef->ddbsymcnt = shdr[symtabindex].sh_size / sizeof(Elf_Sym); 289 ef->ddbsymtab = (Elf_Sym *)shdr[symtabindex].sh_addr; 290 ef->ddbstrcnt = shdr[symstrindex].sh_size; 291 ef->ddbstrtab = (char *)shdr[symstrindex].sh_addr; 292 ef->shstrcnt = shdr[shstrindex].sh_size; 293 ef->shstrtab = (char *)shdr[shstrindex].sh_addr; 294 295 /* Now fill out progtab and the relocation tables. */ 296 pb = 0; 297 rl = 0; 298 ra = 0; 299 for (i = 0; i < hdr->e_shnum; i++) { 300 switch (shdr[i].sh_type) { 301 case SHT_PROGBITS: 302 case SHT_NOBITS: 303 ef->progtab[pb].addr = (void *)shdr[i].sh_addr; 304 if (shdr[i].sh_type == SHT_PROGBITS) 305 ef->progtab[pb].name = "<<PROGBITS>>"; 306 else 307 ef->progtab[pb].name = "<<NOBITS>>"; 308 ef->progtab[pb].size = shdr[i].sh_size; 309 ef->progtab[pb].sec = i; 310 if (ef->shstrtab && shdr[i].sh_name != 0) 311 ef->progtab[pb].name = 312 ef->shstrtab + shdr[i].sh_name; 313 314 /* Update all symbol values with the offset. */ 315 for (j = 0; j < ef->ddbsymcnt; j++) { 316 es = &ef->ddbsymtab[j]; 317 if (es->st_shndx != i) 318 continue; 319 es->st_value += (Elf_Addr)ef->progtab[pb].addr; 320 } 321 pb++; 322 break; 323 case SHT_REL: 324 ef->reltab[rl].rel = (Elf_Rel *)shdr[i].sh_addr; 325 ef->reltab[rl].nrel = shdr[i].sh_size / sizeof(Elf_Rel); 326 ef->reltab[rl].sec = shdr[i].sh_info; 327 rl++; 328 break; 329 case SHT_RELA: 330 ef->relatab[ra].rela = (Elf_Rela *)shdr[i].sh_addr; 331 ef->relatab[ra].nrela = 332 shdr[i].sh_size / sizeof(Elf_Rela); 333 ef->relatab[ra].sec = shdr[i].sh_info; 334 ra++; 335 break; 336 } 337 } 338 if (pb != ef->nprogtab) 339 panic("lost progbits"); 340 if (rl != ef->nrel) 341 panic("lost rel"); 342 if (ra != ef->nrela) 343 panic("lost rela"); 344 345 /* Local intra-module relocations */ 346 link_elf_reloc_local(lf); 347 348 *result = lf; 349 return (0); 350 351 out: 352 /* preload not done this way */ 353 linker_file_unload(lf, LINKER_UNLOAD_FORCE); 354 return (error); 355 } 356 357 static int 358 link_elf_link_preload_finish(linker_file_t lf) 359 { 360 elf_file_t ef; 361 int error; 362 363 ef = (elf_file_t)lf; 364 error = relocate_file(ef); 365 if (error) 366 return error; 367 368 /* Notify MD code that a module is being loaded. */ 369 error = elf_cpu_load_file(lf); 370 if (error) 371 return (error); 372 373 return (0); 374 } 375 376 static int 377 link_elf_load_file(linker_class_t cls, const char *filename, 378 linker_file_t *result) 379 { 380 struct nameidata nd; 381 struct thread *td = curthread; /* XXX */ 382 Elf_Ehdr *hdr; 383 Elf_Shdr *shdr; 384 Elf_Sym *es; 385 int nbytes, i, j; 386 vm_offset_t mapbase; 387 size_t mapsize; 388 int error = 0; 389 int resid, flags; 390 elf_file_t ef; 391 linker_file_t lf; 392 int symtabindex; 393 int symstrindex; 394 int shstrindex; 395 int nsym; 396 int pb, rl, ra; 397 int alignmask; 398 int vfslocked; 399 400 shdr = NULL; 401 lf = NULL; 402 mapsize = 0; 403 hdr = NULL; 404 405 NDINIT(&nd, LOOKUP, FOLLOW | MPSAFE, UIO_SYSSPACE, filename, td); 406 flags = FREAD; 407 error = vn_open(&nd, &flags, 0, NULL); 408 if (error) 409 return error; 410 vfslocked = NDHASGIANT(&nd); 411 NDFREE(&nd, NDF_ONLY_PNBUF); 412 if (nd.ni_vp->v_type != VREG) { 413 error = ENOEXEC; 414 goto out; 415 } 416 #ifdef MAC 417 error = mac_kld_check_load(td->td_ucred, nd.ni_vp); 418 if (error) { 419 goto out; 420 } 421 #endif 422 423 /* Read the elf header from the file. */ 424 hdr = malloc(sizeof(*hdr), M_LINKER, M_WAITOK); 425 if (hdr == NULL) { 426 error = ENOMEM; 427 goto out; 428 } 429 error = vn_rdwr(UIO_READ, nd.ni_vp, (void *)hdr, sizeof(*hdr), 0, 430 UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 431 &resid, td); 432 if (error) 433 goto out; 434 if (resid != 0){ 435 error = ENOEXEC; 436 goto out; 437 } 438 439 if (!IS_ELF(*hdr)) { 440 error = ENOEXEC; 441 goto out; 442 } 443 444 if (hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS 445 || hdr->e_ident[EI_DATA] != ELF_TARG_DATA) { 446 link_elf_error("Unsupported file layout"); 447 error = ENOEXEC; 448 goto out; 449 } 450 if (hdr->e_ident[EI_VERSION] != EV_CURRENT 451 || hdr->e_version != EV_CURRENT) { 452 link_elf_error("Unsupported file version"); 453 error = ENOEXEC; 454 goto out; 455 } 456 if (hdr->e_type != ET_REL) { 457 link_elf_error("Unsupported file type"); 458 error = ENOEXEC; 459 goto out; 460 } 461 if (hdr->e_machine != ELF_TARG_MACH) { 462 link_elf_error("Unsupported machine"); 463 error = ENOEXEC; 464 goto out; 465 } 466 467 lf = linker_make_file(filename, &link_elf_class); 468 if (!lf) { 469 error = ENOMEM; 470 goto out; 471 } 472 ef = (elf_file_t) lf; 473 ef->nprogtab = 0; 474 ef->e_shdr = 0; 475 ef->nrel = 0; 476 ef->nrela = 0; 477 478 /* Allocate and read in the section header */ 479 nbytes = hdr->e_shnum * hdr->e_shentsize; 480 if (nbytes == 0 || hdr->e_shoff == 0 || 481 hdr->e_shentsize != sizeof(Elf_Shdr)) { 482 error = ENOEXEC; 483 goto out; 484 } 485 shdr = malloc(nbytes, M_LINKER, M_WAITOK); 486 if (shdr == NULL) { 487 error = ENOMEM; 488 goto out; 489 } 490 ef->e_shdr = shdr; 491 error = vn_rdwr(UIO_READ, nd.ni_vp, (caddr_t)shdr, nbytes, hdr->e_shoff, 492 UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, &resid, td); 493 if (error) 494 goto out; 495 if (resid) { 496 error = ENOEXEC; 497 goto out; 498 } 499 500 /* Scan the section header for information and table sizing. */ 501 nsym = 0; 502 symtabindex = -1; 503 symstrindex = -1; 504 for (i = 0; i < hdr->e_shnum; i++) { 505 switch (shdr[i].sh_type) { 506 case SHT_PROGBITS: 507 case SHT_NOBITS: 508 ef->nprogtab++; 509 break; 510 case SHT_SYMTAB: 511 nsym++; 512 symtabindex = i; 513 symstrindex = shdr[i].sh_link; 514 break; 515 case SHT_REL: 516 ef->nrel++; 517 break; 518 case SHT_RELA: 519 ef->nrela++; 520 break; 521 case SHT_STRTAB: 522 break; 523 } 524 } 525 if (ef->nprogtab == 0) { 526 link_elf_error("file has no contents"); 527 error = ENOEXEC; 528 goto out; 529 } 530 if (nsym != 1) { 531 /* Only allow one symbol table for now */ 532 link_elf_error("file has no valid symbol table"); 533 error = ENOEXEC; 534 goto out; 535 } 536 if (symstrindex < 0 || symstrindex > hdr->e_shnum || 537 shdr[symstrindex].sh_type != SHT_STRTAB) { 538 link_elf_error("file has invalid symbol strings"); 539 error = ENOEXEC; 540 goto out; 541 } 542 543 /* Allocate space for tracking the load chunks */ 544 if (ef->nprogtab != 0) 545 ef->progtab = malloc(ef->nprogtab * sizeof(*ef->progtab), 546 M_LINKER, M_WAITOK | M_ZERO); 547 if (ef->nrel != 0) 548 ef->reltab = malloc(ef->nrel * sizeof(*ef->reltab), M_LINKER, 549 M_WAITOK | M_ZERO); 550 if (ef->nrela != 0) 551 ef->relatab = malloc(ef->nrela * sizeof(*ef->relatab), M_LINKER, 552 M_WAITOK | M_ZERO); 553 if ((ef->nprogtab != 0 && ef->progtab == NULL) || 554 (ef->nrel != 0 && ef->reltab == NULL) || 555 (ef->nrela != 0 && ef->relatab == NULL)) { 556 error = ENOMEM; 557 goto out; 558 } 559 560 if (symtabindex == -1) 561 panic("lost symbol table index"); 562 /* Allocate space for and load the symbol table */ 563 ef->ddbsymcnt = shdr[symtabindex].sh_size / sizeof(Elf_Sym); 564 ef->ddbsymtab = malloc(shdr[symtabindex].sh_size, M_LINKER, M_WAITOK); 565 if (ef->ddbsymtab == NULL) { 566 error = ENOMEM; 567 goto out; 568 } 569 error = vn_rdwr(UIO_READ, nd.ni_vp, (void *)ef->ddbsymtab, 570 shdr[symtabindex].sh_size, shdr[symtabindex].sh_offset, 571 UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 572 &resid, td); 573 if (error) 574 goto out; 575 if (resid != 0){ 576 error = EINVAL; 577 goto out; 578 } 579 580 if (symstrindex == -1) 581 panic("lost symbol string index"); 582 /* Allocate space for and load the symbol strings */ 583 ef->ddbstrcnt = shdr[symstrindex].sh_size; 584 ef->ddbstrtab = malloc(shdr[symstrindex].sh_size, M_LINKER, M_WAITOK); 585 if (ef->ddbstrtab == NULL) { 586 error = ENOMEM; 587 goto out; 588 } 589 error = vn_rdwr(UIO_READ, nd.ni_vp, ef->ddbstrtab, 590 shdr[symstrindex].sh_size, shdr[symstrindex].sh_offset, 591 UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 592 &resid, td); 593 if (error) 594 goto out; 595 if (resid != 0){ 596 error = EINVAL; 597 goto out; 598 } 599 600 /* Do we have a string table for the section names? */ 601 shstrindex = -1; 602 if (hdr->e_shstrndx != 0 && 603 shdr[hdr->e_shstrndx].sh_type == SHT_STRTAB) { 604 shstrindex = hdr->e_shstrndx; 605 ef->shstrcnt = shdr[shstrindex].sh_size; 606 ef->shstrtab = malloc(shdr[shstrindex].sh_size, M_LINKER, 607 M_WAITOK); 608 if (ef->shstrtab == NULL) { 609 error = ENOMEM; 610 goto out; 611 } 612 error = vn_rdwr(UIO_READ, nd.ni_vp, ef->shstrtab, 613 shdr[shstrindex].sh_size, shdr[shstrindex].sh_offset, 614 UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 615 &resid, td); 616 if (error) 617 goto out; 618 if (resid != 0){ 619 error = EINVAL; 620 goto out; 621 } 622 } 623 624 /* Size up code/data(progbits) and bss(nobits). */ 625 alignmask = 0; 626 for (i = 0; i < hdr->e_shnum; i++) { 627 switch (shdr[i].sh_type) { 628 case SHT_PROGBITS: 629 case SHT_NOBITS: 630 alignmask = shdr[i].sh_addralign - 1; 631 mapsize += alignmask; 632 mapsize &= ~alignmask; 633 mapsize += shdr[i].sh_size; 634 break; 635 } 636 } 637 638 /* 639 * We know how much space we need for the text/data/bss/etc. 640 * This stuff needs to be in a single chunk so that profiling etc 641 * can get the bounds and gdb can associate offsets with modules 642 */ 643 ef->object = vm_object_allocate(OBJT_DEFAULT, 644 round_page(mapsize) >> PAGE_SHIFT); 645 if (ef->object == NULL) { 646 error = ENOMEM; 647 goto out; 648 } 649 ef->address = (caddr_t) vm_map_min(kernel_map); 650 error = vm_map_find(kernel_map, ef->object, 0, &mapbase, 651 round_page(mapsize), TRUE, VM_PROT_ALL, VM_PROT_ALL, FALSE); 652 if (error) { 653 vm_object_deallocate(ef->object); 654 ef->object = 0; 655 goto out; 656 } 657 658 /* Wire the pages */ 659 error = vm_map_wire(kernel_map, mapbase, 660 mapbase + round_page(mapsize), 661 VM_MAP_WIRE_SYSTEM|VM_MAP_WIRE_NOHOLES); 662 if (error != KERN_SUCCESS) { 663 error = ENOMEM; 664 goto out; 665 } 666 667 /* Inform the kld system about the situation */ 668 lf->address = ef->address = (caddr_t)mapbase; 669 lf->size = mapsize; 670 671 /* 672 * Now load code/data(progbits), zero bss(nobits), allocate space for 673 * and load relocs 674 */ 675 pb = 0; 676 rl = 0; 677 ra = 0; 678 alignmask = 0; 679 for (i = 0; i < hdr->e_shnum; i++) { 680 switch (shdr[i].sh_type) { 681 case SHT_PROGBITS: 682 case SHT_NOBITS: 683 alignmask = shdr[i].sh_addralign - 1; 684 mapbase += alignmask; 685 mapbase &= ~alignmask; 686 ef->progtab[pb].addr = (void *)(uintptr_t)mapbase; 687 if (shdr[i].sh_type == SHT_PROGBITS) { 688 ef->progtab[pb].name = "<<PROGBITS>>"; 689 error = vn_rdwr(UIO_READ, nd.ni_vp, 690 ef->progtab[pb].addr, 691 shdr[i].sh_size, shdr[i].sh_offset, 692 UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, 693 NOCRED, &resid, td); 694 if (error) 695 goto out; 696 if (resid != 0){ 697 error = EINVAL; 698 goto out; 699 } 700 } else { 701 ef->progtab[pb].name = "<<NOBITS>>"; 702 bzero(ef->progtab[pb].addr, shdr[i].sh_size); 703 } 704 ef->progtab[pb].size = shdr[i].sh_size; 705 ef->progtab[pb].sec = i; 706 if (ef->shstrtab && shdr[i].sh_name != 0) 707 ef->progtab[pb].name = 708 ef->shstrtab + shdr[i].sh_name; 709 710 /* Update all symbol values with the offset. */ 711 for (j = 0; j < ef->ddbsymcnt; j++) { 712 es = &ef->ddbsymtab[j]; 713 if (es->st_shndx != i) 714 continue; 715 es->st_value += (Elf_Addr)ef->progtab[pb].addr; 716 } 717 mapbase += shdr[i].sh_size; 718 pb++; 719 break; 720 case SHT_REL: 721 ef->reltab[rl].rel = malloc(shdr[i].sh_size, M_LINKER, 722 M_WAITOK); 723 ef->reltab[rl].nrel = shdr[i].sh_size / sizeof(Elf_Rel); 724 ef->reltab[rl].sec = shdr[i].sh_info; 725 error = vn_rdwr(UIO_READ, nd.ni_vp, 726 (void *)ef->reltab[rl].rel, 727 shdr[i].sh_size, shdr[i].sh_offset, 728 UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 729 &resid, td); 730 if (error) 731 goto out; 732 if (resid != 0){ 733 error = EINVAL; 734 goto out; 735 } 736 rl++; 737 break; 738 case SHT_RELA: 739 ef->relatab[ra].rela = malloc(shdr[i].sh_size, M_LINKER, 740 M_WAITOK); 741 ef->relatab[ra].nrela = 742 shdr[i].sh_size / sizeof(Elf_Rela); 743 ef->relatab[ra].sec = shdr[i].sh_info; 744 error = vn_rdwr(UIO_READ, nd.ni_vp, 745 (void *)ef->relatab[ra].rela, 746 shdr[i].sh_size, shdr[i].sh_offset, 747 UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 748 &resid, td); 749 if (error) 750 goto out; 751 if (resid != 0){ 752 error = EINVAL; 753 goto out; 754 } 755 ra++; 756 break; 757 } 758 } 759 if (pb != ef->nprogtab) 760 panic("lost progbits"); 761 if (rl != ef->nrel) 762 panic("lost rel"); 763 if (ra != ef->nrela) 764 panic("lost rela"); 765 if (mapbase != (vm_offset_t)ef->address + mapsize) 766 panic("mapbase 0x%lx != address %p + mapsize 0x%lx (0x%lx)\n", 767 mapbase, ef->address, mapsize, 768 (vm_offset_t)ef->address + mapsize); 769 770 /* Local intra-module relocations */ 771 link_elf_reloc_local(lf); 772 773 /* Pull in dependencies */ 774 error = linker_load_dependencies(lf); 775 if (error) 776 goto out; 777 778 /* External relocations */ 779 error = relocate_file(ef); 780 if (error) 781 goto out; 782 783 /* Notify MD code that a module is being loaded. */ 784 error = elf_cpu_load_file(lf); 785 if (error) 786 goto out; 787 788 *result = lf; 789 790 out: 791 if (error && lf) 792 linker_file_unload(lf, LINKER_UNLOAD_FORCE); 793 if (hdr) 794 free(hdr, M_LINKER); 795 VOP_UNLOCK(nd.ni_vp, 0); 796 vn_close(nd.ni_vp, FREAD, td->td_ucred, td); 797 VFS_UNLOCK_GIANT(vfslocked); 798 799 return error; 800 } 801 802 static void 803 link_elf_unload_file(linker_file_t file) 804 { 805 elf_file_t ef = (elf_file_t) file; 806 int i; 807 808 /* Notify MD code that a module is being unloaded. */ 809 elf_cpu_unload_file(file); 810 811 if (ef->preloaded) { 812 if (ef->reltab) 813 free(ef->reltab, M_LINKER); 814 if (ef->relatab) 815 free(ef->relatab, M_LINKER); 816 if (ef->progtab) 817 free(ef->progtab, M_LINKER); 818 if (file->filename != NULL) 819 preload_delete_name(file->filename); 820 /* XXX reclaim module memory? */ 821 return; 822 } 823 824 for (i = 0; i < ef->nrel; i++) 825 if (ef->reltab[i].rel) 826 free(ef->reltab[i].rel, M_LINKER); 827 for (i = 0; i < ef->nrela; i++) 828 if (ef->relatab[i].rela) 829 free(ef->relatab[i].rela, M_LINKER); 830 if (ef->reltab) 831 free(ef->reltab, M_LINKER); 832 if (ef->relatab) 833 free(ef->relatab, M_LINKER); 834 if (ef->progtab) 835 free(ef->progtab, M_LINKER); 836 837 if (ef->object) { 838 vm_map_remove(kernel_map, (vm_offset_t) ef->address, 839 (vm_offset_t) ef->address + 840 (ef->object->size << PAGE_SHIFT)); 841 } 842 if (ef->e_shdr) 843 free(ef->e_shdr, M_LINKER); 844 if (ef->ddbsymtab) 845 free(ef->ddbsymtab, M_LINKER); 846 if (ef->ddbstrtab) 847 free(ef->ddbstrtab, M_LINKER); 848 if (ef->shstrtab) 849 free(ef->shstrtab, M_LINKER); 850 } 851 852 static const char * 853 symbol_name(elf_file_t ef, Elf_Size r_info) 854 { 855 const Elf_Sym *ref; 856 857 if (ELF_R_SYM(r_info)) { 858 ref = ef->ddbsymtab + ELF_R_SYM(r_info); 859 return ef->ddbstrtab + ref->st_name; 860 } else 861 return NULL; 862 } 863 864 static Elf_Addr 865 findbase(elf_file_t ef, int sec) 866 { 867 int i; 868 Elf_Addr base = 0; 869 870 for (i = 0; i < ef->nprogtab; i++) { 871 if (sec == ef->progtab[i].sec) { 872 base = (Elf_Addr)ef->progtab[i].addr; 873 break; 874 } 875 } 876 return base; 877 } 878 879 static int 880 relocate_file(elf_file_t ef) 881 { 882 const Elf_Rel *rellim; 883 const Elf_Rel *rel; 884 const Elf_Rela *relalim; 885 const Elf_Rela *rela; 886 const char *symname; 887 const Elf_Sym *sym; 888 int i; 889 Elf_Size symidx; 890 Elf_Addr base; 891 892 893 /* Perform relocations without addend if there are any: */ 894 for (i = 0; i < ef->nrel; i++) { 895 rel = ef->reltab[i].rel; 896 if (rel == NULL) 897 panic("lost a reltab!"); 898 rellim = rel + ef->reltab[i].nrel; 899 base = findbase(ef, ef->reltab[i].sec); 900 if (base == 0) 901 panic("lost base for reltab"); 902 for ( ; rel < rellim; rel++) { 903 symidx = ELF_R_SYM(rel->r_info); 904 if (symidx >= ef->ddbsymcnt) 905 continue; 906 sym = ef->ddbsymtab + symidx; 907 /* Local relocs are already done */ 908 if (ELF_ST_BIND(sym->st_info) == STB_LOCAL) 909 continue; 910 if (elf_reloc(&ef->lf, base, rel, ELF_RELOC_REL, 911 elf_obj_lookup)) { 912 symname = symbol_name(ef, rel->r_info); 913 printf("link_elf_obj: symbol %s undefined\n", 914 symname); 915 return ENOENT; 916 } 917 } 918 } 919 920 /* Perform relocations with addend if there are any: */ 921 for (i = 0; i < ef->nrela; i++) { 922 rela = ef->relatab[i].rela; 923 if (rela == NULL) 924 panic("lost a relatab!"); 925 relalim = rela + ef->relatab[i].nrela; 926 base = findbase(ef, ef->relatab[i].sec); 927 if (base == 0) 928 panic("lost base for relatab"); 929 for ( ; rela < relalim; rela++) { 930 symidx = ELF_R_SYM(rela->r_info); 931 if (symidx >= ef->ddbsymcnt) 932 continue; 933 sym = ef->ddbsymtab + symidx; 934 /* Local relocs are already done */ 935 if (ELF_ST_BIND(sym->st_info) == STB_LOCAL) 936 continue; 937 if (elf_reloc(&ef->lf, base, rela, ELF_RELOC_RELA, 938 elf_obj_lookup)) { 939 symname = symbol_name(ef, rela->r_info); 940 printf("link_elf_obj: symbol %s undefined\n", 941 symname); 942 return ENOENT; 943 } 944 } 945 } 946 947 return 0; 948 } 949 950 static int 951 link_elf_lookup_symbol(linker_file_t lf, const char *name, c_linker_sym_t *sym) 952 { 953 elf_file_t ef = (elf_file_t) lf; 954 const Elf_Sym *symp; 955 const char *strp; 956 int i; 957 958 for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) { 959 strp = ef->ddbstrtab + symp->st_name; 960 if (symp->st_shndx != SHN_UNDEF && strcmp(name, strp) == 0) { 961 *sym = (c_linker_sym_t) symp; 962 return 0; 963 } 964 } 965 return ENOENT; 966 } 967 968 static int 969 link_elf_symbol_values(linker_file_t lf, c_linker_sym_t sym, 970 linker_symval_t *symval) 971 { 972 elf_file_t ef = (elf_file_t) lf; 973 const Elf_Sym *es = (const Elf_Sym*) sym; 974 975 if (es >= ef->ddbsymtab && es < (ef->ddbsymtab + ef->ddbsymcnt)) { 976 symval->name = ef->ddbstrtab + es->st_name; 977 symval->value = (caddr_t)es->st_value; 978 symval->size = es->st_size; 979 return 0; 980 } 981 return ENOENT; 982 } 983 984 static int 985 link_elf_search_symbol(linker_file_t lf, caddr_t value, 986 c_linker_sym_t *sym, long *diffp) 987 { 988 elf_file_t ef = (elf_file_t) lf; 989 u_long off = (uintptr_t) (void *) value; 990 u_long diff = off; 991 u_long st_value; 992 const Elf_Sym *es; 993 const Elf_Sym *best = 0; 994 int i; 995 996 for (i = 0, es = ef->ddbsymtab; i < ef->ddbsymcnt; i++, es++) { 997 if (es->st_name == 0) 998 continue; 999 st_value = es->st_value; 1000 if (off >= st_value) { 1001 if (off - st_value < diff) { 1002 diff = off - st_value; 1003 best = es; 1004 if (diff == 0) 1005 break; 1006 } else if (off - st_value == diff) { 1007 best = es; 1008 } 1009 } 1010 } 1011 if (best == 0) 1012 *diffp = off; 1013 else 1014 *diffp = diff; 1015 *sym = (c_linker_sym_t) best; 1016 1017 return 0; 1018 } 1019 1020 /* 1021 * Look up a linker set on an ELF system. 1022 */ 1023 static int 1024 link_elf_lookup_set(linker_file_t lf, const char *name, 1025 void ***startp, void ***stopp, int *countp) 1026 { 1027 elf_file_t ef = (elf_file_t)lf; 1028 void **start, **stop; 1029 int i, count; 1030 1031 /* Relative to section number */ 1032 for (i = 0; i < ef->nprogtab; i++) { 1033 if ((strncmp(ef->progtab[i].name, "set_", 4) == 0) && 1034 strcmp(ef->progtab[i].name + 4, name) == 0) { 1035 start = (void **)ef->progtab[i].addr; 1036 stop = (void **)((char *)ef->progtab[i].addr + 1037 ef->progtab[i].size); 1038 count = stop - start; 1039 if (startp) 1040 *startp = start; 1041 if (stopp) 1042 *stopp = stop; 1043 if (countp) 1044 *countp = count; 1045 return (0); 1046 } 1047 } 1048 return (ESRCH); 1049 } 1050 1051 static int 1052 link_elf_each_function_name(linker_file_t file, 1053 int (*callback)(const char *, void *), void *opaque) 1054 { 1055 elf_file_t ef = (elf_file_t)file; 1056 const Elf_Sym *symp; 1057 int i, error; 1058 1059 /* Exhaustive search */ 1060 for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) { 1061 if (symp->st_value != 0 && 1062 ELF_ST_TYPE(symp->st_info) == STT_FUNC) { 1063 error = callback(ef->ddbstrtab + symp->st_name, opaque); 1064 if (error) 1065 return (error); 1066 } 1067 } 1068 return (0); 1069 } 1070 1071 /* 1072 * Symbol lookup function that can be used when the symbol index is known (ie 1073 * in relocations). It uses the symbol index instead of doing a fully fledged 1074 * hash table based lookup when such is valid. For example for local symbols. 1075 * This is not only more efficient, it's also more correct. It's not always 1076 * the case that the symbol can be found through the hash table. 1077 */ 1078 static Elf_Addr 1079 elf_obj_lookup(linker_file_t lf, Elf_Size symidx, int deps) 1080 { 1081 elf_file_t ef = (elf_file_t)lf; 1082 const Elf_Sym *sym; 1083 const char *symbol; 1084 Elf_Addr ret; 1085 1086 /* Don't even try to lookup the symbol if the index is bogus. */ 1087 if (symidx >= ef->ddbsymcnt) 1088 return (0); 1089 1090 sym = ef->ddbsymtab + symidx; 1091 1092 /* Quick answer if there is a definition included. */ 1093 if (sym->st_shndx != SHN_UNDEF) 1094 return (sym->st_value); 1095 1096 /* If we get here, then it is undefined and needs a lookup. */ 1097 switch (ELF_ST_BIND(sym->st_info)) { 1098 case STB_LOCAL: 1099 /* Local, but undefined? huh? */ 1100 return (0); 1101 1102 case STB_GLOBAL: 1103 /* Relative to Data or Function name */ 1104 symbol = ef->ddbstrtab + sym->st_name; 1105 1106 /* Force a lookup failure if the symbol name is bogus. */ 1107 if (*symbol == 0) 1108 return (0); 1109 ret = ((Elf_Addr)linker_file_lookup_symbol(lf, symbol, deps)); 1110 return ret; 1111 1112 case STB_WEAK: 1113 printf("link_elf_obj: Weak symbols not supported\n"); 1114 return (0); 1115 1116 default: 1117 return (0); 1118 } 1119 } 1120 1121 static void 1122 link_elf_fix_link_set(elf_file_t ef) 1123 { 1124 static const char startn[] = "__start_"; 1125 static const char stopn[] = "__stop_"; 1126 Elf_Sym *sym; 1127 const char *sym_name, *linkset_name; 1128 Elf_Addr startp, stopp; 1129 Elf_Size symidx; 1130 int start, i; 1131 1132 startp = stopp = 0; 1133 for (symidx = 1 /* zero entry is special */; 1134 symidx < ef->ddbsymcnt; symidx++) { 1135 sym = ef->ddbsymtab + symidx; 1136 if (sym->st_shndx != SHN_UNDEF) 1137 continue; 1138 1139 sym_name = ef->ddbstrtab + sym->st_name; 1140 if (strncmp(sym_name, startn, sizeof(startn) - 1) == 0) { 1141 start = 1; 1142 linkset_name = sym_name + sizeof(startn) - 1; 1143 } 1144 else if (strncmp(sym_name, stopn, sizeof(stopn) - 1) == 0) { 1145 start = 0; 1146 linkset_name = sym_name + sizeof(stopn) - 1; 1147 } 1148 else 1149 continue; 1150 1151 for (i = 0; i < ef->nprogtab; i++) { 1152 if (strcmp(ef->progtab[i].name, linkset_name) == 0) { 1153 startp = (Elf_Addr)ef->progtab[i].addr; 1154 stopp = (Elf_Addr)(startp + ef->progtab[i].size); 1155 break; 1156 } 1157 } 1158 if (i == ef->nprogtab) 1159 continue; 1160 1161 sym->st_value = start ? startp : stopp; 1162 sym->st_shndx = i; 1163 } 1164 } 1165 1166 static void 1167 link_elf_reloc_local(linker_file_t lf) 1168 { 1169 elf_file_t ef = (elf_file_t)lf; 1170 const Elf_Rel *rellim; 1171 const Elf_Rel *rel; 1172 const Elf_Rela *relalim; 1173 const Elf_Rela *rela; 1174 const Elf_Sym *sym; 1175 Elf_Addr base; 1176 int i; 1177 Elf_Size symidx; 1178 1179 link_elf_fix_link_set(ef); 1180 1181 /* Perform relocations without addend if there are any: */ 1182 for (i = 0; i < ef->nrel; i++) { 1183 rel = ef->reltab[i].rel; 1184 if (rel == NULL) 1185 panic("lost a reltab!"); 1186 rellim = rel + ef->reltab[i].nrel; 1187 base = findbase(ef, ef->reltab[i].sec); 1188 if (base == 0) 1189 panic("lost base for reltab"); 1190 for ( ; rel < rellim; rel++) { 1191 symidx = ELF_R_SYM(rel->r_info); 1192 if (symidx >= ef->ddbsymcnt) 1193 continue; 1194 sym = ef->ddbsymtab + symidx; 1195 /* Only do local relocs */ 1196 if (ELF_ST_BIND(sym->st_info) != STB_LOCAL) 1197 continue; 1198 elf_reloc_local(lf, base, rel, ELF_RELOC_REL, 1199 elf_obj_lookup); 1200 } 1201 } 1202 1203 /* Perform relocations with addend if there are any: */ 1204 for (i = 0; i < ef->nrela; i++) { 1205 rela = ef->relatab[i].rela; 1206 if (rela == NULL) 1207 panic("lost a relatab!"); 1208 relalim = rela + ef->relatab[i].nrela; 1209 base = findbase(ef, ef->relatab[i].sec); 1210 if (base == 0) 1211 panic("lost base for relatab"); 1212 for ( ; rela < relalim; rela++) { 1213 symidx = ELF_R_SYM(rela->r_info); 1214 if (symidx >= ef->ddbsymcnt) 1215 continue; 1216 sym = ef->ddbsymtab + symidx; 1217 /* Only do local relocs */ 1218 if (ELF_ST_BIND(sym->st_info) != STB_LOCAL) 1219 continue; 1220 elf_reloc_local(lf, base, rela, ELF_RELOC_RELA, 1221 elf_obj_lookup); 1222 } 1223 } 1224 } 1225