1a4f67738SDoug Rabson /*- 2326e27d8SDoug Rabson * Copyright (c) 1998-2000 Doug Rabson 3e9eabf59SPeter Wemm * Copyright (c) 2004 Peter Wemm 4a4f67738SDoug Rabson * All rights reserved. 5a4f67738SDoug Rabson * 6a4f67738SDoug Rabson * Redistribution and use in source and binary forms, with or without 7a4f67738SDoug Rabson * modification, are permitted provided that the following conditions 8a4f67738SDoug Rabson * are met: 9a4f67738SDoug Rabson * 1. Redistributions of source code must retain the above copyright 10a4f67738SDoug Rabson * notice, this list of conditions and the following disclaimer. 11a4f67738SDoug Rabson * 2. Redistributions in binary form must reproduce the above copyright 12a4f67738SDoug Rabson * notice, this list of conditions and the following disclaimer in the 13a4f67738SDoug Rabson * documentation and/or other materials provided with the distribution. 14a4f67738SDoug Rabson * 15a4f67738SDoug Rabson * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16a4f67738SDoug Rabson * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17a4f67738SDoug Rabson * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18a4f67738SDoug Rabson * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19a4f67738SDoug Rabson * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20a4f67738SDoug Rabson * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21a4f67738SDoug Rabson * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22a4f67738SDoug Rabson * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23a4f67738SDoug Rabson * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24a4f67738SDoug Rabson * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25a4f67738SDoug Rabson * SUCH DAMAGE. 26a4f67738SDoug Rabson */ 27a4f67738SDoug Rabson 28677b542eSDavid E. O'Brien #include <sys/cdefs.h> 29677b542eSDavid E. O'Brien __FBSDID("$FreeBSD$"); 30677b542eSDavid E. O'Brien 31326e27d8SDoug Rabson #include "opt_ddb.h" 32a3df768bSRobert Watson #include "opt_mac.h" 33326e27d8SDoug Rabson 34a4f67738SDoug Rabson #include <sys/param.h> 35a4f67738SDoug Rabson #include <sys/systm.h> 36fb919e4dSMark Murray #include <sys/kernel.h> 37fb919e4dSMark Murray #include <sys/lock.h> 38a4f67738SDoug Rabson #include <sys/malloc.h> 39c0b824f9SDima Dorfman #include <sys/mutex.h> 4062d615d5SJohn Baldwin #include <sys/mount.h> 41a4f67738SDoug Rabson #include <sys/proc.h> 42a4f67738SDoug Rabson #include <sys/namei.h> 43a4f67738SDoug Rabson #include <sys/fcntl.h> 44a4f67738SDoug Rabson #include <sys/vnode.h> 45a4f67738SDoug Rabson #include <sys/linker.h> 46fb919e4dSMark Murray 47a4f67738SDoug Rabson #include <machine/elf.h> 48a4f67738SDoug Rabson 49aed55708SRobert Watson #include <security/mac/mac_framework.h> 50aed55708SRobert Watson 51fe3db7c7SDoug Rabson #include <vm/vm.h> 52fe3db7c7SDoug Rabson #include <vm/vm_param.h> 53fe3db7c7SDoug Rabson #include <vm/vm_object.h> 54fe3db7c7SDoug Rabson #include <vm/vm_kern.h> 55fe3db7c7SDoug Rabson #include <vm/vm_extern.h> 56fe3db7c7SDoug Rabson #include <vm/pmap.h> 57fe3db7c7SDoug Rabson #include <vm/vm_map.h> 58fb919e4dSMark Murray 59f9980387SPeter Wemm #include <sys/link_elf.h> 60fe3db7c7SDoug Rabson 61326e27d8SDoug Rabson #include "linker_if.h" 62a4f67738SDoug Rabson 63e9eabf59SPeter Wemm typedef struct { 64e9eabf59SPeter Wemm void *addr; 6520947801SPeter Wemm Elf_Off size; 66e9eabf59SPeter Wemm int flags; 67e9eabf59SPeter Wemm int sec; /* Original section */ 68e9eabf59SPeter Wemm char *name; 69e9eabf59SPeter Wemm } Elf_progent; 70e9eabf59SPeter Wemm 71e9eabf59SPeter Wemm typedef struct { 72e9eabf59SPeter Wemm Elf_Rel *rel; 7320947801SPeter Wemm int nrel; 74e9eabf59SPeter Wemm int sec; 75e9eabf59SPeter Wemm } Elf_relent; 76e9eabf59SPeter Wemm 77e9eabf59SPeter Wemm typedef struct { 78e9eabf59SPeter Wemm Elf_Rela *rela; 7920947801SPeter Wemm int nrela; 80e9eabf59SPeter Wemm int sec; 81e9eabf59SPeter Wemm } Elf_relaent; 82e9eabf59SPeter Wemm 83e9eabf59SPeter Wemm 84a4f67738SDoug Rabson typedef struct elf_file { 85326e27d8SDoug Rabson struct linker_file lf; /* Common fields */ 8620947801SPeter Wemm 8770b7ffeeSIan Dowse int preloaded; 88fe3db7c7SDoug Rabson caddr_t address; /* Relocation address */ 89fe3db7c7SDoug Rabson vm_object_t object; /* VM object to hold file pages */ 90e9eabf59SPeter Wemm Elf_Shdr *e_shdr; 91e9eabf59SPeter Wemm 92e9eabf59SPeter Wemm Elf_progent *progtab; 93e9eabf59SPeter Wemm int nprogtab; 94e9eabf59SPeter Wemm 95e9eabf59SPeter Wemm Elf_relaent *relatab; 96e9eabf59SPeter Wemm int nrela; 97e9eabf59SPeter Wemm 98e9eabf59SPeter Wemm Elf_relent *reltab; 99e9eabf59SPeter Wemm int nrel; 100e9eabf59SPeter Wemm 101e9eabf59SPeter Wemm Elf_Sym *ddbsymtab; /* The symbol table we are using */ 1022d636ab0SPeter Wemm long ddbsymcnt; /* Number of symbols */ 1032d636ab0SPeter Wemm caddr_t ddbstrtab; /* String table */ 1042d636ab0SPeter Wemm long ddbstrcnt; /* number of bytes in string table */ 105e9eabf59SPeter Wemm 106e9eabf59SPeter Wemm caddr_t shstrtab; /* Section name string table */ 107e9eabf59SPeter Wemm long shstrcnt; /* number of bytes in string table */ 108e9eabf59SPeter Wemm 109a4f67738SDoug Rabson } *elf_file_t; 110a4f67738SDoug Rabson 11154823af2SPeter Wemm static int link_elf_link_preload(linker_class_t cls, 112326e27d8SDoug Rabson const char *, linker_file_t *); 11354823af2SPeter Wemm static int link_elf_link_preload_finish(linker_file_t); 11454823af2SPeter Wemm static int link_elf_load_file(linker_class_t, const char *, linker_file_t *); 115326e27d8SDoug Rabson static int link_elf_lookup_symbol(linker_file_t, const char *, 116326e27d8SDoug Rabson c_linker_sym_t *); 117e9eabf59SPeter Wemm static int link_elf_symbol_values(linker_file_t, c_linker_sym_t, 118e9eabf59SPeter Wemm linker_symval_t *); 119326e27d8SDoug Rabson static int link_elf_search_symbol(linker_file_t, caddr_t value, 120326e27d8SDoug Rabson c_linker_sym_t *sym, long *diffp); 121326e27d8SDoug Rabson 122326e27d8SDoug Rabson static void link_elf_unload_file(linker_file_t); 123f41325dbSPeter Wemm static int link_elf_lookup_set(linker_file_t, const char *, 124f41325dbSPeter Wemm void ***, void ***, int *); 125bb9fe9ddSBrian Feldman static int link_elf_each_function_name(linker_file_t, 126e9eabf59SPeter Wemm int (*)(const char *, void *), void *); 1277251b4bfSJake Burkholder static void link_elf_reloc_local(linker_file_t); 128326e27d8SDoug Rabson 129757686b1SMarcel Moolenaar static Elf_Addr elf_obj_lookup(linker_file_t lf, Elf_Size symidx, int deps); 130e9eabf59SPeter Wemm 131326e27d8SDoug Rabson static kobj_method_t link_elf_methods[] = { 132326e27d8SDoug Rabson KOBJMETHOD(linker_lookup_symbol, link_elf_lookup_symbol), 133326e27d8SDoug Rabson KOBJMETHOD(linker_symbol_values, link_elf_symbol_values), 134326e27d8SDoug Rabson KOBJMETHOD(linker_search_symbol, link_elf_search_symbol), 135326e27d8SDoug Rabson KOBJMETHOD(linker_unload, link_elf_unload_file), 13654823af2SPeter Wemm KOBJMETHOD(linker_load_file, link_elf_load_file), 13754823af2SPeter Wemm KOBJMETHOD(linker_link_preload, link_elf_link_preload), 13854823af2SPeter Wemm KOBJMETHOD(linker_link_preload_finish, link_elf_link_preload_finish), 139f41325dbSPeter Wemm KOBJMETHOD(linker_lookup_set, link_elf_lookup_set), 140bb9fe9ddSBrian Feldman KOBJMETHOD(linker_each_function_name, link_elf_each_function_name), 141326e27d8SDoug Rabson { 0, 0 } 142326e27d8SDoug Rabson }; 143326e27d8SDoug Rabson 144326e27d8SDoug Rabson static struct linker_class link_elf_class = { 145326e27d8SDoug Rabson #if ELF_TARG_CLASS == ELFCLASS32 146e9eabf59SPeter Wemm "elf32_obj", 147326e27d8SDoug Rabson #else 148e9eabf59SPeter Wemm "elf64_obj", 149326e27d8SDoug Rabson #endif 150326e27d8SDoug Rabson link_elf_methods, sizeof(struct elf_file) 151326e27d8SDoug Rabson }; 152326e27d8SDoug Rabson 153326e27d8SDoug Rabson static int relocate_file(elf_file_t ef); 154a4f67738SDoug Rabson 155a4f67738SDoug Rabson static void 1561720979bSMarcel Moolenaar link_elf_error(const char *s) 1571720979bSMarcel Moolenaar { 1581720979bSMarcel Moolenaar printf("kldload: %s\n", s); 1591720979bSMarcel Moolenaar } 1601720979bSMarcel Moolenaar 1611720979bSMarcel Moolenaar static void 162a4f67738SDoug Rabson link_elf_init(void *arg) 163a4f67738SDoug Rabson { 164a4f67738SDoug Rabson 165326e27d8SDoug Rabson linker_add_class(&link_elf_class); 166a4f67738SDoug Rabson } 167a4f67738SDoug Rabson 168e9eabf59SPeter Wemm SYSINIT(link_elf_obj, SI_SUB_KLD, SI_ORDER_SECOND, link_elf_init, 0); 169a4f67738SDoug Rabson 170a4f67738SDoug Rabson static int 171e9eabf59SPeter Wemm link_elf_link_preload(linker_class_t cls, const char *filename, 172e9eabf59SPeter Wemm linker_file_t *result) 1732d636ab0SPeter Wemm { 17470b7ffeeSIan Dowse Elf_Ehdr *hdr; 17570b7ffeeSIan Dowse Elf_Shdr *shdr; 17670b7ffeeSIan Dowse Elf_Sym *es; 17770b7ffeeSIan Dowse void *modptr, *baseptr, *sizeptr; 17870b7ffeeSIan Dowse char *type; 17970b7ffeeSIan Dowse elf_file_t ef; 18070b7ffeeSIan Dowse linker_file_t lf; 18170b7ffeeSIan Dowse Elf_Addr off; 18270b7ffeeSIan Dowse int error, i, j, pb, ra, rl, shstrindex, symstrindex, symtabindex; 18370b7ffeeSIan Dowse 18470b7ffeeSIan Dowse /* Look to see if we have the file preloaded */ 18570b7ffeeSIan Dowse modptr = preload_search_by_name(filename); 18670b7ffeeSIan Dowse if (modptr == NULL) 18770b7ffeeSIan Dowse return ENOENT; 18870b7ffeeSIan Dowse 18970b7ffeeSIan Dowse type = (char *)preload_search_info(modptr, MODINFO_TYPE); 19070b7ffeeSIan Dowse baseptr = preload_search_info(modptr, MODINFO_ADDR); 19170b7ffeeSIan Dowse sizeptr = preload_search_info(modptr, MODINFO_SIZE); 19270b7ffeeSIan Dowse hdr = (Elf_Ehdr *)preload_search_info(modptr, MODINFO_METADATA | 19370b7ffeeSIan Dowse MODINFOMD_ELFHDR); 19470b7ffeeSIan Dowse shdr = (Elf_Shdr *)preload_search_info(modptr, MODINFO_METADATA | 19570b7ffeeSIan Dowse MODINFOMD_SHDR); 19670b7ffeeSIan Dowse if (type == NULL || (strcmp(type, "elf" __XSTRING(__ELF_WORD_SIZE) 19770b7ffeeSIan Dowse " obj module") != 0 && 19870b7ffeeSIan Dowse strcmp(type, "elf obj module") != 0)) { 199de78ca7eSPeter Wemm return (EFTYPE); 200de78ca7eSPeter Wemm } 20170b7ffeeSIan Dowse if (baseptr == NULL || sizeptr == NULL || hdr == NULL || 20270b7ffeeSIan Dowse shdr == NULL) 20370b7ffeeSIan Dowse return (EINVAL); 20470b7ffeeSIan Dowse 20570b7ffeeSIan Dowse lf = linker_make_file(filename, &link_elf_class); 20670b7ffeeSIan Dowse if (lf == NULL) 20770b7ffeeSIan Dowse return (ENOMEM); 20870b7ffeeSIan Dowse 20970b7ffeeSIan Dowse ef = (elf_file_t)lf; 21070b7ffeeSIan Dowse ef->preloaded = 1; 21170b7ffeeSIan Dowse ef->address = *(caddr_t *)baseptr; 21270b7ffeeSIan Dowse lf->address = *(caddr_t *)baseptr; 21370b7ffeeSIan Dowse lf->size = *(size_t *)sizeptr; 21470b7ffeeSIan Dowse 21570b7ffeeSIan Dowse if (hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS || 21670b7ffeeSIan Dowse hdr->e_ident[EI_DATA] != ELF_TARG_DATA || 21770b7ffeeSIan Dowse hdr->e_ident[EI_VERSION] != EV_CURRENT || 21870b7ffeeSIan Dowse hdr->e_version != EV_CURRENT || 21970b7ffeeSIan Dowse hdr->e_type != ET_REL || 22070b7ffeeSIan Dowse hdr->e_machine != ELF_TARG_MACH) { 22170b7ffeeSIan Dowse error = EFTYPE; 22270b7ffeeSIan Dowse goto out; 22370b7ffeeSIan Dowse } 22470b7ffeeSIan Dowse ef->e_shdr = shdr; 22570b7ffeeSIan Dowse 22670b7ffeeSIan Dowse /* Scan the section header for information and table sizing. */ 22770b7ffeeSIan Dowse symtabindex = -1; 22870b7ffeeSIan Dowse symstrindex = -1; 22970b7ffeeSIan Dowse for (i = 0; i < hdr->e_shnum; i++) { 23070b7ffeeSIan Dowse switch (shdr[i].sh_type) { 23170b7ffeeSIan Dowse case SHT_PROGBITS: 23270b7ffeeSIan Dowse case SHT_NOBITS: 23370b7ffeeSIan Dowse ef->nprogtab++; 23470b7ffeeSIan Dowse break; 23570b7ffeeSIan Dowse case SHT_SYMTAB: 23670b7ffeeSIan Dowse symtabindex = i; 23770b7ffeeSIan Dowse symstrindex = shdr[i].sh_link; 23870b7ffeeSIan Dowse break; 23970b7ffeeSIan Dowse case SHT_REL: 24070b7ffeeSIan Dowse ef->nrel++; 24170b7ffeeSIan Dowse break; 24270b7ffeeSIan Dowse case SHT_RELA: 24370b7ffeeSIan Dowse ef->nrela++; 24470b7ffeeSIan Dowse break; 24570b7ffeeSIan Dowse } 24670b7ffeeSIan Dowse } 24770b7ffeeSIan Dowse 24870b7ffeeSIan Dowse shstrindex = hdr->e_shstrndx; 24970b7ffeeSIan Dowse if (ef->nprogtab == 0 || symstrindex < 0 || 25070b7ffeeSIan Dowse symstrindex >= hdr->e_shnum || 25170b7ffeeSIan Dowse shdr[symstrindex].sh_type != SHT_STRTAB || shstrindex == 0 || 25270b7ffeeSIan Dowse shstrindex >= hdr->e_shnum || 25370b7ffeeSIan Dowse shdr[shstrindex].sh_type != SHT_STRTAB) { 25470b7ffeeSIan Dowse printf("%s: bad/missing section headers\n", filename); 25570b7ffeeSIan Dowse error = ENOEXEC; 25670b7ffeeSIan Dowse goto out; 25770b7ffeeSIan Dowse } 25870b7ffeeSIan Dowse 25970b7ffeeSIan Dowse /* Allocate space for tracking the load chunks */ 26070b7ffeeSIan Dowse if (ef->nprogtab != 0) 26170b7ffeeSIan Dowse ef->progtab = malloc(ef->nprogtab * sizeof(*ef->progtab), 26270b7ffeeSIan Dowse M_LINKER, M_WAITOK | M_ZERO); 26370b7ffeeSIan Dowse if (ef->nrel != 0) 26470b7ffeeSIan Dowse ef->reltab = malloc(ef->nrel * sizeof(*ef->reltab), M_LINKER, 26570b7ffeeSIan Dowse M_WAITOK | M_ZERO); 26670b7ffeeSIan Dowse if (ef->nrela != 0) 26770b7ffeeSIan Dowse ef->relatab = malloc(ef->nrela * sizeof(*ef->relatab), M_LINKER, 26870b7ffeeSIan Dowse M_WAITOK | M_ZERO); 26970b7ffeeSIan Dowse if ((ef->nprogtab != 0 && ef->progtab == NULL) || 27070b7ffeeSIan Dowse (ef->nrel != 0 && ef->reltab == NULL) || 27170b7ffeeSIan Dowse (ef->nrela != 0 && ef->relatab == NULL)) { 27270b7ffeeSIan Dowse error = ENOMEM; 27370b7ffeeSIan Dowse goto out; 27470b7ffeeSIan Dowse } 27570b7ffeeSIan Dowse 27670b7ffeeSIan Dowse /* XXX, relocate the sh_addr fields saved by the loader. */ 27770b7ffeeSIan Dowse off = 0; 27870b7ffeeSIan Dowse for (i = 0; i < hdr->e_shnum; i++) { 27970b7ffeeSIan Dowse if (shdr[i].sh_addr != 0 && (off == 0 || shdr[i].sh_addr < off)) 28070b7ffeeSIan Dowse off = shdr[i].sh_addr; 28170b7ffeeSIan Dowse } 28270b7ffeeSIan Dowse for (i = 0; i < hdr->e_shnum; i++) { 28370b7ffeeSIan Dowse if (shdr[i].sh_addr != 0) 28470b7ffeeSIan Dowse shdr[i].sh_addr = shdr[i].sh_addr - off + 28570b7ffeeSIan Dowse (Elf_Addr)ef->address; 28670b7ffeeSIan Dowse } 28770b7ffeeSIan Dowse 28870b7ffeeSIan Dowse ef->ddbsymcnt = shdr[symtabindex].sh_size / sizeof(Elf_Sym); 28970b7ffeeSIan Dowse ef->ddbsymtab = (Elf_Sym *)shdr[symtabindex].sh_addr; 29070b7ffeeSIan Dowse ef->ddbstrcnt = shdr[symstrindex].sh_size; 29170b7ffeeSIan Dowse ef->ddbstrtab = (char *)shdr[symstrindex].sh_addr; 29270b7ffeeSIan Dowse ef->shstrcnt = shdr[shstrindex].sh_size; 29370b7ffeeSIan Dowse ef->shstrtab = (char *)shdr[shstrindex].sh_addr; 29470b7ffeeSIan Dowse 29570b7ffeeSIan Dowse /* Now fill out progtab and the relocation tables. */ 29670b7ffeeSIan Dowse pb = 0; 29770b7ffeeSIan Dowse rl = 0; 29870b7ffeeSIan Dowse ra = 0; 29970b7ffeeSIan Dowse for (i = 0; i < hdr->e_shnum; i++) { 30070b7ffeeSIan Dowse switch (shdr[i].sh_type) { 30170b7ffeeSIan Dowse case SHT_PROGBITS: 30270b7ffeeSIan Dowse case SHT_NOBITS: 30370b7ffeeSIan Dowse ef->progtab[pb].addr = (void *)shdr[i].sh_addr; 30470b7ffeeSIan Dowse if (shdr[i].sh_type == SHT_PROGBITS) 30570b7ffeeSIan Dowse ef->progtab[pb].name = "<<PROGBITS>>"; 30670b7ffeeSIan Dowse else 30770b7ffeeSIan Dowse ef->progtab[pb].name = "<<NOBITS>>"; 30870b7ffeeSIan Dowse ef->progtab[pb].size = shdr[i].sh_size; 30970b7ffeeSIan Dowse ef->progtab[pb].sec = i; 31070b7ffeeSIan Dowse if (ef->shstrtab && shdr[i].sh_name != 0) 31170b7ffeeSIan Dowse ef->progtab[pb].name = 31270b7ffeeSIan Dowse ef->shstrtab + shdr[i].sh_name; 31370b7ffeeSIan Dowse 31470b7ffeeSIan Dowse /* Update all symbol values with the offset. */ 31570b7ffeeSIan Dowse for (j = 0; j < ef->ddbsymcnt; j++) { 31670b7ffeeSIan Dowse es = &ef->ddbsymtab[j]; 31770b7ffeeSIan Dowse if (es->st_shndx != i) 31870b7ffeeSIan Dowse continue; 31970b7ffeeSIan Dowse es->st_value += (Elf_Addr)ef->progtab[pb].addr; 32070b7ffeeSIan Dowse } 32170b7ffeeSIan Dowse pb++; 32270b7ffeeSIan Dowse break; 32370b7ffeeSIan Dowse case SHT_REL: 32470b7ffeeSIan Dowse ef->reltab[rl].rel = (Elf_Rel *)shdr[i].sh_addr; 32570b7ffeeSIan Dowse ef->reltab[rl].nrel = shdr[i].sh_size / sizeof(Elf_Rel); 32670b7ffeeSIan Dowse ef->reltab[rl].sec = shdr[i].sh_info; 32770b7ffeeSIan Dowse rl++; 32870b7ffeeSIan Dowse break; 32970b7ffeeSIan Dowse case SHT_RELA: 33070b7ffeeSIan Dowse ef->relatab[ra].rela = (Elf_Rela *)shdr[i].sh_addr; 33170b7ffeeSIan Dowse ef->relatab[ra].nrela = 33270b7ffeeSIan Dowse shdr[i].sh_size / sizeof(Elf_Rela); 33370b7ffeeSIan Dowse ef->relatab[ra].sec = shdr[i].sh_info; 33470b7ffeeSIan Dowse ra++; 33570b7ffeeSIan Dowse break; 33670b7ffeeSIan Dowse } 33770b7ffeeSIan Dowse } 33870b7ffeeSIan Dowse if (pb != ef->nprogtab) 33970b7ffeeSIan Dowse panic("lost progbits"); 34070b7ffeeSIan Dowse if (rl != ef->nrel) 34170b7ffeeSIan Dowse panic("lost rel"); 34270b7ffeeSIan Dowse if (ra != ef->nrela) 34370b7ffeeSIan Dowse panic("lost rela"); 34470b7ffeeSIan Dowse 34570b7ffeeSIan Dowse /* Local intra-module relocations */ 34670b7ffeeSIan Dowse link_elf_reloc_local(lf); 34770b7ffeeSIan Dowse 34870b7ffeeSIan Dowse *result = lf; 34970b7ffeeSIan Dowse return (0); 35070b7ffeeSIan Dowse 35170b7ffeeSIan Dowse out: 35270b7ffeeSIan Dowse /* preload not done this way */ 35370b7ffeeSIan Dowse linker_file_unload(lf, LINKER_UNLOAD_FORCE); 35470b7ffeeSIan Dowse return (error); 35570b7ffeeSIan Dowse } 356de78ca7eSPeter Wemm 357de78ca7eSPeter Wemm static int 35854823af2SPeter Wemm link_elf_link_preload_finish(linker_file_t lf) 35954823af2SPeter Wemm { 36070b7ffeeSIan Dowse elf_file_t ef; 36170b7ffeeSIan Dowse int error; 36270b7ffeeSIan Dowse 36370b7ffeeSIan Dowse ef = (elf_file_t)lf; 36470b7ffeeSIan Dowse error = relocate_file(ef); 36570b7ffeeSIan Dowse if (error) 36670b7ffeeSIan Dowse return error; 36770b7ffeeSIan Dowse 36870b7ffeeSIan Dowse /* Notify MD code that a module is being loaded. */ 36970b7ffeeSIan Dowse error = elf_cpu_load_file(lf); 37070b7ffeeSIan Dowse if (error) 37170b7ffeeSIan Dowse return (error); 37270b7ffeeSIan Dowse 37370b7ffeeSIan Dowse return (0); 37454823af2SPeter Wemm } 37554823af2SPeter Wemm 37654823af2SPeter Wemm static int 377c143d6c2SMarcel Moolenaar link_elf_load_file(linker_class_t cls, const char *filename, 378c143d6c2SMarcel Moolenaar linker_file_t *result) 379a4f67738SDoug Rabson { 380a4f67738SDoug Rabson struct nameidata nd; 381b40ce416SJulian Elischer struct thread *td = curthread; /* XXX */ 382caab6e90SPeter Wemm Elf_Ehdr *hdr; 383e9eabf59SPeter Wemm Elf_Shdr *shdr; 384a8774e39SPeter Wemm Elf_Sym *es; 385a8774e39SPeter Wemm int nbytes, i, j; 38620947801SPeter Wemm vm_offset_t mapbase; 387fe3db7c7SDoug Rabson size_t mapsize; 388a4f67738SDoug Rabson int error = 0; 389e6796b67SKirk McKusick int resid, flags; 390a4f67738SDoug Rabson elf_file_t ef; 391a4f67738SDoug Rabson linker_file_t lf; 392ca65d5c7SPeter Wemm int symtabindex; 393ca65d5c7SPeter Wemm int symstrindex; 394e9eabf59SPeter Wemm int shstrindex; 395e9eabf59SPeter Wemm int nsym; 39620947801SPeter Wemm int pb, rl, ra; 397e9eabf59SPeter Wemm int alignmask; 39862d615d5SJohn Baldwin int vfslocked; 399ca65d5c7SPeter Wemm 400ca65d5c7SPeter Wemm shdr = NULL; 401ca65d5c7SPeter Wemm lf = NULL; 402e9eabf59SPeter Wemm mapsize = 0; 403e9eabf59SPeter Wemm hdr = NULL; 404a4f67738SDoug Rabson 40562d615d5SJohn Baldwin NDINIT(&nd, LOOKUP, FOLLOW | MPSAFE, UIO_SYSSPACE, filename, td); 406e6796b67SKirk McKusick flags = FREAD; 4079e223287SKonstantin Belousov error = vn_open(&nd, &flags, 0, NULL); 408a4f67738SDoug Rabson if (error) 409a4f67738SDoug Rabson return error; 41062d615d5SJohn Baldwin vfslocked = NDHASGIANT(&nd); 411762e6b85SEivind Eklund NDFREE(&nd, NDF_ONLY_PNBUF); 4121f49b573SRuslan Ermilov if (nd.ni_vp->v_type != VREG) { 4131f49b573SRuslan Ermilov error = ENOEXEC; 4141f49b573SRuslan Ermilov goto out; 4151f49b573SRuslan Ermilov } 416a3df768bSRobert Watson #ifdef MAC 41730d239bcSRobert Watson error = mac_kld_check_load(td->td_ucred, nd.ni_vp); 418a3df768bSRobert Watson if (error) { 419a3df768bSRobert Watson goto out; 420a3df768bSRobert Watson } 421a3df768bSRobert Watson #endif 422a4f67738SDoug Rabson 423e9eabf59SPeter Wemm /* Read the elf header from the file. */ 424e9eabf59SPeter Wemm hdr = malloc(sizeof(*hdr), M_LINKER, M_WAITOK); 425e9eabf59SPeter Wemm if (hdr == NULL) { 426caab6e90SPeter Wemm error = ENOMEM; 427caab6e90SPeter Wemm goto out; 428caab6e90SPeter Wemm } 429e9eabf59SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, (void *)hdr, sizeof(*hdr), 0, 4309ca43589SRobert Watson UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 4319ca43589SRobert Watson &resid, td); 432a4f67738SDoug Rabson if (error) 433a4f67738SDoug Rabson goto out; 434e9eabf59SPeter Wemm if (resid != 0){ 435e9eabf59SPeter Wemm error = ENOEXEC; 436e9eabf59SPeter Wemm goto out; 437e9eabf59SPeter Wemm } 438a4f67738SDoug Rabson 439caab6e90SPeter Wemm if (!IS_ELF(*hdr)) { 440fe3db7c7SDoug Rabson error = ENOEXEC; 441a4f67738SDoug Rabson goto out; 442fe3db7c7SDoug Rabson } 443fe3db7c7SDoug Rabson 444caab6e90SPeter Wemm if (hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS 445caab6e90SPeter Wemm || hdr->e_ident[EI_DATA] != ELF_TARG_DATA) { 446fe3db7c7SDoug Rabson link_elf_error("Unsupported file layout"); 447fe3db7c7SDoug Rabson error = ENOEXEC; 448fe3db7c7SDoug Rabson goto out; 449fe3db7c7SDoug Rabson } 450caab6e90SPeter Wemm if (hdr->e_ident[EI_VERSION] != EV_CURRENT 451caab6e90SPeter Wemm || hdr->e_version != EV_CURRENT) { 452fe3db7c7SDoug Rabson link_elf_error("Unsupported file version"); 453fe3db7c7SDoug Rabson error = ENOEXEC; 454fe3db7c7SDoug Rabson goto out; 455fe3db7c7SDoug Rabson } 456e9eabf59SPeter Wemm if (hdr->e_type != ET_REL) { 457fe3db7c7SDoug Rabson link_elf_error("Unsupported file type"); 458fe3db7c7SDoug Rabson error = ENOEXEC; 459fe3db7c7SDoug Rabson goto out; 460fe3db7c7SDoug Rabson } 461caab6e90SPeter Wemm if (hdr->e_machine != ELF_TARG_MACH) { 462fe3db7c7SDoug Rabson link_elf_error("Unsupported machine"); 463fe3db7c7SDoug Rabson error = ENOEXEC; 464fe3db7c7SDoug Rabson goto out; 465fe3db7c7SDoug Rabson } 466a4f67738SDoug Rabson 467326e27d8SDoug Rabson lf = linker_make_file(filename, &link_elf_class); 468326e27d8SDoug Rabson if (!lf) { 469326e27d8SDoug Rabson error = ENOMEM; 470326e27d8SDoug Rabson goto out; 471326e27d8SDoug Rabson } 472326e27d8SDoug Rabson ef = (elf_file_t) lf; 473e9eabf59SPeter Wemm ef->nprogtab = 0; 474e9eabf59SPeter Wemm ef->e_shdr = 0; 475e9eabf59SPeter Wemm ef->nrel = 0; 476e9eabf59SPeter Wemm ef->nrela = 0; 477e9eabf59SPeter Wemm 478e9eabf59SPeter Wemm /* Allocate and read in the section header */ 479e9eabf59SPeter Wemm nbytes = hdr->e_shnum * hdr->e_shentsize; 480e9eabf59SPeter Wemm if (nbytes == 0 || hdr->e_shoff == 0 || 481e9eabf59SPeter Wemm hdr->e_shentsize != sizeof(Elf_Shdr)) { 482e9eabf59SPeter Wemm error = ENOEXEC; 483e9eabf59SPeter Wemm goto out; 484e9eabf59SPeter Wemm } 48520947801SPeter Wemm shdr = malloc(nbytes, M_LINKER, M_WAITOK); 486e9eabf59SPeter Wemm if (shdr == NULL) { 487e9eabf59SPeter Wemm error = ENOMEM; 488e9eabf59SPeter Wemm goto out; 489e9eabf59SPeter Wemm } 490e9eabf59SPeter Wemm ef->e_shdr = shdr; 491e9eabf59SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, (caddr_t)shdr, nbytes, hdr->e_shoff, 492e9eabf59SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, &resid, td); 493e9eabf59SPeter Wemm if (error) 494e9eabf59SPeter Wemm goto out; 495e9eabf59SPeter Wemm if (resid) { 496e9eabf59SPeter Wemm error = ENOEXEC; 497e9eabf59SPeter Wemm goto out; 498e9eabf59SPeter Wemm } 499e9eabf59SPeter Wemm 500e9eabf59SPeter Wemm /* Scan the section header for information and table sizing. */ 501e9eabf59SPeter Wemm nsym = 0; 502e9eabf59SPeter Wemm symtabindex = -1; 503e9eabf59SPeter Wemm symstrindex = -1; 504e9eabf59SPeter Wemm for (i = 0; i < hdr->e_shnum; i++) { 505e9eabf59SPeter Wemm switch (shdr[i].sh_type) { 506e9eabf59SPeter Wemm case SHT_PROGBITS: 507e9eabf59SPeter Wemm case SHT_NOBITS: 50820947801SPeter Wemm ef->nprogtab++; 509e9eabf59SPeter Wemm break; 510e9eabf59SPeter Wemm case SHT_SYMTAB: 511e9eabf59SPeter Wemm nsym++; 512e9eabf59SPeter Wemm symtabindex = i; 513e9eabf59SPeter Wemm symstrindex = shdr[i].sh_link; 514e9eabf59SPeter Wemm break; 515e9eabf59SPeter Wemm case SHT_REL: 516e9eabf59SPeter Wemm ef->nrel++; 517e9eabf59SPeter Wemm break; 518e9eabf59SPeter Wemm case SHT_RELA: 519e9eabf59SPeter Wemm ef->nrela++; 520e9eabf59SPeter Wemm break; 521e9eabf59SPeter Wemm case SHT_STRTAB: 522e9eabf59SPeter Wemm break; 523e9eabf59SPeter Wemm } 524e9eabf59SPeter Wemm } 52520947801SPeter Wemm if (ef->nprogtab == 0) { 526e9eabf59SPeter Wemm link_elf_error("file has no contents"); 527e9eabf59SPeter Wemm error = ENOEXEC; 528e9eabf59SPeter Wemm goto out; 529e9eabf59SPeter Wemm } 530e9eabf59SPeter Wemm if (nsym != 1) { 531e9eabf59SPeter Wemm /* Only allow one symbol table for now */ 532e9eabf59SPeter Wemm link_elf_error("file has no valid symbol table"); 533e9eabf59SPeter Wemm error = ENOEXEC; 534e9eabf59SPeter Wemm goto out; 535e9eabf59SPeter Wemm } 536e9eabf59SPeter Wemm if (symstrindex < 0 || symstrindex > hdr->e_shnum || 537e9eabf59SPeter Wemm shdr[symstrindex].sh_type != SHT_STRTAB) { 538e9eabf59SPeter Wemm link_elf_error("file has invalid symbol strings"); 539e9eabf59SPeter Wemm error = ENOEXEC; 540e9eabf59SPeter Wemm goto out; 541e9eabf59SPeter Wemm } 542e9eabf59SPeter Wemm 543e9eabf59SPeter Wemm /* Allocate space for tracking the load chunks */ 544e9eabf59SPeter Wemm if (ef->nprogtab != 0) 54520947801SPeter Wemm ef->progtab = malloc(ef->nprogtab * sizeof(*ef->progtab), 54620947801SPeter Wemm M_LINKER, M_WAITOK | M_ZERO); 547e9eabf59SPeter Wemm if (ef->nrel != 0) 54820947801SPeter Wemm ef->reltab = malloc(ef->nrel * sizeof(*ef->reltab), M_LINKER, 54920947801SPeter Wemm M_WAITOK | M_ZERO); 550e9eabf59SPeter Wemm if (ef->nrela != 0) 55120947801SPeter Wemm ef->relatab = malloc(ef->nrela * sizeof(*ef->relatab), M_LINKER, 55220947801SPeter Wemm M_WAITOK | M_ZERO); 55320947801SPeter Wemm if ((ef->nprogtab != 0 && ef->progtab == NULL) || 55420947801SPeter Wemm (ef->nrel != 0 && ef->reltab == NULL) || 55520947801SPeter Wemm (ef->nrela != 0 && ef->relatab == NULL)) { 55620947801SPeter Wemm error = ENOMEM; 55720947801SPeter Wemm goto out; 55820947801SPeter Wemm } 559e9eabf59SPeter Wemm 56020947801SPeter Wemm if (symtabindex == -1) 56120947801SPeter Wemm panic("lost symbol table index"); 56220947801SPeter Wemm /* Allocate space for and load the symbol table */ 563e9eabf59SPeter Wemm ef->ddbsymcnt = shdr[symtabindex].sh_size / sizeof(Elf_Sym); 564e9eabf59SPeter Wemm ef->ddbsymtab = malloc(shdr[symtabindex].sh_size, M_LINKER, M_WAITOK); 56520947801SPeter Wemm if (ef->ddbsymtab == NULL) { 56620947801SPeter Wemm error = ENOMEM; 56720947801SPeter Wemm goto out; 56820947801SPeter Wemm } 56920947801SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, (void *)ef->ddbsymtab, 57020947801SPeter Wemm shdr[symtabindex].sh_size, shdr[symtabindex].sh_offset, 57120947801SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 57220947801SPeter Wemm &resid, td); 57320947801SPeter Wemm if (error) 57420947801SPeter Wemm goto out; 57520947801SPeter Wemm if (resid != 0){ 57620947801SPeter Wemm error = EINVAL; 57720947801SPeter Wemm goto out; 57820947801SPeter Wemm } 579e9eabf59SPeter Wemm 58020947801SPeter Wemm if (symstrindex == -1) 58120947801SPeter Wemm panic("lost symbol string index"); 58220947801SPeter Wemm /* Allocate space for and load the symbol strings */ 583e9eabf59SPeter Wemm ef->ddbstrcnt = shdr[symstrindex].sh_size; 584e9eabf59SPeter Wemm ef->ddbstrtab = malloc(shdr[symstrindex].sh_size, M_LINKER, M_WAITOK); 58520947801SPeter Wemm if (ef->ddbstrtab == NULL) { 586e9eabf59SPeter Wemm error = ENOMEM; 587e9eabf59SPeter Wemm goto out; 588e9eabf59SPeter Wemm } 58920947801SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, ef->ddbstrtab, 59020947801SPeter Wemm shdr[symstrindex].sh_size, shdr[symstrindex].sh_offset, 59120947801SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 59220947801SPeter Wemm &resid, td); 59320947801SPeter Wemm if (error) 59420947801SPeter Wemm goto out; 59520947801SPeter Wemm if (resid != 0){ 59620947801SPeter Wemm error = EINVAL; 59720947801SPeter Wemm goto out; 59820947801SPeter Wemm } 599e9eabf59SPeter Wemm 600e9eabf59SPeter Wemm /* Do we have a string table for the section names? */ 601e9eabf59SPeter Wemm shstrindex = -1; 60220947801SPeter Wemm if (hdr->e_shstrndx != 0 && 60320947801SPeter Wemm shdr[hdr->e_shstrndx].sh_type == SHT_STRTAB) { 604e9eabf59SPeter Wemm shstrindex = hdr->e_shstrndx; 605e9eabf59SPeter Wemm ef->shstrcnt = shdr[shstrindex].sh_size; 60620947801SPeter Wemm ef->shstrtab = malloc(shdr[shstrindex].sh_size, M_LINKER, 60720947801SPeter Wemm M_WAITOK); 608e9eabf59SPeter Wemm if (ef->shstrtab == NULL) { 609e9eabf59SPeter Wemm error = ENOMEM; 610e9eabf59SPeter Wemm goto out; 611e9eabf59SPeter Wemm } 61220947801SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, ef->shstrtab, 61320947801SPeter Wemm shdr[shstrindex].sh_size, shdr[shstrindex].sh_offset, 614e9eabf59SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 615e9eabf59SPeter Wemm &resid, td); 616e9eabf59SPeter Wemm if (error) 617e9eabf59SPeter Wemm goto out; 61820947801SPeter Wemm if (resid != 0){ 61920947801SPeter Wemm error = EINVAL; 62020947801SPeter Wemm goto out; 62120947801SPeter Wemm } 622e9eabf59SPeter Wemm } 623e9eabf59SPeter Wemm 62420947801SPeter Wemm /* Size up code/data(progbits) and bss(nobits). */ 625e9eabf59SPeter Wemm alignmask = 0; 626e9eabf59SPeter Wemm for (i = 0; i < hdr->e_shnum; i++) { 627e9eabf59SPeter Wemm switch (shdr[i].sh_type) { 628e9eabf59SPeter Wemm case SHT_PROGBITS: 629e9eabf59SPeter Wemm case SHT_NOBITS: 630e9eabf59SPeter Wemm alignmask = shdr[i].sh_addralign - 1; 631e9eabf59SPeter Wemm mapsize += alignmask; 632e9eabf59SPeter Wemm mapsize &= ~alignmask; 633e9eabf59SPeter Wemm mapsize += shdr[i].sh_size; 634e9eabf59SPeter Wemm break; 635e9eabf59SPeter Wemm } 636e9eabf59SPeter Wemm } 637e9eabf59SPeter Wemm 638e9eabf59SPeter Wemm /* 639e9eabf59SPeter Wemm * We know how much space we need for the text/data/bss/etc. 640e9eabf59SPeter Wemm * This stuff needs to be in a single chunk so that profiling etc 641e9eabf59SPeter Wemm * can get the bounds and gdb can associate offsets with modules 642e9eabf59SPeter Wemm */ 64320947801SPeter Wemm ef->object = vm_object_allocate(OBJT_DEFAULT, 64420947801SPeter Wemm round_page(mapsize) >> PAGE_SHIFT); 645fe3db7c7SDoug Rabson if (ef->object == NULL) { 646fe3db7c7SDoug Rabson error = ENOMEM; 647fe3db7c7SDoug Rabson goto out; 648fe3db7c7SDoug Rabson } 649fe3db7c7SDoug Rabson ef->address = (caddr_t) vm_map_min(kernel_map); 65020947801SPeter Wemm error = vm_map_find(kernel_map, ef->object, 0, &mapbase, 65120947801SPeter Wemm round_page(mapsize), TRUE, VM_PROT_ALL, VM_PROT_ALL, FALSE); 652fe3db7c7SDoug Rabson if (error) { 653fe3db7c7SDoug Rabson vm_object_deallocate(ef->object); 654326e27d8SDoug Rabson ef->object = 0; 655fe3db7c7SDoug Rabson goto out; 656fe3db7c7SDoug Rabson } 65720947801SPeter Wemm 658e9eabf59SPeter Wemm /* Wire the pages */ 6597f1ef325SAlan Cox error = vm_map_wire(kernel_map, mapbase, 66020947801SPeter Wemm mapbase + round_page(mapsize), 661e9eabf59SPeter Wemm VM_MAP_WIRE_SYSTEM|VM_MAP_WIRE_NOHOLES); 6627f1ef325SAlan Cox if (error != KERN_SUCCESS) { 6637f1ef325SAlan Cox error = ENOMEM; 6647f1ef325SAlan Cox goto out; 6657f1ef325SAlan Cox } 666a4f67738SDoug Rabson 66720947801SPeter Wemm /* Inform the kld system about the situation */ 66820947801SPeter Wemm lf->address = ef->address = (caddr_t)mapbase; 66920947801SPeter Wemm lf->size = mapsize; 670e9eabf59SPeter Wemm 671e9eabf59SPeter Wemm /* 67220947801SPeter Wemm * Now load code/data(progbits), zero bss(nobits), allocate space for 67320947801SPeter Wemm * and load relocs 674e9eabf59SPeter Wemm */ 67520947801SPeter Wemm pb = 0; 67620947801SPeter Wemm rl = 0; 67720947801SPeter Wemm ra = 0; 67820947801SPeter Wemm alignmask = 0; 67920947801SPeter Wemm for (i = 0; i < hdr->e_shnum; i++) { 68020947801SPeter Wemm switch (shdr[i].sh_type) { 68120947801SPeter Wemm case SHT_PROGBITS: 68220947801SPeter Wemm case SHT_NOBITS: 68320947801SPeter Wemm alignmask = shdr[i].sh_addralign - 1; 68420947801SPeter Wemm mapbase += alignmask; 68520947801SPeter Wemm mapbase &= ~alignmask; 68620947801SPeter Wemm ef->progtab[pb].addr = (void *)(uintptr_t)mapbase; 68720947801SPeter Wemm if (shdr[i].sh_type == SHT_PROGBITS) { 68820947801SPeter Wemm ef->progtab[pb].name = "<<PROGBITS>>"; 689e9eabf59SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, 69020947801SPeter Wemm ef->progtab[pb].addr, 69120947801SPeter Wemm shdr[i].sh_size, shdr[i].sh_offset, 69220947801SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, 69320947801SPeter Wemm NOCRED, &resid, td); 69420947801SPeter Wemm if (error) 69520947801SPeter Wemm goto out; 69620947801SPeter Wemm if (resid != 0){ 69720947801SPeter Wemm error = EINVAL; 69820947801SPeter Wemm goto out; 69920947801SPeter Wemm } 70020947801SPeter Wemm } else { 70120947801SPeter Wemm ef->progtab[pb].name = "<<NOBITS>>"; 70220947801SPeter Wemm bzero(ef->progtab[pb].addr, shdr[i].sh_size); 70320947801SPeter Wemm } 70420947801SPeter Wemm ef->progtab[pb].size = shdr[i].sh_size; 70520947801SPeter Wemm ef->progtab[pb].sec = i; 70620947801SPeter Wemm if (ef->shstrtab && shdr[i].sh_name != 0) 70720947801SPeter Wemm ef->progtab[pb].name = 70820947801SPeter Wemm ef->shstrtab + shdr[i].sh_name; 709a8774e39SPeter Wemm 710a8774e39SPeter Wemm /* Update all symbol values with the offset. */ 711a8774e39SPeter Wemm for (j = 0; j < ef->ddbsymcnt; j++) { 712a8774e39SPeter Wemm es = &ef->ddbsymtab[j]; 713a8774e39SPeter Wemm if (es->st_shndx != i) 714a8774e39SPeter Wemm continue; 715a8774e39SPeter Wemm es->st_value += (Elf_Addr)ef->progtab[pb].addr; 716a8774e39SPeter Wemm } 71720947801SPeter Wemm mapbase += shdr[i].sh_size; 71820947801SPeter Wemm pb++; 71920947801SPeter Wemm break; 72020947801SPeter Wemm case SHT_REL: 72120947801SPeter Wemm ef->reltab[rl].rel = malloc(shdr[i].sh_size, M_LINKER, 72220947801SPeter Wemm M_WAITOK); 72320947801SPeter Wemm ef->reltab[rl].nrel = shdr[i].sh_size / sizeof(Elf_Rel); 72420947801SPeter Wemm ef->reltab[rl].sec = shdr[i].sh_info; 72520947801SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, 72620947801SPeter Wemm (void *)ef->reltab[rl].rel, 72720947801SPeter Wemm shdr[i].sh_size, shdr[i].sh_offset, 728e9eabf59SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 729e9eabf59SPeter Wemm &resid, td); 730e9eabf59SPeter Wemm if (error) 731e9eabf59SPeter Wemm goto out; 73220947801SPeter Wemm if (resid != 0){ 73320947801SPeter Wemm error = EINVAL; 73420947801SPeter Wemm goto out; 735e9eabf59SPeter Wemm } 73620947801SPeter Wemm rl++; 73720947801SPeter Wemm break; 73820947801SPeter Wemm case SHT_RELA: 73920947801SPeter Wemm ef->relatab[ra].rela = malloc(shdr[i].sh_size, M_LINKER, 74020947801SPeter Wemm M_WAITOK); 74120947801SPeter Wemm ef->relatab[ra].nrela = 74220947801SPeter Wemm shdr[i].sh_size / sizeof(Elf_Rela); 74320947801SPeter Wemm ef->relatab[ra].sec = shdr[i].sh_info; 744e9eabf59SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, 74520947801SPeter Wemm (void *)ef->relatab[ra].rela, 74620947801SPeter Wemm shdr[i].sh_size, shdr[i].sh_offset, 747e9eabf59SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 748e9eabf59SPeter Wemm &resid, td); 749e9eabf59SPeter Wemm if (error) 750e9eabf59SPeter Wemm goto out; 75120947801SPeter Wemm if (resid != 0){ 75220947801SPeter Wemm error = EINVAL; 75320947801SPeter Wemm goto out; 754e9eabf59SPeter Wemm } 75520947801SPeter Wemm ra++; 75620947801SPeter Wemm break; 75720947801SPeter Wemm } 75820947801SPeter Wemm } 75920947801SPeter Wemm if (pb != ef->nprogtab) 76020947801SPeter Wemm panic("lost progbits"); 76120947801SPeter Wemm if (rl != ef->nrel) 76220947801SPeter Wemm panic("lost rel"); 76320947801SPeter Wemm if (ra != ef->nrela) 76420947801SPeter Wemm panic("lost rela"); 76520947801SPeter Wemm if (mapbase != (vm_offset_t)ef->address + mapsize) 7665b201fdcSPeter Wemm panic("mapbase 0x%lx != address %p + mapsize 0x%lx (0x%lx)\n", 7675b201fdcSPeter Wemm mapbase, ef->address, mapsize, 7685b201fdcSPeter Wemm (vm_offset_t)ef->address + mapsize); 769e9eabf59SPeter Wemm 770e9eabf59SPeter Wemm /* Local intra-module relocations */ 7717251b4bfSJake Burkholder link_elf_reloc_local(lf); 7727251b4bfSJake Burkholder 773e9eabf59SPeter Wemm /* Pull in dependencies */ 7747b9716baSIan Dowse error = linker_load_dependencies(lf); 775ca65d5c7SPeter Wemm if (error) 776de78ca7eSPeter Wemm goto out; 777e9eabf59SPeter Wemm 778e9eabf59SPeter Wemm /* External relocations */ 779326e27d8SDoug Rabson error = relocate_file(ef); 780ca65d5c7SPeter Wemm if (error) 781ca65d5c7SPeter Wemm goto out; 782ca65d5c7SPeter Wemm 783e9eabf59SPeter Wemm /* Notify MD code that a module is being loaded. */ 784e9eabf59SPeter Wemm error = elf_cpu_load_file(lf); 785ca65d5c7SPeter Wemm if (error) 786ca65d5c7SPeter Wemm goto out; 787a4f67738SDoug Rabson 788a4f67738SDoug Rabson *result = lf; 789a4f67738SDoug Rabson 790a4f67738SDoug Rabson out: 791ca65d5c7SPeter Wemm if (error && lf) 79265a311fcSPoul-Henning Kamp linker_file_unload(lf, LINKER_UNLOAD_FORCE); 793e9eabf59SPeter Wemm if (hdr) 794e9eabf59SPeter Wemm free(hdr, M_LINKER); 79522db15c0SAttilio Rao VOP_UNLOCK(nd.ni_vp, 0); 796a854ed98SJohn Baldwin vn_close(nd.ni_vp, FREAD, td->td_ucred, td); 79762d615d5SJohn Baldwin VFS_UNLOCK_GIANT(vfslocked); 798a4f67738SDoug Rabson 799a4f67738SDoug Rabson return error; 800a4f67738SDoug Rabson } 801a4f67738SDoug Rabson 802a4f67738SDoug Rabson static void 803de78ca7eSPeter Wemm link_elf_unload_file(linker_file_t file) 804a4f67738SDoug Rabson { 805326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) file; 80620947801SPeter Wemm int i; 807a4f67738SDoug Rabson 8081aeb23cdSMarcel Moolenaar /* Notify MD code that a module is being unloaded. */ 8091aeb23cdSMarcel Moolenaar elf_cpu_unload_file(file); 8101aeb23cdSMarcel Moolenaar 81170b7ffeeSIan Dowse if (ef->preloaded) { 81270b7ffeeSIan Dowse if (ef->reltab) 81370b7ffeeSIan Dowse free(ef->reltab, M_LINKER); 81470b7ffeeSIan Dowse if (ef->relatab) 81570b7ffeeSIan Dowse free(ef->relatab, M_LINKER); 81670b7ffeeSIan Dowse if (ef->progtab) 81770b7ffeeSIan Dowse free(ef->progtab, M_LINKER); 81870b7ffeeSIan Dowse if (file->filename != NULL) 81970b7ffeeSIan Dowse preload_delete_name(file->filename); 82070b7ffeeSIan Dowse /* XXX reclaim module memory? */ 82170b7ffeeSIan Dowse return; 82270b7ffeeSIan Dowse } 82370b7ffeeSIan Dowse 82420947801SPeter Wemm for (i = 0; i < ef->nrel; i++) 82520947801SPeter Wemm if (ef->reltab[i].rel) 82620947801SPeter Wemm free(ef->reltab[i].rel, M_LINKER); 82720947801SPeter Wemm for (i = 0; i < ef->nrela; i++) 82820947801SPeter Wemm if (ef->relatab[i].rela) 82920947801SPeter Wemm free(ef->relatab[i].rela, M_LINKER); 83020947801SPeter Wemm if (ef->reltab) 83120947801SPeter Wemm free(ef->reltab, M_LINKER); 83220947801SPeter Wemm if (ef->relatab) 83320947801SPeter Wemm free(ef->relatab, M_LINKER); 83420947801SPeter Wemm if (ef->progtab) 83520947801SPeter Wemm free(ef->progtab, M_LINKER); 83620947801SPeter Wemm 837fe3db7c7SDoug Rabson if (ef->object) { 838fe3db7c7SDoug Rabson vm_map_remove(kernel_map, (vm_offset_t) ef->address, 83920947801SPeter Wemm (vm_offset_t) ef->address + 84020947801SPeter Wemm (ef->object->size << PAGE_SHIFT)); 841fe3db7c7SDoug Rabson } 842e9eabf59SPeter Wemm if (ef->e_shdr) 843e9eabf59SPeter Wemm free(ef->e_shdr, M_LINKER); 844e9eabf59SPeter Wemm if (ef->ddbsymtab) 845e9eabf59SPeter Wemm free(ef->ddbsymtab, M_LINKER); 846e9eabf59SPeter Wemm if (ef->ddbstrtab) 847e9eabf59SPeter Wemm free(ef->ddbstrtab, M_LINKER); 84820947801SPeter Wemm if (ef->shstrtab) 84920947801SPeter Wemm free(ef->shstrtab, M_LINKER); 850de78ca7eSPeter Wemm } 851de78ca7eSPeter Wemm 852fe3db7c7SDoug Rabson static const char * 853757686b1SMarcel Moolenaar symbol_name(elf_file_t ef, Elf_Size r_info) 854a4f67738SDoug Rabson { 855fe3db7c7SDoug Rabson const Elf_Sym *ref; 856a4f67738SDoug Rabson 857aa855a59SPeter Wemm if (ELF_R_SYM(r_info)) { 858e9eabf59SPeter Wemm ref = ef->ddbsymtab + ELF_R_SYM(r_info); 859e9eabf59SPeter Wemm return ef->ddbstrtab + ref->st_name; 860fe3db7c7SDoug Rabson } else 861fe3db7c7SDoug Rabson return NULL; 862a4f67738SDoug Rabson } 863a4f67738SDoug Rabson 864e9eabf59SPeter Wemm static Elf_Addr 865e9eabf59SPeter Wemm findbase(elf_file_t ef, int sec) 866e9eabf59SPeter Wemm { 867e9eabf59SPeter Wemm int i; 868e9eabf59SPeter Wemm Elf_Addr base = 0; 869e9eabf59SPeter Wemm 870e9eabf59SPeter Wemm for (i = 0; i < ef->nprogtab; i++) { 871a8774e39SPeter Wemm if (sec == ef->progtab[i].sec) { 872e9eabf59SPeter Wemm base = (Elf_Addr)ef->progtab[i].addr; 873a8774e39SPeter Wemm break; 874e9eabf59SPeter Wemm } 875a8774e39SPeter Wemm } 876e9eabf59SPeter Wemm return base; 877e9eabf59SPeter Wemm } 878e9eabf59SPeter Wemm 879a4f67738SDoug Rabson static int 880326e27d8SDoug Rabson relocate_file(elf_file_t ef) 881a4f67738SDoug Rabson { 882fe3db7c7SDoug Rabson const Elf_Rel *rellim; 883fe3db7c7SDoug Rabson const Elf_Rel *rel; 884fe3db7c7SDoug Rabson const Elf_Rela *relalim; 885fe3db7c7SDoug Rabson const Elf_Rela *rela; 886aa855a59SPeter Wemm const char *symname; 887e9eabf59SPeter Wemm const Elf_Sym *sym; 888e9eabf59SPeter Wemm int i; 889757686b1SMarcel Moolenaar Elf_Size symidx; 890e9eabf59SPeter Wemm Elf_Addr base; 891e9eabf59SPeter Wemm 892a4f67738SDoug Rabson 893fe3db7c7SDoug Rabson /* Perform relocations without addend if there are any: */ 894e9eabf59SPeter Wemm for (i = 0; i < ef->nrel; i++) { 895e9eabf59SPeter Wemm rel = ef->reltab[i].rel; 89620947801SPeter Wemm if (rel == NULL) 89782d0d1a0SPeter Wemm panic("lost a reltab!"); 89820947801SPeter Wemm rellim = rel + ef->reltab[i].nrel; 899e9eabf59SPeter Wemm base = findbase(ef, ef->reltab[i].sec); 900a8774e39SPeter Wemm if (base == 0) 901a8774e39SPeter Wemm panic("lost base for reltab"); 90220947801SPeter Wemm for ( ; rel < rellim; rel++) { 903e9eabf59SPeter Wemm symidx = ELF_R_SYM(rel->r_info); 90420947801SPeter Wemm if (symidx >= ef->ddbsymcnt) 90520947801SPeter Wemm continue; 906e9eabf59SPeter Wemm sym = ef->ddbsymtab + symidx; 90720947801SPeter Wemm /* Local relocs are already done */ 90820947801SPeter Wemm if (ELF_ST_BIND(sym->st_info) == STB_LOCAL) 90920947801SPeter Wemm continue; 91020947801SPeter Wemm if (elf_reloc(&ef->lf, base, rel, ELF_RELOC_REL, 91120947801SPeter Wemm elf_obj_lookup)) { 912aa855a59SPeter Wemm symname = symbol_name(ef, rel->r_info); 91320947801SPeter Wemm printf("link_elf_obj: symbol %s undefined\n", 91420947801SPeter Wemm symname); 915a4f67738SDoug Rabson return ENOENT; 916a13ddfb6SPeter Wemm } 917aa855a59SPeter Wemm } 918a4f67738SDoug Rabson } 919a4f67738SDoug Rabson 920fe3db7c7SDoug Rabson /* Perform relocations with addend if there are any: */ 921e9eabf59SPeter Wemm for (i = 0; i < ef->nrela; i++) { 922e9eabf59SPeter Wemm rela = ef->relatab[i].rela; 92320947801SPeter Wemm if (rela == NULL) 92482d0d1a0SPeter Wemm panic("lost a relatab!"); 92520947801SPeter Wemm relalim = rela + ef->relatab[i].nrela; 926e9eabf59SPeter Wemm base = findbase(ef, ef->relatab[i].sec); 927a8774e39SPeter Wemm if (base == 0) 928a8774e39SPeter Wemm panic("lost base for relatab"); 92920947801SPeter Wemm for ( ; rela < relalim; rela++) { 930e9eabf59SPeter Wemm symidx = ELF_R_SYM(rela->r_info); 93120947801SPeter Wemm if (symidx >= ef->ddbsymcnt) 93220947801SPeter Wemm continue; 933e9eabf59SPeter Wemm sym = ef->ddbsymtab + symidx; 93420947801SPeter Wemm /* Local relocs are already done */ 93520947801SPeter Wemm if (ELF_ST_BIND(sym->st_info) == STB_LOCAL) 93620947801SPeter Wemm continue; 93720947801SPeter Wemm if (elf_reloc(&ef->lf, base, rela, ELF_RELOC_RELA, 93820947801SPeter Wemm elf_obj_lookup)) { 939aa855a59SPeter Wemm symname = symbol_name(ef, rela->r_info); 94020947801SPeter Wemm printf("link_elf_obj: symbol %s undefined\n", 94120947801SPeter Wemm symname); 942fe3db7c7SDoug Rabson return ENOENT; 943a13ddfb6SPeter Wemm } 944e9eabf59SPeter Wemm } 945e9eabf59SPeter Wemm } 946a4f67738SDoug Rabson 947a4f67738SDoug Rabson return 0; 948a4f67738SDoug Rabson } 949a4f67738SDoug Rabson 95037c84183SPoul-Henning Kamp static int 951d254af07SMatthew Dillon link_elf_lookup_symbol(linker_file_t lf, const char *name, c_linker_sym_t *sym) 952a4f67738SDoug Rabson { 953326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) lf; 9542d636ab0SPeter Wemm const Elf_Sym *symp; 9552d636ab0SPeter Wemm const char *strp; 956a4f67738SDoug Rabson int i; 957a4f67738SDoug Rabson 9582d636ab0SPeter Wemm for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) { 9592d636ab0SPeter Wemm strp = ef->ddbstrtab + symp->st_name; 960a8774e39SPeter Wemm if (symp->st_shndx != SHN_UNDEF && strcmp(name, strp) == 0) { 961d254af07SMatthew Dillon *sym = (c_linker_sym_t) symp; 9622d636ab0SPeter Wemm return 0; 9632d636ab0SPeter Wemm } 9642d636ab0SPeter Wemm } 965a4f67738SDoug Rabson return ENOENT; 966a4f67738SDoug Rabson } 967a4f67738SDoug Rabson 968de78ca7eSPeter Wemm static int 96920947801SPeter Wemm link_elf_symbol_values(linker_file_t lf, c_linker_sym_t sym, 97020947801SPeter Wemm linker_symval_t *symval) 971a4f67738SDoug Rabson { 972326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) lf; 9738aef1712SMatthew Dillon const Elf_Sym *es = (const Elf_Sym*) sym; 974a4f67738SDoug Rabson 9755cf87418SMarcel Moolenaar if (es >= ef->ddbsymtab && es < (ef->ddbsymtab + ef->ddbsymcnt)) { 9762d636ab0SPeter Wemm symval->name = ef->ddbstrtab + es->st_name; 977a8774e39SPeter Wemm symval->value = (caddr_t)es->st_value; 9782d636ab0SPeter Wemm symval->size = es->st_size; 9792d636ab0SPeter Wemm return 0; 9802d636ab0SPeter Wemm } 9812d636ab0SPeter Wemm return ENOENT; 9822d636ab0SPeter Wemm } 983a4f67738SDoug Rabson 984a4f67738SDoug Rabson static int 985a4f67738SDoug Rabson link_elf_search_symbol(linker_file_t lf, caddr_t value, 986d254af07SMatthew Dillon c_linker_sym_t *sym, long *diffp) 987a4f67738SDoug Rabson { 988326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) lf; 989586453feSBruce Evans u_long off = (uintptr_t) (void *) value; 990a4f67738SDoug Rabson u_long diff = off; 991586453feSBruce Evans u_long st_value; 992fe3db7c7SDoug Rabson const Elf_Sym *es; 993fe3db7c7SDoug Rabson const Elf_Sym *best = 0; 994a4f67738SDoug Rabson int i; 995a4f67738SDoug Rabson 9962d636ab0SPeter Wemm for (i = 0, es = ef->ddbsymtab; i < ef->ddbsymcnt; i++, es++) { 997a4f67738SDoug Rabson if (es->st_name == 0) 998a4f67738SDoug Rabson continue; 999a8774e39SPeter Wemm st_value = es->st_value; 1000b5abfb70SPeter Wemm if (off >= st_value) { 1001b5abfb70SPeter Wemm if (off - st_value < diff) { 1002b5abfb70SPeter Wemm diff = off - st_value; 1003a4f67738SDoug Rabson best = es; 1004a4f67738SDoug Rabson if (diff == 0) 1005a4f67738SDoug Rabson break; 1006b5abfb70SPeter Wemm } else if (off - st_value == diff) { 1007a4f67738SDoug Rabson best = es; 1008a4f67738SDoug Rabson } 1009a4f67738SDoug Rabson } 1010a4f67738SDoug Rabson } 1011a4f67738SDoug Rabson if (best == 0) 1012a4f67738SDoug Rabson *diffp = off; 1013a4f67738SDoug Rabson else 1014a4f67738SDoug Rabson *diffp = diff; 1015d254af07SMatthew Dillon *sym = (c_linker_sym_t) best; 1016a4f67738SDoug Rabson 1017a4f67738SDoug Rabson return 0; 1018a4f67738SDoug Rabson } 1019f41325dbSPeter Wemm 1020f41325dbSPeter Wemm /* 1021f41325dbSPeter Wemm * Look up a linker set on an ELF system. 1022f41325dbSPeter Wemm */ 1023f41325dbSPeter Wemm static int 1024f41325dbSPeter Wemm link_elf_lookup_set(linker_file_t lf, const char *name, 1025f41325dbSPeter Wemm void ***startp, void ***stopp, int *countp) 1026f41325dbSPeter Wemm { 1027e9eabf59SPeter Wemm elf_file_t ef = (elf_file_t)lf; 1028f41325dbSPeter Wemm void **start, **stop; 1029e9eabf59SPeter Wemm int i, count; 1030f41325dbSPeter Wemm 1031e9eabf59SPeter Wemm /* Relative to section number */ 1032e9eabf59SPeter Wemm for (i = 0; i < ef->nprogtab; i++) { 1033e9eabf59SPeter Wemm if ((strncmp(ef->progtab[i].name, "set_", 4) == 0) && 1034e9eabf59SPeter Wemm strcmp(ef->progtab[i].name + 4, name) == 0) { 1035e9eabf59SPeter Wemm start = (void **)ef->progtab[i].addr; 103620947801SPeter Wemm stop = (void **)((char *)ef->progtab[i].addr + 103720947801SPeter Wemm ef->progtab[i].size); 1038f41325dbSPeter Wemm count = stop - start; 1039f41325dbSPeter Wemm if (startp) 1040f41325dbSPeter Wemm *startp = start; 1041f41325dbSPeter Wemm if (stopp) 1042f41325dbSPeter Wemm *stopp = stop; 1043f41325dbSPeter Wemm if (countp) 1044f41325dbSPeter Wemm *countp = count; 1045e9eabf59SPeter Wemm return (0); 1046e9eabf59SPeter Wemm } 1047e9eabf59SPeter Wemm } 1048e9eabf59SPeter Wemm return (ESRCH); 1049f41325dbSPeter Wemm } 1050bb9fe9ddSBrian Feldman 1051bb9fe9ddSBrian Feldman static int 1052bb9fe9ddSBrian Feldman link_elf_each_function_name(linker_file_t file, 1053e9eabf59SPeter Wemm int (*callback)(const char *, void *), void *opaque) 1054e9eabf59SPeter Wemm { 1055bb9fe9ddSBrian Feldman elf_file_t ef = (elf_file_t)file; 1056bb9fe9ddSBrian Feldman const Elf_Sym *symp; 1057bb9fe9ddSBrian Feldman int i, error; 1058bb9fe9ddSBrian Feldman 1059bb9fe9ddSBrian Feldman /* Exhaustive search */ 1060bb9fe9ddSBrian Feldman for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) { 1061bb9fe9ddSBrian Feldman if (symp->st_value != 0 && 1062bb9fe9ddSBrian Feldman ELF_ST_TYPE(symp->st_info) == STT_FUNC) { 1063bb9fe9ddSBrian Feldman error = callback(ef->ddbstrtab + symp->st_name, opaque); 1064bb9fe9ddSBrian Feldman if (error) 1065bb9fe9ddSBrian Feldman return (error); 1066bb9fe9ddSBrian Feldman } 1067bb9fe9ddSBrian Feldman } 1068bb9fe9ddSBrian Feldman return (0); 1069bb9fe9ddSBrian Feldman } 107084201059SMarcel Moolenaar 1071d297ad16SMarcel Moolenaar /* 1072d297ad16SMarcel Moolenaar * Symbol lookup function that can be used when the symbol index is known (ie 1073d297ad16SMarcel Moolenaar * in relocations). It uses the symbol index instead of doing a fully fledged 1074d297ad16SMarcel Moolenaar * hash table based lookup when such is valid. For example for local symbols. 1075d297ad16SMarcel Moolenaar * This is not only more efficient, it's also more correct. It's not always 1076d297ad16SMarcel Moolenaar * the case that the symbol can be found through the hash table. 1077d297ad16SMarcel Moolenaar */ 1078e9eabf59SPeter Wemm static Elf_Addr 1079757686b1SMarcel Moolenaar elf_obj_lookup(linker_file_t lf, Elf_Size symidx, int deps) 1080d297ad16SMarcel Moolenaar { 1081d297ad16SMarcel Moolenaar elf_file_t ef = (elf_file_t)lf; 1082d297ad16SMarcel Moolenaar const Elf_Sym *sym; 1083d297ad16SMarcel Moolenaar const char *symbol; 1084e9eabf59SPeter Wemm Elf_Addr ret; 1085d297ad16SMarcel Moolenaar 1086d297ad16SMarcel Moolenaar /* Don't even try to lookup the symbol if the index is bogus. */ 1087e9eabf59SPeter Wemm if (symidx >= ef->ddbsymcnt) 1088d297ad16SMarcel Moolenaar return (0); 1089d297ad16SMarcel Moolenaar 1090e9eabf59SPeter Wemm sym = ef->ddbsymtab + symidx; 1091d297ad16SMarcel Moolenaar 10924cec6f5dSPeter Wemm /* Quick answer if there is a definition included. */ 1093a8774e39SPeter Wemm if (sym->st_shndx != SHN_UNDEF) 1094a8774e39SPeter Wemm return (sym->st_value); 10954cec6f5dSPeter Wemm 10964cec6f5dSPeter Wemm /* If we get here, then it is undefined and needs a lookup. */ 10974cec6f5dSPeter Wemm switch (ELF_ST_BIND(sym->st_info)) { 10984cec6f5dSPeter Wemm case STB_LOCAL: 10994cec6f5dSPeter Wemm /* Local, but undefined? huh? */ 11004cec6f5dSPeter Wemm return (0); 1101d297ad16SMarcel Moolenaar 1102e9eabf59SPeter Wemm case STB_GLOBAL: 1103e9eabf59SPeter Wemm /* Relative to Data or Function name */ 1104e9eabf59SPeter Wemm symbol = ef->ddbstrtab + sym->st_name; 1105d297ad16SMarcel Moolenaar 1106d297ad16SMarcel Moolenaar /* Force a lookup failure if the symbol name is bogus. */ 1107d297ad16SMarcel Moolenaar if (*symbol == 0) 1108d297ad16SMarcel Moolenaar return (0); 1109e9eabf59SPeter Wemm ret = ((Elf_Addr)linker_file_lookup_symbol(lf, symbol, deps)); 1110e9eabf59SPeter Wemm return ret; 1111d297ad16SMarcel Moolenaar 1112e9eabf59SPeter Wemm case STB_WEAK: 111320947801SPeter Wemm printf("link_elf_obj: Weak symbols not supported\n"); 1114e9eabf59SPeter Wemm return (0); 1115e9eabf59SPeter Wemm 1116e9eabf59SPeter Wemm default: 1117e9eabf59SPeter Wemm return (0); 1118d297ad16SMarcel Moolenaar } 1119e9eabf59SPeter Wemm } 1120e9eabf59SPeter Wemm 11217251b4bfSJake Burkholder static void 11227226306eSKonstantin Belousov link_elf_fix_link_set(elf_file_t ef) 11237226306eSKonstantin Belousov { 11247226306eSKonstantin Belousov static const char startn[] = "__start_"; 11257226306eSKonstantin Belousov static const char stopn[] = "__stop_"; 11267226306eSKonstantin Belousov Elf_Sym *sym; 11277226306eSKonstantin Belousov const char *sym_name, *linkset_name; 11287226306eSKonstantin Belousov Elf_Addr startp, stopp; 11297226306eSKonstantin Belousov Elf_Size symidx; 11307226306eSKonstantin Belousov int start, i; 11317226306eSKonstantin Belousov 11327226306eSKonstantin Belousov startp = stopp = 0; 11337226306eSKonstantin Belousov for (symidx = 1 /* zero entry is special */; 11347226306eSKonstantin Belousov symidx < ef->ddbsymcnt; symidx++) { 11357226306eSKonstantin Belousov sym = ef->ddbsymtab + symidx; 11367226306eSKonstantin Belousov if (sym->st_shndx != SHN_UNDEF) 11377226306eSKonstantin Belousov continue; 11387226306eSKonstantin Belousov 11397226306eSKonstantin Belousov sym_name = ef->ddbstrtab + sym->st_name; 11407226306eSKonstantin Belousov if (strncmp(sym_name, startn, sizeof(startn) - 1) == 0) { 11417226306eSKonstantin Belousov start = 1; 11427226306eSKonstantin Belousov linkset_name = sym_name + sizeof(startn) - 1; 11437226306eSKonstantin Belousov } 11447226306eSKonstantin Belousov else if (strncmp(sym_name, stopn, sizeof(stopn) - 1) == 0) { 11457226306eSKonstantin Belousov start = 0; 11467226306eSKonstantin Belousov linkset_name = sym_name + sizeof(stopn) - 1; 11477226306eSKonstantin Belousov } 11487226306eSKonstantin Belousov else 11497226306eSKonstantin Belousov continue; 11507226306eSKonstantin Belousov 11517226306eSKonstantin Belousov for (i = 0; i < ef->nprogtab; i++) { 11527226306eSKonstantin Belousov if (strcmp(ef->progtab[i].name, linkset_name) == 0) { 11537226306eSKonstantin Belousov startp = (Elf_Addr)ef->progtab[i].addr; 11547226306eSKonstantin Belousov stopp = (Elf_Addr)(startp + ef->progtab[i].size); 11557226306eSKonstantin Belousov break; 11567226306eSKonstantin Belousov } 11577226306eSKonstantin Belousov } 11587226306eSKonstantin Belousov if (i == ef->nprogtab) 11597226306eSKonstantin Belousov continue; 11607226306eSKonstantin Belousov 11617226306eSKonstantin Belousov sym->st_value = start ? startp : stopp; 11627226306eSKonstantin Belousov sym->st_shndx = i; 11637226306eSKonstantin Belousov } 11647226306eSKonstantin Belousov } 11657226306eSKonstantin Belousov 11667226306eSKonstantin Belousov static void 11677251b4bfSJake Burkholder link_elf_reloc_local(linker_file_t lf) 11687251b4bfSJake Burkholder { 1169e9eabf59SPeter Wemm elf_file_t ef = (elf_file_t)lf; 11707251b4bfSJake Burkholder const Elf_Rel *rellim; 11717251b4bfSJake Burkholder const Elf_Rel *rel; 11727251b4bfSJake Burkholder const Elf_Rela *relalim; 11737251b4bfSJake Burkholder const Elf_Rela *rela; 1174e9eabf59SPeter Wemm const Elf_Sym *sym; 1175e9eabf59SPeter Wemm Elf_Addr base; 1176e9eabf59SPeter Wemm int i; 1177757686b1SMarcel Moolenaar Elf_Size symidx; 1178e9eabf59SPeter Wemm 11797226306eSKonstantin Belousov link_elf_fix_link_set(ef); 11807226306eSKonstantin Belousov 11817251b4bfSJake Burkholder /* Perform relocations without addend if there are any: */ 1182e9eabf59SPeter Wemm for (i = 0; i < ef->nrel; i++) { 1183e9eabf59SPeter Wemm rel = ef->reltab[i].rel; 118420947801SPeter Wemm if (rel == NULL) 118582d0d1a0SPeter Wemm panic("lost a reltab!"); 118620947801SPeter Wemm rellim = rel + ef->reltab[i].nrel; 1187e9eabf59SPeter Wemm base = findbase(ef, ef->reltab[i].sec); 1188a8774e39SPeter Wemm if (base == 0) 1189a8774e39SPeter Wemm panic("lost base for reltab"); 119020947801SPeter Wemm for ( ; rel < rellim; rel++) { 1191e9eabf59SPeter Wemm symidx = ELF_R_SYM(rel->r_info); 119220947801SPeter Wemm if (symidx >= ef->ddbsymcnt) 119320947801SPeter Wemm continue; 1194e9eabf59SPeter Wemm sym = ef->ddbsymtab + symidx; 119520947801SPeter Wemm /* Only do local relocs */ 119620947801SPeter Wemm if (ELF_ST_BIND(sym->st_info) != STB_LOCAL) 119720947801SPeter Wemm continue; 119820947801SPeter Wemm elf_reloc_local(lf, base, rel, ELF_RELOC_REL, 119920947801SPeter Wemm elf_obj_lookup); 12007251b4bfSJake Burkholder } 1201e9eabf59SPeter Wemm } 12027251b4bfSJake Burkholder 12037251b4bfSJake Burkholder /* Perform relocations with addend if there are any: */ 1204e9eabf59SPeter Wemm for (i = 0; i < ef->nrela; i++) { 1205e9eabf59SPeter Wemm rela = ef->relatab[i].rela; 120620947801SPeter Wemm if (rela == NULL) 120782d0d1a0SPeter Wemm panic("lost a relatab!"); 120820947801SPeter Wemm relalim = rela + ef->relatab[i].nrela; 1209e9eabf59SPeter Wemm base = findbase(ef, ef->relatab[i].sec); 1210a8774e39SPeter Wemm if (base == 0) 1211a8774e39SPeter Wemm panic("lost base for relatab"); 121220947801SPeter Wemm for ( ; rela < relalim; rela++) { 1213e9eabf59SPeter Wemm symidx = ELF_R_SYM(rela->r_info); 121420947801SPeter Wemm if (symidx >= ef->ddbsymcnt) 121520947801SPeter Wemm continue; 1216e9eabf59SPeter Wemm sym = ef->ddbsymtab + symidx; 121720947801SPeter Wemm /* Only do local relocs */ 121820947801SPeter Wemm if (ELF_ST_BIND(sym->st_info) != STB_LOCAL) 121920947801SPeter Wemm continue; 122020947801SPeter Wemm elf_reloc_local(lf, base, rela, ELF_RELOC_RELA, 122120947801SPeter Wemm elf_obj_lookup); 12227251b4bfSJake Burkholder } 12237251b4bfSJake Burkholder } 1224e9eabf59SPeter Wemm } 1225