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; 458ca987d46SWarner Losh if (ehdr->e_type == ET_EXEC) { 459ca987d46SWarner Losh #if defined(__i386__) || defined(__amd64__) 460ca987d46SWarner Losh #if __ELF_WORD_SIZE == 64 4616b632498SEd Maste /* x86_64 relocates after locore */ 4626b632498SEd Maste off = - (off & 0xffffffffff000000ull); 463ca987d46SWarner Losh #else 4646b632498SEd Maste /* i386 relocates after locore */ 4656b632498SEd Maste off = - (off & 0xff000000u); 466ca987d46SWarner Losh #endif 467ca987d46SWarner Losh #elif defined(__powerpc__) 468ca987d46SWarner Losh /* 4696b632498SEd Maste * On the purely virtual memory machines like e500, the kernel 4706b632498SEd Maste * is linked against its final VA range, which is most often 4716b632498SEd Maste * not available at the loader stage, but only after kernel 4726b632498SEd Maste * initializes and completes its VM settings. In such cases we 4736b632498SEd Maste * cannot use p_vaddr field directly to load ELF segments, but 4746b632498SEd Maste * put them at some 'load-time' locations. 475ca987d46SWarner Losh */ 476ca987d46SWarner Losh if (off & 0xf0000000u) { 477ca987d46SWarner Losh off = -(off & 0xf0000000u); 478ca987d46SWarner Losh /* 4796b632498SEd Maste * XXX the physical load address should not be 4806b632498SEd Maste * hardcoded. Note that the Book-E kernel assumes that 4816b632498SEd Maste * it's loaded at a 16MB boundary for now... 482ca987d46SWarner Losh */ 483ca987d46SWarner Losh off += 0x01000000; 484ca987d46SWarner Losh ehdr->e_entry += off; 485ca987d46SWarner Losh #ifdef ELF_VERBOSE 486ff7449d6SLeandro Lupori printf("Converted entry 0x%jx\n", (uintmax_t)ehdr->e_entry); 487ca987d46SWarner Losh #endif 488ca987d46SWarner Losh } else 489ca987d46SWarner Losh off = 0; 490ca987d46SWarner Losh #elif defined(__arm__) && !defined(EFI) 491ca987d46SWarner Losh /* 4926b632498SEd Maste * The elf headers in arm kernels specify virtual addresses in 4936b632498SEd Maste * all header fields, even the ones that should be physical 4946b632498SEd Maste * addresses. We assume the entry point is in the first page, 4956b632498SEd Maste * and masking the page offset will leave us with the virtual 4966b632498SEd Maste * address the kernel was linked at. We subtract that from the 4976b632498SEd Maste * load offset, making 'off' into the value which, when added 4986b632498SEd Maste * to a virtual address in an elf header, translates it to a 4996b632498SEd Maste * physical address. We do the va->pa conversion on the entry 5006b632498SEd Maste * point address in the header now, so that later we can launch 5016b632498SEd Maste * the kernel by just jumping to that address. 502ca987d46SWarner Losh * 5036b632498SEd Maste * When booting from UEFI the copyin and copyout functions 5046b632498SEd Maste * handle adjusting the location relative to the first virtual 5056b632498SEd Maste * address. Because of this there is no need to adjust the 5066b632498SEd Maste * offset or entry point address as these will both be handled 5076b632498SEd Maste * by the efi code. 508ca987d46SWarner Losh */ 509ca987d46SWarner Losh off -= ehdr->e_entry & ~PAGE_MASK; 510ca987d46SWarner Losh ehdr->e_entry += off; 511ca987d46SWarner Losh #ifdef ELF_VERBOSE 512637b6532SEnji Cooper printf("ehdr->e_entry 0x%jx, va<->pa off %llx\n", 513ff7449d6SLeandro Lupori (uintmax_t)ehdr->e_entry, off); 514ca987d46SWarner Losh #endif 515ca987d46SWarner Losh #else 516ca987d46SWarner Losh off = 0; /* other archs use direct mapped kernels */ 517ca987d46SWarner Losh #endif 518ca987d46SWarner Losh } 519ca987d46SWarner Losh ef->off = off; 520ca987d46SWarner Losh 521ca987d46SWarner Losh if (ef->kernel) 522ca987d46SWarner Losh __elfN(relocation_offset) = off; 523ca987d46SWarner Losh 524ca987d46SWarner Losh if ((ehdr->e_phoff + ehdr->e_phnum * sizeof(*phdr)) > ef->firstlen) { 5256b632498SEd Maste printf("elf" __XSTRING(__ELF_WORD_SIZE) 5266b632498SEd Maste "_loadimage: program header not within first page\n"); 527ca987d46SWarner Losh goto out; 528ca987d46SWarner Losh } 529ca987d46SWarner Losh phdr = (Elf_Phdr *)(ef->firstpage + ehdr->e_phoff); 530ca987d46SWarner Losh 531ca987d46SWarner Losh for (i = 0; i < ehdr->e_phnum; i++) { 53212363d8eSRoger Pau Monné if (elf_program_header_convert(ehdr, phdr)) 53312363d8eSRoger Pau Monné continue; 5348de1ad0bSWojciech Macek 535ca987d46SWarner Losh /* We want to load PT_LOAD segments only.. */ 536ca987d46SWarner Losh if (phdr[i].p_type != PT_LOAD) 537ca987d46SWarner Losh continue; 538ca987d46SWarner Losh 539ca987d46SWarner Losh #ifdef ELF_VERBOSE 540ca987d46SWarner Losh printf("Segment: 0x%lx@0x%lx -> 0x%lx-0x%lx", 541ca987d46SWarner Losh (long)phdr[i].p_filesz, (long)phdr[i].p_offset, 542ca987d46SWarner Losh (long)(phdr[i].p_vaddr + off), 543ca987d46SWarner Losh (long)(phdr[i].p_vaddr + off + phdr[i].p_memsz - 1)); 544ca987d46SWarner Losh #else 545ca987d46SWarner Losh if ((phdr[i].p_flags & PF_W) == 0) { 546ca987d46SWarner Losh printf("text=0x%lx ", (long)phdr[i].p_filesz); 547ca987d46SWarner Losh } else { 548ca987d46SWarner Losh printf("data=0x%lx", (long)phdr[i].p_filesz); 549ca987d46SWarner Losh if (phdr[i].p_filesz < phdr[i].p_memsz) 5506b632498SEd Maste printf("+0x%lx", (long)(phdr[i].p_memsz - 5516b632498SEd Maste phdr[i].p_filesz)); 552ca987d46SWarner Losh printf(" "); 553ca987d46SWarner Losh } 554ca987d46SWarner Losh #endif 555ca987d46SWarner Losh fpcopy = 0; 556ca987d46SWarner Losh if (ef->firstlen > phdr[i].p_offset) { 557ca987d46SWarner Losh fpcopy = ef->firstlen - phdr[i].p_offset; 558ca987d46SWarner Losh archsw.arch_copyin(ef->firstpage + phdr[i].p_offset, 559ca987d46SWarner Losh phdr[i].p_vaddr + off, fpcopy); 560ca987d46SWarner Losh } 561ca987d46SWarner Losh if (phdr[i].p_filesz > fpcopy) { 562ca987d46SWarner Losh if (kern_pread(ef->fd, phdr[i].p_vaddr + off + fpcopy, 5636b632498SEd Maste phdr[i].p_filesz - fpcopy, 5646b632498SEd Maste phdr[i].p_offset + fpcopy) != 0) { 565ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 566ca987d46SWarner Losh "_loadimage: read failed\n"); 567ca987d46SWarner Losh goto out; 568ca987d46SWarner Losh } 569ca987d46SWarner Losh } 570ca987d46SWarner Losh /* clear space from oversized segments; eg: bss */ 571ca987d46SWarner Losh if (phdr[i].p_filesz < phdr[i].p_memsz) { 572ca987d46SWarner Losh #ifdef ELF_VERBOSE 573ca987d46SWarner Losh printf(" (bss: 0x%lx-0x%lx)", 574ca987d46SWarner Losh (long)(phdr[i].p_vaddr + off + phdr[i].p_filesz), 575ca987d46SWarner Losh (long)(phdr[i].p_vaddr + off + phdr[i].p_memsz -1)); 576ca987d46SWarner Losh #endif 577ca987d46SWarner Losh 578ca987d46SWarner Losh kern_bzero(phdr[i].p_vaddr + off + phdr[i].p_filesz, 579ca987d46SWarner Losh phdr[i].p_memsz - phdr[i].p_filesz); 580ca987d46SWarner Losh } 581ca987d46SWarner Losh #ifdef ELF_VERBOSE 582ca987d46SWarner Losh printf("\n"); 583ca987d46SWarner Losh #endif 584ca987d46SWarner Losh 585ca987d46SWarner Losh if (archsw.arch_loadseg != NULL) 586ca987d46SWarner Losh archsw.arch_loadseg(ehdr, phdr + i, off); 587ca987d46SWarner Losh 588ca987d46SWarner Losh if (firstaddr == 0 || firstaddr > (phdr[i].p_vaddr + off)) 589ca987d46SWarner Losh firstaddr = phdr[i].p_vaddr + off; 5906b632498SEd Maste if (lastaddr == 0 || lastaddr < 5916b632498SEd Maste (phdr[i].p_vaddr + off + phdr[i].p_memsz)) 592ca987d46SWarner Losh lastaddr = phdr[i].p_vaddr + off + phdr[i].p_memsz; 593ca987d46SWarner Losh } 594ca987d46SWarner Losh lastaddr = roundup(lastaddr, sizeof(long)); 595ca987d46SWarner Losh 596ca987d46SWarner Losh /* 597ca987d46SWarner Losh * Get the section headers. We need this for finding the .ctors 598ca987d46SWarner Losh * section as well as for loading any symbols. Both may be hard 599ca987d46SWarner Losh * to do if reading from a .gz file as it involves seeking. I 600ca987d46SWarner Losh * think the rule is going to have to be that you must strip a 601ca987d46SWarner Losh * file to remove symbols before gzipping it. 602ca987d46SWarner Losh */ 603db711744SWarner Losh chunk = (size_t)ehdr->e_shnum * (size_t)ehdr->e_shentsize; 604ca987d46SWarner Losh if (chunk == 0 || ehdr->e_shoff == 0) 605ca987d46SWarner Losh goto nosyms; 606ca987d46SWarner Losh shdr = alloc_pread(ef->fd, ehdr->e_shoff, chunk); 607ca987d46SWarner Losh if (shdr == NULL) { 608ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 609ca987d46SWarner Losh "_loadimage: failed to read section headers"); 610ca987d46SWarner Losh goto nosyms; 611ca987d46SWarner Losh } 6128de1ad0bSWojciech Macek 61312363d8eSRoger Pau Monné for (i = 0; i < ehdr->e_shnum; i++) 61412363d8eSRoger Pau Monné elf_section_header_convert(ehdr, &shdr[i]); 6155cca46a9SEd Maste 616ca987d46SWarner Losh file_addmetadata(fp, MODINFOMD_SHDR, chunk, shdr); 617ca987d46SWarner Losh 618ca987d46SWarner Losh /* 619ca987d46SWarner Losh * Read the section string table and look for the .ctors section. 620ca987d46SWarner Losh * We need to tell the kernel where it is so that it can call the 621ca987d46SWarner Losh * ctors. 622ca987d46SWarner Losh */ 623ca987d46SWarner Losh chunk = shdr[ehdr->e_shstrndx].sh_size; 624ca987d46SWarner Losh if (chunk) { 6256b632498SEd Maste shstr = alloc_pread(ef->fd, shdr[ehdr->e_shstrndx].sh_offset, 6266b632498SEd Maste chunk); 627ca987d46SWarner Losh if (shstr) { 628ca987d46SWarner Losh for (i = 0; i < ehdr->e_shnum; i++) { 6296b632498SEd Maste if (strcmp(shstr + shdr[i].sh_name, 6306b632498SEd Maste ".ctors") != 0) 631ca987d46SWarner Losh continue; 632ca987d46SWarner Losh ctors = shdr[i].sh_addr; 6336b632498SEd Maste file_addmetadata(fp, MODINFOMD_CTORS_ADDR, 6346b632498SEd Maste sizeof(ctors), &ctors); 635ca987d46SWarner Losh size = shdr[i].sh_size; 6366b632498SEd Maste file_addmetadata(fp, MODINFOMD_CTORS_SIZE, 6376b632498SEd Maste sizeof(size), &size); 638ca987d46SWarner Losh break; 639ca987d46SWarner Losh } 640ca987d46SWarner Losh free(shstr); 641ca987d46SWarner Losh } 642ca987d46SWarner Losh } 643ca987d46SWarner Losh 644ca987d46SWarner Losh /* 645ca987d46SWarner Losh * Now load any symbols. 646ca987d46SWarner Losh */ 647ca987d46SWarner Losh symtabindex = -1; 648ca987d46SWarner Losh symstrindex = -1; 649ca987d46SWarner Losh for (i = 0; i < ehdr->e_shnum; i++) { 650ca987d46SWarner Losh if (shdr[i].sh_type != SHT_SYMTAB) 651ca987d46SWarner Losh continue; 652ca987d46SWarner Losh for (j = 0; j < ehdr->e_phnum; j++) { 653ca987d46SWarner Losh if (phdr[j].p_type != PT_LOAD) 654ca987d46SWarner Losh continue; 655ca987d46SWarner Losh if (shdr[i].sh_offset >= phdr[j].p_offset && 656ca987d46SWarner Losh (shdr[i].sh_offset + shdr[i].sh_size <= 657ca987d46SWarner Losh phdr[j].p_offset + phdr[j].p_filesz)) { 658ca987d46SWarner Losh shdr[i].sh_offset = 0; 659ca987d46SWarner Losh shdr[i].sh_size = 0; 660ca987d46SWarner Losh break; 661ca987d46SWarner Losh } 662ca987d46SWarner Losh } 663ca987d46SWarner Losh if (shdr[i].sh_offset == 0 || shdr[i].sh_size == 0) 664ca987d46SWarner Losh continue; /* alread loaded in a PT_LOAD above */ 665ca987d46SWarner Losh /* Save it for loading below */ 666ca987d46SWarner Losh symtabindex = i; 667ca987d46SWarner Losh symstrindex = shdr[i].sh_link; 668ca987d46SWarner Losh } 669ca987d46SWarner Losh if (symtabindex < 0 || symstrindex < 0) 670ca987d46SWarner Losh goto nosyms; 671ca987d46SWarner Losh 672ca987d46SWarner Losh /* Ok, committed to a load. */ 673ca987d46SWarner Losh #ifndef ELF_VERBOSE 674ca987d46SWarner Losh printf("syms=["); 675ca987d46SWarner Losh #endif 676ca987d46SWarner Losh ssym = lastaddr; 677ca987d46SWarner Losh for (i = symtabindex; i >= 0; i = symstrindex) { 678ca987d46SWarner Losh #ifdef ELF_VERBOSE 679ca987d46SWarner Losh char *secname; 680ca987d46SWarner Losh 681ca987d46SWarner Losh switch(shdr[i].sh_type) { 682ca987d46SWarner Losh case SHT_SYMTAB: /* Symbol table */ 683ca987d46SWarner Losh secname = "symtab"; 684ca987d46SWarner Losh break; 685ca987d46SWarner Losh case SHT_STRTAB: /* String table */ 686ca987d46SWarner Losh secname = "strtab"; 687ca987d46SWarner Losh break; 688ca987d46SWarner Losh default: 689ca987d46SWarner Losh secname = "WHOA!!"; 690ca987d46SWarner Losh break; 691ca987d46SWarner Losh } 692ca987d46SWarner Losh #endif 693ca987d46SWarner Losh size = shdr[i].sh_size; 6948de1ad0bSWojciech Macek #if defined(__powerpc__) 6958de1ad0bSWojciech Macek #if __ELF_WORD_SIZE == 64 6965cca46a9SEd Maste size = htobe64(size); 6978de1ad0bSWojciech Macek #else 6985cca46a9SEd Maste size = htobe32(size); 6998de1ad0bSWojciech Macek #endif 7008de1ad0bSWojciech Macek #endif 7015cca46a9SEd Maste 7025cca46a9SEd Maste archsw.arch_copyin(&size, lastaddr, sizeof(size)); 7035cca46a9SEd Maste lastaddr += sizeof(size); 704ca987d46SWarner Losh 705ca987d46SWarner Losh #ifdef ELF_VERBOSE 706ca987d46SWarner Losh printf("\n%s: 0x%jx@0x%jx -> 0x%jx-0x%jx", secname, 707ca987d46SWarner Losh (uintmax_t)shdr[i].sh_size, (uintmax_t)shdr[i].sh_offset, 7086b632498SEd Maste (uintmax_t)lastaddr, 7096b632498SEd Maste (uintmax_t)(lastaddr + shdr[i].sh_size)); 710ca987d46SWarner Losh #else 711ca987d46SWarner Losh if (i == symstrindex) 712ca987d46SWarner Losh printf("+"); 713ca987d46SWarner Losh printf("0x%lx+0x%lx", (long)sizeof(size), (long)size); 714ca987d46SWarner Losh #endif 715ca987d46SWarner Losh 716ca987d46SWarner Losh if (lseek(ef->fd, (off_t)shdr[i].sh_offset, SEEK_SET) == -1) { 7176b632498SEd Maste printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 7186b632498SEd Maste "_loadimage: could not seek for symbols - skipped!"); 719ca987d46SWarner Losh lastaddr = ssym; 720ca987d46SWarner Losh ssym = 0; 721ca987d46SWarner Losh goto nosyms; 722ca987d46SWarner Losh } 723ca987d46SWarner Losh result = archsw.arch_readin(ef->fd, lastaddr, shdr[i].sh_size); 724ca987d46SWarner Losh if (result < 0 || (size_t)result != shdr[i].sh_size) { 7256b632498SEd Maste printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 7266b632498SEd Maste "_loadimage: could not read symbols - skipped! " 7276b632498SEd Maste "(%ju != %ju)", (uintmax_t)result, 728ca987d46SWarner Losh (uintmax_t)shdr[i].sh_size); 729ca987d46SWarner Losh lastaddr = ssym; 730ca987d46SWarner Losh ssym = 0; 731ca987d46SWarner Losh goto nosyms; 732ca987d46SWarner Losh } 733ca987d46SWarner Losh /* Reset offsets relative to ssym */ 734ca987d46SWarner Losh lastaddr += shdr[i].sh_size; 735ca987d46SWarner Losh lastaddr = roundup(lastaddr, sizeof(size)); 736ca987d46SWarner Losh if (i == symtabindex) 737ca987d46SWarner Losh symtabindex = -1; 738ca987d46SWarner Losh else if (i == symstrindex) 739ca987d46SWarner Losh symstrindex = -1; 740ca987d46SWarner Losh } 741ca987d46SWarner Losh esym = lastaddr; 742ca987d46SWarner Losh #ifndef ELF_VERBOSE 743ca987d46SWarner Losh printf("]"); 744ca987d46SWarner Losh #endif 745ca987d46SWarner Losh 7468de1ad0bSWojciech Macek #if defined(__powerpc__) 7478de1ad0bSWojciech Macek /* On PowerPC we always need to provide BE data to the kernel */ 7488de1ad0bSWojciech Macek #if __ELF_WORD_SIZE == 64 7495cca46a9SEd Maste ssym = htobe64((uint64_t)ssym); 7505cca46a9SEd Maste esym = htobe64((uint64_t)esym); 7518de1ad0bSWojciech Macek #else 7525cca46a9SEd Maste ssym = htobe32((uint32_t)ssym); 7535cca46a9SEd Maste esym = htobe32((uint32_t)esym); 7548de1ad0bSWojciech Macek #endif 7558de1ad0bSWojciech Macek #endif 7568de1ad0bSWojciech Macek 7575cca46a9SEd Maste file_addmetadata(fp, MODINFOMD_SSYM, sizeof(ssym), &ssym); 7585cca46a9SEd Maste file_addmetadata(fp, MODINFOMD_ESYM, sizeof(esym), &esym); 759ca987d46SWarner Losh 760ca987d46SWarner Losh nosyms: 761ca987d46SWarner Losh printf("\n"); 762ca987d46SWarner Losh 763ca987d46SWarner Losh ret = lastaddr - firstaddr; 764ca987d46SWarner Losh fp->f_addr = firstaddr; 765ca987d46SWarner Losh 766ca987d46SWarner Losh php = NULL; 767ca987d46SWarner Losh for (i = 0; i < ehdr->e_phnum; i++) { 768ca987d46SWarner Losh if (phdr[i].p_type == PT_DYNAMIC) { 769ca987d46SWarner Losh php = phdr + i; 770ca987d46SWarner Losh adp = php->p_vaddr; 7716b632498SEd Maste file_addmetadata(fp, MODINFOMD_DYNAMIC, sizeof(adp), 7726b632498SEd Maste &adp); 773ca987d46SWarner Losh break; 774ca987d46SWarner Losh } 775ca987d46SWarner Losh } 776ca987d46SWarner Losh 777ca987d46SWarner Losh if (php == NULL) /* this is bad, we cannot get to symbols or _DYNAMIC */ 778ca987d46SWarner Losh goto out; 779ca987d46SWarner Losh 780ca987d46SWarner Losh ndp = php->p_filesz / sizeof(Elf_Dyn); 781ca987d46SWarner Losh if (ndp == 0) 782ca987d46SWarner Losh goto out; 783ca987d46SWarner Losh dp = malloc(php->p_filesz); 784ca987d46SWarner Losh if (dp == NULL) 785ca987d46SWarner Losh goto out; 786ca987d46SWarner Losh archsw.arch_copyout(php->p_vaddr + off, dp, php->p_filesz); 787ca987d46SWarner Losh 788ca987d46SWarner Losh ef->strsz = 0; 789ca987d46SWarner Losh for (i = 0; i < ndp; i++) { 790ca987d46SWarner Losh if (dp[i].d_tag == 0) 791ca987d46SWarner Losh break; 792ca987d46SWarner Losh switch (dp[i].d_tag) { 793ca987d46SWarner Losh case DT_HASH: 7946b632498SEd Maste ef->hashtab = 7956b632498SEd Maste (Elf_Hashelt*)(uintptr_t)(dp[i].d_un.d_ptr + off); 796ca987d46SWarner Losh break; 797ca987d46SWarner Losh case DT_STRTAB: 7986b632498SEd Maste ef->strtab = 7996b632498SEd Maste (char *)(uintptr_t)(dp[i].d_un.d_ptr + off); 800ca987d46SWarner Losh break; 801ca987d46SWarner Losh case DT_STRSZ: 802ca987d46SWarner Losh ef->strsz = dp[i].d_un.d_val; 803ca987d46SWarner Losh break; 804ca987d46SWarner Losh case DT_SYMTAB: 8056b632498SEd Maste ef->symtab = 8066b632498SEd Maste (Elf_Sym *)(uintptr_t)(dp[i].d_un.d_ptr + off); 807ca987d46SWarner Losh break; 808ca987d46SWarner Losh case DT_REL: 8096b632498SEd Maste ef->rel = 8106b632498SEd Maste (Elf_Rel *)(uintptr_t)(dp[i].d_un.d_ptr + off); 811ca987d46SWarner Losh break; 812ca987d46SWarner Losh case DT_RELSZ: 813ca987d46SWarner Losh ef->relsz = dp[i].d_un.d_val; 814ca987d46SWarner Losh break; 815ca987d46SWarner Losh case DT_RELA: 8166b632498SEd Maste ef->rela = 8176b632498SEd Maste (Elf_Rela *)(uintptr_t)(dp[i].d_un.d_ptr + off); 818ca987d46SWarner Losh break; 819ca987d46SWarner Losh case DT_RELASZ: 820ca987d46SWarner Losh ef->relasz = dp[i].d_un.d_val; 821ca987d46SWarner Losh break; 822ca987d46SWarner Losh default: 823ca987d46SWarner Losh break; 824ca987d46SWarner Losh } 825ca987d46SWarner Losh } 826ca987d46SWarner Losh if (ef->hashtab == NULL || ef->symtab == NULL || 827ca987d46SWarner Losh ef->strtab == NULL || ef->strsz == 0) 828ca987d46SWarner Losh goto out; 829ca987d46SWarner Losh COPYOUT(ef->hashtab, &ef->nbuckets, sizeof(ef->nbuckets)); 830ca987d46SWarner Losh COPYOUT(ef->hashtab + 1, &ef->nchains, sizeof(ef->nchains)); 831ca987d46SWarner Losh ef->buckets = ef->hashtab + 2; 832ca987d46SWarner Losh ef->chains = ef->buckets + ef->nbuckets; 833ca987d46SWarner Losh 8346b632498SEd Maste if (__elfN(lookup_symbol)(fp, ef, "__start_set_modmetadata_set", 8356b632498SEd Maste &sym) != 0) 836ca987d46SWarner Losh return 0; 837ca987d46SWarner Losh p_start = sym.st_value + ef->off; 8386b632498SEd Maste if (__elfN(lookup_symbol)(fp, ef, "__stop_set_modmetadata_set", 8396b632498SEd Maste &sym) != 0) 840ca987d46SWarner Losh return ENOENT; 841ca987d46SWarner Losh p_end = sym.st_value + ef->off; 842ca987d46SWarner Losh 843ca987d46SWarner Losh if (__elfN(parse_modmetadata)(fp, ef, p_start, p_end) == 0) 844ca987d46SWarner Losh goto out; 845ca987d46SWarner Losh 846ca987d46SWarner Losh if (ef->kernel) /* kernel must not depend on anything */ 847ca987d46SWarner Losh goto out; 848ca987d46SWarner Losh 849ca987d46SWarner Losh out: 850ca987d46SWarner Losh if (dp) 851ca987d46SWarner Losh free(dp); 852ca987d46SWarner Losh if (shdr) 853ca987d46SWarner Losh free(shdr); 854ca987d46SWarner Losh return ret; 855ca987d46SWarner Losh } 856ca987d46SWarner Losh 857ca987d46SWarner Losh static char invalid_name[] = "bad"; 858ca987d46SWarner Losh 859ca987d46SWarner Losh char * 860ca987d46SWarner Losh fake_modname(const char *name) 861ca987d46SWarner Losh { 862ca987d46SWarner Losh const char *sp, *ep; 863ca987d46SWarner Losh char *fp; 864ca987d46SWarner Losh size_t len; 865ca987d46SWarner Losh 866ca987d46SWarner Losh sp = strrchr(name, '/'); 867ca987d46SWarner Losh if (sp) 868ca987d46SWarner Losh sp++; 869ca987d46SWarner Losh else 870ca987d46SWarner Losh sp = name; 871fe6ee081SEd Maste 872fe6ee081SEd Maste ep = strrchr(sp, '.'); 873fe6ee081SEd Maste if (ep == NULL) { 874fe6ee081SEd Maste ep = sp + strlen(sp); 875fe6ee081SEd Maste } 876fe6ee081SEd Maste if (ep == sp) { 877ca987d46SWarner Losh sp = invalid_name; 878ca987d46SWarner Losh ep = invalid_name + sizeof(invalid_name) - 1; 879ca987d46SWarner Losh } 880fe6ee081SEd Maste 881ca987d46SWarner Losh len = ep - sp; 882ca987d46SWarner Losh fp = malloc(len + 1); 883ca987d46SWarner Losh if (fp == NULL) 884ca987d46SWarner Losh return NULL; 885ca987d46SWarner Losh memcpy(fp, sp, len); 886ca987d46SWarner Losh fp[len] = '\0'; 887ca987d46SWarner Losh return fp; 888ca987d46SWarner Losh } 889ca987d46SWarner Losh 890ca987d46SWarner Losh #if (defined(__i386__) || defined(__powerpc__)) && __ELF_WORD_SIZE == 64 891ca987d46SWarner Losh struct mod_metadata64 { 892ca987d46SWarner Losh int md_version; /* structure version MDTV_* */ 893ca987d46SWarner Losh int md_type; /* type of entry MDT_* */ 89456e53cb8SWarner Losh uint64_t md_data; /* specific data */ 89556e53cb8SWarner Losh uint64_t md_cval; /* common string label */ 896ca987d46SWarner Losh }; 897ca987d46SWarner Losh #endif 898ca987d46SWarner Losh #if defined(__amd64__) && __ELF_WORD_SIZE == 32 899ca987d46SWarner Losh struct mod_metadata32 { 900ca987d46SWarner Losh int md_version; /* structure version MDTV_* */ 901ca987d46SWarner Losh int md_type; /* type of entry MDT_* */ 90256e53cb8SWarner Losh uint32_t md_data; /* specific data */ 90356e53cb8SWarner Losh uint32_t md_cval; /* common string label */ 904ca987d46SWarner Losh }; 905ca987d46SWarner Losh #endif 906ca987d46SWarner Losh 907ca987d46SWarner Losh int 90856e53cb8SWarner Losh __elfN(load_modmetadata)(struct preloaded_file *fp, uint64_t dest) 909ca987d46SWarner Losh { 910ca987d46SWarner Losh struct elf_file ef; 911ca987d46SWarner Losh int err, i, j; 912ca987d46SWarner Losh Elf_Shdr *sh_meta, *shdr = NULL; 913ca987d46SWarner Losh Elf_Shdr *sh_data[2]; 914ca987d46SWarner Losh char *shstrtab = NULL; 915ca987d46SWarner Losh size_t size; 916ca987d46SWarner Losh Elf_Addr p_start, p_end; 917ca987d46SWarner Losh 918ca987d46SWarner Losh bzero(&ef, sizeof(struct elf_file)); 919ca987d46SWarner Losh ef.fd = -1; 920ca987d46SWarner Losh 921ca987d46SWarner Losh err = __elfN(load_elf_header)(fp->f_name, &ef); 922ca987d46SWarner Losh if (err != 0) 923ca987d46SWarner Losh goto out; 924ca987d46SWarner Losh 925ca987d46SWarner Losh if (ef.kernel == 1 || ef.ehdr->e_type == ET_EXEC) { 926ca987d46SWarner Losh ef.kernel = 1; 927ca987d46SWarner Losh } else if (ef.ehdr->e_type != ET_DYN) { 928ca987d46SWarner Losh err = EFTYPE; 929ca987d46SWarner Losh goto out; 930ca987d46SWarner Losh } 931ca987d46SWarner Losh 932db711744SWarner Losh size = (size_t)ef.ehdr->e_shnum * (size_t)ef.ehdr->e_shentsize; 933ca987d46SWarner Losh shdr = alloc_pread(ef.fd, ef.ehdr->e_shoff, size); 934ca987d46SWarner Losh if (shdr == NULL) { 935ca987d46SWarner Losh err = ENOMEM; 936ca987d46SWarner Losh goto out; 937ca987d46SWarner Losh } 938ca987d46SWarner Losh 939ca987d46SWarner Losh /* Load shstrtab. */ 940ca987d46SWarner Losh shstrtab = alloc_pread(ef.fd, shdr[ef.ehdr->e_shstrndx].sh_offset, 941ca987d46SWarner Losh shdr[ef.ehdr->e_shstrndx].sh_size); 942ca987d46SWarner Losh if (shstrtab == NULL) { 943ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 944ca987d46SWarner Losh "load_modmetadata: unable to load shstrtab\n"); 945ca987d46SWarner Losh err = EFTYPE; 946ca987d46SWarner Losh goto out; 947ca987d46SWarner Losh } 948ca987d46SWarner Losh 949ca987d46SWarner Losh /* Find set_modmetadata_set and data sections. */ 950ca987d46SWarner Losh sh_data[0] = sh_data[1] = sh_meta = NULL; 951ca987d46SWarner Losh for (i = 0, j = 0; i < ef.ehdr->e_shnum; i++) { 952ca987d46SWarner Losh if (strcmp(&shstrtab[shdr[i].sh_name], 953ca987d46SWarner Losh "set_modmetadata_set") == 0) { 954ca987d46SWarner Losh sh_meta = &shdr[i]; 955ca987d46SWarner Losh } 956ca987d46SWarner Losh if ((strcmp(&shstrtab[shdr[i].sh_name], ".data") == 0) || 957ca987d46SWarner Losh (strcmp(&shstrtab[shdr[i].sh_name], ".rodata") == 0)) { 958ca987d46SWarner Losh sh_data[j++] = &shdr[i]; 959ca987d46SWarner Losh } 960ca987d46SWarner Losh } 961ca987d46SWarner Losh if (sh_meta == NULL || sh_data[0] == NULL || sh_data[1] == NULL) { 962ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 963ca987d46SWarner Losh "load_modmetadata: unable to find set_modmetadata_set or data sections\n"); 964ca987d46SWarner Losh err = EFTYPE; 965ca987d46SWarner Losh goto out; 966ca987d46SWarner Losh } 967ca987d46SWarner Losh 968ca987d46SWarner Losh /* Load set_modmetadata_set into memory */ 969ca987d46SWarner Losh err = kern_pread(ef.fd, dest, sh_meta->sh_size, sh_meta->sh_offset); 970ca987d46SWarner Losh if (err != 0) { 971ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 972ca987d46SWarner Losh "load_modmetadata: unable to load set_modmetadata_set: %d\n", err); 973ca987d46SWarner Losh goto out; 974ca987d46SWarner Losh } 975ca987d46SWarner Losh p_start = dest; 976ca987d46SWarner Losh p_end = dest + sh_meta->sh_size; 977ca987d46SWarner Losh dest += sh_meta->sh_size; 978ca987d46SWarner Losh 979ca987d46SWarner Losh /* Load data sections into memory. */ 980ca987d46SWarner Losh err = kern_pread(ef.fd, dest, sh_data[0]->sh_size, 981ca987d46SWarner Losh sh_data[0]->sh_offset); 982ca987d46SWarner Losh if (err != 0) { 983ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 984ca987d46SWarner Losh "load_modmetadata: unable to load data: %d\n", err); 985ca987d46SWarner Losh goto out; 986ca987d46SWarner Losh } 987ca987d46SWarner Losh 988ca987d46SWarner Losh /* 989ca987d46SWarner Losh * We have to increment the dest, so that the offset is the same into 990ca987d46SWarner Losh * both the .rodata and .data sections. 991ca987d46SWarner Losh */ 992ca987d46SWarner Losh ef.off = -(sh_data[0]->sh_addr - dest); 993ca987d46SWarner Losh dest += (sh_data[1]->sh_addr - sh_data[0]->sh_addr); 994ca987d46SWarner Losh 995ca987d46SWarner Losh err = kern_pread(ef.fd, dest, sh_data[1]->sh_size, 996ca987d46SWarner Losh sh_data[1]->sh_offset); 997ca987d46SWarner Losh if (err != 0) { 998ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 999ca987d46SWarner Losh "load_modmetadata: unable to load data: %d\n", err); 1000ca987d46SWarner Losh goto out; 1001ca987d46SWarner Losh } 1002ca987d46SWarner Losh 1003ca987d46SWarner Losh err = __elfN(parse_modmetadata)(fp, &ef, p_start, p_end); 1004ca987d46SWarner Losh if (err != 0) { 1005ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 1006ca987d46SWarner Losh "load_modmetadata: unable to parse metadata: %d\n", err); 1007ca987d46SWarner Losh goto out; 1008ca987d46SWarner Losh } 1009ca987d46SWarner Losh 1010ca987d46SWarner Losh out: 1011ca987d46SWarner Losh if (shstrtab != NULL) 1012ca987d46SWarner Losh free(shstrtab); 1013ca987d46SWarner Losh if (shdr != NULL) 1014ca987d46SWarner Losh free(shdr); 1015ca987d46SWarner Losh if (ef.firstpage != NULL) 1016ca987d46SWarner Losh free(ef.firstpage); 1017ca987d46SWarner Losh if (ef.fd != -1) 1018ca987d46SWarner Losh close(ef.fd); 1019ca987d46SWarner Losh return (err); 1020ca987d46SWarner Losh } 1021ca987d46SWarner Losh 1022ca987d46SWarner Losh int 1023ca987d46SWarner Losh __elfN(parse_modmetadata)(struct preloaded_file *fp, elf_file_t ef, 1024ca987d46SWarner Losh Elf_Addr p_start, Elf_Addr p_end) 1025ca987d46SWarner Losh { 1026ca987d46SWarner Losh struct mod_metadata md; 1027ca987d46SWarner Losh #if (defined(__i386__) || defined(__powerpc__)) && __ELF_WORD_SIZE == 64 1028ca987d46SWarner Losh struct mod_metadata64 md64; 1029ca987d46SWarner Losh #elif defined(__amd64__) && __ELF_WORD_SIZE == 32 1030ca987d46SWarner Losh struct mod_metadata32 md32; 1031ca987d46SWarner Losh #endif 1032ca987d46SWarner Losh struct mod_depend *mdepend; 1033ca987d46SWarner Losh struct mod_version mver; 1034ca987d46SWarner Losh char *s; 1035ca987d46SWarner Losh int error, modcnt, minfolen; 1036ca987d46SWarner Losh Elf_Addr v, p; 1037ca987d46SWarner Losh 1038ca987d46SWarner Losh modcnt = 0; 1039ca987d46SWarner Losh p = p_start; 1040ca987d46SWarner Losh while (p < p_end) { 1041ca987d46SWarner Losh COPYOUT(p, &v, sizeof(v)); 1042ca987d46SWarner Losh error = __elfN(reloc_ptr)(fp, ef, p, &v, sizeof(v)); 1043ca987d46SWarner Losh if (error == EOPNOTSUPP) 1044ca987d46SWarner Losh v += ef->off; 1045ca987d46SWarner Losh else if (error != 0) 1046ca987d46SWarner Losh return (error); 1047ca987d46SWarner Losh #if (defined(__i386__) || defined(__powerpc__)) && __ELF_WORD_SIZE == 64 1048ca987d46SWarner Losh COPYOUT(v, &md64, sizeof(md64)); 1049ca987d46SWarner Losh error = __elfN(reloc_ptr)(fp, ef, v, &md64, sizeof(md64)); 1050ca987d46SWarner Losh if (error == EOPNOTSUPP) { 1051ca987d46SWarner Losh md64.md_cval += ef->off; 1052ca987d46SWarner Losh md64.md_data += ef->off; 1053ca987d46SWarner Losh } else if (error != 0) 1054ca987d46SWarner Losh return (error); 1055ca987d46SWarner Losh md.md_version = md64.md_version; 1056ca987d46SWarner Losh md.md_type = md64.md_type; 1057ca987d46SWarner Losh md.md_cval = (const char *)(uintptr_t)md64.md_cval; 1058ca987d46SWarner Losh md.md_data = (void *)(uintptr_t)md64.md_data; 1059ca987d46SWarner Losh #elif defined(__amd64__) && __ELF_WORD_SIZE == 32 1060ca987d46SWarner Losh COPYOUT(v, &md32, sizeof(md32)); 1061ca987d46SWarner Losh error = __elfN(reloc_ptr)(fp, ef, v, &md32, sizeof(md32)); 1062ca987d46SWarner Losh if (error == EOPNOTSUPP) { 1063ca987d46SWarner Losh md32.md_cval += ef->off; 1064ca987d46SWarner Losh md32.md_data += ef->off; 1065ca987d46SWarner Losh } else if (error != 0) 1066ca987d46SWarner Losh return (error); 1067ca987d46SWarner Losh md.md_version = md32.md_version; 1068ca987d46SWarner Losh md.md_type = md32.md_type; 1069ca987d46SWarner Losh md.md_cval = (const char *)(uintptr_t)md32.md_cval; 1070ca987d46SWarner Losh md.md_data = (void *)(uintptr_t)md32.md_data; 1071ca987d46SWarner Losh #else 1072ca987d46SWarner Losh COPYOUT(v, &md, sizeof(md)); 1073ca987d46SWarner Losh error = __elfN(reloc_ptr)(fp, ef, v, &md, sizeof(md)); 1074ca987d46SWarner Losh if (error == EOPNOTSUPP) { 1075ca987d46SWarner Losh md.md_cval += ef->off; 10766b632498SEd Maste md.md_data = (void *)((uintptr_t)md.md_data + 10776b632498SEd Maste (uintptr_t)ef->off); 1078ca987d46SWarner Losh } else if (error != 0) 1079ca987d46SWarner Losh return (error); 1080ca987d46SWarner Losh #endif 1081ca987d46SWarner Losh p += sizeof(Elf_Addr); 1082ca987d46SWarner Losh switch(md.md_type) { 1083ca987d46SWarner Losh case MDT_DEPEND: 1084ca987d46SWarner Losh if (ef->kernel) /* kernel must not depend on anything */ 1085ca987d46SWarner Losh break; 1086ca987d46SWarner Losh s = strdupout((vm_offset_t)md.md_cval); 1087ca987d46SWarner Losh minfolen = sizeof(*mdepend) + strlen(s) + 1; 1088ca987d46SWarner Losh mdepend = malloc(minfolen); 1089ca987d46SWarner Losh if (mdepend == NULL) 1090ca987d46SWarner Losh return ENOMEM; 10916b632498SEd Maste COPYOUT((vm_offset_t)md.md_data, mdepend, 10926b632498SEd Maste sizeof(*mdepend)); 1093ca987d46SWarner Losh strcpy((char*)(mdepend + 1), s); 1094ca987d46SWarner Losh free(s); 10956b632498SEd Maste file_addmetadata(fp, MODINFOMD_DEPLIST, minfolen, 10966b632498SEd Maste mdepend); 1097ca987d46SWarner Losh free(mdepend); 1098ca987d46SWarner Losh break; 1099ca987d46SWarner Losh case MDT_VERSION: 1100ca987d46SWarner Losh s = strdupout((vm_offset_t)md.md_cval); 1101ca987d46SWarner Losh COPYOUT((vm_offset_t)md.md_data, &mver, sizeof(mver)); 1102ca987d46SWarner Losh file_addmodule(fp, s, mver.mv_version, NULL); 1103ca987d46SWarner Losh free(s); 1104ca987d46SWarner Losh modcnt++; 1105ca987d46SWarner Losh break; 1106ca987d46SWarner Losh } 1107ca987d46SWarner Losh } 1108ca987d46SWarner Losh if (modcnt == 0) { 1109ca987d46SWarner Losh s = fake_modname(fp->f_name); 1110ca987d46SWarner Losh file_addmodule(fp, s, 1, NULL); 1111ca987d46SWarner Losh free(s); 1112ca987d46SWarner Losh } 1113ca987d46SWarner Losh return 0; 1114ca987d46SWarner Losh } 1115ca987d46SWarner Losh 1116ca987d46SWarner Losh static unsigned long 1117ca987d46SWarner Losh elf_hash(const char *name) 1118ca987d46SWarner Losh { 1119ca987d46SWarner Losh const unsigned char *p = (const unsigned char *) name; 1120ca987d46SWarner Losh unsigned long h = 0; 1121ca987d46SWarner Losh unsigned long g; 1122ca987d46SWarner Losh 1123ca987d46SWarner Losh while (*p != '\0') { 1124ca987d46SWarner Losh h = (h << 4) + *p++; 1125ca987d46SWarner Losh if ((g = h & 0xf0000000) != 0) 1126ca987d46SWarner Losh h ^= g >> 24; 1127ca987d46SWarner Losh h &= ~g; 1128ca987d46SWarner Losh } 1129ca987d46SWarner Losh return h; 1130ca987d46SWarner Losh } 1131ca987d46SWarner Losh 11326b632498SEd Maste static const char __elfN(bad_symtable)[] = "elf" __XSTRING(__ELF_WORD_SIZE) 11336b632498SEd Maste "_lookup_symbol: corrupt symbol table\n"; 1134ca987d46SWarner Losh int 11356b632498SEd Maste __elfN(lookup_symbol)(struct preloaded_file *fp, elf_file_t ef, 11366b632498SEd Maste const char* name, Elf_Sym *symp) 1137ca987d46SWarner Losh { 1138ca987d46SWarner Losh Elf_Hashelt symnum; 1139ca987d46SWarner Losh Elf_Sym sym; 1140ca987d46SWarner Losh char *strp; 1141ca987d46SWarner Losh unsigned long hash; 1142ca987d46SWarner Losh 1143ca987d46SWarner Losh hash = elf_hash(name); 1144ca987d46SWarner Losh COPYOUT(&ef->buckets[hash % ef->nbuckets], &symnum, sizeof(symnum)); 1145ca987d46SWarner Losh 1146ca987d46SWarner Losh while (symnum != STN_UNDEF) { 1147ca987d46SWarner Losh if (symnum >= ef->nchains) { 1148ca987d46SWarner Losh printf(__elfN(bad_symtable)); 1149ca987d46SWarner Losh return ENOENT; 1150ca987d46SWarner Losh } 1151ca987d46SWarner Losh 1152ca987d46SWarner Losh COPYOUT(ef->symtab + symnum, &sym, sizeof(sym)); 1153ca987d46SWarner Losh if (sym.st_name == 0) { 1154ca987d46SWarner Losh printf(__elfN(bad_symtable)); 1155ca987d46SWarner Losh return ENOENT; 1156ca987d46SWarner Losh } 1157ca987d46SWarner Losh 1158ca987d46SWarner Losh strp = strdupout((vm_offset_t)(ef->strtab + sym.st_name)); 1159ca987d46SWarner Losh if (strcmp(name, strp) == 0) { 1160ca987d46SWarner Losh free(strp); 1161ca987d46SWarner Losh if (sym.st_shndx != SHN_UNDEF || 1162ca987d46SWarner Losh (sym.st_value != 0 && 1163ca987d46SWarner Losh ELF_ST_TYPE(sym.st_info) == STT_FUNC)) { 1164ca987d46SWarner Losh *symp = sym; 1165ca987d46SWarner Losh return 0; 1166ca987d46SWarner Losh } 1167ca987d46SWarner Losh return ENOENT; 1168ca987d46SWarner Losh } 1169ca987d46SWarner Losh free(strp); 1170ca987d46SWarner Losh COPYOUT(&ef->chains[symnum], &symnum, sizeof(symnum)); 1171ca987d46SWarner Losh } 1172ca987d46SWarner Losh return ENOENT; 1173ca987d46SWarner Losh } 1174ca987d46SWarner Losh 1175ca987d46SWarner Losh /* 1176ca987d46SWarner Losh * Apply any intra-module relocations to the value. p is the load address 1177ca987d46SWarner Losh * of the value and val/len is the value to be modified. This does NOT modify 1178ca987d46SWarner Losh * the image in-place, because this is done by kern_linker later on. 1179ca987d46SWarner Losh * 1180ca987d46SWarner Losh * Returns EOPNOTSUPP if no relocation method is supplied. 1181ca987d46SWarner Losh */ 1182ca987d46SWarner Losh static int 1183ca987d46SWarner Losh __elfN(reloc_ptr)(struct preloaded_file *mp, elf_file_t ef, 1184ca987d46SWarner Losh Elf_Addr p, void *val, size_t len) 1185ca987d46SWarner Losh { 1186ca987d46SWarner Losh size_t n; 1187ca987d46SWarner Losh Elf_Rela a; 1188ca987d46SWarner Losh Elf_Rel r; 1189ca987d46SWarner Losh int error; 1190ca987d46SWarner Losh 1191ca987d46SWarner Losh /* 1192ca987d46SWarner Losh * The kernel is already relocated, but we still want to apply 1193ca987d46SWarner Losh * offset adjustments. 1194ca987d46SWarner Losh */ 1195ca987d46SWarner Losh if (ef->kernel) 1196ca987d46SWarner Losh return (EOPNOTSUPP); 1197ca987d46SWarner Losh 1198ca987d46SWarner Losh for (n = 0; n < ef->relsz / sizeof(r); n++) { 1199ca987d46SWarner Losh COPYOUT(ef->rel + n, &r, sizeof(r)); 1200ca987d46SWarner Losh 1201ca987d46SWarner Losh error = __elfN(reloc)(ef, __elfN(symaddr), &r, ELF_RELOC_REL, 1202ca987d46SWarner Losh ef->off, p, val, len); 1203ca987d46SWarner Losh if (error != 0) 1204ca987d46SWarner Losh return (error); 1205ca987d46SWarner Losh } 1206ca987d46SWarner Losh for (n = 0; n < ef->relasz / sizeof(a); n++) { 1207ca987d46SWarner Losh COPYOUT(ef->rela + n, &a, sizeof(a)); 1208ca987d46SWarner Losh 1209ca987d46SWarner Losh error = __elfN(reloc)(ef, __elfN(symaddr), &a, ELF_RELOC_RELA, 1210ca987d46SWarner Losh ef->off, p, val, len); 1211ca987d46SWarner Losh if (error != 0) 1212ca987d46SWarner Losh return (error); 1213ca987d46SWarner Losh } 1214ca987d46SWarner Losh 1215ca987d46SWarner Losh return (0); 1216ca987d46SWarner Losh } 1217ca987d46SWarner Losh 1218ca987d46SWarner Losh static Elf_Addr 1219ca987d46SWarner Losh __elfN(symaddr)(struct elf_file *ef, Elf_Size symidx) 1220ca987d46SWarner Losh { 1221ca987d46SWarner Losh 1222ca987d46SWarner Losh /* Symbol lookup by index not required here. */ 1223ca987d46SWarner Losh return (0); 1224ca987d46SWarner Losh } 1225