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> 32ca987d46SWarner Losh #include <sys/exec.h> 33ca987d46SWarner Losh #include <sys/linker.h> 34ca987d46SWarner Losh #include <sys/module.h> 35ca987d46SWarner Losh #include <sys/stdint.h> 36ca987d46SWarner Losh #include <string.h> 37ca987d46SWarner Losh #include <machine/elf.h> 38ca987d46SWarner Losh #include <stand.h> 39ca987d46SWarner Losh #define FREEBSD_ELF 40ca987d46SWarner Losh #include <link.h> 41ca987d46SWarner Losh 42ca987d46SWarner Losh #include "bootstrap.h" 43ca987d46SWarner Losh 44ca987d46SWarner Losh #define COPYOUT(s,d,l) archsw.arch_copyout((vm_offset_t)(s), d, l) 45ca987d46SWarner Losh 46ca987d46SWarner Losh #if defined(__i386__) && __ELF_WORD_SIZE == 64 47ca987d46SWarner Losh #undef ELF_TARG_CLASS 48ca987d46SWarner Losh #undef ELF_TARG_MACH 49ca987d46SWarner Losh #define ELF_TARG_CLASS ELFCLASS64 50ca987d46SWarner Losh #define ELF_TARG_MACH EM_X86_64 51ca987d46SWarner Losh #endif 52ca987d46SWarner Losh 53ca987d46SWarner Losh typedef struct elf_file { 54ca987d46SWarner Losh Elf_Phdr *ph; 55ca987d46SWarner Losh Elf_Ehdr *ehdr; 56ca987d46SWarner Losh Elf_Sym *symtab; 57ca987d46SWarner Losh Elf_Hashelt *hashtab; 58ca987d46SWarner Losh Elf_Hashelt nbuckets; 59ca987d46SWarner Losh Elf_Hashelt nchains; 60ca987d46SWarner Losh Elf_Hashelt *buckets; 61ca987d46SWarner Losh Elf_Hashelt *chains; 62ca987d46SWarner Losh Elf_Rel *rel; 63ca987d46SWarner Losh size_t relsz; 64ca987d46SWarner Losh Elf_Rela *rela; 65ca987d46SWarner Losh size_t relasz; 66ca987d46SWarner Losh char *strtab; 67ca987d46SWarner Losh size_t strsz; 68ca987d46SWarner Losh int fd; 69ca987d46SWarner Losh caddr_t firstpage; 70ca987d46SWarner Losh size_t firstlen; 71ca987d46SWarner Losh int kernel; 72ca987d46SWarner Losh u_int64_t off; 73ca987d46SWarner Losh } *elf_file_t; 74ca987d46SWarner Losh 75ca987d46SWarner Losh static int __elfN(loadimage)(struct preloaded_file *mp, elf_file_t ef, u_int64_t loadaddr); 76ca987d46SWarner Losh static int __elfN(lookup_symbol)(struct preloaded_file *mp, elf_file_t ef, const char* name, Elf_Sym* sym); 77ca987d46SWarner Losh static int __elfN(reloc_ptr)(struct preloaded_file *mp, elf_file_t ef, 78ca987d46SWarner Losh Elf_Addr p, void *val, size_t len); 79ca987d46SWarner Losh static int __elfN(parse_modmetadata)(struct preloaded_file *mp, elf_file_t ef, 80ca987d46SWarner Losh Elf_Addr p_start, Elf_Addr p_end); 81ca987d46SWarner Losh static symaddr_fn __elfN(symaddr); 82ca987d46SWarner Losh static char *fake_modname(const char *name); 83ca987d46SWarner Losh 84ca987d46SWarner Losh const char *__elfN(kerneltype) = "elf kernel"; 85ca987d46SWarner Losh const char *__elfN(moduletype) = "elf module"; 86ca987d46SWarner Losh 87ca987d46SWarner Losh u_int64_t __elfN(relocation_offset) = 0; 88ca987d46SWarner Losh 89ca987d46SWarner Losh static int 90ca987d46SWarner Losh __elfN(load_elf_header)(char *filename, elf_file_t ef) 91ca987d46SWarner Losh { 92ca987d46SWarner Losh ssize_t bytes_read; 93ca987d46SWarner Losh Elf_Ehdr *ehdr; 94ca987d46SWarner Losh int err; 95ca987d46SWarner Losh 96ca987d46SWarner Losh /* 97ca987d46SWarner Losh * Open the image, read and validate the ELF header 98ca987d46SWarner Losh */ 99ca987d46SWarner Losh if (filename == NULL) /* can't handle nameless */ 100ca987d46SWarner Losh return (EFTYPE); 101ca987d46SWarner Losh if ((ef->fd = open(filename, O_RDONLY)) == -1) 102ca987d46SWarner Losh return (errno); 103ca987d46SWarner Losh ef->firstpage = malloc(PAGE_SIZE); 104ca987d46SWarner Losh if (ef->firstpage == NULL) { 105ca987d46SWarner Losh close(ef->fd); 106ca987d46SWarner Losh return (ENOMEM); 107ca987d46SWarner Losh } 108ca987d46SWarner Losh bytes_read = read(ef->fd, ef->firstpage, PAGE_SIZE); 109ca987d46SWarner Losh ef->firstlen = (size_t)bytes_read; 110ca987d46SWarner Losh if (bytes_read < 0 || ef->firstlen <= sizeof(Elf_Ehdr)) { 111ca987d46SWarner Losh err = EFTYPE; /* could be EIO, but may be small file */ 112ca987d46SWarner Losh goto error; 113ca987d46SWarner Losh } 114ca987d46SWarner Losh ehdr = ef->ehdr = (Elf_Ehdr *)ef->firstpage; 115ca987d46SWarner Losh 116ca987d46SWarner Losh /* Is it ELF? */ 117ca987d46SWarner Losh if (!IS_ELF(*ehdr)) { 118ca987d46SWarner Losh err = EFTYPE; 119ca987d46SWarner Losh goto error; 120ca987d46SWarner Losh } 121ca987d46SWarner Losh if (ehdr->e_ident[EI_CLASS] != ELF_TARG_CLASS || /* Layout ? */ 122ca987d46SWarner Losh ehdr->e_ident[EI_DATA] != ELF_TARG_DATA || 123ca987d46SWarner Losh ehdr->e_ident[EI_VERSION] != EV_CURRENT || /* Version ? */ 124ca987d46SWarner Losh ehdr->e_version != EV_CURRENT || 125ca987d46SWarner Losh ehdr->e_machine != ELF_TARG_MACH) { /* Machine ? */ 126ca987d46SWarner Losh err = EFTYPE; 127ca987d46SWarner Losh goto error; 128ca987d46SWarner Losh } 129ca987d46SWarner Losh 130ca987d46SWarner Losh return (0); 131ca987d46SWarner Losh 132ca987d46SWarner Losh error: 133ca987d46SWarner Losh if (ef->firstpage != NULL) { 134ca987d46SWarner Losh free(ef->firstpage); 135ca987d46SWarner Losh ef->firstpage = NULL; 136ca987d46SWarner Losh } 137ca987d46SWarner Losh if (ef->fd != -1) { 138ca987d46SWarner Losh close(ef->fd); 139ca987d46SWarner Losh ef->fd = -1; 140ca987d46SWarner Losh } 141ca987d46SWarner Losh return (err); 142ca987d46SWarner Losh } 143ca987d46SWarner Losh 144ca987d46SWarner Losh /* 145ca987d46SWarner Losh * Attempt to load the file (file) as an ELF module. It will be stored at 146ca987d46SWarner Losh * (dest), and a pointer to a module structure describing the loaded object 147ca987d46SWarner Losh * will be saved in (result). 148ca987d46SWarner Losh */ 149ca987d46SWarner Losh int 150ca987d46SWarner Losh __elfN(loadfile)(char *filename, u_int64_t dest, struct preloaded_file **result) 151ca987d46SWarner Losh { 152ca987d46SWarner Losh return (__elfN(loadfile_raw)(filename, dest, result, 0)); 153ca987d46SWarner Losh } 154ca987d46SWarner Losh 155ca987d46SWarner Losh int 156ca987d46SWarner Losh __elfN(loadfile_raw)(char *filename, u_int64_t dest, 157ca987d46SWarner Losh struct preloaded_file **result, int multiboot) 158ca987d46SWarner Losh { 159ca987d46SWarner Losh struct preloaded_file *fp, *kfp; 160ca987d46SWarner Losh struct elf_file ef; 161ca987d46SWarner Losh Elf_Ehdr *ehdr; 162ca987d46SWarner Losh int err; 163ca987d46SWarner Losh 164ca987d46SWarner Losh fp = NULL; 165ca987d46SWarner Losh bzero(&ef, sizeof(struct elf_file)); 166ca987d46SWarner Losh ef.fd = -1; 167ca987d46SWarner Losh 168ca987d46SWarner Losh err = __elfN(load_elf_header)(filename, &ef); 169ca987d46SWarner Losh if (err != 0) 170ca987d46SWarner Losh return (err); 171ca987d46SWarner Losh 172ca987d46SWarner Losh ehdr = ef.ehdr; 173ca987d46SWarner Losh 174ca987d46SWarner Losh /* 175ca987d46SWarner Losh * Check to see what sort of module we are. 176ca987d46SWarner Losh */ 177ca987d46SWarner Losh kfp = file_findfile(NULL, __elfN(kerneltype)); 178ca987d46SWarner Losh #ifdef __powerpc__ 179ca987d46SWarner Losh /* 180ca987d46SWarner Losh * Kernels can be ET_DYN, so just assume the first loaded object is the 181ca987d46SWarner Losh * kernel. This assumption will be checked later. 182ca987d46SWarner Losh */ 183ca987d46SWarner Losh if (kfp == NULL) 184ca987d46SWarner Losh ef.kernel = 1; 185ca987d46SWarner Losh #endif 186ca987d46SWarner Losh if (ef.kernel || ehdr->e_type == ET_EXEC) { 187ca987d46SWarner Losh /* Looks like a kernel */ 188ca987d46SWarner Losh if (kfp != NULL) { 189ca987d46SWarner Losh printf("elf" __XSTRING(__ELF_WORD_SIZE) "_loadfile: kernel already loaded\n"); 190ca987d46SWarner Losh err = EPERM; 191ca987d46SWarner Losh goto oerr; 192ca987d46SWarner Losh } 193ca987d46SWarner Losh /* 194ca987d46SWarner Losh * Calculate destination address based on kernel entrypoint. 195ca987d46SWarner Losh * 196ca987d46SWarner Losh * For ARM, the destination address is independent of any values in the 197ca987d46SWarner Losh * elf header (an ARM kernel can be loaded at any 2MB boundary), so we 198ca987d46SWarner Losh * leave dest set to the value calculated by archsw.arch_loadaddr() and 199ca987d46SWarner Losh * passed in to this function. 200ca987d46SWarner Losh */ 201ca987d46SWarner Losh #ifndef __arm__ 202ca987d46SWarner Losh if (ehdr->e_type == ET_EXEC) 203ca987d46SWarner Losh dest = (ehdr->e_entry & ~PAGE_MASK); 204ca987d46SWarner Losh #endif 205ca987d46SWarner Losh if ((ehdr->e_entry & ~PAGE_MASK) == 0) { 206ca987d46SWarner Losh printf("elf" __XSTRING(__ELF_WORD_SIZE) "_loadfile: not a kernel (maybe static binary?)\n"); 207ca987d46SWarner Losh err = EPERM; 208ca987d46SWarner Losh goto oerr; 209ca987d46SWarner Losh } 210ca987d46SWarner Losh ef.kernel = 1; 211ca987d46SWarner Losh 212ca987d46SWarner Losh } else if (ehdr->e_type == ET_DYN) { 213ca987d46SWarner Losh /* Looks like a kld module */ 214ca987d46SWarner Losh if (multiboot != 0) { 215ca987d46SWarner Losh printf("elf" __XSTRING(__ELF_WORD_SIZE) "_loadfile: can't load module as multiboot\n"); 216ca987d46SWarner Losh err = EPERM; 217ca987d46SWarner Losh goto oerr; 218ca987d46SWarner Losh } 219ca987d46SWarner Losh if (kfp == NULL) { 220ca987d46SWarner Losh printf("elf" __XSTRING(__ELF_WORD_SIZE) "_loadfile: can't load module before kernel\n"); 221ca987d46SWarner Losh err = EPERM; 222ca987d46SWarner Losh goto oerr; 223ca987d46SWarner Losh } 224ca987d46SWarner Losh if (strcmp(__elfN(kerneltype), kfp->f_type)) { 225ca987d46SWarner Losh printf("elf" __XSTRING(__ELF_WORD_SIZE) "_loadfile: can't load module with kernel type '%s'\n", kfp->f_type); 226ca987d46SWarner Losh err = EPERM; 227ca987d46SWarner Losh goto oerr; 228ca987d46SWarner Losh } 229ca987d46SWarner Losh /* Looks OK, got ahead */ 230ca987d46SWarner Losh ef.kernel = 0; 231ca987d46SWarner Losh 232ca987d46SWarner Losh } else { 233ca987d46SWarner Losh err = EFTYPE; 234ca987d46SWarner Losh goto oerr; 235ca987d46SWarner Losh } 236ca987d46SWarner Losh 237ca987d46SWarner Losh if (archsw.arch_loadaddr != NULL) 238ca987d46SWarner Losh dest = archsw.arch_loadaddr(LOAD_ELF, ehdr, dest); 239ca987d46SWarner Losh else 240ca987d46SWarner Losh dest = roundup(dest, PAGE_SIZE); 241ca987d46SWarner Losh 242ca987d46SWarner Losh /* 243ca987d46SWarner Losh * Ok, we think we should handle this. 244ca987d46SWarner Losh */ 245ca987d46SWarner Losh fp = file_alloc(); 246ca987d46SWarner Losh if (fp == NULL) { 247ca987d46SWarner Losh printf("elf" __XSTRING(__ELF_WORD_SIZE) "_loadfile: cannot allocate module info\n"); 248ca987d46SWarner Losh err = EPERM; 249ca987d46SWarner Losh goto out; 250ca987d46SWarner Losh } 251ca987d46SWarner Losh if (ef.kernel == 1 && multiboot == 0) 252ca987d46SWarner Losh setenv("kernelname", filename, 1); 253ca987d46SWarner Losh fp->f_name = strdup(filename); 254ca987d46SWarner Losh if (multiboot == 0) 255ca987d46SWarner Losh fp->f_type = strdup(ef.kernel ? 256ca987d46SWarner Losh __elfN(kerneltype) : __elfN(moduletype)); 257ca987d46SWarner Losh else 258ca987d46SWarner Losh fp->f_type = strdup("elf multiboot kernel"); 259ca987d46SWarner Losh 260ca987d46SWarner Losh #ifdef ELF_VERBOSE 261ca987d46SWarner Losh if (ef.kernel) 262ca987d46SWarner Losh printf("%s entry at 0x%jx\n", filename, (uintmax_t)ehdr->e_entry); 263ca987d46SWarner Losh #else 264ca987d46SWarner Losh printf("%s ", filename); 265ca987d46SWarner Losh #endif 266ca987d46SWarner Losh 267ca987d46SWarner Losh fp->f_size = __elfN(loadimage)(fp, &ef, dest); 268ca987d46SWarner Losh if (fp->f_size == 0 || fp->f_addr == 0) 269ca987d46SWarner Losh goto ioerr; 270ca987d46SWarner Losh 271ca987d46SWarner Losh /* save exec header as metadata */ 272ca987d46SWarner Losh file_addmetadata(fp, MODINFOMD_ELFHDR, sizeof(*ehdr), ehdr); 273ca987d46SWarner Losh 274ca987d46SWarner Losh /* Load OK, return module pointer */ 275ca987d46SWarner Losh *result = (struct preloaded_file *)fp; 276ca987d46SWarner Losh err = 0; 277ca987d46SWarner Losh goto out; 278ca987d46SWarner Losh 279ca987d46SWarner Losh ioerr: 280ca987d46SWarner Losh err = EIO; 281ca987d46SWarner Losh oerr: 282ca987d46SWarner Losh file_discard(fp); 283ca987d46SWarner Losh out: 284ca987d46SWarner Losh if (ef.firstpage) 285ca987d46SWarner Losh free(ef.firstpage); 286ca987d46SWarner Losh if (ef.fd != -1) 287ca987d46SWarner Losh close(ef.fd); 288ca987d46SWarner Losh return(err); 289ca987d46SWarner Losh } 290ca987d46SWarner Losh 291ca987d46SWarner Losh /* 292ca987d46SWarner Losh * With the file (fd) open on the image, and (ehdr) containing 293ca987d46SWarner Losh * the Elf header, load the image at (off) 294ca987d46SWarner Losh */ 295ca987d46SWarner Losh static int 296ca987d46SWarner Losh __elfN(loadimage)(struct preloaded_file *fp, elf_file_t ef, u_int64_t off) 297ca987d46SWarner Losh { 298ca987d46SWarner Losh int i; 299ca987d46SWarner Losh u_int j; 300ca987d46SWarner Losh Elf_Ehdr *ehdr; 301ca987d46SWarner Losh Elf_Phdr *phdr, *php; 302ca987d46SWarner Losh Elf_Shdr *shdr; 303ca987d46SWarner Losh char *shstr; 304ca987d46SWarner Losh int ret; 305ca987d46SWarner Losh vm_offset_t firstaddr; 306ca987d46SWarner Losh vm_offset_t lastaddr; 307ca987d46SWarner Losh size_t chunk; 308ca987d46SWarner Losh ssize_t result; 309ca987d46SWarner Losh Elf_Addr ssym, esym; 310ca987d46SWarner Losh Elf_Dyn *dp; 311ca987d46SWarner Losh Elf_Addr adp; 312ca987d46SWarner Losh Elf_Addr ctors; 313ca987d46SWarner Losh int ndp; 314ca987d46SWarner Losh int symstrindex; 315ca987d46SWarner Losh int symtabindex; 316ca987d46SWarner Losh Elf_Size size; 317ca987d46SWarner Losh u_int fpcopy; 318ca987d46SWarner Losh Elf_Sym sym; 319ca987d46SWarner Losh Elf_Addr p_start, p_end; 320ca987d46SWarner Losh 321ca987d46SWarner Losh dp = NULL; 322ca987d46SWarner Losh shdr = NULL; 323ca987d46SWarner Losh ret = 0; 324ca987d46SWarner Losh firstaddr = lastaddr = 0; 325ca987d46SWarner Losh ehdr = ef->ehdr; 326ca987d46SWarner Losh if (ehdr->e_type == ET_EXEC) { 327ca987d46SWarner Losh #if defined(__i386__) || defined(__amd64__) 328ca987d46SWarner Losh #if __ELF_WORD_SIZE == 64 329ca987d46SWarner Losh off = - (off & 0xffffffffff000000ull);/* x86_64 relocates after locore */ 330ca987d46SWarner Losh #else 331ca987d46SWarner Losh off = - (off & 0xff000000u); /* i386 relocates after locore */ 332ca987d46SWarner Losh #endif 333ca987d46SWarner Losh #elif defined(__powerpc__) 334ca987d46SWarner Losh /* 335ca987d46SWarner Losh * On the purely virtual memory machines like e500, the kernel is 336ca987d46SWarner Losh * linked against its final VA range, which is most often not 337ca987d46SWarner Losh * available at the loader stage, but only after kernel initializes 338ca987d46SWarner Losh * and completes its VM settings. In such cases we cannot use p_vaddr 339ca987d46SWarner Losh * field directly to load ELF segments, but put them at some 340ca987d46SWarner Losh * 'load-time' locations. 341ca987d46SWarner Losh */ 342ca987d46SWarner Losh if (off & 0xf0000000u) { 343ca987d46SWarner Losh off = -(off & 0xf0000000u); 344ca987d46SWarner Losh /* 345ca987d46SWarner Losh * XXX the physical load address should not be hardcoded. Note 346ca987d46SWarner Losh * that the Book-E kernel assumes that it's loaded at a 16MB 347ca987d46SWarner Losh * boundary for now... 348ca987d46SWarner Losh */ 349ca987d46SWarner Losh off += 0x01000000; 350ca987d46SWarner Losh ehdr->e_entry += off; 351ca987d46SWarner Losh #ifdef ELF_VERBOSE 352ca987d46SWarner Losh printf("Converted entry 0x%08x\n", ehdr->e_entry); 353ca987d46SWarner Losh #endif 354ca987d46SWarner Losh } else 355ca987d46SWarner Losh off = 0; 356ca987d46SWarner Losh #elif defined(__arm__) && !defined(EFI) 357ca987d46SWarner Losh /* 358ca987d46SWarner Losh * The elf headers in arm kernels specify virtual addresses in all 359ca987d46SWarner Losh * header fields, even the ones that should be physical addresses. 360ca987d46SWarner Losh * We assume the entry point is in the first page, and masking the page 361ca987d46SWarner Losh * offset will leave us with the virtual address the kernel was linked 362ca987d46SWarner Losh * at. We subtract that from the load offset, making 'off' into the 363ca987d46SWarner Losh * value which, when added to a virtual address in an elf header, 364ca987d46SWarner Losh * translates it to a physical address. We do the va->pa conversion on 365ca987d46SWarner Losh * the entry point address in the header now, so that later we can 366ca987d46SWarner Losh * launch the kernel by just jumping to that address. 367ca987d46SWarner Losh * 368ca987d46SWarner Losh * When booting from UEFI the copyin and copyout functions handle 369ca987d46SWarner Losh * adjusting the location relative to the first virtual address. 370ca987d46SWarner Losh * Because of this there is no need to adjust the offset or entry 371ca987d46SWarner Losh * point address as these will both be handled by the efi code. 372ca987d46SWarner Losh */ 373ca987d46SWarner Losh off -= ehdr->e_entry & ~PAGE_MASK; 374ca987d46SWarner Losh ehdr->e_entry += off; 375ca987d46SWarner Losh #ifdef ELF_VERBOSE 376ca987d46SWarner Losh printf("ehdr->e_entry 0x%08x, va<->pa off %llx\n", ehdr->e_entry, off); 377ca987d46SWarner Losh #endif 378ca987d46SWarner Losh #else 379ca987d46SWarner Losh off = 0; /* other archs use direct mapped kernels */ 380ca987d46SWarner Losh #endif 381ca987d46SWarner Losh } 382ca987d46SWarner Losh ef->off = off; 383ca987d46SWarner Losh 384ca987d46SWarner Losh if (ef->kernel) 385ca987d46SWarner Losh __elfN(relocation_offset) = off; 386ca987d46SWarner Losh 387ca987d46SWarner Losh if ((ehdr->e_phoff + ehdr->e_phnum * sizeof(*phdr)) > ef->firstlen) { 388ca987d46SWarner Losh printf("elf" __XSTRING(__ELF_WORD_SIZE) "_loadimage: program header not within first page\n"); 389ca987d46SWarner Losh goto out; 390ca987d46SWarner Losh } 391ca987d46SWarner Losh phdr = (Elf_Phdr *)(ef->firstpage + ehdr->e_phoff); 392ca987d46SWarner Losh 393ca987d46SWarner Losh for (i = 0; i < ehdr->e_phnum; i++) { 394ca987d46SWarner Losh /* We want to load PT_LOAD segments only.. */ 395ca987d46SWarner Losh if (phdr[i].p_type != PT_LOAD) 396ca987d46SWarner Losh continue; 397ca987d46SWarner Losh 398ca987d46SWarner Losh #ifdef ELF_VERBOSE 399ca987d46SWarner Losh printf("Segment: 0x%lx@0x%lx -> 0x%lx-0x%lx", 400ca987d46SWarner Losh (long)phdr[i].p_filesz, (long)phdr[i].p_offset, 401ca987d46SWarner Losh (long)(phdr[i].p_vaddr + off), 402ca987d46SWarner Losh (long)(phdr[i].p_vaddr + off + phdr[i].p_memsz - 1)); 403ca987d46SWarner Losh #else 404ca987d46SWarner Losh if ((phdr[i].p_flags & PF_W) == 0) { 405ca987d46SWarner Losh printf("text=0x%lx ", (long)phdr[i].p_filesz); 406ca987d46SWarner Losh } else { 407ca987d46SWarner Losh printf("data=0x%lx", (long)phdr[i].p_filesz); 408ca987d46SWarner Losh if (phdr[i].p_filesz < phdr[i].p_memsz) 409ca987d46SWarner Losh printf("+0x%lx", (long)(phdr[i].p_memsz -phdr[i].p_filesz)); 410ca987d46SWarner Losh printf(" "); 411ca987d46SWarner Losh } 412ca987d46SWarner Losh #endif 413ca987d46SWarner Losh fpcopy = 0; 414ca987d46SWarner Losh if (ef->firstlen > phdr[i].p_offset) { 415ca987d46SWarner Losh fpcopy = ef->firstlen - phdr[i].p_offset; 416ca987d46SWarner Losh archsw.arch_copyin(ef->firstpage + phdr[i].p_offset, 417ca987d46SWarner Losh phdr[i].p_vaddr + off, fpcopy); 418ca987d46SWarner Losh } 419ca987d46SWarner Losh if (phdr[i].p_filesz > fpcopy) { 420ca987d46SWarner Losh if (kern_pread(ef->fd, phdr[i].p_vaddr + off + fpcopy, 421ca987d46SWarner Losh phdr[i].p_filesz - fpcopy, phdr[i].p_offset + fpcopy) != 0) { 422ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 423ca987d46SWarner Losh "_loadimage: read failed\n"); 424ca987d46SWarner Losh goto out; 425ca987d46SWarner Losh } 426ca987d46SWarner Losh } 427ca987d46SWarner Losh /* clear space from oversized segments; eg: bss */ 428ca987d46SWarner Losh if (phdr[i].p_filesz < phdr[i].p_memsz) { 429ca987d46SWarner Losh #ifdef ELF_VERBOSE 430ca987d46SWarner Losh printf(" (bss: 0x%lx-0x%lx)", 431ca987d46SWarner Losh (long)(phdr[i].p_vaddr + off + phdr[i].p_filesz), 432ca987d46SWarner Losh (long)(phdr[i].p_vaddr + off + phdr[i].p_memsz - 1)); 433ca987d46SWarner Losh #endif 434ca987d46SWarner Losh 435ca987d46SWarner Losh kern_bzero(phdr[i].p_vaddr + off + phdr[i].p_filesz, 436ca987d46SWarner Losh phdr[i].p_memsz - phdr[i].p_filesz); 437ca987d46SWarner Losh } 438ca987d46SWarner Losh #ifdef ELF_VERBOSE 439ca987d46SWarner Losh printf("\n"); 440ca987d46SWarner Losh #endif 441ca987d46SWarner Losh 442ca987d46SWarner Losh if (archsw.arch_loadseg != NULL) 443ca987d46SWarner Losh archsw.arch_loadseg(ehdr, phdr + i, off); 444ca987d46SWarner Losh 445ca987d46SWarner Losh if (firstaddr == 0 || firstaddr > (phdr[i].p_vaddr + off)) 446ca987d46SWarner Losh firstaddr = phdr[i].p_vaddr + off; 447ca987d46SWarner Losh if (lastaddr == 0 || lastaddr < (phdr[i].p_vaddr + off + phdr[i].p_memsz)) 448ca987d46SWarner Losh lastaddr = phdr[i].p_vaddr + off + phdr[i].p_memsz; 449ca987d46SWarner Losh } 450ca987d46SWarner Losh lastaddr = roundup(lastaddr, sizeof(long)); 451ca987d46SWarner Losh 452ca987d46SWarner Losh /* 453ca987d46SWarner Losh * Get the section headers. We need this for finding the .ctors 454ca987d46SWarner Losh * section as well as for loading any symbols. Both may be hard 455ca987d46SWarner Losh * to do if reading from a .gz file as it involves seeking. I 456ca987d46SWarner Losh * think the rule is going to have to be that you must strip a 457ca987d46SWarner Losh * file to remove symbols before gzipping it. 458ca987d46SWarner Losh */ 459db711744SWarner Losh chunk = (size_t)ehdr->e_shnum * (size_t)ehdr->e_shentsize; 460ca987d46SWarner Losh if (chunk == 0 || ehdr->e_shoff == 0) 461ca987d46SWarner Losh goto nosyms; 462ca987d46SWarner Losh shdr = alloc_pread(ef->fd, ehdr->e_shoff, chunk); 463ca987d46SWarner Losh if (shdr == NULL) { 464ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 465ca987d46SWarner Losh "_loadimage: failed to read section headers"); 466ca987d46SWarner Losh goto nosyms; 467ca987d46SWarner Losh } 468ca987d46SWarner Losh file_addmetadata(fp, MODINFOMD_SHDR, chunk, shdr); 469ca987d46SWarner Losh 470ca987d46SWarner Losh /* 471ca987d46SWarner Losh * Read the section string table and look for the .ctors section. 472ca987d46SWarner Losh * We need to tell the kernel where it is so that it can call the 473ca987d46SWarner Losh * ctors. 474ca987d46SWarner Losh */ 475ca987d46SWarner Losh chunk = shdr[ehdr->e_shstrndx].sh_size; 476ca987d46SWarner Losh if (chunk) { 477ca987d46SWarner Losh shstr = alloc_pread(ef->fd, shdr[ehdr->e_shstrndx].sh_offset, chunk); 478ca987d46SWarner Losh if (shstr) { 479ca987d46SWarner Losh for (i = 0; i < ehdr->e_shnum; i++) { 480ca987d46SWarner Losh if (strcmp(shstr + shdr[i].sh_name, ".ctors") != 0) 481ca987d46SWarner Losh continue; 482ca987d46SWarner Losh ctors = shdr[i].sh_addr; 483ca987d46SWarner Losh file_addmetadata(fp, MODINFOMD_CTORS_ADDR, sizeof(ctors), 484ca987d46SWarner Losh &ctors); 485ca987d46SWarner Losh size = shdr[i].sh_size; 486ca987d46SWarner Losh file_addmetadata(fp, MODINFOMD_CTORS_SIZE, sizeof(size), 487ca987d46SWarner Losh &size); 488ca987d46SWarner Losh break; 489ca987d46SWarner Losh } 490ca987d46SWarner Losh free(shstr); 491ca987d46SWarner Losh } 492ca987d46SWarner Losh } 493ca987d46SWarner Losh 494ca987d46SWarner Losh /* 495ca987d46SWarner Losh * Now load any symbols. 496ca987d46SWarner Losh */ 497ca987d46SWarner Losh symtabindex = -1; 498ca987d46SWarner Losh symstrindex = -1; 499ca987d46SWarner Losh for (i = 0; i < ehdr->e_shnum; i++) { 500ca987d46SWarner Losh if (shdr[i].sh_type != SHT_SYMTAB) 501ca987d46SWarner Losh continue; 502ca987d46SWarner Losh for (j = 0; j < ehdr->e_phnum; j++) { 503ca987d46SWarner Losh if (phdr[j].p_type != PT_LOAD) 504ca987d46SWarner Losh continue; 505ca987d46SWarner Losh if (shdr[i].sh_offset >= phdr[j].p_offset && 506ca987d46SWarner Losh (shdr[i].sh_offset + shdr[i].sh_size <= 507ca987d46SWarner Losh phdr[j].p_offset + phdr[j].p_filesz)) { 508ca987d46SWarner Losh shdr[i].sh_offset = 0; 509ca987d46SWarner Losh shdr[i].sh_size = 0; 510ca987d46SWarner Losh break; 511ca987d46SWarner Losh } 512ca987d46SWarner Losh } 513ca987d46SWarner Losh if (shdr[i].sh_offset == 0 || shdr[i].sh_size == 0) 514ca987d46SWarner Losh continue; /* alread loaded in a PT_LOAD above */ 515ca987d46SWarner Losh /* Save it for loading below */ 516ca987d46SWarner Losh symtabindex = i; 517ca987d46SWarner Losh symstrindex = shdr[i].sh_link; 518ca987d46SWarner Losh } 519ca987d46SWarner Losh if (symtabindex < 0 || symstrindex < 0) 520ca987d46SWarner Losh goto nosyms; 521ca987d46SWarner Losh 522ca987d46SWarner Losh /* Ok, committed to a load. */ 523ca987d46SWarner Losh #ifndef ELF_VERBOSE 524ca987d46SWarner Losh printf("syms=["); 525ca987d46SWarner Losh #endif 526ca987d46SWarner Losh ssym = lastaddr; 527ca987d46SWarner Losh for (i = symtabindex; i >= 0; i = symstrindex) { 528ca987d46SWarner Losh #ifdef ELF_VERBOSE 529ca987d46SWarner Losh char *secname; 530ca987d46SWarner Losh 531ca987d46SWarner Losh switch(shdr[i].sh_type) { 532ca987d46SWarner Losh case SHT_SYMTAB: /* Symbol table */ 533ca987d46SWarner Losh secname = "symtab"; 534ca987d46SWarner Losh break; 535ca987d46SWarner Losh case SHT_STRTAB: /* String table */ 536ca987d46SWarner Losh secname = "strtab"; 537ca987d46SWarner Losh break; 538ca987d46SWarner Losh default: 539ca987d46SWarner Losh secname = "WHOA!!"; 540ca987d46SWarner Losh break; 541ca987d46SWarner Losh } 542ca987d46SWarner Losh #endif 543ca987d46SWarner Losh 544ca987d46SWarner Losh size = shdr[i].sh_size; 545ca987d46SWarner Losh archsw.arch_copyin(&size, lastaddr, sizeof(size)); 546ca987d46SWarner Losh lastaddr += sizeof(size); 547ca987d46SWarner Losh 548ca987d46SWarner Losh #ifdef ELF_VERBOSE 549ca987d46SWarner Losh printf("\n%s: 0x%jx@0x%jx -> 0x%jx-0x%jx", secname, 550ca987d46SWarner Losh (uintmax_t)shdr[i].sh_size, (uintmax_t)shdr[i].sh_offset, 551ca987d46SWarner Losh (uintmax_t)lastaddr, (uintmax_t)(lastaddr + shdr[i].sh_size)); 552ca987d46SWarner Losh #else 553ca987d46SWarner Losh if (i == symstrindex) 554ca987d46SWarner Losh printf("+"); 555ca987d46SWarner Losh printf("0x%lx+0x%lx", (long)sizeof(size), (long)size); 556ca987d46SWarner Losh #endif 557ca987d46SWarner Losh 558ca987d46SWarner Losh if (lseek(ef->fd, (off_t)shdr[i].sh_offset, SEEK_SET) == -1) { 559ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) "_loadimage: could not seek for symbols - skipped!"); 560ca987d46SWarner Losh lastaddr = ssym; 561ca987d46SWarner Losh ssym = 0; 562ca987d46SWarner Losh goto nosyms; 563ca987d46SWarner Losh } 564ca987d46SWarner Losh result = archsw.arch_readin(ef->fd, lastaddr, shdr[i].sh_size); 565ca987d46SWarner Losh if (result < 0 || (size_t)result != shdr[i].sh_size) { 566ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) "_loadimage: could not read symbols - skipped! (%ju != %ju)", (uintmax_t)result, 567ca987d46SWarner Losh (uintmax_t)shdr[i].sh_size); 568ca987d46SWarner Losh lastaddr = ssym; 569ca987d46SWarner Losh ssym = 0; 570ca987d46SWarner Losh goto nosyms; 571ca987d46SWarner Losh } 572ca987d46SWarner Losh /* Reset offsets relative to ssym */ 573ca987d46SWarner Losh lastaddr += shdr[i].sh_size; 574ca987d46SWarner Losh lastaddr = roundup(lastaddr, sizeof(size)); 575ca987d46SWarner Losh if (i == symtabindex) 576ca987d46SWarner Losh symtabindex = -1; 577ca987d46SWarner Losh else if (i == symstrindex) 578ca987d46SWarner Losh symstrindex = -1; 579ca987d46SWarner Losh } 580ca987d46SWarner Losh esym = lastaddr; 581ca987d46SWarner Losh #ifndef ELF_VERBOSE 582ca987d46SWarner Losh printf("]"); 583ca987d46SWarner Losh #endif 584ca987d46SWarner Losh 585ca987d46SWarner Losh file_addmetadata(fp, MODINFOMD_SSYM, sizeof(ssym), &ssym); 586ca987d46SWarner Losh file_addmetadata(fp, MODINFOMD_ESYM, sizeof(esym), &esym); 587ca987d46SWarner Losh 588ca987d46SWarner Losh nosyms: 589ca987d46SWarner Losh printf("\n"); 590ca987d46SWarner Losh 591ca987d46SWarner Losh ret = lastaddr - firstaddr; 592ca987d46SWarner Losh fp->f_addr = firstaddr; 593ca987d46SWarner Losh 594ca987d46SWarner Losh php = NULL; 595ca987d46SWarner Losh for (i = 0; i < ehdr->e_phnum; i++) { 596ca987d46SWarner Losh if (phdr[i].p_type == PT_DYNAMIC) { 597ca987d46SWarner Losh php = phdr + i; 598ca987d46SWarner Losh adp = php->p_vaddr; 599ca987d46SWarner Losh file_addmetadata(fp, MODINFOMD_DYNAMIC, sizeof(adp), &adp); 600ca987d46SWarner Losh break; 601ca987d46SWarner Losh } 602ca987d46SWarner Losh } 603ca987d46SWarner Losh 604ca987d46SWarner Losh if (php == NULL) /* this is bad, we cannot get to symbols or _DYNAMIC */ 605ca987d46SWarner Losh goto out; 606ca987d46SWarner Losh 607ca987d46SWarner Losh ndp = php->p_filesz / sizeof(Elf_Dyn); 608ca987d46SWarner Losh if (ndp == 0) 609ca987d46SWarner Losh goto out; 610ca987d46SWarner Losh dp = malloc(php->p_filesz); 611ca987d46SWarner Losh if (dp == NULL) 612ca987d46SWarner Losh goto out; 613ca987d46SWarner Losh archsw.arch_copyout(php->p_vaddr + off, dp, php->p_filesz); 614ca987d46SWarner Losh 615ca987d46SWarner Losh ef->strsz = 0; 616ca987d46SWarner Losh for (i = 0; i < ndp; i++) { 617ca987d46SWarner Losh if (dp[i].d_tag == 0) 618ca987d46SWarner Losh break; 619ca987d46SWarner Losh switch (dp[i].d_tag) { 620ca987d46SWarner Losh case DT_HASH: 621ca987d46SWarner Losh ef->hashtab = (Elf_Hashelt*)(uintptr_t)(dp[i].d_un.d_ptr + off); 622ca987d46SWarner Losh break; 623ca987d46SWarner Losh case DT_STRTAB: 624ca987d46SWarner Losh ef->strtab = (char *)(uintptr_t)(dp[i].d_un.d_ptr + off); 625ca987d46SWarner Losh break; 626ca987d46SWarner Losh case DT_STRSZ: 627ca987d46SWarner Losh ef->strsz = dp[i].d_un.d_val; 628ca987d46SWarner Losh break; 629ca987d46SWarner Losh case DT_SYMTAB: 630ca987d46SWarner Losh ef->symtab = (Elf_Sym*)(uintptr_t)(dp[i].d_un.d_ptr + off); 631ca987d46SWarner Losh break; 632ca987d46SWarner Losh case DT_REL: 633ca987d46SWarner Losh ef->rel = (Elf_Rel *)(uintptr_t)(dp[i].d_un.d_ptr + off); 634ca987d46SWarner Losh break; 635ca987d46SWarner Losh case DT_RELSZ: 636ca987d46SWarner Losh ef->relsz = dp[i].d_un.d_val; 637ca987d46SWarner Losh break; 638ca987d46SWarner Losh case DT_RELA: 639ca987d46SWarner Losh ef->rela = (Elf_Rela *)(uintptr_t)(dp[i].d_un.d_ptr + off); 640ca987d46SWarner Losh break; 641ca987d46SWarner Losh case DT_RELASZ: 642ca987d46SWarner Losh ef->relasz = dp[i].d_un.d_val; 643ca987d46SWarner Losh break; 644ca987d46SWarner Losh default: 645ca987d46SWarner Losh break; 646ca987d46SWarner Losh } 647ca987d46SWarner Losh } 648ca987d46SWarner Losh if (ef->hashtab == NULL || ef->symtab == NULL || 649ca987d46SWarner Losh ef->strtab == NULL || ef->strsz == 0) 650ca987d46SWarner Losh goto out; 651ca987d46SWarner Losh COPYOUT(ef->hashtab, &ef->nbuckets, sizeof(ef->nbuckets)); 652ca987d46SWarner Losh COPYOUT(ef->hashtab + 1, &ef->nchains, sizeof(ef->nchains)); 653ca987d46SWarner Losh ef->buckets = ef->hashtab + 2; 654ca987d46SWarner Losh ef->chains = ef->buckets + ef->nbuckets; 655ca987d46SWarner Losh 656ca987d46SWarner Losh if (__elfN(lookup_symbol)(fp, ef, "__start_set_modmetadata_set", &sym) != 0) 657ca987d46SWarner Losh return 0; 658ca987d46SWarner Losh p_start = sym.st_value + ef->off; 659ca987d46SWarner Losh if (__elfN(lookup_symbol)(fp, ef, "__stop_set_modmetadata_set", &sym) != 0) 660ca987d46SWarner Losh return ENOENT; 661ca987d46SWarner Losh p_end = sym.st_value + ef->off; 662ca987d46SWarner Losh 663ca987d46SWarner Losh if (__elfN(parse_modmetadata)(fp, ef, p_start, p_end) == 0) 664ca987d46SWarner Losh goto out; 665ca987d46SWarner Losh 666ca987d46SWarner Losh if (ef->kernel) /* kernel must not depend on anything */ 667ca987d46SWarner Losh goto out; 668ca987d46SWarner Losh 669ca987d46SWarner Losh out: 670ca987d46SWarner Losh if (dp) 671ca987d46SWarner Losh free(dp); 672ca987d46SWarner Losh if (shdr) 673ca987d46SWarner Losh free(shdr); 674ca987d46SWarner Losh return ret; 675ca987d46SWarner Losh } 676ca987d46SWarner Losh 677ca987d46SWarner Losh static char invalid_name[] = "bad"; 678ca987d46SWarner Losh 679ca987d46SWarner Losh char * 680ca987d46SWarner Losh fake_modname(const char *name) 681ca987d46SWarner Losh { 682ca987d46SWarner Losh const char *sp, *ep; 683ca987d46SWarner Losh char *fp; 684ca987d46SWarner Losh size_t len; 685ca987d46SWarner Losh 686ca987d46SWarner Losh sp = strrchr(name, '/'); 687ca987d46SWarner Losh if (sp) 688ca987d46SWarner Losh sp++; 689ca987d46SWarner Losh else 690ca987d46SWarner Losh sp = name; 691ca987d46SWarner Losh ep = strrchr(name, '.'); 692ca987d46SWarner Losh if (ep) { 693ca987d46SWarner Losh if (ep == name) { 694ca987d46SWarner Losh sp = invalid_name; 695ca987d46SWarner Losh ep = invalid_name + sizeof(invalid_name) - 1; 696ca987d46SWarner Losh } 697ca987d46SWarner Losh } else 698ca987d46SWarner Losh ep = name + strlen(name); 699ca987d46SWarner Losh len = ep - sp; 700ca987d46SWarner Losh fp = malloc(len + 1); 701ca987d46SWarner Losh if (fp == NULL) 702ca987d46SWarner Losh return NULL; 703ca987d46SWarner Losh memcpy(fp, sp, len); 704ca987d46SWarner Losh fp[len] = '\0'; 705ca987d46SWarner Losh return fp; 706ca987d46SWarner Losh } 707ca987d46SWarner Losh 708ca987d46SWarner Losh #if (defined(__i386__) || defined(__powerpc__)) && __ELF_WORD_SIZE == 64 709ca987d46SWarner Losh struct mod_metadata64 { 710ca987d46SWarner Losh int md_version; /* structure version MDTV_* */ 711ca987d46SWarner Losh int md_type; /* type of entry MDT_* */ 712ca987d46SWarner Losh u_int64_t md_data; /* specific data */ 713ca987d46SWarner Losh u_int64_t md_cval; /* common string label */ 714ca987d46SWarner Losh }; 715ca987d46SWarner Losh #endif 716ca987d46SWarner Losh #if defined(__amd64__) && __ELF_WORD_SIZE == 32 717ca987d46SWarner Losh struct mod_metadata32 { 718ca987d46SWarner Losh int md_version; /* structure version MDTV_* */ 719ca987d46SWarner Losh int md_type; /* type of entry MDT_* */ 720ca987d46SWarner Losh u_int32_t md_data; /* specific data */ 721ca987d46SWarner Losh u_int32_t md_cval; /* common string label */ 722ca987d46SWarner Losh }; 723ca987d46SWarner Losh #endif 724ca987d46SWarner Losh 725ca987d46SWarner Losh int 726ca987d46SWarner Losh __elfN(load_modmetadata)(struct preloaded_file *fp, u_int64_t dest) 727ca987d46SWarner Losh { 728ca987d46SWarner Losh struct elf_file ef; 729ca987d46SWarner Losh int err, i, j; 730ca987d46SWarner Losh Elf_Shdr *sh_meta, *shdr = NULL; 731ca987d46SWarner Losh Elf_Shdr *sh_data[2]; 732ca987d46SWarner Losh char *shstrtab = NULL; 733ca987d46SWarner Losh size_t size; 734ca987d46SWarner Losh Elf_Addr p_start, p_end; 735ca987d46SWarner Losh 736ca987d46SWarner Losh bzero(&ef, sizeof(struct elf_file)); 737ca987d46SWarner Losh ef.fd = -1; 738ca987d46SWarner Losh 739ca987d46SWarner Losh err = __elfN(load_elf_header)(fp->f_name, &ef); 740ca987d46SWarner Losh if (err != 0) 741ca987d46SWarner Losh goto out; 742ca987d46SWarner Losh 743ca987d46SWarner Losh if (ef.kernel == 1 || ef.ehdr->e_type == ET_EXEC) { 744ca987d46SWarner Losh ef.kernel = 1; 745ca987d46SWarner Losh } else if (ef.ehdr->e_type != ET_DYN) { 746ca987d46SWarner Losh err = EFTYPE; 747ca987d46SWarner Losh goto out; 748ca987d46SWarner Losh } 749ca987d46SWarner Losh 750db711744SWarner Losh size = (size_t)ef.ehdr->e_shnum * (size_t)ef.ehdr->e_shentsize; 751ca987d46SWarner Losh shdr = alloc_pread(ef.fd, ef.ehdr->e_shoff, size); 752ca987d46SWarner Losh if (shdr == NULL) { 753ca987d46SWarner Losh err = ENOMEM; 754ca987d46SWarner Losh goto out; 755ca987d46SWarner Losh } 756ca987d46SWarner Losh 757ca987d46SWarner Losh /* Load shstrtab. */ 758ca987d46SWarner Losh shstrtab = alloc_pread(ef.fd, shdr[ef.ehdr->e_shstrndx].sh_offset, 759ca987d46SWarner Losh shdr[ef.ehdr->e_shstrndx].sh_size); 760ca987d46SWarner Losh if (shstrtab == NULL) { 761ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 762ca987d46SWarner Losh "load_modmetadata: unable to load shstrtab\n"); 763ca987d46SWarner Losh err = EFTYPE; 764ca987d46SWarner Losh goto out; 765ca987d46SWarner Losh } 766ca987d46SWarner Losh 767ca987d46SWarner Losh /* Find set_modmetadata_set and data sections. */ 768ca987d46SWarner Losh sh_data[0] = sh_data[1] = sh_meta = NULL; 769ca987d46SWarner Losh for (i = 0, j = 0; i < ef.ehdr->e_shnum; i++) { 770ca987d46SWarner Losh if (strcmp(&shstrtab[shdr[i].sh_name], 771ca987d46SWarner Losh "set_modmetadata_set") == 0) { 772ca987d46SWarner Losh sh_meta = &shdr[i]; 773ca987d46SWarner Losh } 774ca987d46SWarner Losh if ((strcmp(&shstrtab[shdr[i].sh_name], ".data") == 0) || 775ca987d46SWarner Losh (strcmp(&shstrtab[shdr[i].sh_name], ".rodata") == 0)) { 776ca987d46SWarner Losh sh_data[j++] = &shdr[i]; 777ca987d46SWarner Losh } 778ca987d46SWarner Losh } 779ca987d46SWarner Losh if (sh_meta == NULL || sh_data[0] == NULL || sh_data[1] == NULL) { 780ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 781ca987d46SWarner Losh "load_modmetadata: unable to find set_modmetadata_set or data sections\n"); 782ca987d46SWarner Losh err = EFTYPE; 783ca987d46SWarner Losh goto out; 784ca987d46SWarner Losh } 785ca987d46SWarner Losh 786ca987d46SWarner Losh /* Load set_modmetadata_set into memory */ 787ca987d46SWarner Losh err = kern_pread(ef.fd, dest, sh_meta->sh_size, sh_meta->sh_offset); 788ca987d46SWarner Losh if (err != 0) { 789ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 790ca987d46SWarner Losh "load_modmetadata: unable to load set_modmetadata_set: %d\n", err); 791ca987d46SWarner Losh goto out; 792ca987d46SWarner Losh } 793ca987d46SWarner Losh p_start = dest; 794ca987d46SWarner Losh p_end = dest + sh_meta->sh_size; 795ca987d46SWarner Losh dest += sh_meta->sh_size; 796ca987d46SWarner Losh 797ca987d46SWarner Losh /* Load data sections into memory. */ 798ca987d46SWarner Losh err = kern_pread(ef.fd, dest, sh_data[0]->sh_size, 799ca987d46SWarner Losh sh_data[0]->sh_offset); 800ca987d46SWarner Losh if (err != 0) { 801ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 802ca987d46SWarner Losh "load_modmetadata: unable to load data: %d\n", err); 803ca987d46SWarner Losh goto out; 804ca987d46SWarner Losh } 805ca987d46SWarner Losh 806ca987d46SWarner Losh /* 807ca987d46SWarner Losh * We have to increment the dest, so that the offset is the same into 808ca987d46SWarner Losh * both the .rodata and .data sections. 809ca987d46SWarner Losh */ 810ca987d46SWarner Losh ef.off = -(sh_data[0]->sh_addr - dest); 811ca987d46SWarner Losh dest += (sh_data[1]->sh_addr - sh_data[0]->sh_addr); 812ca987d46SWarner Losh 813ca987d46SWarner Losh err = kern_pread(ef.fd, dest, sh_data[1]->sh_size, 814ca987d46SWarner Losh sh_data[1]->sh_offset); 815ca987d46SWarner Losh if (err != 0) { 816ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 817ca987d46SWarner Losh "load_modmetadata: unable to load data: %d\n", err); 818ca987d46SWarner Losh goto out; 819ca987d46SWarner Losh } 820ca987d46SWarner Losh 821ca987d46SWarner Losh err = __elfN(parse_modmetadata)(fp, &ef, p_start, p_end); 822ca987d46SWarner Losh if (err != 0) { 823ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 824ca987d46SWarner Losh "load_modmetadata: unable to parse metadata: %d\n", err); 825ca987d46SWarner Losh goto out; 826ca987d46SWarner Losh } 827ca987d46SWarner Losh 828ca987d46SWarner Losh out: 829ca987d46SWarner Losh if (shstrtab != NULL) 830ca987d46SWarner Losh free(shstrtab); 831ca987d46SWarner Losh if (shdr != NULL) 832ca987d46SWarner Losh free(shdr); 833ca987d46SWarner Losh if (ef.firstpage != NULL) 834ca987d46SWarner Losh free(ef.firstpage); 835ca987d46SWarner Losh if (ef.fd != -1) 836ca987d46SWarner Losh close(ef.fd); 837ca987d46SWarner Losh return (err); 838ca987d46SWarner Losh } 839ca987d46SWarner Losh 840ca987d46SWarner Losh int 841ca987d46SWarner Losh __elfN(parse_modmetadata)(struct preloaded_file *fp, elf_file_t ef, 842ca987d46SWarner Losh Elf_Addr p_start, Elf_Addr p_end) 843ca987d46SWarner Losh { 844ca987d46SWarner Losh struct mod_metadata md; 845ca987d46SWarner Losh #if (defined(__i386__) || defined(__powerpc__)) && __ELF_WORD_SIZE == 64 846ca987d46SWarner Losh struct mod_metadata64 md64; 847ca987d46SWarner Losh #elif defined(__amd64__) && __ELF_WORD_SIZE == 32 848ca987d46SWarner Losh struct mod_metadata32 md32; 849ca987d46SWarner Losh #endif 850ca987d46SWarner Losh struct mod_depend *mdepend; 851ca987d46SWarner Losh struct mod_version mver; 852ca987d46SWarner Losh char *s; 853ca987d46SWarner Losh int error, modcnt, minfolen; 854ca987d46SWarner Losh Elf_Addr v, p; 855ca987d46SWarner Losh 856ca987d46SWarner Losh modcnt = 0; 857ca987d46SWarner Losh p = p_start; 858ca987d46SWarner Losh while (p < p_end) { 859ca987d46SWarner Losh COPYOUT(p, &v, sizeof(v)); 860ca987d46SWarner Losh error = __elfN(reloc_ptr)(fp, ef, p, &v, sizeof(v)); 861ca987d46SWarner Losh if (error == EOPNOTSUPP) 862ca987d46SWarner Losh v += ef->off; 863ca987d46SWarner Losh else if (error != 0) 864ca987d46SWarner Losh return (error); 865ca987d46SWarner Losh #if (defined(__i386__) || defined(__powerpc__)) && __ELF_WORD_SIZE == 64 866ca987d46SWarner Losh COPYOUT(v, &md64, sizeof(md64)); 867ca987d46SWarner Losh error = __elfN(reloc_ptr)(fp, ef, v, &md64, sizeof(md64)); 868ca987d46SWarner Losh if (error == EOPNOTSUPP) { 869ca987d46SWarner Losh md64.md_cval += ef->off; 870ca987d46SWarner Losh md64.md_data += ef->off; 871ca987d46SWarner Losh } else if (error != 0) 872ca987d46SWarner Losh return (error); 873ca987d46SWarner Losh md.md_version = md64.md_version; 874ca987d46SWarner Losh md.md_type = md64.md_type; 875ca987d46SWarner Losh md.md_cval = (const char *)(uintptr_t)md64.md_cval; 876ca987d46SWarner Losh md.md_data = (void *)(uintptr_t)md64.md_data; 877ca987d46SWarner Losh #elif defined(__amd64__) && __ELF_WORD_SIZE == 32 878ca987d46SWarner Losh COPYOUT(v, &md32, sizeof(md32)); 879ca987d46SWarner Losh error = __elfN(reloc_ptr)(fp, ef, v, &md32, sizeof(md32)); 880ca987d46SWarner Losh if (error == EOPNOTSUPP) { 881ca987d46SWarner Losh md32.md_cval += ef->off; 882ca987d46SWarner Losh md32.md_data += ef->off; 883ca987d46SWarner Losh } else if (error != 0) 884ca987d46SWarner Losh return (error); 885ca987d46SWarner Losh md.md_version = md32.md_version; 886ca987d46SWarner Losh md.md_type = md32.md_type; 887ca987d46SWarner Losh md.md_cval = (const char *)(uintptr_t)md32.md_cval; 888ca987d46SWarner Losh md.md_data = (void *)(uintptr_t)md32.md_data; 889ca987d46SWarner Losh #else 890ca987d46SWarner Losh COPYOUT(v, &md, sizeof(md)); 891ca987d46SWarner Losh error = __elfN(reloc_ptr)(fp, ef, v, &md, sizeof(md)); 892ca987d46SWarner Losh if (error == EOPNOTSUPP) { 893ca987d46SWarner Losh md.md_cval += ef->off; 894ca987d46SWarner Losh md.md_data = (void *)((uintptr_t)md.md_data + (uintptr_t)ef->off); 895ca987d46SWarner Losh } else if (error != 0) 896ca987d46SWarner Losh return (error); 897ca987d46SWarner Losh #endif 898ca987d46SWarner Losh p += sizeof(Elf_Addr); 899ca987d46SWarner Losh switch(md.md_type) { 900ca987d46SWarner Losh case MDT_DEPEND: 901ca987d46SWarner Losh if (ef->kernel) /* kernel must not depend on anything */ 902ca987d46SWarner Losh break; 903ca987d46SWarner Losh s = strdupout((vm_offset_t)md.md_cval); 904ca987d46SWarner Losh minfolen = sizeof(*mdepend) + strlen(s) + 1; 905ca987d46SWarner Losh mdepend = malloc(minfolen); 906ca987d46SWarner Losh if (mdepend == NULL) 907ca987d46SWarner Losh return ENOMEM; 908ca987d46SWarner Losh COPYOUT((vm_offset_t)md.md_data, mdepend, sizeof(*mdepend)); 909ca987d46SWarner Losh strcpy((char*)(mdepend + 1), s); 910ca987d46SWarner Losh free(s); 911ca987d46SWarner Losh file_addmetadata(fp, MODINFOMD_DEPLIST, minfolen, mdepend); 912ca987d46SWarner Losh free(mdepend); 913ca987d46SWarner Losh break; 914ca987d46SWarner Losh case MDT_VERSION: 915ca987d46SWarner Losh s = strdupout((vm_offset_t)md.md_cval); 916ca987d46SWarner Losh COPYOUT((vm_offset_t)md.md_data, &mver, sizeof(mver)); 917ca987d46SWarner Losh file_addmodule(fp, s, mver.mv_version, NULL); 918ca987d46SWarner Losh free(s); 919ca987d46SWarner Losh modcnt++; 920ca987d46SWarner Losh break; 921ca987d46SWarner Losh } 922ca987d46SWarner Losh } 923ca987d46SWarner Losh if (modcnt == 0) { 924ca987d46SWarner Losh s = fake_modname(fp->f_name); 925ca987d46SWarner Losh file_addmodule(fp, s, 1, NULL); 926ca987d46SWarner Losh free(s); 927ca987d46SWarner Losh } 928ca987d46SWarner Losh return 0; 929ca987d46SWarner Losh } 930ca987d46SWarner Losh 931ca987d46SWarner Losh static unsigned long 932ca987d46SWarner Losh elf_hash(const char *name) 933ca987d46SWarner Losh { 934ca987d46SWarner Losh const unsigned char *p = (const unsigned char *) name; 935ca987d46SWarner Losh unsigned long h = 0; 936ca987d46SWarner Losh unsigned long g; 937ca987d46SWarner Losh 938ca987d46SWarner Losh while (*p != '\0') { 939ca987d46SWarner Losh h = (h << 4) + *p++; 940ca987d46SWarner Losh if ((g = h & 0xf0000000) != 0) 941ca987d46SWarner Losh h ^= g >> 24; 942ca987d46SWarner Losh h &= ~g; 943ca987d46SWarner Losh } 944ca987d46SWarner Losh return h; 945ca987d46SWarner Losh } 946ca987d46SWarner Losh 947ca987d46SWarner Losh static const char __elfN(bad_symtable)[] = "elf" __XSTRING(__ELF_WORD_SIZE) "_lookup_symbol: corrupt symbol table\n"; 948ca987d46SWarner Losh int 949ca987d46SWarner Losh __elfN(lookup_symbol)(struct preloaded_file *fp, elf_file_t ef, const char* name, 950ca987d46SWarner Losh Elf_Sym *symp) 951ca987d46SWarner Losh { 952ca987d46SWarner Losh Elf_Hashelt symnum; 953ca987d46SWarner Losh Elf_Sym sym; 954ca987d46SWarner Losh char *strp; 955ca987d46SWarner Losh unsigned long hash; 956ca987d46SWarner Losh 957ca987d46SWarner Losh hash = elf_hash(name); 958ca987d46SWarner Losh COPYOUT(&ef->buckets[hash % ef->nbuckets], &symnum, sizeof(symnum)); 959ca987d46SWarner Losh 960ca987d46SWarner Losh while (symnum != STN_UNDEF) { 961ca987d46SWarner Losh if (symnum >= ef->nchains) { 962ca987d46SWarner Losh printf(__elfN(bad_symtable)); 963ca987d46SWarner Losh return ENOENT; 964ca987d46SWarner Losh } 965ca987d46SWarner Losh 966ca987d46SWarner Losh COPYOUT(ef->symtab + symnum, &sym, sizeof(sym)); 967ca987d46SWarner Losh if (sym.st_name == 0) { 968ca987d46SWarner Losh printf(__elfN(bad_symtable)); 969ca987d46SWarner Losh return ENOENT; 970ca987d46SWarner Losh } 971ca987d46SWarner Losh 972ca987d46SWarner Losh strp = strdupout((vm_offset_t)(ef->strtab + sym.st_name)); 973ca987d46SWarner Losh if (strcmp(name, strp) == 0) { 974ca987d46SWarner Losh free(strp); 975ca987d46SWarner Losh if (sym.st_shndx != SHN_UNDEF || 976ca987d46SWarner Losh (sym.st_value != 0 && 977ca987d46SWarner Losh ELF_ST_TYPE(sym.st_info) == STT_FUNC)) { 978ca987d46SWarner Losh *symp = sym; 979ca987d46SWarner Losh return 0; 980ca987d46SWarner Losh } 981ca987d46SWarner Losh return ENOENT; 982ca987d46SWarner Losh } 983ca987d46SWarner Losh free(strp); 984ca987d46SWarner Losh COPYOUT(&ef->chains[symnum], &symnum, sizeof(symnum)); 985ca987d46SWarner Losh } 986ca987d46SWarner Losh return ENOENT; 987ca987d46SWarner Losh } 988ca987d46SWarner Losh 989ca987d46SWarner Losh /* 990ca987d46SWarner Losh * Apply any intra-module relocations to the value. p is the load address 991ca987d46SWarner Losh * of the value and val/len is the value to be modified. This does NOT modify 992ca987d46SWarner Losh * the image in-place, because this is done by kern_linker later on. 993ca987d46SWarner Losh * 994ca987d46SWarner Losh * Returns EOPNOTSUPP if no relocation method is supplied. 995ca987d46SWarner Losh */ 996ca987d46SWarner Losh static int 997ca987d46SWarner Losh __elfN(reloc_ptr)(struct preloaded_file *mp, elf_file_t ef, 998ca987d46SWarner Losh Elf_Addr p, void *val, size_t len) 999ca987d46SWarner Losh { 1000ca987d46SWarner Losh size_t n; 1001ca987d46SWarner Losh Elf_Rela a; 1002ca987d46SWarner Losh Elf_Rel r; 1003ca987d46SWarner Losh int error; 1004ca987d46SWarner Losh 1005ca987d46SWarner Losh /* 1006ca987d46SWarner Losh * The kernel is already relocated, but we still want to apply 1007ca987d46SWarner Losh * offset adjustments. 1008ca987d46SWarner Losh */ 1009ca987d46SWarner Losh if (ef->kernel) 1010ca987d46SWarner Losh return (EOPNOTSUPP); 1011ca987d46SWarner Losh 1012ca987d46SWarner Losh for (n = 0; n < ef->relsz / sizeof(r); n++) { 1013ca987d46SWarner Losh COPYOUT(ef->rel + n, &r, sizeof(r)); 1014ca987d46SWarner Losh 1015ca987d46SWarner Losh error = __elfN(reloc)(ef, __elfN(symaddr), &r, ELF_RELOC_REL, 1016ca987d46SWarner Losh ef->off, p, val, len); 1017ca987d46SWarner Losh if (error != 0) 1018ca987d46SWarner Losh return (error); 1019ca987d46SWarner Losh } 1020ca987d46SWarner Losh for (n = 0; n < ef->relasz / sizeof(a); n++) { 1021ca987d46SWarner Losh COPYOUT(ef->rela + n, &a, sizeof(a)); 1022ca987d46SWarner Losh 1023ca987d46SWarner Losh error = __elfN(reloc)(ef, __elfN(symaddr), &a, ELF_RELOC_RELA, 1024ca987d46SWarner Losh ef->off, p, val, len); 1025ca987d46SWarner Losh if (error != 0) 1026ca987d46SWarner Losh return (error); 1027ca987d46SWarner Losh } 1028ca987d46SWarner Losh 1029ca987d46SWarner Losh return (0); 1030ca987d46SWarner Losh } 1031ca987d46SWarner Losh 1032ca987d46SWarner Losh static Elf_Addr 1033ca987d46SWarner Losh __elfN(symaddr)(struct elf_file *ef, Elf_Size symidx) 1034ca987d46SWarner Losh { 1035ca987d46SWarner Losh 1036ca987d46SWarner Losh /* Symbol lookup by index not required here. */ 1037ca987d46SWarner Losh return (0); 1038ca987d46SWarner Losh } 1039