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); 412a3df768bSRobert Watson #ifdef MAC 413e9eabf59SPeter Wemm error = mac_check_kld_load(td->td_ucred, nd.ni_vp); 414a3df768bSRobert Watson if (error) { 415a3df768bSRobert Watson goto out; 416a3df768bSRobert Watson } 417a3df768bSRobert Watson #endif 418a4f67738SDoug Rabson 419e9eabf59SPeter Wemm /* Read the elf header from the file. */ 420e9eabf59SPeter Wemm hdr = malloc(sizeof(*hdr), M_LINKER, M_WAITOK); 421e9eabf59SPeter Wemm if (hdr == NULL) { 422caab6e90SPeter Wemm error = ENOMEM; 423caab6e90SPeter Wemm goto out; 424caab6e90SPeter Wemm } 425e9eabf59SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, (void *)hdr, sizeof(*hdr), 0, 4269ca43589SRobert Watson UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 4279ca43589SRobert Watson &resid, td); 428a4f67738SDoug Rabson if (error) 429a4f67738SDoug Rabson goto out; 430e9eabf59SPeter Wemm if (resid != 0){ 431e9eabf59SPeter Wemm error = ENOEXEC; 432e9eabf59SPeter Wemm goto out; 433e9eabf59SPeter Wemm } 434a4f67738SDoug Rabson 435caab6e90SPeter Wemm if (!IS_ELF(*hdr)) { 436fe3db7c7SDoug Rabson error = ENOEXEC; 437a4f67738SDoug Rabson goto out; 438fe3db7c7SDoug Rabson } 439fe3db7c7SDoug Rabson 440caab6e90SPeter Wemm if (hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS 441caab6e90SPeter Wemm || hdr->e_ident[EI_DATA] != ELF_TARG_DATA) { 442fe3db7c7SDoug Rabson link_elf_error("Unsupported file layout"); 443fe3db7c7SDoug Rabson error = ENOEXEC; 444fe3db7c7SDoug Rabson goto out; 445fe3db7c7SDoug Rabson } 446caab6e90SPeter Wemm if (hdr->e_ident[EI_VERSION] != EV_CURRENT 447caab6e90SPeter Wemm || hdr->e_version != EV_CURRENT) { 448fe3db7c7SDoug Rabson link_elf_error("Unsupported file version"); 449fe3db7c7SDoug Rabson error = ENOEXEC; 450fe3db7c7SDoug Rabson goto out; 451fe3db7c7SDoug Rabson } 452e9eabf59SPeter Wemm if (hdr->e_type != ET_REL) { 453fe3db7c7SDoug Rabson link_elf_error("Unsupported file type"); 454fe3db7c7SDoug Rabson error = ENOEXEC; 455fe3db7c7SDoug Rabson goto out; 456fe3db7c7SDoug Rabson } 457caab6e90SPeter Wemm if (hdr->e_machine != ELF_TARG_MACH) { 458fe3db7c7SDoug Rabson link_elf_error("Unsupported machine"); 459fe3db7c7SDoug Rabson error = ENOEXEC; 460fe3db7c7SDoug Rabson goto out; 461fe3db7c7SDoug Rabson } 462a4f67738SDoug Rabson 463326e27d8SDoug Rabson lf = linker_make_file(filename, &link_elf_class); 464326e27d8SDoug Rabson if (!lf) { 465326e27d8SDoug Rabson error = ENOMEM; 466326e27d8SDoug Rabson goto out; 467326e27d8SDoug Rabson } 468326e27d8SDoug Rabson ef = (elf_file_t) lf; 469e9eabf59SPeter Wemm ef->nprogtab = 0; 470e9eabf59SPeter Wemm ef->e_shdr = 0; 471e9eabf59SPeter Wemm ef->nrel = 0; 472e9eabf59SPeter Wemm ef->nrela = 0; 473e9eabf59SPeter Wemm 474e9eabf59SPeter Wemm /* Allocate and read in the section header */ 475e9eabf59SPeter Wemm nbytes = hdr->e_shnum * hdr->e_shentsize; 476e9eabf59SPeter Wemm if (nbytes == 0 || hdr->e_shoff == 0 || 477e9eabf59SPeter Wemm hdr->e_shentsize != sizeof(Elf_Shdr)) { 478e9eabf59SPeter Wemm error = ENOEXEC; 479e9eabf59SPeter Wemm goto out; 480e9eabf59SPeter Wemm } 48120947801SPeter Wemm shdr = malloc(nbytes, M_LINKER, M_WAITOK); 482e9eabf59SPeter Wemm if (shdr == NULL) { 483e9eabf59SPeter Wemm error = ENOMEM; 484e9eabf59SPeter Wemm goto out; 485e9eabf59SPeter Wemm } 486e9eabf59SPeter Wemm ef->e_shdr = shdr; 487e9eabf59SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, (caddr_t)shdr, nbytes, hdr->e_shoff, 488e9eabf59SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, &resid, td); 489e9eabf59SPeter Wemm if (error) 490e9eabf59SPeter Wemm goto out; 491e9eabf59SPeter Wemm if (resid) { 492e9eabf59SPeter Wemm error = ENOEXEC; 493e9eabf59SPeter Wemm goto out; 494e9eabf59SPeter Wemm } 495e9eabf59SPeter Wemm 496e9eabf59SPeter Wemm /* Scan the section header for information and table sizing. */ 497e9eabf59SPeter Wemm nsym = 0; 498e9eabf59SPeter Wemm symtabindex = -1; 499e9eabf59SPeter Wemm symstrindex = -1; 500e9eabf59SPeter Wemm for (i = 0; i < hdr->e_shnum; i++) { 501e9eabf59SPeter Wemm switch (shdr[i].sh_type) { 502e9eabf59SPeter Wemm case SHT_PROGBITS: 503e9eabf59SPeter Wemm case SHT_NOBITS: 50420947801SPeter Wemm ef->nprogtab++; 505e9eabf59SPeter Wemm break; 506e9eabf59SPeter Wemm case SHT_SYMTAB: 507e9eabf59SPeter Wemm nsym++; 508e9eabf59SPeter Wemm symtabindex = i; 509e9eabf59SPeter Wemm symstrindex = shdr[i].sh_link; 510e9eabf59SPeter Wemm break; 511e9eabf59SPeter Wemm case SHT_REL: 512e9eabf59SPeter Wemm ef->nrel++; 513e9eabf59SPeter Wemm break; 514e9eabf59SPeter Wemm case SHT_RELA: 515e9eabf59SPeter Wemm ef->nrela++; 516e9eabf59SPeter Wemm break; 517e9eabf59SPeter Wemm case SHT_STRTAB: 518e9eabf59SPeter Wemm break; 519e9eabf59SPeter Wemm } 520e9eabf59SPeter Wemm } 52120947801SPeter Wemm if (ef->nprogtab == 0) { 522e9eabf59SPeter Wemm link_elf_error("file has no contents"); 523e9eabf59SPeter Wemm error = ENOEXEC; 524e9eabf59SPeter Wemm goto out; 525e9eabf59SPeter Wemm } 526e9eabf59SPeter Wemm if (nsym != 1) { 527e9eabf59SPeter Wemm /* Only allow one symbol table for now */ 528e9eabf59SPeter Wemm link_elf_error("file has no valid symbol table"); 529e9eabf59SPeter Wemm error = ENOEXEC; 530e9eabf59SPeter Wemm goto out; 531e9eabf59SPeter Wemm } 532e9eabf59SPeter Wemm if (symstrindex < 0 || symstrindex > hdr->e_shnum || 533e9eabf59SPeter Wemm shdr[symstrindex].sh_type != SHT_STRTAB) { 534e9eabf59SPeter Wemm link_elf_error("file has invalid symbol strings"); 535e9eabf59SPeter Wemm error = ENOEXEC; 536e9eabf59SPeter Wemm goto out; 537e9eabf59SPeter Wemm } 538e9eabf59SPeter Wemm 539e9eabf59SPeter Wemm /* Allocate space for tracking the load chunks */ 540e9eabf59SPeter Wemm if (ef->nprogtab != 0) 54120947801SPeter Wemm ef->progtab = malloc(ef->nprogtab * sizeof(*ef->progtab), 54220947801SPeter Wemm M_LINKER, M_WAITOK | M_ZERO); 543e9eabf59SPeter Wemm if (ef->nrel != 0) 54420947801SPeter Wemm ef->reltab = malloc(ef->nrel * sizeof(*ef->reltab), M_LINKER, 54520947801SPeter Wemm M_WAITOK | M_ZERO); 546e9eabf59SPeter Wemm if (ef->nrela != 0) 54720947801SPeter Wemm ef->relatab = malloc(ef->nrela * sizeof(*ef->relatab), M_LINKER, 54820947801SPeter Wemm M_WAITOK | M_ZERO); 54920947801SPeter Wemm if ((ef->nprogtab != 0 && ef->progtab == NULL) || 55020947801SPeter Wemm (ef->nrel != 0 && ef->reltab == NULL) || 55120947801SPeter Wemm (ef->nrela != 0 && ef->relatab == NULL)) { 55220947801SPeter Wemm error = ENOMEM; 55320947801SPeter Wemm goto out; 55420947801SPeter Wemm } 555e9eabf59SPeter Wemm 55620947801SPeter Wemm if (symtabindex == -1) 55720947801SPeter Wemm panic("lost symbol table index"); 55820947801SPeter Wemm /* Allocate space for and load the symbol table */ 559e9eabf59SPeter Wemm ef->ddbsymcnt = shdr[symtabindex].sh_size / sizeof(Elf_Sym); 560e9eabf59SPeter Wemm ef->ddbsymtab = malloc(shdr[symtabindex].sh_size, M_LINKER, M_WAITOK); 56120947801SPeter Wemm if (ef->ddbsymtab == NULL) { 56220947801SPeter Wemm error = ENOMEM; 56320947801SPeter Wemm goto out; 56420947801SPeter Wemm } 56520947801SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, (void *)ef->ddbsymtab, 56620947801SPeter Wemm shdr[symtabindex].sh_size, shdr[symtabindex].sh_offset, 56720947801SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 56820947801SPeter Wemm &resid, td); 56920947801SPeter Wemm if (error) 57020947801SPeter Wemm goto out; 57120947801SPeter Wemm if (resid != 0){ 57220947801SPeter Wemm error = EINVAL; 57320947801SPeter Wemm goto out; 57420947801SPeter Wemm } 575e9eabf59SPeter Wemm 57620947801SPeter Wemm if (symstrindex == -1) 57720947801SPeter Wemm panic("lost symbol string index"); 57820947801SPeter Wemm /* Allocate space for and load the symbol strings */ 579e9eabf59SPeter Wemm ef->ddbstrcnt = shdr[symstrindex].sh_size; 580e9eabf59SPeter Wemm ef->ddbstrtab = malloc(shdr[symstrindex].sh_size, M_LINKER, M_WAITOK); 58120947801SPeter Wemm if (ef->ddbstrtab == NULL) { 582e9eabf59SPeter Wemm error = ENOMEM; 583e9eabf59SPeter Wemm goto out; 584e9eabf59SPeter Wemm } 58520947801SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, ef->ddbstrtab, 58620947801SPeter Wemm shdr[symstrindex].sh_size, shdr[symstrindex].sh_offset, 58720947801SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 58820947801SPeter Wemm &resid, td); 58920947801SPeter Wemm if (error) 59020947801SPeter Wemm goto out; 59120947801SPeter Wemm if (resid != 0){ 59220947801SPeter Wemm error = EINVAL; 59320947801SPeter Wemm goto out; 59420947801SPeter Wemm } 595e9eabf59SPeter Wemm 596e9eabf59SPeter Wemm /* Do we have a string table for the section names? */ 597e9eabf59SPeter Wemm shstrindex = -1; 59820947801SPeter Wemm if (hdr->e_shstrndx != 0 && 59920947801SPeter Wemm shdr[hdr->e_shstrndx].sh_type == SHT_STRTAB) { 600e9eabf59SPeter Wemm shstrindex = hdr->e_shstrndx; 601e9eabf59SPeter Wemm ef->shstrcnt = shdr[shstrindex].sh_size; 60220947801SPeter Wemm ef->shstrtab = malloc(shdr[shstrindex].sh_size, M_LINKER, 60320947801SPeter Wemm M_WAITOK); 604e9eabf59SPeter Wemm if (ef->shstrtab == NULL) { 605e9eabf59SPeter Wemm error = ENOMEM; 606e9eabf59SPeter Wemm goto out; 607e9eabf59SPeter Wemm } 60820947801SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, ef->shstrtab, 60920947801SPeter Wemm shdr[shstrindex].sh_size, shdr[shstrindex].sh_offset, 610e9eabf59SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 611e9eabf59SPeter Wemm &resid, td); 612e9eabf59SPeter Wemm if (error) 613e9eabf59SPeter Wemm goto out; 61420947801SPeter Wemm if (resid != 0){ 61520947801SPeter Wemm error = EINVAL; 61620947801SPeter Wemm goto out; 61720947801SPeter Wemm } 618e9eabf59SPeter Wemm } 619e9eabf59SPeter Wemm 62020947801SPeter Wemm /* Size up code/data(progbits) and bss(nobits). */ 621e9eabf59SPeter Wemm alignmask = 0; 622e9eabf59SPeter Wemm for (i = 0; i < hdr->e_shnum; i++) { 623e9eabf59SPeter Wemm switch (shdr[i].sh_type) { 624e9eabf59SPeter Wemm case SHT_PROGBITS: 625e9eabf59SPeter Wemm case SHT_NOBITS: 626e9eabf59SPeter Wemm alignmask = shdr[i].sh_addralign - 1; 627e9eabf59SPeter Wemm mapsize += alignmask; 628e9eabf59SPeter Wemm mapsize &= ~alignmask; 629e9eabf59SPeter Wemm mapsize += shdr[i].sh_size; 630e9eabf59SPeter Wemm break; 631e9eabf59SPeter Wemm } 632e9eabf59SPeter Wemm } 633e9eabf59SPeter Wemm 634e9eabf59SPeter Wemm /* 635e9eabf59SPeter Wemm * We know how much space we need for the text/data/bss/etc. 636e9eabf59SPeter Wemm * This stuff needs to be in a single chunk so that profiling etc 637e9eabf59SPeter Wemm * can get the bounds and gdb can associate offsets with modules 638e9eabf59SPeter Wemm */ 63920947801SPeter Wemm ef->object = vm_object_allocate(OBJT_DEFAULT, 64020947801SPeter Wemm round_page(mapsize) >> PAGE_SHIFT); 641fe3db7c7SDoug Rabson if (ef->object == NULL) { 642fe3db7c7SDoug Rabson error = ENOMEM; 643fe3db7c7SDoug Rabson goto out; 644fe3db7c7SDoug Rabson } 645fe3db7c7SDoug Rabson ef->address = (caddr_t) vm_map_min(kernel_map); 64620947801SPeter Wemm error = vm_map_find(kernel_map, ef->object, 0, &mapbase, 64720947801SPeter Wemm round_page(mapsize), TRUE, VM_PROT_ALL, VM_PROT_ALL, FALSE); 648fe3db7c7SDoug Rabson if (error) { 649fe3db7c7SDoug Rabson vm_object_deallocate(ef->object); 650326e27d8SDoug Rabson ef->object = 0; 651fe3db7c7SDoug Rabson goto out; 652fe3db7c7SDoug Rabson } 65320947801SPeter Wemm 654e9eabf59SPeter Wemm /* Wire the pages */ 6557f1ef325SAlan Cox error = vm_map_wire(kernel_map, mapbase, 65620947801SPeter Wemm mapbase + round_page(mapsize), 657e9eabf59SPeter Wemm VM_MAP_WIRE_SYSTEM|VM_MAP_WIRE_NOHOLES); 6587f1ef325SAlan Cox if (error != KERN_SUCCESS) { 6597f1ef325SAlan Cox error = ENOMEM; 6607f1ef325SAlan Cox goto out; 6617f1ef325SAlan Cox } 662a4f67738SDoug Rabson 66320947801SPeter Wemm /* Inform the kld system about the situation */ 66420947801SPeter Wemm lf->address = ef->address = (caddr_t)mapbase; 66520947801SPeter Wemm lf->size = mapsize; 666e9eabf59SPeter Wemm 667e9eabf59SPeter Wemm /* 66820947801SPeter Wemm * Now load code/data(progbits), zero bss(nobits), allocate space for 66920947801SPeter Wemm * and load relocs 670e9eabf59SPeter Wemm */ 67120947801SPeter Wemm pb = 0; 67220947801SPeter Wemm rl = 0; 67320947801SPeter Wemm ra = 0; 67420947801SPeter Wemm alignmask = 0; 67520947801SPeter Wemm for (i = 0; i < hdr->e_shnum; i++) { 67620947801SPeter Wemm switch (shdr[i].sh_type) { 67720947801SPeter Wemm case SHT_PROGBITS: 67820947801SPeter Wemm case SHT_NOBITS: 67920947801SPeter Wemm alignmask = shdr[i].sh_addralign - 1; 68020947801SPeter Wemm mapbase += alignmask; 68120947801SPeter Wemm mapbase &= ~alignmask; 68220947801SPeter Wemm ef->progtab[pb].addr = (void *)(uintptr_t)mapbase; 68320947801SPeter Wemm if (shdr[i].sh_type == SHT_PROGBITS) { 68420947801SPeter Wemm ef->progtab[pb].name = "<<PROGBITS>>"; 685e9eabf59SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, 68620947801SPeter Wemm ef->progtab[pb].addr, 68720947801SPeter Wemm shdr[i].sh_size, shdr[i].sh_offset, 68820947801SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, 68920947801SPeter Wemm NOCRED, &resid, td); 69020947801SPeter Wemm if (error) 69120947801SPeter Wemm goto out; 69220947801SPeter Wemm if (resid != 0){ 69320947801SPeter Wemm error = EINVAL; 69420947801SPeter Wemm goto out; 69520947801SPeter Wemm } 69620947801SPeter Wemm } else { 69720947801SPeter Wemm ef->progtab[pb].name = "<<NOBITS>>"; 69820947801SPeter Wemm bzero(ef->progtab[pb].addr, shdr[i].sh_size); 69920947801SPeter Wemm } 70020947801SPeter Wemm ef->progtab[pb].size = shdr[i].sh_size; 70120947801SPeter Wemm ef->progtab[pb].sec = i; 70220947801SPeter Wemm if (ef->shstrtab && shdr[i].sh_name != 0) 70320947801SPeter Wemm ef->progtab[pb].name = 70420947801SPeter Wemm ef->shstrtab + shdr[i].sh_name; 705a8774e39SPeter Wemm 706a8774e39SPeter Wemm /* Update all symbol values with the offset. */ 707a8774e39SPeter Wemm for (j = 0; j < ef->ddbsymcnt; j++) { 708a8774e39SPeter Wemm es = &ef->ddbsymtab[j]; 709a8774e39SPeter Wemm if (es->st_shndx != i) 710a8774e39SPeter Wemm continue; 711a8774e39SPeter Wemm es->st_value += (Elf_Addr)ef->progtab[pb].addr; 712a8774e39SPeter Wemm } 71320947801SPeter Wemm mapbase += shdr[i].sh_size; 71420947801SPeter Wemm pb++; 71520947801SPeter Wemm break; 71620947801SPeter Wemm case SHT_REL: 71720947801SPeter Wemm ef->reltab[rl].rel = malloc(shdr[i].sh_size, M_LINKER, 71820947801SPeter Wemm M_WAITOK); 71920947801SPeter Wemm ef->reltab[rl].nrel = shdr[i].sh_size / sizeof(Elf_Rel); 72020947801SPeter Wemm ef->reltab[rl].sec = shdr[i].sh_info; 72120947801SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, 72220947801SPeter Wemm (void *)ef->reltab[rl].rel, 72320947801SPeter Wemm shdr[i].sh_size, shdr[i].sh_offset, 724e9eabf59SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 725e9eabf59SPeter Wemm &resid, td); 726e9eabf59SPeter Wemm if (error) 727e9eabf59SPeter Wemm goto out; 72820947801SPeter Wemm if (resid != 0){ 72920947801SPeter Wemm error = EINVAL; 73020947801SPeter Wemm goto out; 731e9eabf59SPeter Wemm } 73220947801SPeter Wemm rl++; 73320947801SPeter Wemm break; 73420947801SPeter Wemm case SHT_RELA: 73520947801SPeter Wemm ef->relatab[ra].rela = malloc(shdr[i].sh_size, M_LINKER, 73620947801SPeter Wemm M_WAITOK); 73720947801SPeter Wemm ef->relatab[ra].nrela = 73820947801SPeter Wemm shdr[i].sh_size / sizeof(Elf_Rela); 73920947801SPeter Wemm ef->relatab[ra].sec = shdr[i].sh_info; 740e9eabf59SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, 74120947801SPeter Wemm (void *)ef->relatab[ra].rela, 74220947801SPeter Wemm shdr[i].sh_size, shdr[i].sh_offset, 743e9eabf59SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 744e9eabf59SPeter Wemm &resid, td); 745e9eabf59SPeter Wemm if (error) 746e9eabf59SPeter Wemm goto out; 74720947801SPeter Wemm if (resid != 0){ 74820947801SPeter Wemm error = EINVAL; 74920947801SPeter Wemm goto out; 750e9eabf59SPeter Wemm } 75120947801SPeter Wemm ra++; 75220947801SPeter Wemm break; 75320947801SPeter Wemm } 75420947801SPeter Wemm } 75520947801SPeter Wemm if (pb != ef->nprogtab) 75620947801SPeter Wemm panic("lost progbits"); 75720947801SPeter Wemm if (rl != ef->nrel) 75820947801SPeter Wemm panic("lost rel"); 75920947801SPeter Wemm if (ra != ef->nrela) 76020947801SPeter Wemm panic("lost rela"); 76120947801SPeter Wemm if (mapbase != (vm_offset_t)ef->address + mapsize) 7625b201fdcSPeter Wemm panic("mapbase 0x%lx != address %p + mapsize 0x%lx (0x%lx)\n", 7635b201fdcSPeter Wemm mapbase, ef->address, mapsize, 7645b201fdcSPeter Wemm (vm_offset_t)ef->address + mapsize); 765e9eabf59SPeter Wemm 766e9eabf59SPeter Wemm /* Local intra-module relocations */ 7677251b4bfSJake Burkholder link_elf_reloc_local(lf); 7687251b4bfSJake Burkholder 769e9eabf59SPeter Wemm /* Pull in dependencies */ 7707b9716baSIan Dowse error = linker_load_dependencies(lf); 771ca65d5c7SPeter Wemm if (error) 772de78ca7eSPeter Wemm goto out; 773e9eabf59SPeter Wemm 774e9eabf59SPeter Wemm /* External relocations */ 775326e27d8SDoug Rabson error = relocate_file(ef); 776ca65d5c7SPeter Wemm if (error) 777ca65d5c7SPeter Wemm goto out; 778ca65d5c7SPeter Wemm 779e9eabf59SPeter Wemm /* Notify MD code that a module is being loaded. */ 780e9eabf59SPeter Wemm error = elf_cpu_load_file(lf); 781ca65d5c7SPeter Wemm if (error) 782ca65d5c7SPeter Wemm goto out; 783a4f67738SDoug Rabson 784a4f67738SDoug Rabson *result = lf; 785a4f67738SDoug Rabson 786a4f67738SDoug Rabson out: 787ca65d5c7SPeter Wemm if (error && lf) 78865a311fcSPoul-Henning Kamp linker_file_unload(lf, LINKER_UNLOAD_FORCE); 789e9eabf59SPeter Wemm if (hdr) 790e9eabf59SPeter Wemm free(hdr, M_LINKER); 791b40ce416SJulian Elischer VOP_UNLOCK(nd.ni_vp, 0, td); 792a854ed98SJohn Baldwin vn_close(nd.ni_vp, FREAD, td->td_ucred, td); 79362d615d5SJohn Baldwin VFS_UNLOCK_GIANT(vfslocked); 794a4f67738SDoug Rabson 795a4f67738SDoug Rabson return error; 796a4f67738SDoug Rabson } 797a4f67738SDoug Rabson 798a4f67738SDoug Rabson static void 799de78ca7eSPeter Wemm link_elf_unload_file(linker_file_t file) 800a4f67738SDoug Rabson { 801326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) file; 80220947801SPeter Wemm int i; 803a4f67738SDoug Rabson 8041aeb23cdSMarcel Moolenaar /* Notify MD code that a module is being unloaded. */ 8051aeb23cdSMarcel Moolenaar elf_cpu_unload_file(file); 8061aeb23cdSMarcel Moolenaar 80770b7ffeeSIan Dowse if (ef->preloaded) { 80870b7ffeeSIan Dowse if (ef->reltab) 80970b7ffeeSIan Dowse free(ef->reltab, M_LINKER); 81070b7ffeeSIan Dowse if (ef->relatab) 81170b7ffeeSIan Dowse free(ef->relatab, M_LINKER); 81270b7ffeeSIan Dowse if (ef->progtab) 81370b7ffeeSIan Dowse free(ef->progtab, M_LINKER); 81470b7ffeeSIan Dowse if (file->filename != NULL) 81570b7ffeeSIan Dowse preload_delete_name(file->filename); 81670b7ffeeSIan Dowse /* XXX reclaim module memory? */ 81770b7ffeeSIan Dowse return; 81870b7ffeeSIan Dowse } 81970b7ffeeSIan Dowse 82020947801SPeter Wemm for (i = 0; i < ef->nrel; i++) 82120947801SPeter Wemm if (ef->reltab[i].rel) 82220947801SPeter Wemm free(ef->reltab[i].rel, M_LINKER); 82320947801SPeter Wemm for (i = 0; i < ef->nrela; i++) 82420947801SPeter Wemm if (ef->relatab[i].rela) 82520947801SPeter Wemm free(ef->relatab[i].rela, M_LINKER); 82620947801SPeter Wemm if (ef->reltab) 82720947801SPeter Wemm free(ef->reltab, M_LINKER); 82820947801SPeter Wemm if (ef->relatab) 82920947801SPeter Wemm free(ef->relatab, M_LINKER); 83020947801SPeter Wemm if (ef->progtab) 83120947801SPeter Wemm free(ef->progtab, M_LINKER); 83220947801SPeter Wemm 833fe3db7c7SDoug Rabson if (ef->object) { 834fe3db7c7SDoug Rabson vm_map_remove(kernel_map, (vm_offset_t) ef->address, 83520947801SPeter Wemm (vm_offset_t) ef->address + 83620947801SPeter Wemm (ef->object->size << PAGE_SHIFT)); 837fe3db7c7SDoug Rabson } 838e9eabf59SPeter Wemm if (ef->e_shdr) 839e9eabf59SPeter Wemm free(ef->e_shdr, M_LINKER); 840e9eabf59SPeter Wemm if (ef->ddbsymtab) 841e9eabf59SPeter Wemm free(ef->ddbsymtab, M_LINKER); 842e9eabf59SPeter Wemm if (ef->ddbstrtab) 843e9eabf59SPeter Wemm free(ef->ddbstrtab, M_LINKER); 84420947801SPeter Wemm if (ef->shstrtab) 84520947801SPeter Wemm free(ef->shstrtab, M_LINKER); 846de78ca7eSPeter Wemm } 847de78ca7eSPeter Wemm 848fe3db7c7SDoug Rabson static const char * 849757686b1SMarcel Moolenaar symbol_name(elf_file_t ef, Elf_Size r_info) 850a4f67738SDoug Rabson { 851fe3db7c7SDoug Rabson const Elf_Sym *ref; 852a4f67738SDoug Rabson 853aa855a59SPeter Wemm if (ELF_R_SYM(r_info)) { 854e9eabf59SPeter Wemm ref = ef->ddbsymtab + ELF_R_SYM(r_info); 855e9eabf59SPeter Wemm return ef->ddbstrtab + ref->st_name; 856fe3db7c7SDoug Rabson } else 857fe3db7c7SDoug Rabson return NULL; 858a4f67738SDoug Rabson } 859a4f67738SDoug Rabson 860e9eabf59SPeter Wemm static Elf_Addr 861e9eabf59SPeter Wemm findbase(elf_file_t ef, int sec) 862e9eabf59SPeter Wemm { 863e9eabf59SPeter Wemm int i; 864e9eabf59SPeter Wemm Elf_Addr base = 0; 865e9eabf59SPeter Wemm 866e9eabf59SPeter Wemm for (i = 0; i < ef->nprogtab; i++) { 867a8774e39SPeter Wemm if (sec == ef->progtab[i].sec) { 868e9eabf59SPeter Wemm base = (Elf_Addr)ef->progtab[i].addr; 869a8774e39SPeter Wemm break; 870e9eabf59SPeter Wemm } 871a8774e39SPeter Wemm } 872e9eabf59SPeter Wemm return base; 873e9eabf59SPeter Wemm } 874e9eabf59SPeter Wemm 875a4f67738SDoug Rabson static int 876326e27d8SDoug Rabson relocate_file(elf_file_t ef) 877a4f67738SDoug Rabson { 878fe3db7c7SDoug Rabson const Elf_Rel *rellim; 879fe3db7c7SDoug Rabson const Elf_Rel *rel; 880fe3db7c7SDoug Rabson const Elf_Rela *relalim; 881fe3db7c7SDoug Rabson const Elf_Rela *rela; 882aa855a59SPeter Wemm const char *symname; 883e9eabf59SPeter Wemm const Elf_Sym *sym; 884e9eabf59SPeter Wemm int i; 885757686b1SMarcel Moolenaar Elf_Size symidx; 886e9eabf59SPeter Wemm Elf_Addr base; 887e9eabf59SPeter Wemm 888a4f67738SDoug Rabson 889fe3db7c7SDoug Rabson /* Perform relocations without addend if there are any: */ 890e9eabf59SPeter Wemm for (i = 0; i < ef->nrel; i++) { 891e9eabf59SPeter Wemm rel = ef->reltab[i].rel; 89220947801SPeter Wemm if (rel == NULL) 89382d0d1a0SPeter Wemm panic("lost a reltab!"); 89420947801SPeter Wemm rellim = rel + ef->reltab[i].nrel; 895e9eabf59SPeter Wemm base = findbase(ef, ef->reltab[i].sec); 896a8774e39SPeter Wemm if (base == 0) 897a8774e39SPeter Wemm panic("lost base for reltab"); 89820947801SPeter Wemm for ( ; rel < rellim; rel++) { 899e9eabf59SPeter Wemm symidx = ELF_R_SYM(rel->r_info); 90020947801SPeter Wemm if (symidx >= ef->ddbsymcnt) 90120947801SPeter Wemm continue; 902e9eabf59SPeter Wemm sym = ef->ddbsymtab + symidx; 90320947801SPeter Wemm /* Local relocs are already done */ 90420947801SPeter Wemm if (ELF_ST_BIND(sym->st_info) == STB_LOCAL) 90520947801SPeter Wemm continue; 90620947801SPeter Wemm if (elf_reloc(&ef->lf, base, rel, ELF_RELOC_REL, 90720947801SPeter Wemm elf_obj_lookup)) { 908aa855a59SPeter Wemm symname = symbol_name(ef, rel->r_info); 90920947801SPeter Wemm printf("link_elf_obj: symbol %s undefined\n", 91020947801SPeter Wemm symname); 911a4f67738SDoug Rabson return ENOENT; 912a13ddfb6SPeter Wemm } 913aa855a59SPeter Wemm } 914a4f67738SDoug Rabson } 915a4f67738SDoug Rabson 916fe3db7c7SDoug Rabson /* Perform relocations with addend if there are any: */ 917e9eabf59SPeter Wemm for (i = 0; i < ef->nrela; i++) { 918e9eabf59SPeter Wemm rela = ef->relatab[i].rela; 91920947801SPeter Wemm if (rela == NULL) 92082d0d1a0SPeter Wemm panic("lost a relatab!"); 92120947801SPeter Wemm relalim = rela + ef->relatab[i].nrela; 922e9eabf59SPeter Wemm base = findbase(ef, ef->relatab[i].sec); 923a8774e39SPeter Wemm if (base == 0) 924a8774e39SPeter Wemm panic("lost base for relatab"); 92520947801SPeter Wemm for ( ; rela < relalim; rela++) { 926e9eabf59SPeter Wemm symidx = ELF_R_SYM(rela->r_info); 92720947801SPeter Wemm if (symidx >= ef->ddbsymcnt) 92820947801SPeter Wemm continue; 929e9eabf59SPeter Wemm sym = ef->ddbsymtab + symidx; 93020947801SPeter Wemm /* Local relocs are already done */ 93120947801SPeter Wemm if (ELF_ST_BIND(sym->st_info) == STB_LOCAL) 93220947801SPeter Wemm continue; 93320947801SPeter Wemm if (elf_reloc(&ef->lf, base, rela, ELF_RELOC_RELA, 93420947801SPeter Wemm elf_obj_lookup)) { 935aa855a59SPeter Wemm symname = symbol_name(ef, rela->r_info); 93620947801SPeter Wemm printf("link_elf_obj: symbol %s undefined\n", 93720947801SPeter Wemm symname); 938fe3db7c7SDoug Rabson return ENOENT; 939a13ddfb6SPeter Wemm } 940e9eabf59SPeter Wemm } 941e9eabf59SPeter Wemm } 942a4f67738SDoug Rabson 943a4f67738SDoug Rabson return 0; 944a4f67738SDoug Rabson } 945a4f67738SDoug Rabson 94637c84183SPoul-Henning Kamp static int 947d254af07SMatthew Dillon link_elf_lookup_symbol(linker_file_t lf, const char *name, c_linker_sym_t *sym) 948a4f67738SDoug Rabson { 949326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) lf; 9502d636ab0SPeter Wemm const Elf_Sym *symp; 9512d636ab0SPeter Wemm const char *strp; 952a4f67738SDoug Rabson int i; 953a4f67738SDoug Rabson 9542d636ab0SPeter Wemm for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) { 9552d636ab0SPeter Wemm strp = ef->ddbstrtab + symp->st_name; 956a8774e39SPeter Wemm if (symp->st_shndx != SHN_UNDEF && strcmp(name, strp) == 0) { 957d254af07SMatthew Dillon *sym = (c_linker_sym_t) symp; 9582d636ab0SPeter Wemm return 0; 9592d636ab0SPeter Wemm } 9602d636ab0SPeter Wemm } 961a4f67738SDoug Rabson return ENOENT; 962a4f67738SDoug Rabson } 963a4f67738SDoug Rabson 964de78ca7eSPeter Wemm static int 96520947801SPeter Wemm link_elf_symbol_values(linker_file_t lf, c_linker_sym_t sym, 96620947801SPeter Wemm linker_symval_t *symval) 967a4f67738SDoug Rabson { 968326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) lf; 9698aef1712SMatthew Dillon const Elf_Sym *es = (const Elf_Sym*) sym; 970a4f67738SDoug Rabson 9715cf87418SMarcel Moolenaar if (es >= ef->ddbsymtab && es < (ef->ddbsymtab + ef->ddbsymcnt)) { 9722d636ab0SPeter Wemm symval->name = ef->ddbstrtab + es->st_name; 973a8774e39SPeter Wemm symval->value = (caddr_t)es->st_value; 9742d636ab0SPeter Wemm symval->size = es->st_size; 9752d636ab0SPeter Wemm return 0; 9762d636ab0SPeter Wemm } 9772d636ab0SPeter Wemm return ENOENT; 9782d636ab0SPeter Wemm } 979a4f67738SDoug Rabson 980a4f67738SDoug Rabson static int 981a4f67738SDoug Rabson link_elf_search_symbol(linker_file_t lf, caddr_t value, 982d254af07SMatthew Dillon c_linker_sym_t *sym, long *diffp) 983a4f67738SDoug Rabson { 984326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) lf; 985586453feSBruce Evans u_long off = (uintptr_t) (void *) value; 986a4f67738SDoug Rabson u_long diff = off; 987586453feSBruce Evans u_long st_value; 988fe3db7c7SDoug Rabson const Elf_Sym *es; 989fe3db7c7SDoug Rabson const Elf_Sym *best = 0; 990a4f67738SDoug Rabson int i; 991a4f67738SDoug Rabson 9922d636ab0SPeter Wemm for (i = 0, es = ef->ddbsymtab; i < ef->ddbsymcnt; i++, es++) { 993a4f67738SDoug Rabson if (es->st_name == 0) 994a4f67738SDoug Rabson continue; 995a8774e39SPeter Wemm st_value = es->st_value; 996b5abfb70SPeter Wemm if (off >= st_value) { 997b5abfb70SPeter Wemm if (off - st_value < diff) { 998b5abfb70SPeter Wemm diff = off - st_value; 999a4f67738SDoug Rabson best = es; 1000a4f67738SDoug Rabson if (diff == 0) 1001a4f67738SDoug Rabson break; 1002b5abfb70SPeter Wemm } else if (off - st_value == diff) { 1003a4f67738SDoug Rabson best = es; 1004a4f67738SDoug Rabson } 1005a4f67738SDoug Rabson } 1006a4f67738SDoug Rabson } 1007a4f67738SDoug Rabson if (best == 0) 1008a4f67738SDoug Rabson *diffp = off; 1009a4f67738SDoug Rabson else 1010a4f67738SDoug Rabson *diffp = diff; 1011d254af07SMatthew Dillon *sym = (c_linker_sym_t) best; 1012a4f67738SDoug Rabson 1013a4f67738SDoug Rabson return 0; 1014a4f67738SDoug Rabson } 1015f41325dbSPeter Wemm 1016f41325dbSPeter Wemm /* 1017f41325dbSPeter Wemm * Look up a linker set on an ELF system. 1018f41325dbSPeter Wemm */ 1019f41325dbSPeter Wemm static int 1020f41325dbSPeter Wemm link_elf_lookup_set(linker_file_t lf, const char *name, 1021f41325dbSPeter Wemm void ***startp, void ***stopp, int *countp) 1022f41325dbSPeter Wemm { 1023e9eabf59SPeter Wemm elf_file_t ef = (elf_file_t)lf; 1024f41325dbSPeter Wemm void **start, **stop; 1025e9eabf59SPeter Wemm int i, count; 1026f41325dbSPeter Wemm 1027e9eabf59SPeter Wemm /* Relative to section number */ 1028e9eabf59SPeter Wemm for (i = 0; i < ef->nprogtab; i++) { 1029e9eabf59SPeter Wemm if ((strncmp(ef->progtab[i].name, "set_", 4) == 0) && 1030e9eabf59SPeter Wemm strcmp(ef->progtab[i].name + 4, name) == 0) { 1031e9eabf59SPeter Wemm start = (void **)ef->progtab[i].addr; 103220947801SPeter Wemm stop = (void **)((char *)ef->progtab[i].addr + 103320947801SPeter Wemm ef->progtab[i].size); 1034f41325dbSPeter Wemm count = stop - start; 1035f41325dbSPeter Wemm if (startp) 1036f41325dbSPeter Wemm *startp = start; 1037f41325dbSPeter Wemm if (stopp) 1038f41325dbSPeter Wemm *stopp = stop; 1039f41325dbSPeter Wemm if (countp) 1040f41325dbSPeter Wemm *countp = count; 1041e9eabf59SPeter Wemm return (0); 1042e9eabf59SPeter Wemm } 1043e9eabf59SPeter Wemm } 1044e9eabf59SPeter Wemm return (ESRCH); 1045f41325dbSPeter Wemm } 1046bb9fe9ddSBrian Feldman 1047bb9fe9ddSBrian Feldman static int 1048bb9fe9ddSBrian Feldman link_elf_each_function_name(linker_file_t file, 1049e9eabf59SPeter Wemm int (*callback)(const char *, void *), void *opaque) 1050e9eabf59SPeter Wemm { 1051bb9fe9ddSBrian Feldman elf_file_t ef = (elf_file_t)file; 1052bb9fe9ddSBrian Feldman const Elf_Sym *symp; 1053bb9fe9ddSBrian Feldman int i, error; 1054bb9fe9ddSBrian Feldman 1055bb9fe9ddSBrian Feldman /* Exhaustive search */ 1056bb9fe9ddSBrian Feldman for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) { 1057bb9fe9ddSBrian Feldman if (symp->st_value != 0 && 1058bb9fe9ddSBrian Feldman ELF_ST_TYPE(symp->st_info) == STT_FUNC) { 1059bb9fe9ddSBrian Feldman error = callback(ef->ddbstrtab + symp->st_name, opaque); 1060bb9fe9ddSBrian Feldman if (error) 1061bb9fe9ddSBrian Feldman return (error); 1062bb9fe9ddSBrian Feldman } 1063bb9fe9ddSBrian Feldman } 1064bb9fe9ddSBrian Feldman return (0); 1065bb9fe9ddSBrian Feldman } 106684201059SMarcel Moolenaar 1067d297ad16SMarcel Moolenaar /* 1068d297ad16SMarcel Moolenaar * Symbol lookup function that can be used when the symbol index is known (ie 1069d297ad16SMarcel Moolenaar * in relocations). It uses the symbol index instead of doing a fully fledged 1070d297ad16SMarcel Moolenaar * hash table based lookup when such is valid. For example for local symbols. 1071d297ad16SMarcel Moolenaar * This is not only more efficient, it's also more correct. It's not always 1072d297ad16SMarcel Moolenaar * the case that the symbol can be found through the hash table. 1073d297ad16SMarcel Moolenaar */ 1074e9eabf59SPeter Wemm static Elf_Addr 1075757686b1SMarcel Moolenaar elf_obj_lookup(linker_file_t lf, Elf_Size symidx, int deps) 1076d297ad16SMarcel Moolenaar { 1077d297ad16SMarcel Moolenaar elf_file_t ef = (elf_file_t)lf; 1078d297ad16SMarcel Moolenaar const Elf_Sym *sym; 1079d297ad16SMarcel Moolenaar const char *symbol; 1080e9eabf59SPeter Wemm Elf_Addr ret; 1081d297ad16SMarcel Moolenaar 1082d297ad16SMarcel Moolenaar /* Don't even try to lookup the symbol if the index is bogus. */ 1083e9eabf59SPeter Wemm if (symidx >= ef->ddbsymcnt) 1084d297ad16SMarcel Moolenaar return (0); 1085d297ad16SMarcel Moolenaar 1086e9eabf59SPeter Wemm sym = ef->ddbsymtab + symidx; 1087d297ad16SMarcel Moolenaar 10884cec6f5dSPeter Wemm /* Quick answer if there is a definition included. */ 1089a8774e39SPeter Wemm if (sym->st_shndx != SHN_UNDEF) 1090a8774e39SPeter Wemm return (sym->st_value); 10914cec6f5dSPeter Wemm 10924cec6f5dSPeter Wemm /* If we get here, then it is undefined and needs a lookup. */ 10934cec6f5dSPeter Wemm switch (ELF_ST_BIND(sym->st_info)) { 10944cec6f5dSPeter Wemm case STB_LOCAL: 10954cec6f5dSPeter Wemm /* Local, but undefined? huh? */ 10964cec6f5dSPeter Wemm return (0); 1097d297ad16SMarcel Moolenaar 1098e9eabf59SPeter Wemm case STB_GLOBAL: 1099e9eabf59SPeter Wemm /* Relative to Data or Function name */ 1100e9eabf59SPeter Wemm symbol = ef->ddbstrtab + sym->st_name; 1101d297ad16SMarcel Moolenaar 1102d297ad16SMarcel Moolenaar /* Force a lookup failure if the symbol name is bogus. */ 1103d297ad16SMarcel Moolenaar if (*symbol == 0) 1104d297ad16SMarcel Moolenaar return (0); 1105e9eabf59SPeter Wemm ret = ((Elf_Addr)linker_file_lookup_symbol(lf, symbol, deps)); 1106e9eabf59SPeter Wemm return ret; 1107d297ad16SMarcel Moolenaar 1108e9eabf59SPeter Wemm case STB_WEAK: 110920947801SPeter Wemm printf("link_elf_obj: Weak symbols not supported\n"); 1110e9eabf59SPeter Wemm return (0); 1111e9eabf59SPeter Wemm 1112e9eabf59SPeter Wemm default: 1113e9eabf59SPeter Wemm return (0); 1114d297ad16SMarcel Moolenaar } 1115e9eabf59SPeter Wemm } 1116e9eabf59SPeter Wemm 11177251b4bfSJake Burkholder static void 11187226306eSKonstantin Belousov link_elf_fix_link_set(elf_file_t ef) 11197226306eSKonstantin Belousov { 11207226306eSKonstantin Belousov static const char startn[] = "__start_"; 11217226306eSKonstantin Belousov static const char stopn[] = "__stop_"; 11227226306eSKonstantin Belousov Elf_Sym *sym; 11237226306eSKonstantin Belousov const char *sym_name, *linkset_name; 11247226306eSKonstantin Belousov Elf_Addr startp, stopp; 11257226306eSKonstantin Belousov Elf_Size symidx; 11267226306eSKonstantin Belousov int start, i; 11277226306eSKonstantin Belousov 11287226306eSKonstantin Belousov startp = stopp = 0; 11297226306eSKonstantin Belousov for (symidx = 1 /* zero entry is special */; 11307226306eSKonstantin Belousov symidx < ef->ddbsymcnt; symidx++) { 11317226306eSKonstantin Belousov sym = ef->ddbsymtab + symidx; 11327226306eSKonstantin Belousov if (sym->st_shndx != SHN_UNDEF) 11337226306eSKonstantin Belousov continue; 11347226306eSKonstantin Belousov 11357226306eSKonstantin Belousov sym_name = ef->ddbstrtab + sym->st_name; 11367226306eSKonstantin Belousov if (strncmp(sym_name, startn, sizeof(startn) - 1) == 0) { 11377226306eSKonstantin Belousov start = 1; 11387226306eSKonstantin Belousov linkset_name = sym_name + sizeof(startn) - 1; 11397226306eSKonstantin Belousov } 11407226306eSKonstantin Belousov else if (strncmp(sym_name, stopn, sizeof(stopn) - 1) == 0) { 11417226306eSKonstantin Belousov start = 0; 11427226306eSKonstantin Belousov linkset_name = sym_name + sizeof(stopn) - 1; 11437226306eSKonstantin Belousov } 11447226306eSKonstantin Belousov else 11457226306eSKonstantin Belousov continue; 11467226306eSKonstantin Belousov 11477226306eSKonstantin Belousov for (i = 0; i < ef->nprogtab; i++) { 11487226306eSKonstantin Belousov if (strcmp(ef->progtab[i].name, linkset_name) == 0) { 11497226306eSKonstantin Belousov startp = (Elf_Addr)ef->progtab[i].addr; 11507226306eSKonstantin Belousov stopp = (Elf_Addr)(startp + ef->progtab[i].size); 11517226306eSKonstantin Belousov break; 11527226306eSKonstantin Belousov } 11537226306eSKonstantin Belousov } 11547226306eSKonstantin Belousov if (i == ef->nprogtab) 11557226306eSKonstantin Belousov continue; 11567226306eSKonstantin Belousov 11577226306eSKonstantin Belousov sym->st_value = start ? startp : stopp; 11587226306eSKonstantin Belousov sym->st_shndx = i; 11597226306eSKonstantin Belousov } 11607226306eSKonstantin Belousov } 11617226306eSKonstantin Belousov 11627226306eSKonstantin Belousov static void 11637251b4bfSJake Burkholder link_elf_reloc_local(linker_file_t lf) 11647251b4bfSJake Burkholder { 1165e9eabf59SPeter Wemm elf_file_t ef = (elf_file_t)lf; 11667251b4bfSJake Burkholder const Elf_Rel *rellim; 11677251b4bfSJake Burkholder const Elf_Rel *rel; 11687251b4bfSJake Burkholder const Elf_Rela *relalim; 11697251b4bfSJake Burkholder const Elf_Rela *rela; 1170e9eabf59SPeter Wemm const Elf_Sym *sym; 1171e9eabf59SPeter Wemm Elf_Addr base; 1172e9eabf59SPeter Wemm int i; 1173757686b1SMarcel Moolenaar Elf_Size symidx; 1174e9eabf59SPeter Wemm 11757226306eSKonstantin Belousov link_elf_fix_link_set(ef); 11767226306eSKonstantin Belousov 11777251b4bfSJake Burkholder /* Perform relocations without addend if there are any: */ 1178e9eabf59SPeter Wemm for (i = 0; i < ef->nrel; i++) { 1179e9eabf59SPeter Wemm rel = ef->reltab[i].rel; 118020947801SPeter Wemm if (rel == NULL) 118182d0d1a0SPeter Wemm panic("lost a reltab!"); 118220947801SPeter Wemm rellim = rel + ef->reltab[i].nrel; 1183e9eabf59SPeter Wemm base = findbase(ef, ef->reltab[i].sec); 1184a8774e39SPeter Wemm if (base == 0) 1185a8774e39SPeter Wemm panic("lost base for reltab"); 118620947801SPeter Wemm for ( ; rel < rellim; rel++) { 1187e9eabf59SPeter Wemm symidx = ELF_R_SYM(rel->r_info); 118820947801SPeter Wemm if (symidx >= ef->ddbsymcnt) 118920947801SPeter Wemm continue; 1190e9eabf59SPeter Wemm sym = ef->ddbsymtab + symidx; 119120947801SPeter Wemm /* Only do local relocs */ 119220947801SPeter Wemm if (ELF_ST_BIND(sym->st_info) != STB_LOCAL) 119320947801SPeter Wemm continue; 119420947801SPeter Wemm elf_reloc_local(lf, base, rel, ELF_RELOC_REL, 119520947801SPeter Wemm elf_obj_lookup); 11967251b4bfSJake Burkholder } 1197e9eabf59SPeter Wemm } 11987251b4bfSJake Burkholder 11997251b4bfSJake Burkholder /* Perform relocations with addend if there are any: */ 1200e9eabf59SPeter Wemm for (i = 0; i < ef->nrela; i++) { 1201e9eabf59SPeter Wemm rela = ef->relatab[i].rela; 120220947801SPeter Wemm if (rela == NULL) 120382d0d1a0SPeter Wemm panic("lost a relatab!"); 120420947801SPeter Wemm relalim = rela + ef->relatab[i].nrela; 1205e9eabf59SPeter Wemm base = findbase(ef, ef->relatab[i].sec); 1206a8774e39SPeter Wemm if (base == 0) 1207a8774e39SPeter Wemm panic("lost base for relatab"); 120820947801SPeter Wemm for ( ; rela < relalim; rela++) { 1209e9eabf59SPeter Wemm symidx = ELF_R_SYM(rela->r_info); 121020947801SPeter Wemm if (symidx >= ef->ddbsymcnt) 121120947801SPeter Wemm continue; 1212e9eabf59SPeter Wemm sym = ef->ddbsymtab + symidx; 121320947801SPeter Wemm /* Only do local relocs */ 121420947801SPeter Wemm if (ELF_ST_BIND(sym->st_info) != STB_LOCAL) 121520947801SPeter Wemm continue; 121620947801SPeter Wemm elf_reloc_local(lf, base, rela, ELF_RELOC_RELA, 121720947801SPeter Wemm elf_obj_lookup); 12187251b4bfSJake Burkholder } 12197251b4bfSJake Burkholder } 1220e9eabf59SPeter Wemm } 1221