Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/boot/common/load_elf.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /*- 2 * Copyright (c) 1998 Michael Smith <msmith@freebsd.org> 3 * Copyright (c) 1998 Peter Wemm <peter@freebsd.org> 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: releng/8.2/sys/boot/common/load_elf.c 216043 2010-11-29 08:12:21Z attilio $"); 30 31 #include <sys/param.h> 32 #include <sys/exec.h> 33 #include <sys/linker.h> 34 #include <sys/module.h> 35 #include <sys/stdint.h> 36 #include <string.h> 37 #include <machine/elf.h> 38 #include <stand.h> 39 #define FREEBSD_ELF 40 #include <link.h> 41 42 #include "bootstrap.h" 43 44 #define COPYOUT(s,d,l) archsw.arch_copyout((vm_offset_t)(s), d, l) 45 46 #if defined(__i386__) && __ELF_WORD_SIZE == 64 47 #undef ELF_TARG_CLASS 48 #undef ELF_TARG_MACH 49 #define ELF_TARG_CLASS ELFCLASS64 50 #define ELF_TARG_MACH EM_X86_64 51 #endif 52 53 typedef struct elf_file { 54 Elf_Phdr *ph; 55 Elf_Ehdr *ehdr; 56 Elf_Sym *symtab; 57 Elf_Hashelt *hashtab; 58 Elf_Hashelt nbuckets; 59 Elf_Hashelt nchains; 60 Elf_Hashelt *buckets; 61 Elf_Hashelt *chains; 62 Elf_Rel *rel; 63 size_t relsz; 64 Elf_Rela *rela; 65 size_t relasz; 66 char *strtab; 67 size_t strsz; 68 int fd; 69 caddr_t firstpage; 70 size_t firstlen; 71 int kernel; 72 u_int64_t off; 73 } *elf_file_t; 74 75 static int __elfN(loadimage)(struct preloaded_file *mp, elf_file_t ef, u_int64_t loadaddr); 76 static int __elfN(lookup_symbol)(struct preloaded_file *mp, elf_file_t ef, const char* name, Elf_Sym* sym); 77 static int __elfN(reloc_ptr)(struct preloaded_file *mp, elf_file_t ef, 78 Elf_Addr p, void *val, size_t len); 79 static int __elfN(parse_modmetadata)(struct preloaded_file *mp, elf_file_t ef); 80 static symaddr_fn __elfN(symaddr); 81 static char *fake_modname(const char *name); 82 83 const char *__elfN(kerneltype) = "elf kernel"; 84 const char *__elfN(moduletype) = "elf module"; 85 86 u_int64_t __elfN(relocation_offset) = 0; 87 88 /* 89 * Attempt to load the file (file) as an ELF module. It will be stored at 90 * (dest), and a pointer to a module structure describing the loaded object 91 * will be saved in (result). 92 */ 93 int 94 __elfN(loadfile)(char *filename, u_int64_t dest, struct preloaded_file **result) 95 { 96 struct preloaded_file *fp, *kfp; 97 struct elf_file ef; 98 Elf_Ehdr *ehdr; 99 int err; 100 u_int pad; 101 ssize_t bytes_read; 102 103 fp = NULL; 104 bzero(&ef, sizeof(struct elf_file)); 105 106 /* 107 * Open the image, read and validate the ELF header 108 */ 109 if (filename == NULL) /* can't handle nameless */ 110 return(EFTYPE); 111 if ((ef.fd = open(filename, O_RDONLY)) == -1) 112 return(errno); 113 ef.firstpage = malloc(PAGE_SIZE); 114 if (ef.firstpage == NULL) { 115 close(ef.fd); 116 return(ENOMEM); 117 } 118 bytes_read = read(ef.fd, ef.firstpage, PAGE_SIZE); 119 ef.firstlen = (size_t)bytes_read; 120 if (bytes_read < 0 || ef.firstlen <= sizeof(Elf_Ehdr)) { 121 err = EFTYPE; /* could be EIO, but may be small file */ 122 goto oerr; 123 } 124 ehdr = ef.ehdr = (Elf_Ehdr *)ef.firstpage; 125 126 /* Is it ELF? */ 127 if (!IS_ELF(*ehdr)) { 128 err = EFTYPE; 129 goto oerr; 130 } 131 if (ehdr->e_ident[EI_CLASS] != ELF_TARG_CLASS || /* Layout ? */ 132 ehdr->e_ident[EI_DATA] != ELF_TARG_DATA || 133 ehdr->e_ident[EI_VERSION] != EV_CURRENT || /* Version ? */ 134 ehdr->e_version != EV_CURRENT || 135 ehdr->e_machine != ELF_TARG_MACH) { /* Machine ? */ 136 err = EFTYPE; 137 goto oerr; 138 } 139 140 141 /* 142 * Check to see what sort of module we are. 143 */ 144 kfp = file_findfile(NULL, NULL); 145 if (ehdr->e_type == ET_DYN) { 146 /* Looks like a kld module */ 147 if (kfp == NULL) { 148 printf("elf" __XSTRING(__ELF_WORD_SIZE) "_loadfile: can't load module before kernel\n"); 149 err = EPERM; 150 goto oerr; 151 } 152 if (strcmp(__elfN(kerneltype), kfp->f_type)) { 153 printf("elf" __XSTRING(__ELF_WORD_SIZE) "_loadfile: can't load module with kernel type '%s'\n", kfp->f_type); 154 err = EPERM; 155 goto oerr; 156 } 157 /* Looks OK, got ahead */ 158 ef.kernel = 0; 159 160 /* Page-align the load address */ 161 pad = (u_int)dest & PAGE_MASK; 162 if (pad != 0) { 163 pad = PAGE_SIZE - pad; 164 dest += pad; 165 } 166 } else if (ehdr->e_type == ET_EXEC) { 167 /* Looks like a kernel */ 168 if (kfp != NULL) { 169 printf("elf" __XSTRING(__ELF_WORD_SIZE) "_loadfile: kernel already loaded\n"); 170 err = EPERM; 171 goto oerr; 172 } 173 /* 174 * Calculate destination address based on kernel entrypoint 175 */ 176 dest = ehdr->e_entry; 177 if (dest == 0) { 178 printf("elf" __XSTRING(__ELF_WORD_SIZE) "_loadfile: not a kernel (maybe static binary?)\n"); 179 err = EPERM; 180 goto oerr; 181 } 182 ef.kernel = 1; 183 184 } else { 185 err = EFTYPE; 186 goto oerr; 187 } 188 189 /* 190 * Ok, we think we should handle this. 191 */ 192 fp = file_alloc(); 193 if (fp == NULL) { 194 printf("elf" __XSTRING(__ELF_WORD_SIZE) "_loadfile: cannot allocate module info\n"); 195 err = EPERM; 196 goto out; 197 } 198 if (ef.kernel) 199 setenv("kernelname", filename, 1); 200 fp->f_name = strdup(filename); 201 fp->f_type = strdup(ef.kernel ? __elfN(kerneltype) : __elfN(moduletype)); 202 203 #ifdef ELF_VERBOSE 204 if (ef.kernel) 205 printf("%s entry at 0x%jx\n", filename, (uintmax_t)dest); 206 #else 207 printf("%s ", filename); 208 #endif 209 210 fp->f_size = __elfN(loadimage)(fp, &ef, dest); 211 if (fp->f_size == 0 || fp->f_addr == 0) 212 goto ioerr; 213 214 /* save exec header as metadata */ 215 file_addmetadata(fp, MODINFOMD_ELFHDR, sizeof(*ehdr), ehdr); 216 217 /* Load OK, return module pointer */ 218 *result = (struct preloaded_file *)fp; 219 err = 0; 220 goto out; 221 222 ioerr: 223 err = EIO; 224 oerr: 225 file_discard(fp); 226 out: 227 if (ef.firstpage) 228 free(ef.firstpage); 229 close(ef.fd); 230 return(err); 231 } 232 233 /* 234 * With the file (fd) open on the image, and (ehdr) containing 235 * the Elf header, load the image at (off) 236 */ 237 static int 238 __elfN(loadimage)(struct preloaded_file *fp, elf_file_t ef, u_int64_t off) 239 { 240 int i; 241 u_int j; 242 Elf_Ehdr *ehdr; 243 Elf_Phdr *phdr, *php; 244 Elf_Shdr *shdr; 245 int ret; 246 vm_offset_t firstaddr; 247 vm_offset_t lastaddr; 248 size_t chunk; 249 ssize_t result; 250 Elf_Addr ssym, esym; 251 Elf_Dyn *dp; 252 Elf_Addr adp; 253 int ndp; 254 int symstrindex; 255 int symtabindex; 256 Elf_Size size; 257 u_int fpcopy; 258 259 dp = NULL; 260 shdr = NULL; 261 ret = 0; 262 firstaddr = lastaddr = 0; 263 ehdr = ef->ehdr; 264 if (ef->kernel) { 265 #ifdef __i386__ 266 #if __ELF_WORD_SIZE == 64 267 off = - (off & 0xffffffffff000000ull);/* x86_64 relocates after locore */ 268 #else 269 off = - (off & 0xff000000u); /* i386 relocates after locore */ 270 #endif 271 #elif defined(__powerpc__) 272 /* 273 * On the purely virtual memory machines like e500, the kernel is 274 * linked against its final VA range, which is most often not 275 * available at the loader stage, but only after kernel initializes 276 * and completes its VM settings. In such cases we cannot use p_vaddr 277 * field directly to load ELF segments, but put them at some 278 * 'load-time' locations. 279 */ 280 if (off & 0xf0000000u) { 281 off = -(off & 0xf0000000u); 282 /* 283 * XXX the physical load address should not be hardcoded. Note 284 * that the Book-E kernel assumes that it's loaded at a 16MB 285 * boundary for now... 286 */ 287 off += 0x01000000; 288 ehdr->e_entry += off; 289 #ifdef ELF_VERBOSE 290 printf("Converted entry 0x%08x\n", ehdr->e_entry); 291 #endif 292 } else 293 off = 0; 294 #elif defined(__arm__) 295 if (off & 0xf0000000u) { 296 off = -(off & 0xf0000000u); 297 ehdr->e_entry += off; 298 #ifdef ELF_VERBOSE 299 printf("Converted entry 0x%08x\n", ehdr->e_entry); 300 #endif 301 } else 302 off = 0; 303 #else 304 off = 0; /* other archs use direct mapped kernels */ 305 #endif 306 __elfN(relocation_offset) = off; 307 } 308 ef->off = off; 309 310 if ((ehdr->e_phoff + ehdr->e_phnum * sizeof(*phdr)) > ef->firstlen) { 311 printf("elf" __XSTRING(__ELF_WORD_SIZE) "_loadimage: program header not within first page\n"); 312 goto out; 313 } 314 phdr = (Elf_Phdr *)(ef->firstpage + ehdr->e_phoff); 315 316 for (i = 0; i < ehdr->e_phnum; i++) { 317 /* We want to load PT_LOAD segments only.. */ 318 if (phdr[i].p_type != PT_LOAD) 319 continue; 320 321 #ifdef ELF_VERBOSE 322 printf("Segment: 0x%lx@0x%lx -> 0x%lx-0x%lx", 323 (long)phdr[i].p_filesz, (long)phdr[i].p_offset, 324 (long)(phdr[i].p_vaddr + off), 325 (long)(phdr[i].p_vaddr + off + phdr[i].p_memsz - 1)); 326 #else 327 if ((phdr[i].p_flags & PF_W) == 0) { 328 printf("text=0x%lx ", (long)phdr[i].p_filesz); 329 } else { 330 printf("data=0x%lx", (long)phdr[i].p_filesz); 331 if (phdr[i].p_filesz < phdr[i].p_memsz) 332 printf("+0x%lx", (long)(phdr[i].p_memsz -phdr[i].p_filesz)); 333 printf(" "); 334 } 335 #endif 336 fpcopy = 0; 337 if (ef->firstlen > phdr[i].p_offset) { 338 fpcopy = ef->firstlen - phdr[i].p_offset; 339 archsw.arch_copyin(ef->firstpage + phdr[i].p_offset, 340 phdr[i].p_vaddr + off, fpcopy); 341 } 342 if (phdr[i].p_filesz > fpcopy) { 343 if (kern_pread(ef->fd, phdr[i].p_vaddr + off + fpcopy, 344 phdr[i].p_filesz - fpcopy, phdr[i].p_offset + fpcopy) != 0) { 345 printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 346 "_loadimage: read failed\n"); 347 goto out; 348 } 349 } 350 /* clear space from oversized segments; eg: bss */ 351 if (phdr[i].p_filesz < phdr[i].p_memsz) { 352 #ifdef ELF_VERBOSE 353 printf(" (bss: 0x%lx-0x%lx)", 354 (long)(phdr[i].p_vaddr + off + phdr[i].p_filesz), 355 (long)(phdr[i].p_vaddr + off + phdr[i].p_memsz - 1)); 356 #endif 357 358 kern_bzero(phdr[i].p_vaddr + off + phdr[i].p_filesz, 359 phdr[i].p_memsz - phdr[i].p_filesz); 360 } 361 #ifdef ELF_VERBOSE 362 printf("\n"); 363 #endif 364 365 if (firstaddr == 0 || firstaddr > (phdr[i].p_vaddr + off)) 366 firstaddr = phdr[i].p_vaddr + off; 367 if (lastaddr == 0 || lastaddr < (phdr[i].p_vaddr + off + phdr[i].p_memsz)) 368 lastaddr = phdr[i].p_vaddr + off + phdr[i].p_memsz; 369 } 370 lastaddr = roundup(lastaddr, sizeof(long)); 371 372 /* 373 * Now grab the symbol tables. This isn't easy if we're reading a 374 * .gz file. I think the rule is going to have to be that you must 375 * strip a file to remove symbols before gzipping it so that we do not 376 * try to lseek() on it. 377 */ 378 chunk = ehdr->e_shnum * ehdr->e_shentsize; 379 if (chunk == 0 || ehdr->e_shoff == 0) 380 goto nosyms; 381 shdr = alloc_pread(ef->fd, ehdr->e_shoff, chunk); 382 if (shdr == NULL) { 383 printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 384 "_loadimage: failed to read section headers"); 385 goto nosyms; 386 } 387 symtabindex = -1; 388 symstrindex = -1; 389 for (i = 0; i < ehdr->e_shnum; i++) { 390 if (shdr[i].sh_type != SHT_SYMTAB) 391 continue; 392 for (j = 0; j < ehdr->e_phnum; j++) { 393 if (phdr[j].p_type != PT_LOAD) 394 continue; 395 if (shdr[i].sh_offset >= phdr[j].p_offset && 396 (shdr[i].sh_offset + shdr[i].sh_size <= 397 phdr[j].p_offset + phdr[j].p_filesz)) { 398 shdr[i].sh_offset = 0; 399 shdr[i].sh_size = 0; 400 break; 401 } 402 } 403 if (shdr[i].sh_offset == 0 || shdr[i].sh_size == 0) 404 continue; /* alread loaded in a PT_LOAD above */ 405 /* Save it for loading below */ 406 symtabindex = i; 407 symstrindex = shdr[i].sh_link; 408 } 409 if (symtabindex < 0 || symstrindex < 0) 410 goto nosyms; 411 412 /* Ok, committed to a load. */ 413 #ifndef ELF_VERBOSE 414 printf("syms=["); 415 #endif 416 ssym = lastaddr; 417 for (i = symtabindex; i >= 0; i = symstrindex) { 418 #ifdef ELF_VERBOSE 419 char *secname; 420 421 switch(shdr[i].sh_type) { 422 case SHT_SYMTAB: /* Symbol table */ 423 secname = "symtab"; 424 break; 425 case SHT_STRTAB: /* String table */ 426 secname = "strtab"; 427 break; 428 default: 429 secname = "WHOA!!"; 430 break; 431 } 432 #endif 433 434 size = shdr[i].sh_size; 435 archsw.arch_copyin(&size, lastaddr, sizeof(size)); 436 lastaddr += sizeof(size); 437 438 #ifdef ELF_VERBOSE 439 printf("\n%s: 0x%jx@0x%jx -> 0x%jx-0x%jx", secname, 440 (uintmax_t)shdr[i].sh_size, (uintmax_t)shdr[i].sh_offset, 441 (uintmax_t)lastaddr, (uintmax_t)(lastaddr + shdr[i].sh_size)); 442 #else 443 if (i == symstrindex) 444 printf("+"); 445 printf("0x%lx+0x%lx", (long)sizeof(size), (long)size); 446 #endif 447 448 if (lseek(ef->fd, (off_t)shdr[i].sh_offset, SEEK_SET) == -1) { 449 printf("\nelf" __XSTRING(__ELF_WORD_SIZE) "_loadimage: could not seek for symbols - skipped!"); 450 lastaddr = ssym; 451 ssym = 0; 452 goto nosyms; 453 } 454 result = archsw.arch_readin(ef->fd, lastaddr, shdr[i].sh_size); 455 if (result < 0 || (size_t)result != shdr[i].sh_size) { 456 printf("\nelf" __XSTRING(__ELF_WORD_SIZE) "_loadimage: could not read symbols - skipped! (%ju != %ju)", (uintmax_t)result, 457 (uintmax_t)shdr[i].sh_size); 458 lastaddr = ssym; 459 ssym = 0; 460 goto nosyms; 461 } 462 /* Reset offsets relative to ssym */ 463 lastaddr += shdr[i].sh_size; 464 lastaddr = roundup(lastaddr, sizeof(size)); 465 if (i == symtabindex) 466 symtabindex = -1; 467 else if (i == symstrindex) 468 symstrindex = -1; 469 } 470 esym = lastaddr; 471 #ifndef ELF_VERBOSE 472 printf("]"); 473 #endif 474 475 file_addmetadata(fp, MODINFOMD_SSYM, sizeof(ssym), &ssym); 476 file_addmetadata(fp, MODINFOMD_ESYM, sizeof(esym), &esym); 477 478 nosyms: 479 printf("\n"); 480 481 ret = lastaddr - firstaddr; 482 fp->f_addr = firstaddr; 483 484 php = NULL; 485 for (i = 0; i < ehdr->e_phnum; i++) { 486 if (phdr[i].p_type == PT_DYNAMIC) { 487 php = phdr + i; 488 adp = php->p_vaddr; 489 file_addmetadata(fp, MODINFOMD_DYNAMIC, sizeof(adp), &adp); 490 break; 491 } 492 } 493 494 if (php == NULL) /* this is bad, we cannot get to symbols or _DYNAMIC */ 495 goto out; 496 497 ndp = php->p_filesz / sizeof(Elf_Dyn); 498 if (ndp == 0) 499 goto out; 500 dp = malloc(php->p_filesz); 501 if (dp == NULL) 502 goto out; 503 archsw.arch_copyout(php->p_vaddr + off, dp, php->p_filesz); 504 505 ef->strsz = 0; 506 for (i = 0; i < ndp; i++) { 507 if (dp[i].d_tag == 0) 508 break; 509 switch (dp[i].d_tag) { 510 case DT_HASH: 511 ef->hashtab = (Elf_Hashelt*)(uintptr_t)(dp[i].d_un.d_ptr + off); 512 break; 513 case DT_STRTAB: 514 ef->strtab = (char *)(uintptr_t)(dp[i].d_un.d_ptr + off); 515 break; 516 case DT_STRSZ: 517 ef->strsz = dp[i].d_un.d_val; 518 break; 519 case DT_SYMTAB: 520 ef->symtab = (Elf_Sym*)(uintptr_t)(dp[i].d_un.d_ptr + off); 521 break; 522 case DT_REL: 523 ef->rel = (Elf_Rel *)(uintptr_t)(dp[i].d_un.d_ptr + off); 524 break; 525 case DT_RELSZ: 526 ef->relsz = dp[i].d_un.d_val; 527 break; 528 case DT_RELA: 529 ef->rela = (Elf_Rela *)(uintptr_t)(dp[i].d_un.d_ptr + off); 530 break; 531 case DT_RELASZ: 532 ef->relasz = dp[i].d_un.d_val; 533 break; 534 default: 535 break; 536 } 537 } 538 if (ef->hashtab == NULL || ef->symtab == NULL || 539 ef->strtab == NULL || ef->strsz == 0) 540 goto out; 541 COPYOUT(ef->hashtab, &ef->nbuckets, sizeof(ef->nbuckets)); 542 COPYOUT(ef->hashtab + 1, &ef->nchains, sizeof(ef->nchains)); 543 ef->buckets = ef->hashtab + 2; 544 ef->chains = ef->buckets + ef->nbuckets; 545 if (__elfN(parse_modmetadata)(fp, ef) == 0) 546 goto out; 547 548 if (ef->kernel) /* kernel must not depend on anything */ 549 goto out; 550 551 out: 552 if (dp) 553 free(dp); 554 if (shdr) 555 free(shdr); 556 return ret; 557 } 558 559 static char invalid_name[] = "bad"; 560 561 char * 562 fake_modname(const char *name) 563 { 564 const char *sp, *ep; 565 char *fp; 566 size_t len; 567 568 sp = strrchr(name, '/'); 569 if (sp) 570 sp++; 571 else 572 sp = name; 573 ep = strrchr(name, '.'); 574 if (ep) { 575 if (ep == name) { 576 sp = invalid_name; 577 ep = invalid_name + sizeof(invalid_name) - 1; 578 } 579 } else 580 ep = name + strlen(name); 581 len = ep - sp; 582 fp = malloc(len + 1); 583 if (fp == NULL) 584 return NULL; 585 memcpy(fp, sp, len); 586 fp[len] = '\0'; 587 return fp; 588 } 589 590 #if defined(__i386__) && __ELF_WORD_SIZE == 64 591 struct mod_metadata64 { 592 int md_version; /* structure version MDTV_* */ 593 int md_type; /* type of entry MDT_* */ 594 u_int64_t md_data; /* specific data */ 595 u_int64_t md_cval; /* common string label */ 596 }; 597 #endif 598 599 int 600 __elfN(parse_modmetadata)(struct preloaded_file *fp, elf_file_t ef) 601 { 602 struct mod_metadata md; 603 #if defined(__i386__) && __ELF_WORD_SIZE == 64 604 struct mod_metadata64 md64; 605 #endif 606 struct mod_depend *mdepend; 607 struct mod_version mver; 608 Elf_Sym sym; 609 char *s; 610 int error, modcnt, minfolen; 611 Elf_Addr v, p, p_stop; 612 613 if (__elfN(lookup_symbol)(fp, ef, "__start_set_modmetadata_set", &sym) != 0) 614 return ENOENT; 615 p = sym.st_value + ef->off; 616 if (__elfN(lookup_symbol)(fp, ef, "__stop_set_modmetadata_set", &sym) != 0) 617 return ENOENT; 618 p_stop = sym.st_value + ef->off; 619 620 modcnt = 0; 621 while (p < p_stop) { 622 COPYOUT(p, &v, sizeof(v)); 623 error = __elfN(reloc_ptr)(fp, ef, p, &v, sizeof(v)); 624 if (error == EOPNOTSUPP) 625 v += ef->off; 626 else if (error != 0) 627 return (error); 628 #if defined(__i386__) && __ELF_WORD_SIZE == 64 629 COPYOUT(v, &md64, sizeof(md64)); 630 error = __elfN(reloc_ptr)(fp, ef, v, &md64, sizeof(md64)); 631 if (error == EOPNOTSUPP) { 632 md64.md_cval += ef->off; 633 md64.md_data += ef->off; 634 } else if (error != 0) 635 return (error); 636 md.md_version = md64.md_version; 637 md.md_type = md64.md_type; 638 md.md_cval = (const char *)(uintptr_t)md64.md_cval; 639 md.md_data = (void *)(uintptr_t)md64.md_data; 640 #else 641 COPYOUT(v, &md, sizeof(md)); 642 error = __elfN(reloc_ptr)(fp, ef, v, &md, sizeof(md)); 643 if (error == EOPNOTSUPP) { 644 md.md_cval += ef->off; 645 md.md_data += ef->off; 646 } else if (error != 0) 647 return (error); 648 #endif 649 p += sizeof(Elf_Addr); 650 switch(md.md_type) { 651 case MDT_DEPEND: 652 if (ef->kernel) /* kernel must not depend on anything */ 653 break; 654 s = strdupout((vm_offset_t)md.md_cval); 655 minfolen = sizeof(*mdepend) + strlen(s) + 1; 656 mdepend = malloc(minfolen); 657 if (mdepend == NULL) 658 return ENOMEM; 659 COPYOUT((vm_offset_t)md.md_data, mdepend, sizeof(*mdepend)); 660 strcpy((char*)(mdepend + 1), s); 661 free(s); 662 file_addmetadata(fp, MODINFOMD_DEPLIST, minfolen, mdepend); 663 free(mdepend); 664 break; 665 case MDT_VERSION: 666 s = strdupout((vm_offset_t)md.md_cval); 667 COPYOUT((vm_offset_t)md.md_data, &mver, sizeof(mver)); 668 file_addmodule(fp, s, mver.mv_version, NULL); 669 free(s); 670 modcnt++; 671 break; 672 } 673 } 674 if (modcnt == 0) { 675 s = fake_modname(fp->f_name); 676 file_addmodule(fp, s, 1, NULL); 677 free(s); 678 } 679 return 0; 680 } 681 682 static unsigned long 683 elf_hash(const char *name) 684 { 685 const unsigned char *p = (const unsigned char *) name; 686 unsigned long h = 0; 687 unsigned long g; 688 689 while (*p != '\0') { 690 h = (h << 4) + *p++; 691 if ((g = h & 0xf0000000) != 0) 692 h ^= g >> 24; 693 h &= ~g; 694 } 695 return h; 696 } 697 698 static const char __elfN(bad_symtable)[] = "elf" __XSTRING(__ELF_WORD_SIZE) "_lookup_symbol: corrupt symbol table\n"; 699 int 700 __elfN(lookup_symbol)(struct preloaded_file *fp, elf_file_t ef, const char* name, 701 Elf_Sym *symp) 702 { 703 Elf_Hashelt symnum; 704 Elf_Sym sym; 705 char *strp; 706 unsigned long hash; 707 708 hash = elf_hash(name); 709 COPYOUT(&ef->buckets[hash % ef->nbuckets], &symnum, sizeof(symnum)); 710 711 while (symnum != STN_UNDEF) { 712 if (symnum >= ef->nchains) { 713 printf(__elfN(bad_symtable)); 714 return ENOENT; 715 } 716 717 COPYOUT(ef->symtab + symnum, &sym, sizeof(sym)); 718 if (sym.st_name == 0) { 719 printf(__elfN(bad_symtable)); 720 return ENOENT; 721 } 722 723 strp = strdupout((vm_offset_t)(ef->strtab + sym.st_name)); 724 if (strcmp(name, strp) == 0) { 725 free(strp); 726 if (sym.st_shndx != SHN_UNDEF || 727 (sym.st_value != 0 && 728 ELF_ST_TYPE(sym.st_info) == STT_FUNC)) { 729 *symp = sym; 730 return 0; 731 } 732 return ENOENT; 733 } 734 free(strp); 735 COPYOUT(&ef->chains[symnum], &symnum, sizeof(symnum)); 736 } 737 return ENOENT; 738 } 739 740 /* 741 * Apply any intra-module relocations to the value. p is the load address 742 * of the value and val/len is the value to be modified. This does NOT modify 743 * the image in-place, because this is done by kern_linker later on. 744 * 745 * Returns EOPNOTSUPP if no relocation method is supplied. 746 */ 747 static int 748 __elfN(reloc_ptr)(struct preloaded_file *mp, elf_file_t ef, 749 Elf_Addr p, void *val, size_t len) 750 { 751 size_t n; 752 Elf_Rela a; 753 Elf_Rel r; 754 int error; 755 756 /* 757 * The kernel is already relocated, but we still want to apply 758 * offset adjustments. 759 */ 760 if (ef->kernel) 761 return (EOPNOTSUPP); 762 763 for (n = 0; n < ef->relsz / sizeof(r); n++) { 764 COPYOUT(ef->rel + n, &r, sizeof(r)); 765 766 error = __elfN(reloc)(ef, __elfN(symaddr), &r, ELF_RELOC_REL, 767 ef->off, p, val, len); 768 if (error != 0) 769 return (error); 770 } 771 for (n = 0; n < ef->relasz / sizeof(a); n++) { 772 COPYOUT(ef->rela + n, &a, sizeof(a)); 773 774 error = __elfN(reloc)(ef, __elfN(symaddr), &a, ELF_RELOC_RELA, 775 ef->off, p, val, len); 776 if (error != 0) 777 return (error); 778 } 779 780 return (0); 781 } 782 783 static Elf_Addr 784 __elfN(symaddr)(struct elf_file *ef, Elf_Size symidx) 785 { 786 787 /* Symbol lookup by index not required here. */ 788 return (0); 789 }
Cache object: baa789d5f39aa8c5d641f8391472e09a
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]