1ca987d46SWarner Losh /*- 2ca987d46SWarner Losh * Copyright (c) 1998 Michael Smith <msmith@freebsd.org> 3ca987d46SWarner Losh * Copyright (c) 1998 Peter Wemm <peter@freebsd.org> 4ca987d46SWarner Losh * All rights reserved. 5ca987d46SWarner Losh * 6ca987d46SWarner Losh * Redistribution and use in source and binary forms, with or without 7ca987d46SWarner Losh * modification, are permitted provided that the following conditions 8ca987d46SWarner Losh * are met: 9ca987d46SWarner Losh * 1. Redistributions of source code must retain the above copyright 10ca987d46SWarner Losh * notice, this list of conditions and the following disclaimer. 11ca987d46SWarner Losh * 2. Redistributions in binary form must reproduce the above copyright 12ca987d46SWarner Losh * notice, this list of conditions and the following disclaimer in the 13ca987d46SWarner Losh * documentation and/or other materials provided with the distribution. 14ca987d46SWarner Losh * 15ca987d46SWarner Losh * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16ca987d46SWarner Losh * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17ca987d46SWarner Losh * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18ca987d46SWarner Losh * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19ca987d46SWarner Losh * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20ca987d46SWarner Losh * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21ca987d46SWarner Losh * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22ca987d46SWarner Losh * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23ca987d46SWarner Losh * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24ca987d46SWarner Losh * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25ca987d46SWarner Losh * SUCH DAMAGE. 26ca987d46SWarner Losh */ 27ca987d46SWarner Losh 28ca987d46SWarner Losh #include <sys/cdefs.h> 29ca987d46SWarner Losh __FBSDID("$FreeBSD$"); 30ca987d46SWarner Losh 31ca987d46SWarner Losh #include <sys/param.h> 328de1ad0bSWojciech Macek #include <sys/endian.h> 33ca987d46SWarner Losh #include <sys/exec.h> 34ca987d46SWarner Losh #include <sys/linker.h> 35ca987d46SWarner Losh #include <sys/module.h> 36ca987d46SWarner Losh #include <sys/stdint.h> 37ca987d46SWarner Losh #include <string.h> 38ca987d46SWarner Losh #include <machine/elf.h> 39ca987d46SWarner Losh #include <stand.h> 40ca987d46SWarner Losh #define FREEBSD_ELF 41f38658e1SWarner Losh #include <sys/link_elf.h> 42ca987d46SWarner Losh 43ca987d46SWarner Losh #include "bootstrap.h" 44ca987d46SWarner Losh 45ca987d46SWarner Losh #define COPYOUT(s,d,l) archsw.arch_copyout((vm_offset_t)(s), d, l) 46ca987d46SWarner Losh 47ca987d46SWarner Losh #if defined(__i386__) && __ELF_WORD_SIZE == 64 48ca987d46SWarner Losh #undef ELF_TARG_CLASS 49ca987d46SWarner Losh #undef ELF_TARG_MACH 50ca987d46SWarner Losh #define ELF_TARG_CLASS ELFCLASS64 51ca987d46SWarner Losh #define ELF_TARG_MACH EM_X86_64 52ca987d46SWarner Losh #endif 53ca987d46SWarner Losh 54ca987d46SWarner Losh typedef struct elf_file { 55ca987d46SWarner Losh Elf_Phdr *ph; 56ca987d46SWarner Losh Elf_Ehdr *ehdr; 57ca987d46SWarner Losh Elf_Sym *symtab; 58ca987d46SWarner Losh Elf_Hashelt *hashtab; 59ca987d46SWarner Losh Elf_Hashelt nbuckets; 60ca987d46SWarner Losh Elf_Hashelt nchains; 61ca987d46SWarner Losh Elf_Hashelt *buckets; 62ca987d46SWarner Losh Elf_Hashelt *chains; 63ca987d46SWarner Losh Elf_Rel *rel; 64ca987d46SWarner Losh size_t relsz; 65ca987d46SWarner Losh Elf_Rela *rela; 66ca987d46SWarner Losh size_t relasz; 67ca987d46SWarner Losh char *strtab; 68ca987d46SWarner Losh size_t strsz; 69ca987d46SWarner Losh int fd; 70ca987d46SWarner Losh caddr_t firstpage; 71ca987d46SWarner Losh size_t firstlen; 72ca987d46SWarner Losh int kernel; 73ca987d46SWarner Losh u_int64_t off; 74ca987d46SWarner Losh } *elf_file_t; 75ca987d46SWarner Losh 76ca987d46SWarner Losh static int __elfN(loadimage)(struct preloaded_file *mp, elf_file_t ef, u_int64_t loadaddr); 77ca987d46SWarner Losh static int __elfN(lookup_symbol)(struct preloaded_file *mp, elf_file_t ef, const char* name, Elf_Sym* sym); 78ca987d46SWarner Losh static int __elfN(reloc_ptr)(struct preloaded_file *mp, elf_file_t ef, 79ca987d46SWarner Losh Elf_Addr p, void *val, size_t len); 80ca987d46SWarner Losh static int __elfN(parse_modmetadata)(struct preloaded_file *mp, elf_file_t ef, 81ca987d46SWarner Losh Elf_Addr p_start, Elf_Addr p_end); 82ca987d46SWarner Losh static symaddr_fn __elfN(symaddr); 83ca987d46SWarner Losh static char *fake_modname(const char *name); 84ca987d46SWarner Losh 85ca987d46SWarner Losh const char *__elfN(kerneltype) = "elf kernel"; 86ca987d46SWarner Losh const char *__elfN(moduletype) = "elf module"; 87ca987d46SWarner Losh 88ca987d46SWarner Losh u_int64_t __elfN(relocation_offset) = 0; 89ca987d46SWarner Losh 9012363d8eSRoger Pau Monné extern void elf_wrong_field_size(void); 9112363d8eSRoger Pau Monné #define CONVERT_FIELD(b, f, e) \ 9212363d8eSRoger Pau Monné switch (sizeof((b)->f)) { \ 9312363d8eSRoger Pau Monné case 2: \ 9412363d8eSRoger Pau Monné (b)->f = e ## 16toh((b)->f); \ 9512363d8eSRoger Pau Monné break; \ 9612363d8eSRoger Pau Monné case 4: \ 9712363d8eSRoger Pau Monné (b)->f = e ## 32toh((b)->f); \ 9812363d8eSRoger Pau Monné break; \ 9912363d8eSRoger Pau Monné case 8: \ 10012363d8eSRoger Pau Monné (b)->f = e ## 64toh((b)->f); \ 10112363d8eSRoger Pau Monné break; \ 10212363d8eSRoger Pau Monné default: \ 10312363d8eSRoger Pau Monné /* Force a link time error. */ \ 10412363d8eSRoger Pau Monné elf_wrong_field_size(); \ 10512363d8eSRoger Pau Monné break; \ 10612363d8eSRoger Pau Monné } 10712363d8eSRoger Pau Monné 10812363d8eSRoger Pau Monné #define CONVERT_SWITCH(h, d, f) \ 10912363d8eSRoger Pau Monné switch ((h)->e_ident[EI_DATA]) { \ 11012363d8eSRoger Pau Monné case ELFDATA2MSB: \ 11112363d8eSRoger Pau Monné f(d, be); \ 11212363d8eSRoger Pau Monné break; \ 11312363d8eSRoger Pau Monné case ELFDATA2LSB: \ 11412363d8eSRoger Pau Monné f(d, le); \ 11512363d8eSRoger Pau Monné break; \ 11612363d8eSRoger Pau Monné default: \ 11712363d8eSRoger Pau Monné return (EINVAL); \ 11812363d8eSRoger Pau Monné } 11912363d8eSRoger Pau Monné 12012363d8eSRoger Pau Monné 12112363d8eSRoger Pau Monné static int elf_header_convert(Elf_Ehdr *ehdr) 12212363d8eSRoger Pau Monné { 12312363d8eSRoger Pau Monné /* 12412363d8eSRoger Pau Monné * Fixup ELF header endianness. 12512363d8eSRoger Pau Monné * 12612363d8eSRoger Pau Monné * The Xhdr structure was loaded using block read call to optimize file 12712363d8eSRoger Pau Monné * accesses. It might happen, that the endianness of the system memory 12812363d8eSRoger Pau Monné * is different that endianness of the ELF header. Swap fields here to 12912363d8eSRoger Pau Monné * guarantee that Xhdr always contain valid data regardless of 13012363d8eSRoger Pau Monné * architecture. 13112363d8eSRoger Pau Monné */ 13212363d8eSRoger Pau Monné #define HEADER_FIELDS(b, e) \ 13312363d8eSRoger Pau Monné CONVERT_FIELD(b, e_type, e); \ 13412363d8eSRoger Pau Monné CONVERT_FIELD(b, e_machine, e); \ 13512363d8eSRoger Pau Monné CONVERT_FIELD(b, e_version, e); \ 13612363d8eSRoger Pau Monné CONVERT_FIELD(b, e_entry, e); \ 13712363d8eSRoger Pau Monné CONVERT_FIELD(b, e_phoff, e); \ 13812363d8eSRoger Pau Monné CONVERT_FIELD(b, e_shoff, e); \ 13912363d8eSRoger Pau Monné CONVERT_FIELD(b, e_flags, e); \ 14012363d8eSRoger Pau Monné CONVERT_FIELD(b, e_ehsize, e); \ 14112363d8eSRoger Pau Monné CONVERT_FIELD(b, e_phentsize, e); \ 14212363d8eSRoger Pau Monné CONVERT_FIELD(b, e_phnum, e); \ 14312363d8eSRoger Pau Monné CONVERT_FIELD(b, e_shentsize, e); \ 14412363d8eSRoger Pau Monné CONVERT_FIELD(b, e_shnum, e); \ 14512363d8eSRoger Pau Monné CONVERT_FIELD(b, e_shstrndx, e) 14612363d8eSRoger Pau Monné 14712363d8eSRoger Pau Monné CONVERT_SWITCH(ehdr, ehdr, HEADER_FIELDS); 14812363d8eSRoger Pau Monné 14912363d8eSRoger Pau Monné #undef HEADER_FIELDS 15012363d8eSRoger Pau Monné 15112363d8eSRoger Pau Monné return (0); 15212363d8eSRoger Pau Monné } 15312363d8eSRoger Pau Monné 15412363d8eSRoger Pau Monné static int elf_program_header_convert(const Elf_Ehdr *ehdr, Elf_Phdr *phdr) 15512363d8eSRoger Pau Monné { 15612363d8eSRoger Pau Monné #define PROGRAM_HEADER_FIELDS(b, e) \ 15712363d8eSRoger Pau Monné CONVERT_FIELD(b, p_type, e); \ 15812363d8eSRoger Pau Monné CONVERT_FIELD(b, p_flags, e); \ 15912363d8eSRoger Pau Monné CONVERT_FIELD(b, p_offset, e); \ 16012363d8eSRoger Pau Monné CONVERT_FIELD(b, p_vaddr, e); \ 16112363d8eSRoger Pau Monné CONVERT_FIELD(b, p_paddr, e); \ 16212363d8eSRoger Pau Monné CONVERT_FIELD(b, p_filesz, e); \ 16312363d8eSRoger Pau Monné CONVERT_FIELD(b, p_memsz, e); \ 16412363d8eSRoger Pau Monné CONVERT_FIELD(b, p_align, e) 16512363d8eSRoger Pau Monné 16612363d8eSRoger Pau Monné CONVERT_SWITCH(ehdr, phdr, PROGRAM_HEADER_FIELDS); 16712363d8eSRoger Pau Monné 16812363d8eSRoger Pau Monné #undef PROGRAM_HEADER_FIELDS 16912363d8eSRoger Pau Monné 17012363d8eSRoger Pau Monné return (0); 17112363d8eSRoger Pau Monné } 17212363d8eSRoger Pau Monné 17312363d8eSRoger Pau Monné static int elf_section_header_convert(const Elf_Ehdr *ehdr, Elf_Shdr *shdr) 17412363d8eSRoger Pau Monné { 17512363d8eSRoger Pau Monné #define SECTION_HEADER_FIELDS(b, e) \ 17612363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_name, e); \ 17712363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_type, e); \ 17812363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_link, e); \ 17912363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_info, e); \ 18012363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_flags, e); \ 18112363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_addr, e); \ 18212363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_offset, e); \ 18312363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_size, e); \ 18412363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_addralign, e); \ 18512363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_entsize, e) 18612363d8eSRoger Pau Monné 18712363d8eSRoger Pau Monné CONVERT_SWITCH(ehdr, shdr, SECTION_HEADER_FIELDS); 18812363d8eSRoger Pau Monné 18912363d8eSRoger Pau Monné #undef SECTION_HEADER_FIELDS 19012363d8eSRoger Pau Monné 19112363d8eSRoger Pau Monné return (0); 19212363d8eSRoger Pau Monné } 19312363d8eSRoger Pau Monné #undef CONVERT_SWITCH 19412363d8eSRoger Pau Monné #undef CONVERT_FIELD 19512363d8eSRoger Pau Monné 196ca987d46SWarner Losh static int 197ca987d46SWarner Losh __elfN(load_elf_header)(char *filename, elf_file_t ef) 198ca987d46SWarner Losh { 199ca987d46SWarner Losh ssize_t bytes_read; 200ca987d46SWarner Losh Elf_Ehdr *ehdr; 201ca987d46SWarner Losh int err; 202ca987d46SWarner Losh 203ca987d46SWarner Losh /* 204ca987d46SWarner Losh * Open the image, read and validate the ELF header 205ca987d46SWarner Losh */ 206ca987d46SWarner Losh if (filename == NULL) /* can't handle nameless */ 207ca987d46SWarner Losh return (EFTYPE); 208ca987d46SWarner Losh if ((ef->fd = open(filename, O_RDONLY)) == -1) 209ca987d46SWarner Losh return (errno); 210ca987d46SWarner Losh ef->firstpage = malloc(PAGE_SIZE); 211ca987d46SWarner Losh if (ef->firstpage == NULL) { 212ca987d46SWarner Losh close(ef->fd); 213ca987d46SWarner Losh return (ENOMEM); 214ca987d46SWarner Losh } 215ca987d46SWarner Losh bytes_read = read(ef->fd, ef->firstpage, PAGE_SIZE); 216ca987d46SWarner Losh ef->firstlen = (size_t)bytes_read; 217ca987d46SWarner Losh if (bytes_read < 0 || ef->firstlen <= sizeof(Elf_Ehdr)) { 218ca987d46SWarner Losh err = EFTYPE; /* could be EIO, but may be small file */ 219ca987d46SWarner Losh goto error; 220ca987d46SWarner Losh } 221ca987d46SWarner Losh ehdr = ef->ehdr = (Elf_Ehdr *)ef->firstpage; 222ca987d46SWarner Losh 223ca987d46SWarner Losh /* Is it ELF? */ 224ca987d46SWarner Losh if (!IS_ELF(*ehdr)) { 225ca987d46SWarner Losh err = EFTYPE; 226ca987d46SWarner Losh goto error; 227ca987d46SWarner Losh } 2288de1ad0bSWojciech Macek 229ca987d46SWarner Losh if (ehdr->e_ident[EI_CLASS] != ELF_TARG_CLASS || /* Layout ? */ 230ca987d46SWarner Losh ehdr->e_ident[EI_DATA] != ELF_TARG_DATA || 2318de1ad0bSWojciech Macek ehdr->e_ident[EI_VERSION] != EV_CURRENT) /* Version ? */ { 2328de1ad0bSWojciech Macek err = EFTYPE; 2338de1ad0bSWojciech Macek goto error; 2348de1ad0bSWojciech Macek } 2358de1ad0bSWojciech Macek 23612363d8eSRoger Pau Monné err = elf_header_convert(ehdr); 23712363d8eSRoger Pau Monné if (err) 23812363d8eSRoger Pau Monné goto error; 2398de1ad0bSWojciech Macek 2408de1ad0bSWojciech Macek if (ehdr->e_version != EV_CURRENT || ehdr->e_machine != ELF_TARG_MACH) { /* Machine ? */ 241ca987d46SWarner Losh err = EFTYPE; 242ca987d46SWarner Losh goto error; 243ca987d46SWarner Losh } 244ca987d46SWarner Losh 245ca987d46SWarner Losh return (0); 246ca987d46SWarner Losh 247ca987d46SWarner Losh error: 248ca987d46SWarner Losh if (ef->firstpage != NULL) { 249ca987d46SWarner Losh free(ef->firstpage); 250ca987d46SWarner Losh ef->firstpage = NULL; 251ca987d46SWarner Losh } 252ca987d46SWarner Losh if (ef->fd != -1) { 253ca987d46SWarner Losh close(ef->fd); 254ca987d46SWarner Losh ef->fd = -1; 255ca987d46SWarner Losh } 256ca987d46SWarner Losh return (err); 257ca987d46SWarner Losh } 258ca987d46SWarner Losh 259ca987d46SWarner Losh /* 260ca987d46SWarner Losh * Attempt to load the file (file) as an ELF module. It will be stored at 261ca987d46SWarner Losh * (dest), and a pointer to a module structure describing the loaded object 262ca987d46SWarner Losh * will be saved in (result). 263ca987d46SWarner Losh */ 264ca987d46SWarner Losh int 265ca987d46SWarner Losh __elfN(loadfile)(char *filename, u_int64_t dest, struct preloaded_file **result) 266ca987d46SWarner Losh { 267ca987d46SWarner Losh return (__elfN(loadfile_raw)(filename, dest, result, 0)); 268ca987d46SWarner Losh } 269ca987d46SWarner Losh 270ca987d46SWarner Losh int 271ca987d46SWarner Losh __elfN(loadfile_raw)(char *filename, u_int64_t dest, 272ca987d46SWarner Losh struct preloaded_file **result, int multiboot) 273ca987d46SWarner Losh { 274ca987d46SWarner Losh struct preloaded_file *fp, *kfp; 275ca987d46SWarner Losh struct elf_file ef; 276ca987d46SWarner Losh Elf_Ehdr *ehdr; 277ca987d46SWarner Losh int err; 278ca987d46SWarner Losh 279ca987d46SWarner Losh fp = NULL; 280ca987d46SWarner Losh bzero(&ef, sizeof(struct elf_file)); 281ca987d46SWarner Losh ef.fd = -1; 282ca987d46SWarner Losh 283ca987d46SWarner Losh err = __elfN(load_elf_header)(filename, &ef); 284ca987d46SWarner Losh if (err != 0) 285ca987d46SWarner Losh return (err); 286ca987d46SWarner Losh 287ca987d46SWarner Losh ehdr = ef.ehdr; 288ca987d46SWarner Losh 289ca987d46SWarner Losh /* 290ca987d46SWarner Losh * Check to see what sort of module we are. 291ca987d46SWarner Losh */ 292ca987d46SWarner Losh kfp = file_findfile(NULL, __elfN(kerneltype)); 293ca987d46SWarner Losh #ifdef __powerpc__ 294ca987d46SWarner Losh /* 295ca987d46SWarner Losh * Kernels can be ET_DYN, so just assume the first loaded object is the 296ca987d46SWarner Losh * kernel. This assumption will be checked later. 297ca987d46SWarner Losh */ 298ca987d46SWarner Losh if (kfp == NULL) 299ca987d46SWarner Losh ef.kernel = 1; 300ca987d46SWarner Losh #endif 301ca987d46SWarner Losh if (ef.kernel || ehdr->e_type == ET_EXEC) { 302ca987d46SWarner Losh /* Looks like a kernel */ 303ca987d46SWarner Losh if (kfp != NULL) { 304ca987d46SWarner Losh printf("elf" __XSTRING(__ELF_WORD_SIZE) "_loadfile: kernel already loaded\n"); 305ca987d46SWarner Losh err = EPERM; 306ca987d46SWarner Losh goto oerr; 307ca987d46SWarner Losh } 308ca987d46SWarner Losh /* 309ca987d46SWarner Losh * Calculate destination address based on kernel entrypoint. 310ca987d46SWarner Losh * 311ca987d46SWarner Losh * For ARM, the destination address is independent of any values in the 312ca987d46SWarner Losh * elf header (an ARM kernel can be loaded at any 2MB boundary), so we 313ca987d46SWarner Losh * leave dest set to the value calculated by archsw.arch_loadaddr() and 314ca987d46SWarner Losh * passed in to this function. 315ca987d46SWarner Losh */ 316ca987d46SWarner Losh #ifndef __arm__ 317ca987d46SWarner Losh if (ehdr->e_type == ET_EXEC) 318ca987d46SWarner Losh dest = (ehdr->e_entry & ~PAGE_MASK); 319ca987d46SWarner Losh #endif 320ca987d46SWarner Losh if ((ehdr->e_entry & ~PAGE_MASK) == 0) { 321ca987d46SWarner Losh printf("elf" __XSTRING(__ELF_WORD_SIZE) "_loadfile: not a kernel (maybe static binary?)\n"); 322ca987d46SWarner Losh err = EPERM; 323ca987d46SWarner Losh goto oerr; 324ca987d46SWarner Losh } 325ca987d46SWarner Losh ef.kernel = 1; 326ca987d46SWarner Losh 327ca987d46SWarner Losh } else if (ehdr->e_type == ET_DYN) { 328ca987d46SWarner Losh /* Looks like a kld module */ 329ca987d46SWarner Losh if (multiboot != 0) { 330ca987d46SWarner Losh printf("elf" __XSTRING(__ELF_WORD_SIZE) "_loadfile: can't load module as multiboot\n"); 331ca987d46SWarner Losh err = EPERM; 332ca987d46SWarner Losh goto oerr; 333ca987d46SWarner Losh } 334ca987d46SWarner Losh if (kfp == NULL) { 335ca987d46SWarner Losh printf("elf" __XSTRING(__ELF_WORD_SIZE) "_loadfile: can't load module before kernel\n"); 336ca987d46SWarner Losh err = EPERM; 337ca987d46SWarner Losh goto oerr; 338ca987d46SWarner Losh } 339ca987d46SWarner Losh if (strcmp(__elfN(kerneltype), kfp->f_type)) { 340ca987d46SWarner Losh printf("elf" __XSTRING(__ELF_WORD_SIZE) "_loadfile: can't load module with kernel type '%s'\n", kfp->f_type); 341ca987d46SWarner Losh err = EPERM; 342ca987d46SWarner Losh goto oerr; 343ca987d46SWarner Losh } 344ca987d46SWarner Losh /* Looks OK, got ahead */ 345ca987d46SWarner Losh ef.kernel = 0; 346ca987d46SWarner Losh 347ca987d46SWarner Losh } else { 348ca987d46SWarner Losh err = EFTYPE; 349ca987d46SWarner Losh goto oerr; 350ca987d46SWarner Losh } 351ca987d46SWarner Losh 352ca987d46SWarner Losh if (archsw.arch_loadaddr != NULL) 353ca987d46SWarner Losh dest = archsw.arch_loadaddr(LOAD_ELF, ehdr, dest); 354ca987d46SWarner Losh else 355ca987d46SWarner Losh dest = roundup(dest, PAGE_SIZE); 356ca987d46SWarner Losh 357ca987d46SWarner Losh /* 358ca987d46SWarner Losh * Ok, we think we should handle this. 359ca987d46SWarner Losh */ 360ca987d46SWarner Losh fp = file_alloc(); 361ca987d46SWarner Losh if (fp == NULL) { 362ca987d46SWarner Losh printf("elf" __XSTRING(__ELF_WORD_SIZE) "_loadfile: cannot allocate module info\n"); 363ca987d46SWarner Losh err = EPERM; 364ca987d46SWarner Losh goto out; 365ca987d46SWarner Losh } 366ca987d46SWarner Losh if (ef.kernel == 1 && multiboot == 0) 367ca987d46SWarner Losh setenv("kernelname", filename, 1); 368ca987d46SWarner Losh fp->f_name = strdup(filename); 369ca987d46SWarner Losh if (multiboot == 0) 370ca987d46SWarner Losh fp->f_type = strdup(ef.kernel ? 371ca987d46SWarner Losh __elfN(kerneltype) : __elfN(moduletype)); 372ca987d46SWarner Losh else 373ca987d46SWarner Losh fp->f_type = strdup("elf multiboot kernel"); 374ca987d46SWarner Losh 375ca987d46SWarner Losh #ifdef ELF_VERBOSE 376ca987d46SWarner Losh if (ef.kernel) 377ca987d46SWarner Losh printf("%s entry at 0x%jx\n", filename, (uintmax_t)ehdr->e_entry); 378ca987d46SWarner Losh #else 379ca987d46SWarner Losh printf("%s ", filename); 380ca987d46SWarner Losh #endif 381ca987d46SWarner Losh 382ca987d46SWarner Losh fp->f_size = __elfN(loadimage)(fp, &ef, dest); 383ca987d46SWarner Losh if (fp->f_size == 0 || fp->f_addr == 0) 384ca987d46SWarner Losh goto ioerr; 385ca987d46SWarner Losh 386ca987d46SWarner Losh /* save exec header as metadata */ 387ca987d46SWarner Losh file_addmetadata(fp, MODINFOMD_ELFHDR, sizeof(*ehdr), ehdr); 388ca987d46SWarner Losh 389ca987d46SWarner Losh /* Load OK, return module pointer */ 390ca987d46SWarner Losh *result = (struct preloaded_file *)fp; 391ca987d46SWarner Losh err = 0; 392ca987d46SWarner Losh goto out; 393ca987d46SWarner Losh 394ca987d46SWarner Losh ioerr: 395ca987d46SWarner Losh err = EIO; 396ca987d46SWarner Losh oerr: 397ca987d46SWarner Losh file_discard(fp); 398ca987d46SWarner Losh out: 399ca987d46SWarner Losh if (ef.firstpage) 400ca987d46SWarner Losh free(ef.firstpage); 401ca987d46SWarner Losh if (ef.fd != -1) 402ca987d46SWarner Losh close(ef.fd); 403ca987d46SWarner Losh return(err); 404ca987d46SWarner Losh } 405ca987d46SWarner Losh 406ca987d46SWarner Losh /* 407ca987d46SWarner Losh * With the file (fd) open on the image, and (ehdr) containing 408ca987d46SWarner Losh * the Elf header, load the image at (off) 409ca987d46SWarner Losh */ 410ca987d46SWarner Losh static int 411ca987d46SWarner Losh __elfN(loadimage)(struct preloaded_file *fp, elf_file_t ef, u_int64_t off) 412ca987d46SWarner Losh { 413ca987d46SWarner Losh int i; 414ca987d46SWarner Losh u_int j; 415ca987d46SWarner Losh Elf_Ehdr *ehdr; 416ca987d46SWarner Losh Elf_Phdr *phdr, *php; 417ca987d46SWarner Losh Elf_Shdr *shdr; 418ca987d46SWarner Losh char *shstr; 419ca987d46SWarner Losh int ret; 420ca987d46SWarner Losh vm_offset_t firstaddr; 421ca987d46SWarner Losh vm_offset_t lastaddr; 422ca987d46SWarner Losh size_t chunk; 423ca987d46SWarner Losh ssize_t result; 424ca987d46SWarner Losh Elf_Addr ssym, esym; 425ca987d46SWarner Losh Elf_Dyn *dp; 426ca987d46SWarner Losh Elf_Addr adp; 427ca987d46SWarner Losh Elf_Addr ctors; 428ca987d46SWarner Losh int ndp; 429ca987d46SWarner Losh int symstrindex; 430ca987d46SWarner Losh int symtabindex; 431ca987d46SWarner Losh Elf_Size size; 432ca987d46SWarner Losh u_int fpcopy; 433ca987d46SWarner Losh Elf_Sym sym; 434ca987d46SWarner Losh Elf_Addr p_start, p_end; 435ca987d46SWarner Losh 436ca987d46SWarner Losh dp = NULL; 437ca987d46SWarner Losh shdr = NULL; 438ca987d46SWarner Losh ret = 0; 439ca987d46SWarner Losh firstaddr = lastaddr = 0; 440ca987d46SWarner Losh ehdr = ef->ehdr; 441ca987d46SWarner Losh if (ehdr->e_type == ET_EXEC) { 442ca987d46SWarner Losh #if defined(__i386__) || defined(__amd64__) 443ca987d46SWarner Losh #if __ELF_WORD_SIZE == 64 444ca987d46SWarner Losh off = - (off & 0xffffffffff000000ull);/* x86_64 relocates after locore */ 445ca987d46SWarner Losh #else 446ca987d46SWarner Losh off = - (off & 0xff000000u); /* i386 relocates after locore */ 447ca987d46SWarner Losh #endif 448ca987d46SWarner Losh #elif defined(__powerpc__) 449ca987d46SWarner Losh /* 450ca987d46SWarner Losh * On the purely virtual memory machines like e500, the kernel is 451ca987d46SWarner Losh * linked against its final VA range, which is most often not 452ca987d46SWarner Losh * available at the loader stage, but only after kernel initializes 453ca987d46SWarner Losh * and completes its VM settings. In such cases we cannot use p_vaddr 454ca987d46SWarner Losh * field directly to load ELF segments, but put them at some 455ca987d46SWarner Losh * 'load-time' locations. 456ca987d46SWarner Losh */ 457ca987d46SWarner Losh if (off & 0xf0000000u) { 458ca987d46SWarner Losh off = -(off & 0xf0000000u); 459ca987d46SWarner Losh /* 460ca987d46SWarner Losh * XXX the physical load address should not be hardcoded. Note 461ca987d46SWarner Losh * that the Book-E kernel assumes that it's loaded at a 16MB 462ca987d46SWarner Losh * boundary for now... 463ca987d46SWarner Losh */ 464ca987d46SWarner Losh off += 0x01000000; 465ca987d46SWarner Losh ehdr->e_entry += off; 466ca987d46SWarner Losh #ifdef ELF_VERBOSE 467ca987d46SWarner Losh printf("Converted entry 0x%08x\n", ehdr->e_entry); 468ca987d46SWarner Losh #endif 469ca987d46SWarner Losh } else 470ca987d46SWarner Losh off = 0; 471ca987d46SWarner Losh #elif defined(__arm__) && !defined(EFI) 472ca987d46SWarner Losh /* 473ca987d46SWarner Losh * The elf headers in arm kernels specify virtual addresses in all 474ca987d46SWarner Losh * header fields, even the ones that should be physical addresses. 475ca987d46SWarner Losh * We assume the entry point is in the first page, and masking the page 476ca987d46SWarner Losh * offset will leave us with the virtual address the kernel was linked 477ca987d46SWarner Losh * at. We subtract that from the load offset, making 'off' into the 478ca987d46SWarner Losh * value which, when added to a virtual address in an elf header, 479ca987d46SWarner Losh * translates it to a physical address. We do the va->pa conversion on 480ca987d46SWarner Losh * the entry point address in the header now, so that later we can 481ca987d46SWarner Losh * launch the kernel by just jumping to that address. 482ca987d46SWarner Losh * 483ca987d46SWarner Losh * When booting from UEFI the copyin and copyout functions handle 484ca987d46SWarner Losh * adjusting the location relative to the first virtual address. 485ca987d46SWarner Losh * Because of this there is no need to adjust the offset or entry 486ca987d46SWarner Losh * point address as these will both be handled by the efi code. 487ca987d46SWarner Losh */ 488ca987d46SWarner Losh off -= ehdr->e_entry & ~PAGE_MASK; 489ca987d46SWarner Losh ehdr->e_entry += off; 490ca987d46SWarner Losh #ifdef ELF_VERBOSE 491ca987d46SWarner Losh printf("ehdr->e_entry 0x%08x, va<->pa off %llx\n", ehdr->e_entry, off); 492ca987d46SWarner Losh #endif 493ca987d46SWarner Losh #else 494ca987d46SWarner Losh off = 0; /* other archs use direct mapped kernels */ 495ca987d46SWarner Losh #endif 496ca987d46SWarner Losh } 497ca987d46SWarner Losh ef->off = off; 498ca987d46SWarner Losh 499ca987d46SWarner Losh if (ef->kernel) 500ca987d46SWarner Losh __elfN(relocation_offset) = off; 501ca987d46SWarner Losh 502ca987d46SWarner Losh if ((ehdr->e_phoff + ehdr->e_phnum * sizeof(*phdr)) > ef->firstlen) { 503ca987d46SWarner Losh printf("elf" __XSTRING(__ELF_WORD_SIZE) "_loadimage: program header not within first page\n"); 504ca987d46SWarner Losh goto out; 505ca987d46SWarner Losh } 506ca987d46SWarner Losh phdr = (Elf_Phdr *)(ef->firstpage + ehdr->e_phoff); 507ca987d46SWarner Losh 508ca987d46SWarner Losh for (i = 0; i < ehdr->e_phnum; i++) { 50912363d8eSRoger Pau Monné if (elf_program_header_convert(ehdr, phdr)) 51012363d8eSRoger Pau Monné continue; 5118de1ad0bSWojciech Macek 512ca987d46SWarner Losh /* We want to load PT_LOAD segments only.. */ 513ca987d46SWarner Losh if (phdr[i].p_type != PT_LOAD) 514ca987d46SWarner Losh continue; 515ca987d46SWarner Losh 516ca987d46SWarner Losh #ifdef ELF_VERBOSE 517ca987d46SWarner Losh printf("Segment: 0x%lx@0x%lx -> 0x%lx-0x%lx", 518ca987d46SWarner Losh (long)phdr[i].p_filesz, (long)phdr[i].p_offset, 519ca987d46SWarner Losh (long)(phdr[i].p_vaddr + off), 520ca987d46SWarner Losh (long)(phdr[i].p_vaddr + off + phdr[i].p_memsz - 1)); 521ca987d46SWarner Losh #else 522ca987d46SWarner Losh if ((phdr[i].p_flags & PF_W) == 0) { 523ca987d46SWarner Losh printf("text=0x%lx ", (long)phdr[i].p_filesz); 524ca987d46SWarner Losh } else { 525ca987d46SWarner Losh printf("data=0x%lx", (long)phdr[i].p_filesz); 526ca987d46SWarner Losh if (phdr[i].p_filesz < phdr[i].p_memsz) 527ca987d46SWarner Losh printf("+0x%lx", (long)(phdr[i].p_memsz -phdr[i].p_filesz)); 528ca987d46SWarner Losh printf(" "); 529ca987d46SWarner Losh } 530ca987d46SWarner Losh #endif 531ca987d46SWarner Losh fpcopy = 0; 532ca987d46SWarner Losh if (ef->firstlen > phdr[i].p_offset) { 533ca987d46SWarner Losh fpcopy = ef->firstlen - phdr[i].p_offset; 534ca987d46SWarner Losh archsw.arch_copyin(ef->firstpage + phdr[i].p_offset, 535ca987d46SWarner Losh phdr[i].p_vaddr + off, fpcopy); 536ca987d46SWarner Losh } 537ca987d46SWarner Losh if (phdr[i].p_filesz > fpcopy) { 538ca987d46SWarner Losh if (kern_pread(ef->fd, phdr[i].p_vaddr + off + fpcopy, 539ca987d46SWarner Losh phdr[i].p_filesz - fpcopy, phdr[i].p_offset + fpcopy) != 0) { 540ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 541ca987d46SWarner Losh "_loadimage: read failed\n"); 542ca987d46SWarner Losh goto out; 543ca987d46SWarner Losh } 544ca987d46SWarner Losh } 545ca987d46SWarner Losh /* clear space from oversized segments; eg: bss */ 546ca987d46SWarner Losh if (phdr[i].p_filesz < phdr[i].p_memsz) { 547ca987d46SWarner Losh #ifdef ELF_VERBOSE 548ca987d46SWarner Losh printf(" (bss: 0x%lx-0x%lx)", 549ca987d46SWarner Losh (long)(phdr[i].p_vaddr + off + phdr[i].p_filesz), 550ca987d46SWarner Losh (long)(phdr[i].p_vaddr + off + phdr[i].p_memsz - 1)); 551ca987d46SWarner Losh #endif 552ca987d46SWarner Losh 553ca987d46SWarner Losh kern_bzero(phdr[i].p_vaddr + off + phdr[i].p_filesz, 554ca987d46SWarner Losh phdr[i].p_memsz - phdr[i].p_filesz); 555ca987d46SWarner Losh } 556ca987d46SWarner Losh #ifdef ELF_VERBOSE 557ca987d46SWarner Losh printf("\n"); 558ca987d46SWarner Losh #endif 559ca987d46SWarner Losh 560ca987d46SWarner Losh if (archsw.arch_loadseg != NULL) 561ca987d46SWarner Losh archsw.arch_loadseg(ehdr, phdr + i, off); 562ca987d46SWarner Losh 563ca987d46SWarner Losh if (firstaddr == 0 || firstaddr > (phdr[i].p_vaddr + off)) 564ca987d46SWarner Losh firstaddr = phdr[i].p_vaddr + off; 565ca987d46SWarner Losh if (lastaddr == 0 || lastaddr < (phdr[i].p_vaddr + off + phdr[i].p_memsz)) 566ca987d46SWarner Losh lastaddr = phdr[i].p_vaddr + off + phdr[i].p_memsz; 567ca987d46SWarner Losh } 568ca987d46SWarner Losh lastaddr = roundup(lastaddr, sizeof(long)); 569ca987d46SWarner Losh 570ca987d46SWarner Losh /* 571ca987d46SWarner Losh * Get the section headers. We need this for finding the .ctors 572ca987d46SWarner Losh * section as well as for loading any symbols. Both may be hard 573ca987d46SWarner Losh * to do if reading from a .gz file as it involves seeking. I 574ca987d46SWarner Losh * think the rule is going to have to be that you must strip a 575ca987d46SWarner Losh * file to remove symbols before gzipping it. 576ca987d46SWarner Losh */ 577db711744SWarner Losh chunk = (size_t)ehdr->e_shnum * (size_t)ehdr->e_shentsize; 578ca987d46SWarner Losh if (chunk == 0 || ehdr->e_shoff == 0) 579ca987d46SWarner Losh goto nosyms; 580ca987d46SWarner Losh shdr = alloc_pread(ef->fd, ehdr->e_shoff, chunk); 581ca987d46SWarner Losh if (shdr == NULL) { 582ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 583ca987d46SWarner Losh "_loadimage: failed to read section headers"); 584ca987d46SWarner Losh goto nosyms; 585ca987d46SWarner Losh } 5868de1ad0bSWojciech Macek 58712363d8eSRoger Pau Monné for (i = 0; i < ehdr->e_shnum; i++) 58812363d8eSRoger Pau Monné elf_section_header_convert(ehdr, &shdr[i]); 5895cca46a9SEd Maste 590ca987d46SWarner Losh file_addmetadata(fp, MODINFOMD_SHDR, chunk, shdr); 591ca987d46SWarner Losh 592ca987d46SWarner Losh /* 593ca987d46SWarner Losh * Read the section string table and look for the .ctors section. 594ca987d46SWarner Losh * We need to tell the kernel where it is so that it can call the 595ca987d46SWarner Losh * ctors. 596ca987d46SWarner Losh */ 597ca987d46SWarner Losh chunk = shdr[ehdr->e_shstrndx].sh_size; 598ca987d46SWarner Losh if (chunk) { 599ca987d46SWarner Losh shstr = alloc_pread(ef->fd, shdr[ehdr->e_shstrndx].sh_offset, chunk); 600ca987d46SWarner Losh if (shstr) { 601ca987d46SWarner Losh for (i = 0; i < ehdr->e_shnum; i++) { 602ca987d46SWarner Losh if (strcmp(shstr + shdr[i].sh_name, ".ctors") != 0) 603ca987d46SWarner Losh continue; 604ca987d46SWarner Losh ctors = shdr[i].sh_addr; 605ca987d46SWarner Losh file_addmetadata(fp, MODINFOMD_CTORS_ADDR, sizeof(ctors), 606ca987d46SWarner Losh &ctors); 607ca987d46SWarner Losh size = shdr[i].sh_size; 608ca987d46SWarner Losh file_addmetadata(fp, MODINFOMD_CTORS_SIZE, sizeof(size), 609ca987d46SWarner Losh &size); 610ca987d46SWarner Losh break; 611ca987d46SWarner Losh } 612ca987d46SWarner Losh free(shstr); 613ca987d46SWarner Losh } 614ca987d46SWarner Losh } 615ca987d46SWarner Losh 616ca987d46SWarner Losh /* 617ca987d46SWarner Losh * Now load any symbols. 618ca987d46SWarner Losh */ 619ca987d46SWarner Losh symtabindex = -1; 620ca987d46SWarner Losh symstrindex = -1; 621ca987d46SWarner Losh for (i = 0; i < ehdr->e_shnum; i++) { 622ca987d46SWarner Losh if (shdr[i].sh_type != SHT_SYMTAB) 623ca987d46SWarner Losh continue; 624ca987d46SWarner Losh for (j = 0; j < ehdr->e_phnum; j++) { 625ca987d46SWarner Losh if (phdr[j].p_type != PT_LOAD) 626ca987d46SWarner Losh continue; 627ca987d46SWarner Losh if (shdr[i].sh_offset >= phdr[j].p_offset && 628ca987d46SWarner Losh (shdr[i].sh_offset + shdr[i].sh_size <= 629ca987d46SWarner Losh phdr[j].p_offset + phdr[j].p_filesz)) { 630ca987d46SWarner Losh shdr[i].sh_offset = 0; 631ca987d46SWarner Losh shdr[i].sh_size = 0; 632ca987d46SWarner Losh break; 633ca987d46SWarner Losh } 634ca987d46SWarner Losh } 635ca987d46SWarner Losh if (shdr[i].sh_offset == 0 || shdr[i].sh_size == 0) 636ca987d46SWarner Losh continue; /* alread loaded in a PT_LOAD above */ 637ca987d46SWarner Losh /* Save it for loading below */ 638ca987d46SWarner Losh symtabindex = i; 639ca987d46SWarner Losh symstrindex = shdr[i].sh_link; 640ca987d46SWarner Losh } 641ca987d46SWarner Losh if (symtabindex < 0 || symstrindex < 0) 642ca987d46SWarner Losh goto nosyms; 643ca987d46SWarner Losh 644ca987d46SWarner Losh /* Ok, committed to a load. */ 645ca987d46SWarner Losh #ifndef ELF_VERBOSE 646ca987d46SWarner Losh printf("syms=["); 647ca987d46SWarner Losh #endif 648ca987d46SWarner Losh ssym = lastaddr; 649ca987d46SWarner Losh for (i = symtabindex; i >= 0; i = symstrindex) { 650ca987d46SWarner Losh #ifdef ELF_VERBOSE 651ca987d46SWarner Losh char *secname; 652ca987d46SWarner Losh 653ca987d46SWarner Losh switch(shdr[i].sh_type) { 654ca987d46SWarner Losh case SHT_SYMTAB: /* Symbol table */ 655ca987d46SWarner Losh secname = "symtab"; 656ca987d46SWarner Losh break; 657ca987d46SWarner Losh case SHT_STRTAB: /* String table */ 658ca987d46SWarner Losh secname = "strtab"; 659ca987d46SWarner Losh break; 660ca987d46SWarner Losh default: 661ca987d46SWarner Losh secname = "WHOA!!"; 662ca987d46SWarner Losh break; 663ca987d46SWarner Losh } 664ca987d46SWarner Losh #endif 665ca987d46SWarner Losh size = shdr[i].sh_size; 6668de1ad0bSWojciech Macek #if defined(__powerpc__) 6678de1ad0bSWojciech Macek #if __ELF_WORD_SIZE == 64 6685cca46a9SEd Maste size = htobe64(size); 6698de1ad0bSWojciech Macek #else 6705cca46a9SEd Maste size = htobe32(size); 6718de1ad0bSWojciech Macek #endif 6728de1ad0bSWojciech Macek #endif 6735cca46a9SEd Maste 6745cca46a9SEd Maste archsw.arch_copyin(&size, lastaddr, sizeof(size)); 6755cca46a9SEd Maste lastaddr += sizeof(size); 676ca987d46SWarner Losh 677ca987d46SWarner Losh #ifdef ELF_VERBOSE 678ca987d46SWarner Losh printf("\n%s: 0x%jx@0x%jx -> 0x%jx-0x%jx", secname, 679ca987d46SWarner Losh (uintmax_t)shdr[i].sh_size, (uintmax_t)shdr[i].sh_offset, 680ca987d46SWarner Losh (uintmax_t)lastaddr, (uintmax_t)(lastaddr + shdr[i].sh_size)); 681ca987d46SWarner Losh #else 682ca987d46SWarner Losh if (i == symstrindex) 683ca987d46SWarner Losh printf("+"); 684ca987d46SWarner Losh printf("0x%lx+0x%lx", (long)sizeof(size), (long)size); 685ca987d46SWarner Losh #endif 686ca987d46SWarner Losh 687ca987d46SWarner Losh if (lseek(ef->fd, (off_t)shdr[i].sh_offset, SEEK_SET) == -1) { 688ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) "_loadimage: could not seek for symbols - skipped!"); 689ca987d46SWarner Losh lastaddr = ssym; 690ca987d46SWarner Losh ssym = 0; 691ca987d46SWarner Losh goto nosyms; 692ca987d46SWarner Losh } 693ca987d46SWarner Losh result = archsw.arch_readin(ef->fd, lastaddr, shdr[i].sh_size); 694ca987d46SWarner Losh if (result < 0 || (size_t)result != shdr[i].sh_size) { 695ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) "_loadimage: could not read symbols - skipped! (%ju != %ju)", (uintmax_t)result, 696ca987d46SWarner Losh (uintmax_t)shdr[i].sh_size); 697ca987d46SWarner Losh lastaddr = ssym; 698ca987d46SWarner Losh ssym = 0; 699ca987d46SWarner Losh goto nosyms; 700ca987d46SWarner Losh } 701ca987d46SWarner Losh /* Reset offsets relative to ssym */ 702ca987d46SWarner Losh lastaddr += shdr[i].sh_size; 703ca987d46SWarner Losh lastaddr = roundup(lastaddr, sizeof(size)); 704ca987d46SWarner Losh if (i == symtabindex) 705ca987d46SWarner Losh symtabindex = -1; 706ca987d46SWarner Losh else if (i == symstrindex) 707ca987d46SWarner Losh symstrindex = -1; 708ca987d46SWarner Losh } 709ca987d46SWarner Losh esym = lastaddr; 710ca987d46SWarner Losh #ifndef ELF_VERBOSE 711ca987d46SWarner Losh printf("]"); 712ca987d46SWarner Losh #endif 713ca987d46SWarner Losh 7148de1ad0bSWojciech Macek #if defined(__powerpc__) 7158de1ad0bSWojciech Macek /* On PowerPC we always need to provide BE data to the kernel */ 7168de1ad0bSWojciech Macek #if __ELF_WORD_SIZE == 64 7175cca46a9SEd Maste ssym = htobe64((uint64_t)ssym); 7185cca46a9SEd Maste esym = htobe64((uint64_t)esym); 7198de1ad0bSWojciech Macek #else 7205cca46a9SEd Maste ssym = htobe32((uint32_t)ssym); 7215cca46a9SEd Maste esym = htobe32((uint32_t)esym); 7228de1ad0bSWojciech Macek #endif 7238de1ad0bSWojciech Macek #endif 7248de1ad0bSWojciech Macek 7255cca46a9SEd Maste file_addmetadata(fp, MODINFOMD_SSYM, sizeof(ssym), &ssym); 7265cca46a9SEd Maste file_addmetadata(fp, MODINFOMD_ESYM, sizeof(esym), &esym); 727ca987d46SWarner Losh 728ca987d46SWarner Losh nosyms: 729ca987d46SWarner Losh printf("\n"); 730ca987d46SWarner Losh 731ca987d46SWarner Losh ret = lastaddr - firstaddr; 732ca987d46SWarner Losh fp->f_addr = firstaddr; 733ca987d46SWarner Losh 734ca987d46SWarner Losh php = NULL; 735ca987d46SWarner Losh for (i = 0; i < ehdr->e_phnum; i++) { 736ca987d46SWarner Losh if (phdr[i].p_type == PT_DYNAMIC) { 737ca987d46SWarner Losh php = phdr + i; 738ca987d46SWarner Losh adp = php->p_vaddr; 739ca987d46SWarner Losh file_addmetadata(fp, MODINFOMD_DYNAMIC, sizeof(adp), &adp); 740ca987d46SWarner Losh break; 741ca987d46SWarner Losh } 742ca987d46SWarner Losh } 743ca987d46SWarner Losh 744ca987d46SWarner Losh if (php == NULL) /* this is bad, we cannot get to symbols or _DYNAMIC */ 745ca987d46SWarner Losh goto out; 746ca987d46SWarner Losh 747ca987d46SWarner Losh ndp = php->p_filesz / sizeof(Elf_Dyn); 748ca987d46SWarner Losh if (ndp == 0) 749ca987d46SWarner Losh goto out; 750ca987d46SWarner Losh dp = malloc(php->p_filesz); 751ca987d46SWarner Losh if (dp == NULL) 752ca987d46SWarner Losh goto out; 753ca987d46SWarner Losh archsw.arch_copyout(php->p_vaddr + off, dp, php->p_filesz); 754ca987d46SWarner Losh 755ca987d46SWarner Losh ef->strsz = 0; 756ca987d46SWarner Losh for (i = 0; i < ndp; i++) { 757ca987d46SWarner Losh if (dp[i].d_tag == 0) 758ca987d46SWarner Losh break; 759ca987d46SWarner Losh switch (dp[i].d_tag) { 760ca987d46SWarner Losh case DT_HASH: 761ca987d46SWarner Losh ef->hashtab = (Elf_Hashelt*)(uintptr_t)(dp[i].d_un.d_ptr + off); 762ca987d46SWarner Losh break; 763ca987d46SWarner Losh case DT_STRTAB: 764ca987d46SWarner Losh ef->strtab = (char *)(uintptr_t)(dp[i].d_un.d_ptr + off); 765ca987d46SWarner Losh break; 766ca987d46SWarner Losh case DT_STRSZ: 767ca987d46SWarner Losh ef->strsz = dp[i].d_un.d_val; 768ca987d46SWarner Losh break; 769ca987d46SWarner Losh case DT_SYMTAB: 770ca987d46SWarner Losh ef->symtab = (Elf_Sym*)(uintptr_t)(dp[i].d_un.d_ptr + off); 771ca987d46SWarner Losh break; 772ca987d46SWarner Losh case DT_REL: 773ca987d46SWarner Losh ef->rel = (Elf_Rel *)(uintptr_t)(dp[i].d_un.d_ptr + off); 774ca987d46SWarner Losh break; 775ca987d46SWarner Losh case DT_RELSZ: 776ca987d46SWarner Losh ef->relsz = dp[i].d_un.d_val; 777ca987d46SWarner Losh break; 778ca987d46SWarner Losh case DT_RELA: 779ca987d46SWarner Losh ef->rela = (Elf_Rela *)(uintptr_t)(dp[i].d_un.d_ptr + off); 780ca987d46SWarner Losh break; 781ca987d46SWarner Losh case DT_RELASZ: 782ca987d46SWarner Losh ef->relasz = dp[i].d_un.d_val; 783ca987d46SWarner Losh break; 784ca987d46SWarner Losh default: 785ca987d46SWarner Losh break; 786ca987d46SWarner Losh } 787ca987d46SWarner Losh } 788ca987d46SWarner Losh if (ef->hashtab == NULL || ef->symtab == NULL || 789ca987d46SWarner Losh ef->strtab == NULL || ef->strsz == 0) 790ca987d46SWarner Losh goto out; 791ca987d46SWarner Losh COPYOUT(ef->hashtab, &ef->nbuckets, sizeof(ef->nbuckets)); 792ca987d46SWarner Losh COPYOUT(ef->hashtab + 1, &ef->nchains, sizeof(ef->nchains)); 793ca987d46SWarner Losh ef->buckets = ef->hashtab + 2; 794ca987d46SWarner Losh ef->chains = ef->buckets + ef->nbuckets; 795ca987d46SWarner Losh 796ca987d46SWarner Losh if (__elfN(lookup_symbol)(fp, ef, "__start_set_modmetadata_set", &sym) != 0) 797ca987d46SWarner Losh return 0; 798ca987d46SWarner Losh p_start = sym.st_value + ef->off; 799ca987d46SWarner Losh if (__elfN(lookup_symbol)(fp, ef, "__stop_set_modmetadata_set", &sym) != 0) 800ca987d46SWarner Losh return ENOENT; 801ca987d46SWarner Losh p_end = sym.st_value + ef->off; 802ca987d46SWarner Losh 803ca987d46SWarner Losh if (__elfN(parse_modmetadata)(fp, ef, p_start, p_end) == 0) 804ca987d46SWarner Losh goto out; 805ca987d46SWarner Losh 806ca987d46SWarner Losh if (ef->kernel) /* kernel must not depend on anything */ 807ca987d46SWarner Losh goto out; 808ca987d46SWarner Losh 809ca987d46SWarner Losh out: 810ca987d46SWarner Losh if (dp) 811ca987d46SWarner Losh free(dp); 812ca987d46SWarner Losh if (shdr) 813ca987d46SWarner Losh free(shdr); 814ca987d46SWarner Losh return ret; 815ca987d46SWarner Losh } 816ca987d46SWarner Losh 817ca987d46SWarner Losh static char invalid_name[] = "bad"; 818ca987d46SWarner Losh 819ca987d46SWarner Losh char * 820ca987d46SWarner Losh fake_modname(const char *name) 821ca987d46SWarner Losh { 822ca987d46SWarner Losh const char *sp, *ep; 823ca987d46SWarner Losh char *fp; 824ca987d46SWarner Losh size_t len; 825ca987d46SWarner Losh 826ca987d46SWarner Losh sp = strrchr(name, '/'); 827ca987d46SWarner Losh if (sp) 828ca987d46SWarner Losh sp++; 829ca987d46SWarner Losh else 830ca987d46SWarner Losh sp = name; 831ca987d46SWarner Losh ep = strrchr(name, '.'); 832ca987d46SWarner Losh if (ep) { 833ca987d46SWarner Losh if (ep == name) { 834ca987d46SWarner Losh sp = invalid_name; 835ca987d46SWarner Losh ep = invalid_name + sizeof(invalid_name) - 1; 836ca987d46SWarner Losh } 837ca987d46SWarner Losh } else 838ca987d46SWarner Losh ep = name + strlen(name); 839ca987d46SWarner Losh len = ep - sp; 840ca987d46SWarner Losh fp = malloc(len + 1); 841ca987d46SWarner Losh if (fp == NULL) 842ca987d46SWarner Losh return NULL; 843ca987d46SWarner Losh memcpy(fp, sp, len); 844ca987d46SWarner Losh fp[len] = '\0'; 845ca987d46SWarner Losh return fp; 846ca987d46SWarner Losh } 847ca987d46SWarner Losh 848ca987d46SWarner Losh #if (defined(__i386__) || defined(__powerpc__)) && __ELF_WORD_SIZE == 64 849ca987d46SWarner Losh struct mod_metadata64 { 850ca987d46SWarner Losh int md_version; /* structure version MDTV_* */ 851ca987d46SWarner Losh int md_type; /* type of entry MDT_* */ 852ca987d46SWarner Losh u_int64_t md_data; /* specific data */ 853ca987d46SWarner Losh u_int64_t md_cval; /* common string label */ 854ca987d46SWarner Losh }; 855ca987d46SWarner Losh #endif 856ca987d46SWarner Losh #if defined(__amd64__) && __ELF_WORD_SIZE == 32 857ca987d46SWarner Losh struct mod_metadata32 { 858ca987d46SWarner Losh int md_version; /* structure version MDTV_* */ 859ca987d46SWarner Losh int md_type; /* type of entry MDT_* */ 860ca987d46SWarner Losh u_int32_t md_data; /* specific data */ 861ca987d46SWarner Losh u_int32_t md_cval; /* common string label */ 862ca987d46SWarner Losh }; 863ca987d46SWarner Losh #endif 864ca987d46SWarner Losh 865ca987d46SWarner Losh int 866ca987d46SWarner Losh __elfN(load_modmetadata)(struct preloaded_file *fp, u_int64_t dest) 867ca987d46SWarner Losh { 868ca987d46SWarner Losh struct elf_file ef; 869ca987d46SWarner Losh int err, i, j; 870ca987d46SWarner Losh Elf_Shdr *sh_meta, *shdr = NULL; 871ca987d46SWarner Losh Elf_Shdr *sh_data[2]; 872ca987d46SWarner Losh char *shstrtab = NULL; 873ca987d46SWarner Losh size_t size; 874ca987d46SWarner Losh Elf_Addr p_start, p_end; 875ca987d46SWarner Losh 876ca987d46SWarner Losh bzero(&ef, sizeof(struct elf_file)); 877ca987d46SWarner Losh ef.fd = -1; 878ca987d46SWarner Losh 879ca987d46SWarner Losh err = __elfN(load_elf_header)(fp->f_name, &ef); 880ca987d46SWarner Losh if (err != 0) 881ca987d46SWarner Losh goto out; 882ca987d46SWarner Losh 883ca987d46SWarner Losh if (ef.kernel == 1 || ef.ehdr->e_type == ET_EXEC) { 884ca987d46SWarner Losh ef.kernel = 1; 885ca987d46SWarner Losh } else if (ef.ehdr->e_type != ET_DYN) { 886ca987d46SWarner Losh err = EFTYPE; 887ca987d46SWarner Losh goto out; 888ca987d46SWarner Losh } 889ca987d46SWarner Losh 890db711744SWarner Losh size = (size_t)ef.ehdr->e_shnum * (size_t)ef.ehdr->e_shentsize; 891ca987d46SWarner Losh shdr = alloc_pread(ef.fd, ef.ehdr->e_shoff, size); 892ca987d46SWarner Losh if (shdr == NULL) { 893ca987d46SWarner Losh err = ENOMEM; 894ca987d46SWarner Losh goto out; 895ca987d46SWarner Losh } 896ca987d46SWarner Losh 897ca987d46SWarner Losh /* Load shstrtab. */ 898ca987d46SWarner Losh shstrtab = alloc_pread(ef.fd, shdr[ef.ehdr->e_shstrndx].sh_offset, 899ca987d46SWarner Losh shdr[ef.ehdr->e_shstrndx].sh_size); 900ca987d46SWarner Losh if (shstrtab == NULL) { 901ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 902ca987d46SWarner Losh "load_modmetadata: unable to load shstrtab\n"); 903ca987d46SWarner Losh err = EFTYPE; 904ca987d46SWarner Losh goto out; 905ca987d46SWarner Losh } 906ca987d46SWarner Losh 907ca987d46SWarner Losh /* Find set_modmetadata_set and data sections. */ 908ca987d46SWarner Losh sh_data[0] = sh_data[1] = sh_meta = NULL; 909ca987d46SWarner Losh for (i = 0, j = 0; i < ef.ehdr->e_shnum; i++) { 910ca987d46SWarner Losh if (strcmp(&shstrtab[shdr[i].sh_name], 911ca987d46SWarner Losh "set_modmetadata_set") == 0) { 912ca987d46SWarner Losh sh_meta = &shdr[i]; 913ca987d46SWarner Losh } 914ca987d46SWarner Losh if ((strcmp(&shstrtab[shdr[i].sh_name], ".data") == 0) || 915ca987d46SWarner Losh (strcmp(&shstrtab[shdr[i].sh_name], ".rodata") == 0)) { 916ca987d46SWarner Losh sh_data[j++] = &shdr[i]; 917ca987d46SWarner Losh } 918ca987d46SWarner Losh } 919ca987d46SWarner Losh if (sh_meta == NULL || sh_data[0] == NULL || sh_data[1] == NULL) { 920ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 921ca987d46SWarner Losh "load_modmetadata: unable to find set_modmetadata_set or data sections\n"); 922ca987d46SWarner Losh err = EFTYPE; 923ca987d46SWarner Losh goto out; 924ca987d46SWarner Losh } 925ca987d46SWarner Losh 926ca987d46SWarner Losh /* Load set_modmetadata_set into memory */ 927ca987d46SWarner Losh err = kern_pread(ef.fd, dest, sh_meta->sh_size, sh_meta->sh_offset); 928ca987d46SWarner Losh if (err != 0) { 929ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 930ca987d46SWarner Losh "load_modmetadata: unable to load set_modmetadata_set: %d\n", err); 931ca987d46SWarner Losh goto out; 932ca987d46SWarner Losh } 933ca987d46SWarner Losh p_start = dest; 934ca987d46SWarner Losh p_end = dest + sh_meta->sh_size; 935ca987d46SWarner Losh dest += sh_meta->sh_size; 936ca987d46SWarner Losh 937ca987d46SWarner Losh /* Load data sections into memory. */ 938ca987d46SWarner Losh err = kern_pread(ef.fd, dest, sh_data[0]->sh_size, 939ca987d46SWarner Losh sh_data[0]->sh_offset); 940ca987d46SWarner Losh if (err != 0) { 941ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 942ca987d46SWarner Losh "load_modmetadata: unable to load data: %d\n", err); 943ca987d46SWarner Losh goto out; 944ca987d46SWarner Losh } 945ca987d46SWarner Losh 946ca987d46SWarner Losh /* 947ca987d46SWarner Losh * We have to increment the dest, so that the offset is the same into 948ca987d46SWarner Losh * both the .rodata and .data sections. 949ca987d46SWarner Losh */ 950ca987d46SWarner Losh ef.off = -(sh_data[0]->sh_addr - dest); 951ca987d46SWarner Losh dest += (sh_data[1]->sh_addr - sh_data[0]->sh_addr); 952ca987d46SWarner Losh 953ca987d46SWarner Losh err = kern_pread(ef.fd, dest, sh_data[1]->sh_size, 954ca987d46SWarner Losh sh_data[1]->sh_offset); 955ca987d46SWarner Losh if (err != 0) { 956ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 957ca987d46SWarner Losh "load_modmetadata: unable to load data: %d\n", err); 958ca987d46SWarner Losh goto out; 959ca987d46SWarner Losh } 960ca987d46SWarner Losh 961ca987d46SWarner Losh err = __elfN(parse_modmetadata)(fp, &ef, p_start, p_end); 962ca987d46SWarner Losh if (err != 0) { 963ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 964ca987d46SWarner Losh "load_modmetadata: unable to parse metadata: %d\n", err); 965ca987d46SWarner Losh goto out; 966ca987d46SWarner Losh } 967ca987d46SWarner Losh 968ca987d46SWarner Losh out: 969ca987d46SWarner Losh if (shstrtab != NULL) 970ca987d46SWarner Losh free(shstrtab); 971ca987d46SWarner Losh if (shdr != NULL) 972ca987d46SWarner Losh free(shdr); 973ca987d46SWarner Losh if (ef.firstpage != NULL) 974ca987d46SWarner Losh free(ef.firstpage); 975ca987d46SWarner Losh if (ef.fd != -1) 976ca987d46SWarner Losh close(ef.fd); 977ca987d46SWarner Losh return (err); 978ca987d46SWarner Losh } 979ca987d46SWarner Losh 980ca987d46SWarner Losh int 981ca987d46SWarner Losh __elfN(parse_modmetadata)(struct preloaded_file *fp, elf_file_t ef, 982ca987d46SWarner Losh Elf_Addr p_start, Elf_Addr p_end) 983ca987d46SWarner Losh { 984ca987d46SWarner Losh struct mod_metadata md; 985ca987d46SWarner Losh #if (defined(__i386__) || defined(__powerpc__)) && __ELF_WORD_SIZE == 64 986ca987d46SWarner Losh struct mod_metadata64 md64; 987ca987d46SWarner Losh #elif defined(__amd64__) && __ELF_WORD_SIZE == 32 988ca987d46SWarner Losh struct mod_metadata32 md32; 989ca987d46SWarner Losh #endif 990ca987d46SWarner Losh struct mod_depend *mdepend; 991ca987d46SWarner Losh struct mod_version mver; 992ca987d46SWarner Losh char *s; 993ca987d46SWarner Losh int error, modcnt, minfolen; 994ca987d46SWarner Losh Elf_Addr v, p; 995ca987d46SWarner Losh 996ca987d46SWarner Losh modcnt = 0; 997ca987d46SWarner Losh p = p_start; 998ca987d46SWarner Losh while (p < p_end) { 999ca987d46SWarner Losh COPYOUT(p, &v, sizeof(v)); 1000ca987d46SWarner Losh error = __elfN(reloc_ptr)(fp, ef, p, &v, sizeof(v)); 1001ca987d46SWarner Losh if (error == EOPNOTSUPP) 1002ca987d46SWarner Losh v += ef->off; 1003ca987d46SWarner Losh else if (error != 0) 1004ca987d46SWarner Losh return (error); 1005ca987d46SWarner Losh #if (defined(__i386__) || defined(__powerpc__)) && __ELF_WORD_SIZE == 64 1006ca987d46SWarner Losh COPYOUT(v, &md64, sizeof(md64)); 1007ca987d46SWarner Losh error = __elfN(reloc_ptr)(fp, ef, v, &md64, sizeof(md64)); 1008ca987d46SWarner Losh if (error == EOPNOTSUPP) { 1009ca987d46SWarner Losh md64.md_cval += ef->off; 1010ca987d46SWarner Losh md64.md_data += ef->off; 1011ca987d46SWarner Losh } else if (error != 0) 1012ca987d46SWarner Losh return (error); 1013ca987d46SWarner Losh md.md_version = md64.md_version; 1014ca987d46SWarner Losh md.md_type = md64.md_type; 1015ca987d46SWarner Losh md.md_cval = (const char *)(uintptr_t)md64.md_cval; 1016ca987d46SWarner Losh md.md_data = (void *)(uintptr_t)md64.md_data; 1017ca987d46SWarner Losh #elif defined(__amd64__) && __ELF_WORD_SIZE == 32 1018ca987d46SWarner Losh COPYOUT(v, &md32, sizeof(md32)); 1019ca987d46SWarner Losh error = __elfN(reloc_ptr)(fp, ef, v, &md32, sizeof(md32)); 1020ca987d46SWarner Losh if (error == EOPNOTSUPP) { 1021ca987d46SWarner Losh md32.md_cval += ef->off; 1022ca987d46SWarner Losh md32.md_data += ef->off; 1023ca987d46SWarner Losh } else if (error != 0) 1024ca987d46SWarner Losh return (error); 1025ca987d46SWarner Losh md.md_version = md32.md_version; 1026ca987d46SWarner Losh md.md_type = md32.md_type; 1027ca987d46SWarner Losh md.md_cval = (const char *)(uintptr_t)md32.md_cval; 1028ca987d46SWarner Losh md.md_data = (void *)(uintptr_t)md32.md_data; 1029ca987d46SWarner Losh #else 1030ca987d46SWarner Losh COPYOUT(v, &md, sizeof(md)); 1031ca987d46SWarner Losh error = __elfN(reloc_ptr)(fp, ef, v, &md, sizeof(md)); 1032ca987d46SWarner Losh if (error == EOPNOTSUPP) { 1033ca987d46SWarner Losh md.md_cval += ef->off; 1034ca987d46SWarner Losh md.md_data = (void *)((uintptr_t)md.md_data + (uintptr_t)ef->off); 1035ca987d46SWarner Losh } else if (error != 0) 1036ca987d46SWarner Losh return (error); 1037ca987d46SWarner Losh #endif 1038ca987d46SWarner Losh p += sizeof(Elf_Addr); 1039ca987d46SWarner Losh switch(md.md_type) { 1040ca987d46SWarner Losh case MDT_DEPEND: 1041ca987d46SWarner Losh if (ef->kernel) /* kernel must not depend on anything */ 1042ca987d46SWarner Losh break; 1043ca987d46SWarner Losh s = strdupout((vm_offset_t)md.md_cval); 1044ca987d46SWarner Losh minfolen = sizeof(*mdepend) + strlen(s) + 1; 1045ca987d46SWarner Losh mdepend = malloc(minfolen); 1046ca987d46SWarner Losh if (mdepend == NULL) 1047ca987d46SWarner Losh return ENOMEM; 1048ca987d46SWarner Losh COPYOUT((vm_offset_t)md.md_data, mdepend, sizeof(*mdepend)); 1049ca987d46SWarner Losh strcpy((char*)(mdepend + 1), s); 1050ca987d46SWarner Losh free(s); 1051ca987d46SWarner Losh file_addmetadata(fp, MODINFOMD_DEPLIST, minfolen, mdepend); 1052ca987d46SWarner Losh free(mdepend); 1053ca987d46SWarner Losh break; 1054ca987d46SWarner Losh case MDT_VERSION: 1055ca987d46SWarner Losh s = strdupout((vm_offset_t)md.md_cval); 1056ca987d46SWarner Losh COPYOUT((vm_offset_t)md.md_data, &mver, sizeof(mver)); 1057ca987d46SWarner Losh file_addmodule(fp, s, mver.mv_version, NULL); 1058ca987d46SWarner Losh free(s); 1059ca987d46SWarner Losh modcnt++; 1060ca987d46SWarner Losh break; 1061ca987d46SWarner Losh } 1062ca987d46SWarner Losh } 1063ca987d46SWarner Losh if (modcnt == 0) { 1064ca987d46SWarner Losh s = fake_modname(fp->f_name); 1065ca987d46SWarner Losh file_addmodule(fp, s, 1, NULL); 1066ca987d46SWarner Losh free(s); 1067ca987d46SWarner Losh } 1068ca987d46SWarner Losh return 0; 1069ca987d46SWarner Losh } 1070ca987d46SWarner Losh 1071ca987d46SWarner Losh static unsigned long 1072ca987d46SWarner Losh elf_hash(const char *name) 1073ca987d46SWarner Losh { 1074ca987d46SWarner Losh const unsigned char *p = (const unsigned char *) name; 1075ca987d46SWarner Losh unsigned long h = 0; 1076ca987d46SWarner Losh unsigned long g; 1077ca987d46SWarner Losh 1078ca987d46SWarner Losh while (*p != '\0') { 1079ca987d46SWarner Losh h = (h << 4) + *p++; 1080ca987d46SWarner Losh if ((g = h & 0xf0000000) != 0) 1081ca987d46SWarner Losh h ^= g >> 24; 1082ca987d46SWarner Losh h &= ~g; 1083ca987d46SWarner Losh } 1084ca987d46SWarner Losh return h; 1085ca987d46SWarner Losh } 1086ca987d46SWarner Losh 1087ca987d46SWarner Losh static const char __elfN(bad_symtable)[] = "elf" __XSTRING(__ELF_WORD_SIZE) "_lookup_symbol: corrupt symbol table\n"; 1088ca987d46SWarner Losh int 1089ca987d46SWarner Losh __elfN(lookup_symbol)(struct preloaded_file *fp, elf_file_t ef, const char* name, 1090ca987d46SWarner Losh Elf_Sym *symp) 1091ca987d46SWarner Losh { 1092ca987d46SWarner Losh Elf_Hashelt symnum; 1093ca987d46SWarner Losh Elf_Sym sym; 1094ca987d46SWarner Losh char *strp; 1095ca987d46SWarner Losh unsigned long hash; 1096ca987d46SWarner Losh 1097ca987d46SWarner Losh hash = elf_hash(name); 1098ca987d46SWarner Losh COPYOUT(&ef->buckets[hash % ef->nbuckets], &symnum, sizeof(symnum)); 1099ca987d46SWarner Losh 1100ca987d46SWarner Losh while (symnum != STN_UNDEF) { 1101ca987d46SWarner Losh if (symnum >= ef->nchains) { 1102ca987d46SWarner Losh printf(__elfN(bad_symtable)); 1103ca987d46SWarner Losh return ENOENT; 1104ca987d46SWarner Losh } 1105ca987d46SWarner Losh 1106ca987d46SWarner Losh COPYOUT(ef->symtab + symnum, &sym, sizeof(sym)); 1107ca987d46SWarner Losh if (sym.st_name == 0) { 1108ca987d46SWarner Losh printf(__elfN(bad_symtable)); 1109ca987d46SWarner Losh return ENOENT; 1110ca987d46SWarner Losh } 1111ca987d46SWarner Losh 1112ca987d46SWarner Losh strp = strdupout((vm_offset_t)(ef->strtab + sym.st_name)); 1113ca987d46SWarner Losh if (strcmp(name, strp) == 0) { 1114ca987d46SWarner Losh free(strp); 1115ca987d46SWarner Losh if (sym.st_shndx != SHN_UNDEF || 1116ca987d46SWarner Losh (sym.st_value != 0 && 1117ca987d46SWarner Losh ELF_ST_TYPE(sym.st_info) == STT_FUNC)) { 1118ca987d46SWarner Losh *symp = sym; 1119ca987d46SWarner Losh return 0; 1120ca987d46SWarner Losh } 1121ca987d46SWarner Losh return ENOENT; 1122ca987d46SWarner Losh } 1123ca987d46SWarner Losh free(strp); 1124ca987d46SWarner Losh COPYOUT(&ef->chains[symnum], &symnum, sizeof(symnum)); 1125ca987d46SWarner Losh } 1126ca987d46SWarner Losh return ENOENT; 1127ca987d46SWarner Losh } 1128ca987d46SWarner Losh 1129ca987d46SWarner Losh /* 1130ca987d46SWarner Losh * Apply any intra-module relocations to the value. p is the load address 1131ca987d46SWarner Losh * of the value and val/len is the value to be modified. This does NOT modify 1132ca987d46SWarner Losh * the image in-place, because this is done by kern_linker later on. 1133ca987d46SWarner Losh * 1134ca987d46SWarner Losh * Returns EOPNOTSUPP if no relocation method is supplied. 1135ca987d46SWarner Losh */ 1136ca987d46SWarner Losh static int 1137ca987d46SWarner Losh __elfN(reloc_ptr)(struct preloaded_file *mp, elf_file_t ef, 1138ca987d46SWarner Losh Elf_Addr p, void *val, size_t len) 1139ca987d46SWarner Losh { 1140ca987d46SWarner Losh size_t n; 1141ca987d46SWarner Losh Elf_Rela a; 1142ca987d46SWarner Losh Elf_Rel r; 1143ca987d46SWarner Losh int error; 1144ca987d46SWarner Losh 1145ca987d46SWarner Losh /* 1146ca987d46SWarner Losh * The kernel is already relocated, but we still want to apply 1147ca987d46SWarner Losh * offset adjustments. 1148ca987d46SWarner Losh */ 1149ca987d46SWarner Losh if (ef->kernel) 1150ca987d46SWarner Losh return (EOPNOTSUPP); 1151ca987d46SWarner Losh 1152ca987d46SWarner Losh for (n = 0; n < ef->relsz / sizeof(r); n++) { 1153ca987d46SWarner Losh COPYOUT(ef->rel + n, &r, sizeof(r)); 1154ca987d46SWarner Losh 1155ca987d46SWarner Losh error = __elfN(reloc)(ef, __elfN(symaddr), &r, ELF_RELOC_REL, 1156ca987d46SWarner Losh ef->off, p, val, len); 1157ca987d46SWarner Losh if (error != 0) 1158ca987d46SWarner Losh return (error); 1159ca987d46SWarner Losh } 1160ca987d46SWarner Losh for (n = 0; n < ef->relasz / sizeof(a); n++) { 1161ca987d46SWarner Losh COPYOUT(ef->rela + n, &a, sizeof(a)); 1162ca987d46SWarner Losh 1163ca987d46SWarner Losh error = __elfN(reloc)(ef, __elfN(symaddr), &a, ELF_RELOC_RELA, 1164ca987d46SWarner Losh ef->off, p, val, len); 1165ca987d46SWarner Losh if (error != 0) 1166ca987d46SWarner Losh return (error); 1167ca987d46SWarner Losh } 1168ca987d46SWarner Losh 1169ca987d46SWarner Losh return (0); 1170ca987d46SWarner Losh } 1171ca987d46SWarner Losh 1172ca987d46SWarner Losh static Elf_Addr 1173ca987d46SWarner Losh __elfN(symaddr)(struct elf_file *ef, Elf_Size symidx) 1174ca987d46SWarner Losh { 1175ca987d46SWarner Losh 1176ca987d46SWarner Losh /* Symbol lookup by index not required here. */ 1177ca987d46SWarner Losh return (0); 1178ca987d46SWarner Losh } 1179