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; 7356e53cb8SWarner Losh uint64_t off; 74ca987d46SWarner Losh } *elf_file_t; 75ca987d46SWarner Losh 766b632498SEd Maste static int __elfN(loadimage)(struct preloaded_file *mp, elf_file_t ef, 7756e53cb8SWarner Losh uint64_t loadaddr); 786b632498SEd Maste static int __elfN(lookup_symbol)(struct preloaded_file *mp, elf_file_t ef, 796b632498SEd Maste const char* name, Elf_Sym* sym); 80ca987d46SWarner Losh static int __elfN(reloc_ptr)(struct preloaded_file *mp, elf_file_t ef, 81ca987d46SWarner Losh Elf_Addr p, void *val, size_t len); 82ca987d46SWarner Losh static int __elfN(parse_modmetadata)(struct preloaded_file *mp, elf_file_t ef, 83ca987d46SWarner Losh Elf_Addr p_start, Elf_Addr p_end); 84ca987d46SWarner Losh static symaddr_fn __elfN(symaddr); 85ca987d46SWarner Losh static char *fake_modname(const char *name); 86ca987d46SWarner Losh 87ca987d46SWarner Losh const char *__elfN(kerneltype) = "elf kernel"; 88ca987d46SWarner Losh const char *__elfN(moduletype) = "elf module"; 89ca987d46SWarner Losh 9056e53cb8SWarner Losh uint64_t __elfN(relocation_offset) = 0; 91ca987d46SWarner Losh 9212363d8eSRoger Pau Monné extern void elf_wrong_field_size(void); 9312363d8eSRoger Pau Monné #define CONVERT_FIELD(b, f, e) \ 9412363d8eSRoger Pau Monné switch (sizeof((b)->f)) { \ 9512363d8eSRoger Pau Monné case 2: \ 9612363d8eSRoger Pau Monné (b)->f = e ## 16toh((b)->f); \ 9712363d8eSRoger Pau Monné break; \ 9812363d8eSRoger Pau Monné case 4: \ 9912363d8eSRoger Pau Monné (b)->f = e ## 32toh((b)->f); \ 10012363d8eSRoger Pau Monné break; \ 10112363d8eSRoger Pau Monné case 8: \ 10212363d8eSRoger Pau Monné (b)->f = e ## 64toh((b)->f); \ 10312363d8eSRoger Pau Monné break; \ 10412363d8eSRoger Pau Monné default: \ 10512363d8eSRoger Pau Monné /* Force a link time error. */ \ 10612363d8eSRoger Pau Monné elf_wrong_field_size(); \ 10712363d8eSRoger Pau Monné break; \ 10812363d8eSRoger Pau Monné } 10912363d8eSRoger Pau Monné 11012363d8eSRoger Pau Monné #define CONVERT_SWITCH(h, d, f) \ 11112363d8eSRoger Pau Monné switch ((h)->e_ident[EI_DATA]) { \ 11212363d8eSRoger Pau Monné case ELFDATA2MSB: \ 11312363d8eSRoger Pau Monné f(d, be); \ 11412363d8eSRoger Pau Monné break; \ 11512363d8eSRoger Pau Monné case ELFDATA2LSB: \ 11612363d8eSRoger Pau Monné f(d, le); \ 11712363d8eSRoger Pau Monné break; \ 11812363d8eSRoger Pau Monné default: \ 11912363d8eSRoger Pau Monné return (EINVAL); \ 12012363d8eSRoger Pau Monné } 12112363d8eSRoger Pau Monné 12212363d8eSRoger Pau Monné 12312363d8eSRoger Pau Monné static int elf_header_convert(Elf_Ehdr *ehdr) 12412363d8eSRoger Pau Monné { 12512363d8eSRoger Pau Monné /* 12612363d8eSRoger Pau Monné * Fixup ELF header endianness. 12712363d8eSRoger Pau Monné * 12812363d8eSRoger Pau Monné * The Xhdr structure was loaded using block read call to optimize file 12912363d8eSRoger Pau Monné * accesses. It might happen, that the endianness of the system memory 13012363d8eSRoger Pau Monné * is different that endianness of the ELF header. Swap fields here to 13112363d8eSRoger Pau Monné * guarantee that Xhdr always contain valid data regardless of 13212363d8eSRoger Pau Monné * architecture. 13312363d8eSRoger Pau Monné */ 13412363d8eSRoger Pau Monné #define HEADER_FIELDS(b, e) \ 13512363d8eSRoger Pau Monné CONVERT_FIELD(b, e_type, e); \ 13612363d8eSRoger Pau Monné CONVERT_FIELD(b, e_machine, e); \ 13712363d8eSRoger Pau Monné CONVERT_FIELD(b, e_version, e); \ 13812363d8eSRoger Pau Monné CONVERT_FIELD(b, e_entry, e); \ 13912363d8eSRoger Pau Monné CONVERT_FIELD(b, e_phoff, e); \ 14012363d8eSRoger Pau Monné CONVERT_FIELD(b, e_shoff, e); \ 14112363d8eSRoger Pau Monné CONVERT_FIELD(b, e_flags, e); \ 14212363d8eSRoger Pau Monné CONVERT_FIELD(b, e_ehsize, e); \ 14312363d8eSRoger Pau Monné CONVERT_FIELD(b, e_phentsize, e); \ 14412363d8eSRoger Pau Monné CONVERT_FIELD(b, e_phnum, e); \ 14512363d8eSRoger Pau Monné CONVERT_FIELD(b, e_shentsize, e); \ 14612363d8eSRoger Pau Monné CONVERT_FIELD(b, e_shnum, e); \ 14712363d8eSRoger Pau Monné CONVERT_FIELD(b, e_shstrndx, e) 14812363d8eSRoger Pau Monné 14912363d8eSRoger Pau Monné CONVERT_SWITCH(ehdr, ehdr, HEADER_FIELDS); 15012363d8eSRoger Pau Monné 15112363d8eSRoger Pau Monné #undef HEADER_FIELDS 15212363d8eSRoger Pau Monné 15312363d8eSRoger Pau Monné return (0); 15412363d8eSRoger Pau Monné } 15512363d8eSRoger Pau Monné 15612363d8eSRoger Pau Monné static int elf_program_header_convert(const Elf_Ehdr *ehdr, Elf_Phdr *phdr) 15712363d8eSRoger Pau Monné { 15812363d8eSRoger Pau Monné #define PROGRAM_HEADER_FIELDS(b, e) \ 15912363d8eSRoger Pau Monné CONVERT_FIELD(b, p_type, e); \ 16012363d8eSRoger Pau Monné CONVERT_FIELD(b, p_flags, e); \ 16112363d8eSRoger Pau Monné CONVERT_FIELD(b, p_offset, e); \ 16212363d8eSRoger Pau Monné CONVERT_FIELD(b, p_vaddr, e); \ 16312363d8eSRoger Pau Monné CONVERT_FIELD(b, p_paddr, e); \ 16412363d8eSRoger Pau Monné CONVERT_FIELD(b, p_filesz, e); \ 16512363d8eSRoger Pau Monné CONVERT_FIELD(b, p_memsz, e); \ 16612363d8eSRoger Pau Monné CONVERT_FIELD(b, p_align, e) 16712363d8eSRoger Pau Monné 16812363d8eSRoger Pau Monné CONVERT_SWITCH(ehdr, phdr, PROGRAM_HEADER_FIELDS); 16912363d8eSRoger Pau Monné 17012363d8eSRoger Pau Monné #undef PROGRAM_HEADER_FIELDS 17112363d8eSRoger Pau Monné 17212363d8eSRoger Pau Monné return (0); 17312363d8eSRoger Pau Monné } 17412363d8eSRoger Pau Monné 17512363d8eSRoger Pau Monné static int elf_section_header_convert(const Elf_Ehdr *ehdr, Elf_Shdr *shdr) 17612363d8eSRoger Pau Monné { 17712363d8eSRoger Pau Monné #define SECTION_HEADER_FIELDS(b, e) \ 17812363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_name, e); \ 17912363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_type, e); \ 18012363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_link, e); \ 18112363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_info, e); \ 18212363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_flags, e); \ 18312363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_addr, e); \ 18412363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_offset, e); \ 18512363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_size, e); \ 18612363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_addralign, e); \ 18712363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_entsize, e) 18812363d8eSRoger Pau Monné 18912363d8eSRoger Pau Monné CONVERT_SWITCH(ehdr, shdr, SECTION_HEADER_FIELDS); 19012363d8eSRoger Pau Monné 19112363d8eSRoger Pau Monné #undef SECTION_HEADER_FIELDS 19212363d8eSRoger Pau Monné 19312363d8eSRoger Pau Monné return (0); 19412363d8eSRoger Pau Monné } 19512363d8eSRoger Pau Monné #undef CONVERT_SWITCH 19612363d8eSRoger Pau Monné #undef CONVERT_FIELD 19712363d8eSRoger Pau Monné 198ca987d46SWarner Losh static int 199ca987d46SWarner Losh __elfN(load_elf_header)(char *filename, elf_file_t ef) 200ca987d46SWarner Losh { 201ca987d46SWarner Losh ssize_t bytes_read; 202ca987d46SWarner Losh Elf_Ehdr *ehdr; 203ca987d46SWarner Losh int err; 204ca987d46SWarner Losh 205ca987d46SWarner Losh /* 206ca987d46SWarner Losh * Open the image, read and validate the ELF header 207ca987d46SWarner Losh */ 208ca987d46SWarner Losh if (filename == NULL) /* can't handle nameless */ 209ca987d46SWarner Losh return (EFTYPE); 210ca987d46SWarner Losh if ((ef->fd = open(filename, O_RDONLY)) == -1) 211ca987d46SWarner Losh return (errno); 212ca987d46SWarner Losh ef->firstpage = malloc(PAGE_SIZE); 213ca987d46SWarner Losh if (ef->firstpage == NULL) { 214ca987d46SWarner Losh close(ef->fd); 215ca987d46SWarner Losh return (ENOMEM); 216ca987d46SWarner Losh } 217ca987d46SWarner Losh bytes_read = read(ef->fd, ef->firstpage, PAGE_SIZE); 218ca987d46SWarner Losh ef->firstlen = (size_t)bytes_read; 219ca987d46SWarner Losh if (bytes_read < 0 || ef->firstlen <= sizeof(Elf_Ehdr)) { 220ca987d46SWarner Losh err = EFTYPE; /* could be EIO, but may be small file */ 221ca987d46SWarner Losh goto error; 222ca987d46SWarner Losh } 223ca987d46SWarner Losh ehdr = ef->ehdr = (Elf_Ehdr *)ef->firstpage; 224ca987d46SWarner Losh 225ca987d46SWarner Losh /* Is it ELF? */ 226ca987d46SWarner Losh if (!IS_ELF(*ehdr)) { 227ca987d46SWarner Losh err = EFTYPE; 228ca987d46SWarner Losh goto error; 229ca987d46SWarner Losh } 2308de1ad0bSWojciech Macek 231ca987d46SWarner Losh if (ehdr->e_ident[EI_CLASS] != ELF_TARG_CLASS || /* Layout ? */ 232ca987d46SWarner Losh ehdr->e_ident[EI_DATA] != ELF_TARG_DATA || 2338de1ad0bSWojciech Macek ehdr->e_ident[EI_VERSION] != EV_CURRENT) /* Version ? */ { 2348de1ad0bSWojciech Macek err = EFTYPE; 2358de1ad0bSWojciech Macek goto error; 2368de1ad0bSWojciech Macek } 2378de1ad0bSWojciech Macek 23812363d8eSRoger Pau Monné err = elf_header_convert(ehdr); 23912363d8eSRoger Pau Monné if (err) 24012363d8eSRoger Pau Monné goto error; 2418de1ad0bSWojciech Macek 2426b632498SEd Maste if (ehdr->e_version != EV_CURRENT || ehdr->e_machine != ELF_TARG_MACH) { 2436b632498SEd Maste /* Machine ? */ 244ca987d46SWarner Losh err = EFTYPE; 245ca987d46SWarner Losh goto error; 246ca987d46SWarner Losh } 247ca987d46SWarner Losh 2488df8b2d3SSimon J. Gerraty #ifdef LOADER_VERIEXEC 2498df8b2d3SSimon J. Gerraty if (verify_file(ef->fd, filename, bytes_read, VE_MUST) < 0) { 2508df8b2d3SSimon J. Gerraty err = EAUTH; 2518df8b2d3SSimon J. Gerraty goto error; 2528df8b2d3SSimon J. Gerraty } 2538df8b2d3SSimon J. Gerraty #endif 254ca987d46SWarner Losh return (0); 255ca987d46SWarner Losh 256ca987d46SWarner Losh error: 257ca987d46SWarner Losh if (ef->firstpage != NULL) { 258ca987d46SWarner Losh free(ef->firstpage); 259ca987d46SWarner Losh ef->firstpage = NULL; 260ca987d46SWarner Losh } 261ca987d46SWarner Losh if (ef->fd != -1) { 262ca987d46SWarner Losh close(ef->fd); 263ca987d46SWarner Losh ef->fd = -1; 264ca987d46SWarner Losh } 265ca987d46SWarner Losh return (err); 266ca987d46SWarner Losh } 267ca987d46SWarner Losh 268ca987d46SWarner Losh /* 269ca987d46SWarner Losh * Attempt to load the file (file) as an ELF module. It will be stored at 270ca987d46SWarner Losh * (dest), and a pointer to a module structure describing the loaded object 271ca987d46SWarner Losh * will be saved in (result). 272ca987d46SWarner Losh */ 273ca987d46SWarner Losh int 27456e53cb8SWarner Losh __elfN(loadfile)(char *filename, uint64_t dest, struct preloaded_file **result) 275ca987d46SWarner Losh { 276ca987d46SWarner Losh return (__elfN(loadfile_raw)(filename, dest, result, 0)); 277ca987d46SWarner Losh } 278ca987d46SWarner Losh 279ca987d46SWarner Losh int 28056e53cb8SWarner Losh __elfN(loadfile_raw)(char *filename, uint64_t dest, 281ca987d46SWarner Losh struct preloaded_file **result, int multiboot) 282ca987d46SWarner Losh { 283ca987d46SWarner Losh struct preloaded_file *fp, *kfp; 284ca987d46SWarner Losh struct elf_file ef; 285ca987d46SWarner Losh Elf_Ehdr *ehdr; 286ca987d46SWarner Losh int err; 287ca987d46SWarner Losh 288ca987d46SWarner Losh fp = NULL; 289ca987d46SWarner Losh bzero(&ef, sizeof(struct elf_file)); 290ca987d46SWarner Losh ef.fd = -1; 291ca987d46SWarner Losh 292ca987d46SWarner Losh err = __elfN(load_elf_header)(filename, &ef); 293ca987d46SWarner Losh if (err != 0) 294ca987d46SWarner Losh return (err); 295ca987d46SWarner Losh 296ca987d46SWarner Losh ehdr = ef.ehdr; 297ca987d46SWarner Losh 298ca987d46SWarner Losh /* 299ca987d46SWarner Losh * Check to see what sort of module we are. 300ca987d46SWarner Losh */ 301ca987d46SWarner Losh kfp = file_findfile(NULL, __elfN(kerneltype)); 302ca987d46SWarner Losh #ifdef __powerpc__ 303ca987d46SWarner Losh /* 304ca987d46SWarner Losh * Kernels can be ET_DYN, so just assume the first loaded object is the 305ca987d46SWarner Losh * kernel. This assumption will be checked later. 306ca987d46SWarner Losh */ 307ca987d46SWarner Losh if (kfp == NULL) 308ca987d46SWarner Losh ef.kernel = 1; 309ca987d46SWarner Losh #endif 310ca987d46SWarner Losh if (ef.kernel || ehdr->e_type == ET_EXEC) { 311ca987d46SWarner Losh /* Looks like a kernel */ 312ca987d46SWarner Losh if (kfp != NULL) { 3136b632498SEd Maste printf("elf" __XSTRING(__ELF_WORD_SIZE) 3146b632498SEd Maste "_loadfile: kernel already loaded\n"); 315ca987d46SWarner Losh err = EPERM; 316ca987d46SWarner Losh goto oerr; 317ca987d46SWarner Losh } 318ca987d46SWarner Losh /* 319ca987d46SWarner Losh * Calculate destination address based on kernel entrypoint. 320ca987d46SWarner Losh * 3216b632498SEd Maste * For ARM, the destination address is independent of any values 3226b632498SEd Maste * in the elf header (an ARM kernel can be loaded at any 2MB 3236b632498SEd Maste * boundary), so we leave dest set to the value calculated by 3246b632498SEd Maste * archsw.arch_loadaddr() and passed in to this function. 325ca987d46SWarner Losh */ 326ca987d46SWarner Losh #ifndef __arm__ 327ca987d46SWarner Losh if (ehdr->e_type == ET_EXEC) 328ca987d46SWarner Losh dest = (ehdr->e_entry & ~PAGE_MASK); 329ca987d46SWarner Losh #endif 330ca987d46SWarner Losh if ((ehdr->e_entry & ~PAGE_MASK) == 0) { 3316b632498SEd Maste printf("elf" __XSTRING(__ELF_WORD_SIZE) 3326b632498SEd Maste "_loadfile: not a kernel (maybe static binary?)\n"); 333ca987d46SWarner Losh err = EPERM; 334ca987d46SWarner Losh goto oerr; 335ca987d46SWarner Losh } 336ca987d46SWarner Losh ef.kernel = 1; 337ca987d46SWarner Losh 338ca987d46SWarner Losh } else if (ehdr->e_type == ET_DYN) { 339ca987d46SWarner Losh /* Looks like a kld module */ 340ca987d46SWarner Losh if (multiboot != 0) { 3416b632498SEd Maste printf("elf" __XSTRING(__ELF_WORD_SIZE) 3426b632498SEd Maste "_loadfile: can't load module as multiboot\n"); 343ca987d46SWarner Losh err = EPERM; 344ca987d46SWarner Losh goto oerr; 345ca987d46SWarner Losh } 346ca987d46SWarner Losh if (kfp == NULL) { 3476b632498SEd Maste printf("elf" __XSTRING(__ELF_WORD_SIZE) 3486b632498SEd Maste "_loadfile: can't load module before kernel\n"); 349ca987d46SWarner Losh err = EPERM; 350ca987d46SWarner Losh goto oerr; 351ca987d46SWarner Losh } 352ca987d46SWarner Losh if (strcmp(__elfN(kerneltype), kfp->f_type)) { 3536b632498SEd Maste printf("elf" __XSTRING(__ELF_WORD_SIZE) 3546b632498SEd Maste "_loadfile: can't load module with kernel type '%s'\n", 3556b632498SEd Maste kfp->f_type); 356ca987d46SWarner Losh err = EPERM; 357ca987d46SWarner Losh goto oerr; 358ca987d46SWarner Losh } 359ca987d46SWarner Losh /* Looks OK, got ahead */ 360ca987d46SWarner Losh ef.kernel = 0; 361ca987d46SWarner Losh 362ca987d46SWarner Losh } else { 363ca987d46SWarner Losh err = EFTYPE; 364ca987d46SWarner Losh goto oerr; 365ca987d46SWarner Losh } 366ca987d46SWarner Losh 367ca987d46SWarner Losh if (archsw.arch_loadaddr != NULL) 368ca987d46SWarner Losh dest = archsw.arch_loadaddr(LOAD_ELF, ehdr, dest); 369ca987d46SWarner Losh else 370ca987d46SWarner Losh dest = roundup(dest, PAGE_SIZE); 371ca987d46SWarner Losh 372ca987d46SWarner Losh /* 373ca987d46SWarner Losh * Ok, we think we should handle this. 374ca987d46SWarner Losh */ 375ca987d46SWarner Losh fp = file_alloc(); 376ca987d46SWarner Losh if (fp == NULL) { 3776b632498SEd Maste printf("elf" __XSTRING(__ELF_WORD_SIZE) 3786b632498SEd Maste "_loadfile: cannot allocate module info\n"); 379ca987d46SWarner Losh err = EPERM; 380ca987d46SWarner Losh goto out; 381ca987d46SWarner Losh } 382ca987d46SWarner Losh if (ef.kernel == 1 && multiboot == 0) 383ca987d46SWarner Losh setenv("kernelname", filename, 1); 384ca987d46SWarner Losh fp->f_name = strdup(filename); 385ca987d46SWarner Losh if (multiboot == 0) 386ca987d46SWarner Losh fp->f_type = strdup(ef.kernel ? 387ca987d46SWarner Losh __elfN(kerneltype) : __elfN(moduletype)); 388ca987d46SWarner Losh else 389ca987d46SWarner Losh fp->f_type = strdup("elf multiboot kernel"); 390ca987d46SWarner Losh 391ca987d46SWarner Losh #ifdef ELF_VERBOSE 392ca987d46SWarner Losh if (ef.kernel) 3936b632498SEd Maste printf("%s entry at 0x%jx\n", filename, 3946b632498SEd Maste (uintmax_t)ehdr->e_entry); 395ca987d46SWarner Losh #else 396ca987d46SWarner Losh printf("%s ", filename); 397ca987d46SWarner Losh #endif 398ca987d46SWarner Losh 399ca987d46SWarner Losh fp->f_size = __elfN(loadimage)(fp, &ef, dest); 400ca987d46SWarner Losh if (fp->f_size == 0 || fp->f_addr == 0) 401ca987d46SWarner Losh goto ioerr; 402ca987d46SWarner Losh 403ca987d46SWarner Losh /* save exec header as metadata */ 404ca987d46SWarner Losh file_addmetadata(fp, MODINFOMD_ELFHDR, sizeof(*ehdr), ehdr); 405ca987d46SWarner Losh 406ca987d46SWarner Losh /* Load OK, return module pointer */ 407ca987d46SWarner Losh *result = (struct preloaded_file *)fp; 408ca987d46SWarner Losh err = 0; 409ca987d46SWarner Losh goto out; 410ca987d46SWarner Losh 411ca987d46SWarner Losh ioerr: 412ca987d46SWarner Losh err = EIO; 413ca987d46SWarner Losh oerr: 414ca987d46SWarner Losh file_discard(fp); 415ca987d46SWarner Losh out: 416ca987d46SWarner Losh if (ef.firstpage) 417ca987d46SWarner Losh free(ef.firstpage); 418ca987d46SWarner Losh if (ef.fd != -1) 419ca987d46SWarner Losh close(ef.fd); 420ca987d46SWarner Losh return (err); 421ca987d46SWarner Losh } 422ca987d46SWarner Losh 423ca987d46SWarner Losh /* 424ca987d46SWarner Losh * With the file (fd) open on the image, and (ehdr) containing 425ca987d46SWarner Losh * the Elf header, load the image at (off) 426ca987d46SWarner Losh */ 427ca987d46SWarner Losh static int 42856e53cb8SWarner Losh __elfN(loadimage)(struct preloaded_file *fp, elf_file_t ef, uint64_t off) 429ca987d46SWarner Losh { 430ca987d46SWarner Losh int i; 431ca987d46SWarner Losh u_int j; 432ca987d46SWarner Losh Elf_Ehdr *ehdr; 433ca987d46SWarner Losh Elf_Phdr *phdr, *php; 434ca987d46SWarner Losh Elf_Shdr *shdr; 435ca987d46SWarner Losh char *shstr; 436ca987d46SWarner Losh int ret; 437ca987d46SWarner Losh vm_offset_t firstaddr; 438ca987d46SWarner Losh vm_offset_t lastaddr; 439ca987d46SWarner Losh size_t chunk; 440ca987d46SWarner Losh ssize_t result; 441ca987d46SWarner Losh Elf_Addr ssym, esym; 442ca987d46SWarner Losh Elf_Dyn *dp; 443ca987d46SWarner Losh Elf_Addr adp; 444ca987d46SWarner Losh Elf_Addr ctors; 445ca987d46SWarner Losh int ndp; 446ca987d46SWarner Losh int symstrindex; 447ca987d46SWarner Losh int symtabindex; 448ca987d46SWarner Losh Elf_Size size; 449ca987d46SWarner Losh u_int fpcopy; 450ca987d46SWarner Losh Elf_Sym sym; 451ca987d46SWarner Losh Elf_Addr p_start, p_end; 452ca987d46SWarner Losh 453ca987d46SWarner Losh dp = NULL; 454ca987d46SWarner Losh shdr = NULL; 455ca987d46SWarner Losh ret = 0; 456ca987d46SWarner Losh firstaddr = lastaddr = 0; 457ca987d46SWarner Losh ehdr = ef->ehdr; 4582f6823d4SJustin Hibbits #ifdef __powerpc__ 4592f6823d4SJustin Hibbits if (ef->kernel) { 4602f6823d4SJustin Hibbits #else 461ca987d46SWarner Losh if (ehdr->e_type == ET_EXEC) { 4622f6823d4SJustin Hibbits #endif 463ca987d46SWarner Losh #if defined(__i386__) || defined(__amd64__) 464ca987d46SWarner Losh #if __ELF_WORD_SIZE == 64 4656b632498SEd Maste /* x86_64 relocates after locore */ 4666b632498SEd Maste off = - (off & 0xffffffffff000000ull); 467ca987d46SWarner Losh #else 4686b632498SEd Maste /* i386 relocates after locore */ 4696b632498SEd Maste off = - (off & 0xff000000u); 470ca987d46SWarner Losh #endif 471ca987d46SWarner Losh #elif defined(__powerpc__) 472ca987d46SWarner Losh /* 4736b632498SEd Maste * On the purely virtual memory machines like e500, the kernel 4746b632498SEd Maste * is linked against its final VA range, which is most often 4756b632498SEd Maste * not available at the loader stage, but only after kernel 4766b632498SEd Maste * initializes and completes its VM settings. In such cases we 4776b632498SEd Maste * cannot use p_vaddr field directly to load ELF segments, but 4786b632498SEd Maste * put them at some 'load-time' locations. 479ca987d46SWarner Losh */ 480ca987d46SWarner Losh if (off & 0xf0000000u) { 481ca987d46SWarner Losh off = -(off & 0xf0000000u); 482ca987d46SWarner Losh /* 4836b632498SEd Maste * XXX the physical load address should not be 4846b632498SEd Maste * hardcoded. Note that the Book-E kernel assumes that 4856b632498SEd Maste * it's loaded at a 16MB boundary for now... 486ca987d46SWarner Losh */ 487ca987d46SWarner Losh off += 0x01000000; 4882f6823d4SJustin Hibbits } 489ca987d46SWarner Losh ehdr->e_entry += off; 490ca987d46SWarner Losh #ifdef ELF_VERBOSE 491ff7449d6SLeandro Lupori printf("Converted entry 0x%jx\n", (uintmax_t)ehdr->e_entry); 492ca987d46SWarner Losh #endif 493ca987d46SWarner Losh #elif defined(__arm__) && !defined(EFI) 494ca987d46SWarner Losh /* 4956b632498SEd Maste * The elf headers in arm kernels specify virtual addresses in 4966b632498SEd Maste * all header fields, even the ones that should be physical 4976b632498SEd Maste * addresses. We assume the entry point is in the first page, 4986b632498SEd Maste * and masking the page offset will leave us with the virtual 4996b632498SEd Maste * address the kernel was linked at. We subtract that from the 5006b632498SEd Maste * load offset, making 'off' into the value which, when added 5016b632498SEd Maste * to a virtual address in an elf header, translates it to a 5026b632498SEd Maste * physical address. We do the va->pa conversion on the entry 5036b632498SEd Maste * point address in the header now, so that later we can launch 5046b632498SEd Maste * the kernel by just jumping to that address. 505ca987d46SWarner Losh * 5066b632498SEd Maste * When booting from UEFI the copyin and copyout functions 5076b632498SEd Maste * handle adjusting the location relative to the first virtual 5086b632498SEd Maste * address. Because of this there is no need to adjust the 5096b632498SEd Maste * offset or entry point address as these will both be handled 5106b632498SEd Maste * by the efi code. 511ca987d46SWarner Losh */ 512ca987d46SWarner Losh off -= ehdr->e_entry & ~PAGE_MASK; 513ca987d46SWarner Losh ehdr->e_entry += off; 514ca987d46SWarner Losh #ifdef ELF_VERBOSE 515637b6532SEnji Cooper printf("ehdr->e_entry 0x%jx, va<->pa off %llx\n", 516ff7449d6SLeandro Lupori (uintmax_t)ehdr->e_entry, off); 517ca987d46SWarner Losh #endif 518ca987d46SWarner Losh #else 519ca987d46SWarner Losh off = 0; /* other archs use direct mapped kernels */ 520ca987d46SWarner Losh #endif 521ca987d46SWarner Losh } 522ca987d46SWarner Losh ef->off = off; 523ca987d46SWarner Losh 524ca987d46SWarner Losh if (ef->kernel) 525ca987d46SWarner Losh __elfN(relocation_offset) = off; 526ca987d46SWarner Losh 527ca987d46SWarner Losh if ((ehdr->e_phoff + ehdr->e_phnum * sizeof(*phdr)) > ef->firstlen) { 5286b632498SEd Maste printf("elf" __XSTRING(__ELF_WORD_SIZE) 5296b632498SEd Maste "_loadimage: program header not within first page\n"); 530ca987d46SWarner Losh goto out; 531ca987d46SWarner Losh } 532ca987d46SWarner Losh phdr = (Elf_Phdr *)(ef->firstpage + ehdr->e_phoff); 533ca987d46SWarner Losh 534ca987d46SWarner Losh for (i = 0; i < ehdr->e_phnum; i++) { 53512363d8eSRoger Pau Monné if (elf_program_header_convert(ehdr, phdr)) 53612363d8eSRoger Pau Monné continue; 5378de1ad0bSWojciech Macek 538ca987d46SWarner Losh /* We want to load PT_LOAD segments only.. */ 539ca987d46SWarner Losh if (phdr[i].p_type != PT_LOAD) 540ca987d46SWarner Losh continue; 541ca987d46SWarner Losh 542ca987d46SWarner Losh #ifdef ELF_VERBOSE 543ca987d46SWarner Losh printf("Segment: 0x%lx@0x%lx -> 0x%lx-0x%lx", 544ca987d46SWarner Losh (long)phdr[i].p_filesz, (long)phdr[i].p_offset, 545ca987d46SWarner Losh (long)(phdr[i].p_vaddr + off), 546ca987d46SWarner Losh (long)(phdr[i].p_vaddr + off + phdr[i].p_memsz - 1)); 547ca987d46SWarner Losh #else 548ca987d46SWarner Losh if ((phdr[i].p_flags & PF_W) == 0) { 549ca987d46SWarner Losh printf("text=0x%lx ", (long)phdr[i].p_filesz); 550ca987d46SWarner Losh } else { 551ca987d46SWarner Losh printf("data=0x%lx", (long)phdr[i].p_filesz); 552ca987d46SWarner Losh if (phdr[i].p_filesz < phdr[i].p_memsz) 5536b632498SEd Maste printf("+0x%lx", (long)(phdr[i].p_memsz - 5546b632498SEd Maste phdr[i].p_filesz)); 555ca987d46SWarner Losh printf(" "); 556ca987d46SWarner Losh } 557ca987d46SWarner Losh #endif 558ca987d46SWarner Losh fpcopy = 0; 559ca987d46SWarner Losh if (ef->firstlen > phdr[i].p_offset) { 560ca987d46SWarner Losh fpcopy = ef->firstlen - phdr[i].p_offset; 561ca987d46SWarner Losh archsw.arch_copyin(ef->firstpage + phdr[i].p_offset, 562ca987d46SWarner Losh phdr[i].p_vaddr + off, fpcopy); 563ca987d46SWarner Losh } 564ca987d46SWarner Losh if (phdr[i].p_filesz > fpcopy) { 565ca987d46SWarner Losh if (kern_pread(ef->fd, phdr[i].p_vaddr + off + fpcopy, 5666b632498SEd Maste phdr[i].p_filesz - fpcopy, 5676b632498SEd Maste phdr[i].p_offset + fpcopy) != 0) { 568ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 569ca987d46SWarner Losh "_loadimage: read failed\n"); 570ca987d46SWarner Losh goto out; 571ca987d46SWarner Losh } 572ca987d46SWarner Losh } 573ca987d46SWarner Losh /* clear space from oversized segments; eg: bss */ 574ca987d46SWarner Losh if (phdr[i].p_filesz < phdr[i].p_memsz) { 575ca987d46SWarner Losh #ifdef ELF_VERBOSE 576ca987d46SWarner Losh printf(" (bss: 0x%lx-0x%lx)", 577ca987d46SWarner Losh (long)(phdr[i].p_vaddr + off + phdr[i].p_filesz), 578ca987d46SWarner Losh (long)(phdr[i].p_vaddr + off + phdr[i].p_memsz -1)); 579ca987d46SWarner Losh #endif 580ca987d46SWarner Losh 581ca987d46SWarner Losh kern_bzero(phdr[i].p_vaddr + off + phdr[i].p_filesz, 582ca987d46SWarner Losh phdr[i].p_memsz - phdr[i].p_filesz); 583ca987d46SWarner Losh } 584ca987d46SWarner Losh #ifdef ELF_VERBOSE 585ca987d46SWarner Losh printf("\n"); 586ca987d46SWarner Losh #endif 587ca987d46SWarner Losh 588ca987d46SWarner Losh if (archsw.arch_loadseg != NULL) 589ca987d46SWarner Losh archsw.arch_loadseg(ehdr, phdr + i, off); 590ca987d46SWarner Losh 591ca987d46SWarner Losh if (firstaddr == 0 || firstaddr > (phdr[i].p_vaddr + off)) 592ca987d46SWarner Losh firstaddr = phdr[i].p_vaddr + off; 5936b632498SEd Maste if (lastaddr == 0 || lastaddr < 5946b632498SEd Maste (phdr[i].p_vaddr + off + phdr[i].p_memsz)) 595ca987d46SWarner Losh lastaddr = phdr[i].p_vaddr + off + phdr[i].p_memsz; 596ca987d46SWarner Losh } 597ca987d46SWarner Losh lastaddr = roundup(lastaddr, sizeof(long)); 598ca987d46SWarner Losh 599ca987d46SWarner Losh /* 600ca987d46SWarner Losh * Get the section headers. We need this for finding the .ctors 601ca987d46SWarner Losh * section as well as for loading any symbols. Both may be hard 602ca987d46SWarner Losh * to do if reading from a .gz file as it involves seeking. I 603ca987d46SWarner Losh * think the rule is going to have to be that you must strip a 604ca987d46SWarner Losh * file to remove symbols before gzipping it. 605ca987d46SWarner Losh */ 606db711744SWarner Losh chunk = (size_t)ehdr->e_shnum * (size_t)ehdr->e_shentsize; 607ca987d46SWarner Losh if (chunk == 0 || ehdr->e_shoff == 0) 608ca987d46SWarner Losh goto nosyms; 609ca987d46SWarner Losh shdr = alloc_pread(ef->fd, ehdr->e_shoff, chunk); 610ca987d46SWarner Losh if (shdr == NULL) { 611ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 612ca987d46SWarner Losh "_loadimage: failed to read section headers"); 613ca987d46SWarner Losh goto nosyms; 614ca987d46SWarner Losh } 6158de1ad0bSWojciech Macek 61612363d8eSRoger Pau Monné for (i = 0; i < ehdr->e_shnum; i++) 61712363d8eSRoger Pau Monné elf_section_header_convert(ehdr, &shdr[i]); 6185cca46a9SEd Maste 619ca987d46SWarner Losh file_addmetadata(fp, MODINFOMD_SHDR, chunk, shdr); 620ca987d46SWarner Losh 621ca987d46SWarner Losh /* 622ca987d46SWarner Losh * Read the section string table and look for the .ctors section. 623ca987d46SWarner Losh * We need to tell the kernel where it is so that it can call the 624ca987d46SWarner Losh * ctors. 625ca987d46SWarner Losh */ 626ca987d46SWarner Losh chunk = shdr[ehdr->e_shstrndx].sh_size; 627ca987d46SWarner Losh if (chunk) { 6286b632498SEd Maste shstr = alloc_pread(ef->fd, shdr[ehdr->e_shstrndx].sh_offset, 6296b632498SEd Maste chunk); 630ca987d46SWarner Losh if (shstr) { 631ca987d46SWarner Losh for (i = 0; i < ehdr->e_shnum; i++) { 6326b632498SEd Maste if (strcmp(shstr + shdr[i].sh_name, 6336b632498SEd Maste ".ctors") != 0) 634ca987d46SWarner Losh continue; 635ca987d46SWarner Losh ctors = shdr[i].sh_addr; 6366b632498SEd Maste file_addmetadata(fp, MODINFOMD_CTORS_ADDR, 6376b632498SEd Maste sizeof(ctors), &ctors); 638ca987d46SWarner Losh size = shdr[i].sh_size; 6396b632498SEd Maste file_addmetadata(fp, MODINFOMD_CTORS_SIZE, 6406b632498SEd Maste sizeof(size), &size); 641ca987d46SWarner Losh break; 642ca987d46SWarner Losh } 643ca987d46SWarner Losh free(shstr); 644ca987d46SWarner Losh } 645ca987d46SWarner Losh } 646ca987d46SWarner Losh 647ca987d46SWarner Losh /* 648ca987d46SWarner Losh * Now load any symbols. 649ca987d46SWarner Losh */ 650ca987d46SWarner Losh symtabindex = -1; 651ca987d46SWarner Losh symstrindex = -1; 652ca987d46SWarner Losh for (i = 0; i < ehdr->e_shnum; i++) { 653ca987d46SWarner Losh if (shdr[i].sh_type != SHT_SYMTAB) 654ca987d46SWarner Losh continue; 655ca987d46SWarner Losh for (j = 0; j < ehdr->e_phnum; j++) { 656ca987d46SWarner Losh if (phdr[j].p_type != PT_LOAD) 657ca987d46SWarner Losh continue; 658ca987d46SWarner Losh if (shdr[i].sh_offset >= phdr[j].p_offset && 659ca987d46SWarner Losh (shdr[i].sh_offset + shdr[i].sh_size <= 660ca987d46SWarner Losh phdr[j].p_offset + phdr[j].p_filesz)) { 661ca987d46SWarner Losh shdr[i].sh_offset = 0; 662ca987d46SWarner Losh shdr[i].sh_size = 0; 663ca987d46SWarner Losh break; 664ca987d46SWarner Losh } 665ca987d46SWarner Losh } 666ca987d46SWarner Losh if (shdr[i].sh_offset == 0 || shdr[i].sh_size == 0) 667ca987d46SWarner Losh continue; /* alread loaded in a PT_LOAD above */ 668ca987d46SWarner Losh /* Save it for loading below */ 669ca987d46SWarner Losh symtabindex = i; 670ca987d46SWarner Losh symstrindex = shdr[i].sh_link; 671ca987d46SWarner Losh } 672ca987d46SWarner Losh if (symtabindex < 0 || symstrindex < 0) 673ca987d46SWarner Losh goto nosyms; 674ca987d46SWarner Losh 675ca987d46SWarner Losh /* Ok, committed to a load. */ 676ca987d46SWarner Losh #ifndef ELF_VERBOSE 677ca987d46SWarner Losh printf("syms=["); 678ca987d46SWarner Losh #endif 679ca987d46SWarner Losh ssym = lastaddr; 680ca987d46SWarner Losh for (i = symtabindex; i >= 0; i = symstrindex) { 681ca987d46SWarner Losh #ifdef ELF_VERBOSE 682ca987d46SWarner Losh char *secname; 683ca987d46SWarner Losh 684ca987d46SWarner Losh switch(shdr[i].sh_type) { 685ca987d46SWarner Losh case SHT_SYMTAB: /* Symbol table */ 686ca987d46SWarner Losh secname = "symtab"; 687ca987d46SWarner Losh break; 688ca987d46SWarner Losh case SHT_STRTAB: /* String table */ 689ca987d46SWarner Losh secname = "strtab"; 690ca987d46SWarner Losh break; 691ca987d46SWarner Losh default: 692ca987d46SWarner Losh secname = "WHOA!!"; 693ca987d46SWarner Losh break; 694ca987d46SWarner Losh } 695ca987d46SWarner Losh #endif 696ca987d46SWarner Losh size = shdr[i].sh_size; 6978de1ad0bSWojciech Macek #if defined(__powerpc__) 6988de1ad0bSWojciech Macek #if __ELF_WORD_SIZE == 64 6995cca46a9SEd Maste size = htobe64(size); 7008de1ad0bSWojciech Macek #else 7015cca46a9SEd Maste size = htobe32(size); 7028de1ad0bSWojciech Macek #endif 7038de1ad0bSWojciech Macek #endif 7045cca46a9SEd Maste 7055cca46a9SEd Maste archsw.arch_copyin(&size, lastaddr, sizeof(size)); 7065cca46a9SEd Maste lastaddr += sizeof(size); 707ca987d46SWarner Losh 708ca987d46SWarner Losh #ifdef ELF_VERBOSE 709ca987d46SWarner Losh printf("\n%s: 0x%jx@0x%jx -> 0x%jx-0x%jx", secname, 710ca987d46SWarner Losh (uintmax_t)shdr[i].sh_size, (uintmax_t)shdr[i].sh_offset, 7116b632498SEd Maste (uintmax_t)lastaddr, 7126b632498SEd Maste (uintmax_t)(lastaddr + shdr[i].sh_size)); 713ca987d46SWarner Losh #else 714ca987d46SWarner Losh if (i == symstrindex) 715ca987d46SWarner Losh printf("+"); 716ca987d46SWarner Losh printf("0x%lx+0x%lx", (long)sizeof(size), (long)size); 717ca987d46SWarner Losh #endif 718ca987d46SWarner Losh 719ca987d46SWarner Losh if (lseek(ef->fd, (off_t)shdr[i].sh_offset, SEEK_SET) == -1) { 7206b632498SEd Maste printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 7216b632498SEd Maste "_loadimage: could not seek for symbols - skipped!"); 722ca987d46SWarner Losh lastaddr = ssym; 723ca987d46SWarner Losh ssym = 0; 724ca987d46SWarner Losh goto nosyms; 725ca987d46SWarner Losh } 726ca987d46SWarner Losh result = archsw.arch_readin(ef->fd, lastaddr, shdr[i].sh_size); 727ca987d46SWarner Losh if (result < 0 || (size_t)result != shdr[i].sh_size) { 7286b632498SEd Maste printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 7296b632498SEd Maste "_loadimage: could not read symbols - skipped! " 7306b632498SEd Maste "(%ju != %ju)", (uintmax_t)result, 731ca987d46SWarner Losh (uintmax_t)shdr[i].sh_size); 732ca987d46SWarner Losh lastaddr = ssym; 733ca987d46SWarner Losh ssym = 0; 734ca987d46SWarner Losh goto nosyms; 735ca987d46SWarner Losh } 736ca987d46SWarner Losh /* Reset offsets relative to ssym */ 737ca987d46SWarner Losh lastaddr += shdr[i].sh_size; 738ca987d46SWarner Losh lastaddr = roundup(lastaddr, sizeof(size)); 739ca987d46SWarner Losh if (i == symtabindex) 740ca987d46SWarner Losh symtabindex = -1; 741ca987d46SWarner Losh else if (i == symstrindex) 742ca987d46SWarner Losh symstrindex = -1; 743ca987d46SWarner Losh } 744ca987d46SWarner Losh esym = lastaddr; 745ca987d46SWarner Losh #ifndef ELF_VERBOSE 746ca987d46SWarner Losh printf("]"); 747ca987d46SWarner Losh #endif 748ca987d46SWarner Losh 7498de1ad0bSWojciech Macek #if defined(__powerpc__) 7508de1ad0bSWojciech Macek /* On PowerPC we always need to provide BE data to the kernel */ 7518de1ad0bSWojciech Macek #if __ELF_WORD_SIZE == 64 7525cca46a9SEd Maste ssym = htobe64((uint64_t)ssym); 7535cca46a9SEd Maste esym = htobe64((uint64_t)esym); 7548de1ad0bSWojciech Macek #else 7555cca46a9SEd Maste ssym = htobe32((uint32_t)ssym); 7565cca46a9SEd Maste esym = htobe32((uint32_t)esym); 7578de1ad0bSWojciech Macek #endif 7588de1ad0bSWojciech Macek #endif 7598de1ad0bSWojciech Macek 7605cca46a9SEd Maste file_addmetadata(fp, MODINFOMD_SSYM, sizeof(ssym), &ssym); 7615cca46a9SEd Maste file_addmetadata(fp, MODINFOMD_ESYM, sizeof(esym), &esym); 762ca987d46SWarner Losh 763ca987d46SWarner Losh nosyms: 764ca987d46SWarner Losh printf("\n"); 765ca987d46SWarner Losh 766ca987d46SWarner Losh ret = lastaddr - firstaddr; 767ca987d46SWarner Losh fp->f_addr = firstaddr; 768ca987d46SWarner Losh 769ca987d46SWarner Losh php = NULL; 770ca987d46SWarner Losh for (i = 0; i < ehdr->e_phnum; i++) { 771ca987d46SWarner Losh if (phdr[i].p_type == PT_DYNAMIC) { 772ca987d46SWarner Losh php = phdr + i; 773ca987d46SWarner Losh adp = php->p_vaddr; 7746b632498SEd Maste file_addmetadata(fp, MODINFOMD_DYNAMIC, sizeof(adp), 7756b632498SEd Maste &adp); 776ca987d46SWarner Losh break; 777ca987d46SWarner Losh } 778ca987d46SWarner Losh } 779ca987d46SWarner Losh 780ca987d46SWarner Losh if (php == NULL) /* this is bad, we cannot get to symbols or _DYNAMIC */ 781ca987d46SWarner Losh goto out; 782ca987d46SWarner Losh 783ca987d46SWarner Losh ndp = php->p_filesz / sizeof(Elf_Dyn); 784ca987d46SWarner Losh if (ndp == 0) 785ca987d46SWarner Losh goto out; 786ca987d46SWarner Losh dp = malloc(php->p_filesz); 787ca987d46SWarner Losh if (dp == NULL) 788ca987d46SWarner Losh goto out; 789ca987d46SWarner Losh archsw.arch_copyout(php->p_vaddr + off, dp, php->p_filesz); 790ca987d46SWarner Losh 791ca987d46SWarner Losh ef->strsz = 0; 792ca987d46SWarner Losh for (i = 0; i < ndp; i++) { 793ca987d46SWarner Losh if (dp[i].d_tag == 0) 794ca987d46SWarner Losh break; 795ca987d46SWarner Losh switch (dp[i].d_tag) { 796ca987d46SWarner Losh case DT_HASH: 7976b632498SEd Maste ef->hashtab = 7986b632498SEd Maste (Elf_Hashelt*)(uintptr_t)(dp[i].d_un.d_ptr + off); 799ca987d46SWarner Losh break; 800ca987d46SWarner Losh case DT_STRTAB: 8016b632498SEd Maste ef->strtab = 8026b632498SEd Maste (char *)(uintptr_t)(dp[i].d_un.d_ptr + off); 803ca987d46SWarner Losh break; 804ca987d46SWarner Losh case DT_STRSZ: 805ca987d46SWarner Losh ef->strsz = dp[i].d_un.d_val; 806ca987d46SWarner Losh break; 807ca987d46SWarner Losh case DT_SYMTAB: 8086b632498SEd Maste ef->symtab = 8096b632498SEd Maste (Elf_Sym *)(uintptr_t)(dp[i].d_un.d_ptr + off); 810ca987d46SWarner Losh break; 811ca987d46SWarner Losh case DT_REL: 8126b632498SEd Maste ef->rel = 8136b632498SEd Maste (Elf_Rel *)(uintptr_t)(dp[i].d_un.d_ptr + off); 814ca987d46SWarner Losh break; 815ca987d46SWarner Losh case DT_RELSZ: 816ca987d46SWarner Losh ef->relsz = dp[i].d_un.d_val; 817ca987d46SWarner Losh break; 818ca987d46SWarner Losh case DT_RELA: 8196b632498SEd Maste ef->rela = 8206b632498SEd Maste (Elf_Rela *)(uintptr_t)(dp[i].d_un.d_ptr + off); 821ca987d46SWarner Losh break; 822ca987d46SWarner Losh case DT_RELASZ: 823ca987d46SWarner Losh ef->relasz = dp[i].d_un.d_val; 824ca987d46SWarner Losh break; 825ca987d46SWarner Losh default: 826ca987d46SWarner Losh break; 827ca987d46SWarner Losh } 828ca987d46SWarner Losh } 829ca987d46SWarner Losh if (ef->hashtab == NULL || ef->symtab == NULL || 830ca987d46SWarner Losh ef->strtab == NULL || ef->strsz == 0) 831ca987d46SWarner Losh goto out; 832ca987d46SWarner Losh COPYOUT(ef->hashtab, &ef->nbuckets, sizeof(ef->nbuckets)); 833ca987d46SWarner Losh COPYOUT(ef->hashtab + 1, &ef->nchains, sizeof(ef->nchains)); 834ca987d46SWarner Losh ef->buckets = ef->hashtab + 2; 835ca987d46SWarner Losh ef->chains = ef->buckets + ef->nbuckets; 836ca987d46SWarner Losh 8376b632498SEd Maste if (__elfN(lookup_symbol)(fp, ef, "__start_set_modmetadata_set", 8386b632498SEd Maste &sym) != 0) 839ca987d46SWarner Losh return 0; 840ca987d46SWarner Losh p_start = sym.st_value + ef->off; 8416b632498SEd Maste if (__elfN(lookup_symbol)(fp, ef, "__stop_set_modmetadata_set", 8426b632498SEd Maste &sym) != 0) 843ca987d46SWarner Losh return ENOENT; 844ca987d46SWarner Losh p_end = sym.st_value + ef->off; 845ca987d46SWarner Losh 846ca987d46SWarner Losh if (__elfN(parse_modmetadata)(fp, ef, p_start, p_end) == 0) 847ca987d46SWarner Losh goto out; 848ca987d46SWarner Losh 849ca987d46SWarner Losh if (ef->kernel) /* kernel must not depend on anything */ 850ca987d46SWarner Losh goto out; 851ca987d46SWarner Losh 852ca987d46SWarner Losh out: 853ca987d46SWarner Losh if (dp) 854ca987d46SWarner Losh free(dp); 855ca987d46SWarner Losh if (shdr) 856ca987d46SWarner Losh free(shdr); 857ca987d46SWarner Losh return ret; 858ca987d46SWarner Losh } 859ca987d46SWarner Losh 860ca987d46SWarner Losh static char invalid_name[] = "bad"; 861ca987d46SWarner Losh 862ca987d46SWarner Losh char * 863ca987d46SWarner Losh fake_modname(const char *name) 864ca987d46SWarner Losh { 865ca987d46SWarner Losh const char *sp, *ep; 866ca987d46SWarner Losh char *fp; 867ca987d46SWarner Losh size_t len; 868ca987d46SWarner Losh 869ca987d46SWarner Losh sp = strrchr(name, '/'); 870ca987d46SWarner Losh if (sp) 871ca987d46SWarner Losh sp++; 872ca987d46SWarner Losh else 873ca987d46SWarner Losh sp = name; 874fe6ee081SEd Maste 875fe6ee081SEd Maste ep = strrchr(sp, '.'); 876fe6ee081SEd Maste if (ep == NULL) { 877fe6ee081SEd Maste ep = sp + strlen(sp); 878fe6ee081SEd Maste } 879fe6ee081SEd Maste if (ep == sp) { 880ca987d46SWarner Losh sp = invalid_name; 881ca987d46SWarner Losh ep = invalid_name + sizeof(invalid_name) - 1; 882ca987d46SWarner Losh } 883fe6ee081SEd Maste 884ca987d46SWarner Losh len = ep - sp; 885ca987d46SWarner Losh fp = malloc(len + 1); 886ca987d46SWarner Losh if (fp == NULL) 887ca987d46SWarner Losh return NULL; 888ca987d46SWarner Losh memcpy(fp, sp, len); 889ca987d46SWarner Losh fp[len] = '\0'; 890ca987d46SWarner Losh return fp; 891ca987d46SWarner Losh } 892ca987d46SWarner Losh 893ca987d46SWarner Losh #if (defined(__i386__) || defined(__powerpc__)) && __ELF_WORD_SIZE == 64 894ca987d46SWarner Losh struct mod_metadata64 { 895ca987d46SWarner Losh int md_version; /* structure version MDTV_* */ 896ca987d46SWarner Losh int md_type; /* type of entry MDT_* */ 89756e53cb8SWarner Losh uint64_t md_data; /* specific data */ 89856e53cb8SWarner Losh uint64_t md_cval; /* common string label */ 899ca987d46SWarner Losh }; 900ca987d46SWarner Losh #endif 901ca987d46SWarner Losh #if defined(__amd64__) && __ELF_WORD_SIZE == 32 902ca987d46SWarner Losh struct mod_metadata32 { 903ca987d46SWarner Losh int md_version; /* structure version MDTV_* */ 904ca987d46SWarner Losh int md_type; /* type of entry MDT_* */ 90556e53cb8SWarner Losh uint32_t md_data; /* specific data */ 90656e53cb8SWarner Losh uint32_t md_cval; /* common string label */ 907ca987d46SWarner Losh }; 908ca987d46SWarner Losh #endif 909ca987d46SWarner Losh 910ca987d46SWarner Losh int 91156e53cb8SWarner Losh __elfN(load_modmetadata)(struct preloaded_file *fp, uint64_t dest) 912ca987d46SWarner Losh { 913ca987d46SWarner Losh struct elf_file ef; 914ca987d46SWarner Losh int err, i, j; 915ca987d46SWarner Losh Elf_Shdr *sh_meta, *shdr = NULL; 916ca987d46SWarner Losh Elf_Shdr *sh_data[2]; 917ca987d46SWarner Losh char *shstrtab = NULL; 918ca987d46SWarner Losh size_t size; 919ca987d46SWarner Losh Elf_Addr p_start, p_end; 920ca987d46SWarner Losh 921ca987d46SWarner Losh bzero(&ef, sizeof(struct elf_file)); 922ca987d46SWarner Losh ef.fd = -1; 923ca987d46SWarner Losh 924ca987d46SWarner Losh err = __elfN(load_elf_header)(fp->f_name, &ef); 925ca987d46SWarner Losh if (err != 0) 926ca987d46SWarner Losh goto out; 927ca987d46SWarner Losh 928ca987d46SWarner Losh if (ef.kernel == 1 || ef.ehdr->e_type == ET_EXEC) { 929ca987d46SWarner Losh ef.kernel = 1; 930ca987d46SWarner Losh } else if (ef.ehdr->e_type != ET_DYN) { 931ca987d46SWarner Losh err = EFTYPE; 932ca987d46SWarner Losh goto out; 933ca987d46SWarner Losh } 934ca987d46SWarner Losh 935db711744SWarner Losh size = (size_t)ef.ehdr->e_shnum * (size_t)ef.ehdr->e_shentsize; 936ca987d46SWarner Losh shdr = alloc_pread(ef.fd, ef.ehdr->e_shoff, size); 937ca987d46SWarner Losh if (shdr == NULL) { 938ca987d46SWarner Losh err = ENOMEM; 939ca987d46SWarner Losh goto out; 940ca987d46SWarner Losh } 941ca987d46SWarner Losh 942ca987d46SWarner Losh /* Load shstrtab. */ 943ca987d46SWarner Losh shstrtab = alloc_pread(ef.fd, shdr[ef.ehdr->e_shstrndx].sh_offset, 944ca987d46SWarner Losh shdr[ef.ehdr->e_shstrndx].sh_size); 945ca987d46SWarner Losh if (shstrtab == NULL) { 946ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 947ca987d46SWarner Losh "load_modmetadata: unable to load shstrtab\n"); 948ca987d46SWarner Losh err = EFTYPE; 949ca987d46SWarner Losh goto out; 950ca987d46SWarner Losh } 951ca987d46SWarner Losh 952ca987d46SWarner Losh /* Find set_modmetadata_set and data sections. */ 953ca987d46SWarner Losh sh_data[0] = sh_data[1] = sh_meta = NULL; 954ca987d46SWarner Losh for (i = 0, j = 0; i < ef.ehdr->e_shnum; i++) { 955ca987d46SWarner Losh if (strcmp(&shstrtab[shdr[i].sh_name], 956ca987d46SWarner Losh "set_modmetadata_set") == 0) { 957ca987d46SWarner Losh sh_meta = &shdr[i]; 958ca987d46SWarner Losh } 959ca987d46SWarner Losh if ((strcmp(&shstrtab[shdr[i].sh_name], ".data") == 0) || 960ca987d46SWarner Losh (strcmp(&shstrtab[shdr[i].sh_name], ".rodata") == 0)) { 961ca987d46SWarner Losh sh_data[j++] = &shdr[i]; 962ca987d46SWarner Losh } 963ca987d46SWarner Losh } 964ca987d46SWarner Losh if (sh_meta == NULL || sh_data[0] == NULL || sh_data[1] == NULL) { 965ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 966ca987d46SWarner Losh "load_modmetadata: unable to find set_modmetadata_set or data sections\n"); 967ca987d46SWarner Losh err = EFTYPE; 968ca987d46SWarner Losh goto out; 969ca987d46SWarner Losh } 970ca987d46SWarner Losh 971ca987d46SWarner Losh /* Load set_modmetadata_set into memory */ 972ca987d46SWarner Losh err = kern_pread(ef.fd, dest, sh_meta->sh_size, sh_meta->sh_offset); 973ca987d46SWarner Losh if (err != 0) { 974ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 975ca987d46SWarner Losh "load_modmetadata: unable to load set_modmetadata_set: %d\n", err); 976ca987d46SWarner Losh goto out; 977ca987d46SWarner Losh } 978ca987d46SWarner Losh p_start = dest; 979ca987d46SWarner Losh p_end = dest + sh_meta->sh_size; 980ca987d46SWarner Losh dest += sh_meta->sh_size; 981ca987d46SWarner Losh 982ca987d46SWarner Losh /* Load data sections into memory. */ 983ca987d46SWarner Losh err = kern_pread(ef.fd, dest, sh_data[0]->sh_size, 984ca987d46SWarner Losh sh_data[0]->sh_offset); 985ca987d46SWarner Losh if (err != 0) { 986ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 987ca987d46SWarner Losh "load_modmetadata: unable to load data: %d\n", err); 988ca987d46SWarner Losh goto out; 989ca987d46SWarner Losh } 990ca987d46SWarner Losh 991ca987d46SWarner Losh /* 992ca987d46SWarner Losh * We have to increment the dest, so that the offset is the same into 993ca987d46SWarner Losh * both the .rodata and .data sections. 994ca987d46SWarner Losh */ 995ca987d46SWarner Losh ef.off = -(sh_data[0]->sh_addr - dest); 996ca987d46SWarner Losh dest += (sh_data[1]->sh_addr - sh_data[0]->sh_addr); 997ca987d46SWarner Losh 998ca987d46SWarner Losh err = kern_pread(ef.fd, dest, sh_data[1]->sh_size, 999ca987d46SWarner Losh sh_data[1]->sh_offset); 1000ca987d46SWarner Losh if (err != 0) { 1001ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 1002ca987d46SWarner Losh "load_modmetadata: unable to load data: %d\n", err); 1003ca987d46SWarner Losh goto out; 1004ca987d46SWarner Losh } 1005ca987d46SWarner Losh 1006ca987d46SWarner Losh err = __elfN(parse_modmetadata)(fp, &ef, p_start, p_end); 1007ca987d46SWarner Losh if (err != 0) { 1008ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 1009ca987d46SWarner Losh "load_modmetadata: unable to parse metadata: %d\n", err); 1010ca987d46SWarner Losh goto out; 1011ca987d46SWarner Losh } 1012ca987d46SWarner Losh 1013ca987d46SWarner Losh out: 1014ca987d46SWarner Losh if (shstrtab != NULL) 1015ca987d46SWarner Losh free(shstrtab); 1016ca987d46SWarner Losh if (shdr != NULL) 1017ca987d46SWarner Losh free(shdr); 1018ca987d46SWarner Losh if (ef.firstpage != NULL) 1019ca987d46SWarner Losh free(ef.firstpage); 1020ca987d46SWarner Losh if (ef.fd != -1) 1021ca987d46SWarner Losh close(ef.fd); 1022ca987d46SWarner Losh return (err); 1023ca987d46SWarner Losh } 1024ca987d46SWarner Losh 1025ca987d46SWarner Losh int 1026ca987d46SWarner Losh __elfN(parse_modmetadata)(struct preloaded_file *fp, elf_file_t ef, 1027ca987d46SWarner Losh Elf_Addr p_start, Elf_Addr p_end) 1028ca987d46SWarner Losh { 1029ca987d46SWarner Losh struct mod_metadata md; 1030ca987d46SWarner Losh #if (defined(__i386__) || defined(__powerpc__)) && __ELF_WORD_SIZE == 64 1031ca987d46SWarner Losh struct mod_metadata64 md64; 1032ca987d46SWarner Losh #elif defined(__amd64__) && __ELF_WORD_SIZE == 32 1033ca987d46SWarner Losh struct mod_metadata32 md32; 1034ca987d46SWarner Losh #endif 1035ca987d46SWarner Losh struct mod_depend *mdepend; 1036ca987d46SWarner Losh struct mod_version mver; 1037ca987d46SWarner Losh char *s; 1038ca987d46SWarner Losh int error, modcnt, minfolen; 1039ca987d46SWarner Losh Elf_Addr v, p; 1040ca987d46SWarner Losh 1041ca987d46SWarner Losh modcnt = 0; 1042ca987d46SWarner Losh p = p_start; 1043ca987d46SWarner Losh while (p < p_end) { 1044ca987d46SWarner Losh COPYOUT(p, &v, sizeof(v)); 1045ca987d46SWarner Losh error = __elfN(reloc_ptr)(fp, ef, p, &v, sizeof(v)); 1046ca987d46SWarner Losh if (error == EOPNOTSUPP) 1047ca987d46SWarner Losh v += ef->off; 1048ca987d46SWarner Losh else if (error != 0) 1049ca987d46SWarner Losh return (error); 1050ca987d46SWarner Losh #if (defined(__i386__) || defined(__powerpc__)) && __ELF_WORD_SIZE == 64 1051ca987d46SWarner Losh COPYOUT(v, &md64, sizeof(md64)); 1052ca987d46SWarner Losh error = __elfN(reloc_ptr)(fp, ef, v, &md64, sizeof(md64)); 1053ca987d46SWarner Losh if (error == EOPNOTSUPP) { 1054ca987d46SWarner Losh md64.md_cval += ef->off; 1055ca987d46SWarner Losh md64.md_data += ef->off; 1056ca987d46SWarner Losh } else if (error != 0) 1057ca987d46SWarner Losh return (error); 1058ca987d46SWarner Losh md.md_version = md64.md_version; 1059ca987d46SWarner Losh md.md_type = md64.md_type; 1060ca987d46SWarner Losh md.md_cval = (const char *)(uintptr_t)md64.md_cval; 1061ca987d46SWarner Losh md.md_data = (void *)(uintptr_t)md64.md_data; 1062ca987d46SWarner Losh #elif defined(__amd64__) && __ELF_WORD_SIZE == 32 1063ca987d46SWarner Losh COPYOUT(v, &md32, sizeof(md32)); 1064ca987d46SWarner Losh error = __elfN(reloc_ptr)(fp, ef, v, &md32, sizeof(md32)); 1065ca987d46SWarner Losh if (error == EOPNOTSUPP) { 1066ca987d46SWarner Losh md32.md_cval += ef->off; 1067ca987d46SWarner Losh md32.md_data += ef->off; 1068ca987d46SWarner Losh } else if (error != 0) 1069ca987d46SWarner Losh return (error); 1070ca987d46SWarner Losh md.md_version = md32.md_version; 1071ca987d46SWarner Losh md.md_type = md32.md_type; 1072ca987d46SWarner Losh md.md_cval = (const char *)(uintptr_t)md32.md_cval; 1073ca987d46SWarner Losh md.md_data = (void *)(uintptr_t)md32.md_data; 1074ca987d46SWarner Losh #else 1075ca987d46SWarner Losh COPYOUT(v, &md, sizeof(md)); 1076ca987d46SWarner Losh error = __elfN(reloc_ptr)(fp, ef, v, &md, sizeof(md)); 1077ca987d46SWarner Losh if (error == EOPNOTSUPP) { 1078ca987d46SWarner Losh md.md_cval += ef->off; 10796b632498SEd Maste md.md_data = (void *)((uintptr_t)md.md_data + 10806b632498SEd Maste (uintptr_t)ef->off); 1081ca987d46SWarner Losh } else if (error != 0) 1082ca987d46SWarner Losh return (error); 1083ca987d46SWarner Losh #endif 1084ca987d46SWarner Losh p += sizeof(Elf_Addr); 1085ca987d46SWarner Losh switch(md.md_type) { 1086ca987d46SWarner Losh case MDT_DEPEND: 1087ca987d46SWarner Losh if (ef->kernel) /* kernel must not depend on anything */ 1088ca987d46SWarner Losh break; 1089ca987d46SWarner Losh s = strdupout((vm_offset_t)md.md_cval); 1090ca987d46SWarner Losh minfolen = sizeof(*mdepend) + strlen(s) + 1; 1091ca987d46SWarner Losh mdepend = malloc(minfolen); 1092ca987d46SWarner Losh if (mdepend == NULL) 1093ca987d46SWarner Losh return ENOMEM; 10946b632498SEd Maste COPYOUT((vm_offset_t)md.md_data, mdepend, 10956b632498SEd Maste sizeof(*mdepend)); 1096ca987d46SWarner Losh strcpy((char*)(mdepend + 1), s); 1097ca987d46SWarner Losh free(s); 10986b632498SEd Maste file_addmetadata(fp, MODINFOMD_DEPLIST, minfolen, 10996b632498SEd Maste mdepend); 1100ca987d46SWarner Losh free(mdepend); 1101ca987d46SWarner Losh break; 1102ca987d46SWarner Losh case MDT_VERSION: 1103ca987d46SWarner Losh s = strdupout((vm_offset_t)md.md_cval); 1104ca987d46SWarner Losh COPYOUT((vm_offset_t)md.md_data, &mver, sizeof(mver)); 1105ca987d46SWarner Losh file_addmodule(fp, s, mver.mv_version, NULL); 1106ca987d46SWarner Losh free(s); 1107ca987d46SWarner Losh modcnt++; 1108ca987d46SWarner Losh break; 1109ca987d46SWarner Losh } 1110ca987d46SWarner Losh } 1111ca987d46SWarner Losh if (modcnt == 0) { 1112ca987d46SWarner Losh s = fake_modname(fp->f_name); 1113ca987d46SWarner Losh file_addmodule(fp, s, 1, NULL); 1114ca987d46SWarner Losh free(s); 1115ca987d46SWarner Losh } 1116ca987d46SWarner Losh return 0; 1117ca987d46SWarner Losh } 1118ca987d46SWarner Losh 1119ca987d46SWarner Losh static unsigned long 1120ca987d46SWarner Losh elf_hash(const char *name) 1121ca987d46SWarner Losh { 1122ca987d46SWarner Losh const unsigned char *p = (const unsigned char *) name; 1123ca987d46SWarner Losh unsigned long h = 0; 1124ca987d46SWarner Losh unsigned long g; 1125ca987d46SWarner Losh 1126ca987d46SWarner Losh while (*p != '\0') { 1127ca987d46SWarner Losh h = (h << 4) + *p++; 1128ca987d46SWarner Losh if ((g = h & 0xf0000000) != 0) 1129ca987d46SWarner Losh h ^= g >> 24; 1130ca987d46SWarner Losh h &= ~g; 1131ca987d46SWarner Losh } 1132ca987d46SWarner Losh return h; 1133ca987d46SWarner Losh } 1134ca987d46SWarner Losh 11356b632498SEd Maste static const char __elfN(bad_symtable)[] = "elf" __XSTRING(__ELF_WORD_SIZE) 11366b632498SEd Maste "_lookup_symbol: corrupt symbol table\n"; 1137ca987d46SWarner Losh int 11386b632498SEd Maste __elfN(lookup_symbol)(struct preloaded_file *fp, elf_file_t ef, 11396b632498SEd Maste const char* name, Elf_Sym *symp) 1140ca987d46SWarner Losh { 1141ca987d46SWarner Losh Elf_Hashelt symnum; 1142ca987d46SWarner Losh Elf_Sym sym; 1143ca987d46SWarner Losh char *strp; 1144ca987d46SWarner Losh unsigned long hash; 1145ca987d46SWarner Losh 1146ca987d46SWarner Losh hash = elf_hash(name); 1147ca987d46SWarner Losh COPYOUT(&ef->buckets[hash % ef->nbuckets], &symnum, sizeof(symnum)); 1148ca987d46SWarner Losh 1149ca987d46SWarner Losh while (symnum != STN_UNDEF) { 1150ca987d46SWarner Losh if (symnum >= ef->nchains) { 1151ca987d46SWarner Losh printf(__elfN(bad_symtable)); 1152ca987d46SWarner Losh return ENOENT; 1153ca987d46SWarner Losh } 1154ca987d46SWarner Losh 1155ca987d46SWarner Losh COPYOUT(ef->symtab + symnum, &sym, sizeof(sym)); 1156ca987d46SWarner Losh if (sym.st_name == 0) { 1157ca987d46SWarner Losh printf(__elfN(bad_symtable)); 1158ca987d46SWarner Losh return ENOENT; 1159ca987d46SWarner Losh } 1160ca987d46SWarner Losh 1161ca987d46SWarner Losh strp = strdupout((vm_offset_t)(ef->strtab + sym.st_name)); 1162ca987d46SWarner Losh if (strcmp(name, strp) == 0) { 1163ca987d46SWarner Losh free(strp); 1164ca987d46SWarner Losh if (sym.st_shndx != SHN_UNDEF || 1165ca987d46SWarner Losh (sym.st_value != 0 && 1166ca987d46SWarner Losh ELF_ST_TYPE(sym.st_info) == STT_FUNC)) { 1167ca987d46SWarner Losh *symp = sym; 1168ca987d46SWarner Losh return 0; 1169ca987d46SWarner Losh } 1170ca987d46SWarner Losh return ENOENT; 1171ca987d46SWarner Losh } 1172ca987d46SWarner Losh free(strp); 1173ca987d46SWarner Losh COPYOUT(&ef->chains[symnum], &symnum, sizeof(symnum)); 1174ca987d46SWarner Losh } 1175ca987d46SWarner Losh return ENOENT; 1176ca987d46SWarner Losh } 1177ca987d46SWarner Losh 1178ca987d46SWarner Losh /* 1179ca987d46SWarner Losh * Apply any intra-module relocations to the value. p is the load address 1180ca987d46SWarner Losh * of the value and val/len is the value to be modified. This does NOT modify 1181ca987d46SWarner Losh * the image in-place, because this is done by kern_linker later on. 1182ca987d46SWarner Losh * 1183ca987d46SWarner Losh * Returns EOPNOTSUPP if no relocation method is supplied. 1184ca987d46SWarner Losh */ 1185ca987d46SWarner Losh static int 1186ca987d46SWarner Losh __elfN(reloc_ptr)(struct preloaded_file *mp, elf_file_t ef, 1187ca987d46SWarner Losh Elf_Addr p, void *val, size_t len) 1188ca987d46SWarner Losh { 1189ca987d46SWarner Losh size_t n; 1190ca987d46SWarner Losh Elf_Rela a; 1191ca987d46SWarner Losh Elf_Rel r; 1192ca987d46SWarner Losh int error; 1193ca987d46SWarner Losh 1194ca987d46SWarner Losh /* 1195ca987d46SWarner Losh * The kernel is already relocated, but we still want to apply 1196ca987d46SWarner Losh * offset adjustments. 1197ca987d46SWarner Losh */ 1198ca987d46SWarner Losh if (ef->kernel) 1199ca987d46SWarner Losh return (EOPNOTSUPP); 1200ca987d46SWarner Losh 1201ca987d46SWarner Losh for (n = 0; n < ef->relsz / sizeof(r); n++) { 1202ca987d46SWarner Losh COPYOUT(ef->rel + n, &r, sizeof(r)); 1203ca987d46SWarner Losh 1204ca987d46SWarner Losh error = __elfN(reloc)(ef, __elfN(symaddr), &r, ELF_RELOC_REL, 1205ca987d46SWarner Losh ef->off, p, val, len); 1206ca987d46SWarner Losh if (error != 0) 1207ca987d46SWarner Losh return (error); 1208ca987d46SWarner Losh } 1209ca987d46SWarner Losh for (n = 0; n < ef->relasz / sizeof(a); n++) { 1210ca987d46SWarner Losh COPYOUT(ef->rela + n, &a, sizeof(a)); 1211ca987d46SWarner Losh 1212ca987d46SWarner Losh error = __elfN(reloc)(ef, __elfN(symaddr), &a, ELF_RELOC_RELA, 1213ca987d46SWarner Losh ef->off, p, val, len); 1214ca987d46SWarner Losh if (error != 0) 1215ca987d46SWarner Losh return (error); 1216ca987d46SWarner Losh } 1217ca987d46SWarner Losh 1218ca987d46SWarner Losh return (0); 1219ca987d46SWarner Losh } 1220ca987d46SWarner Losh 1221ca987d46SWarner Losh static Elf_Addr 1222ca987d46SWarner Losh __elfN(symaddr)(struct elf_file *ef, Elf_Size symidx) 1223ca987d46SWarner Losh { 1224ca987d46SWarner Losh 1225ca987d46SWarner Losh /* Symbol lookup by index not required here. */ 1226ca987d46SWarner Losh return (0); 1227ca987d46SWarner Losh } 1228