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" 32326e27d8SDoug Rabson 33a4f67738SDoug Rabson #include <sys/param.h> 34a4f67738SDoug Rabson #include <sys/systm.h> 35fb919e4dSMark Murray #include <sys/kernel.h> 36fb919e4dSMark Murray #include <sys/lock.h> 37a4f67738SDoug Rabson #include <sys/malloc.h> 38c0b824f9SDima Dorfman #include <sys/mutex.h> 3962d615d5SJohn Baldwin #include <sys/mount.h> 40a4f67738SDoug Rabson #include <sys/proc.h> 41a4f67738SDoug Rabson #include <sys/namei.h> 42a4f67738SDoug Rabson #include <sys/fcntl.h> 43a4f67738SDoug Rabson #include <sys/vnode.h> 44a4f67738SDoug Rabson #include <sys/linker.h> 45fb919e4dSMark Murray 46a4f67738SDoug Rabson #include <machine/elf.h> 47a4f67738SDoug Rabson 48aed55708SRobert Watson #include <security/mac/mac_framework.h> 49aed55708SRobert Watson 50fe3db7c7SDoug Rabson #include <vm/vm.h> 51fe3db7c7SDoug Rabson #include <vm/vm_param.h> 52fe3db7c7SDoug Rabson #include <vm/vm_object.h> 53fe3db7c7SDoug Rabson #include <vm/vm_kern.h> 54fe3db7c7SDoug Rabson #include <vm/vm_extern.h> 55fe3db7c7SDoug Rabson #include <vm/pmap.h> 56fe3db7c7SDoug Rabson #include <vm/vm_map.h> 57fb919e4dSMark Murray 58f9980387SPeter Wemm #include <sys/link_elf.h> 59fe3db7c7SDoug Rabson 60a2024a3eSJohn Birrell #ifdef DDB_CTF 61a2024a3eSJohn Birrell #include <net/zlib.h> 62a2024a3eSJohn Birrell #endif 63a2024a3eSJohn Birrell 64326e27d8SDoug Rabson #include "linker_if.h" 65a4f67738SDoug Rabson 66e9eabf59SPeter Wemm typedef struct { 67e9eabf59SPeter Wemm void *addr; 6820947801SPeter Wemm Elf_Off size; 69e9eabf59SPeter Wemm int flags; 70e9eabf59SPeter Wemm int sec; /* Original section */ 71e9eabf59SPeter Wemm char *name; 72e9eabf59SPeter Wemm } Elf_progent; 73e9eabf59SPeter Wemm 74e9eabf59SPeter Wemm typedef struct { 75e9eabf59SPeter Wemm Elf_Rel *rel; 7620947801SPeter Wemm int nrel; 77e9eabf59SPeter Wemm int sec; 78e9eabf59SPeter Wemm } Elf_relent; 79e9eabf59SPeter Wemm 80e9eabf59SPeter Wemm typedef struct { 81e9eabf59SPeter Wemm Elf_Rela *rela; 8220947801SPeter Wemm int nrela; 83e9eabf59SPeter Wemm int sec; 84e9eabf59SPeter Wemm } Elf_relaent; 85e9eabf59SPeter Wemm 86e9eabf59SPeter Wemm 87a4f67738SDoug Rabson typedef struct elf_file { 88326e27d8SDoug Rabson struct linker_file lf; /* Common fields */ 8920947801SPeter Wemm 9070b7ffeeSIan Dowse int preloaded; 91fe3db7c7SDoug Rabson caddr_t address; /* Relocation address */ 92fe3db7c7SDoug Rabson vm_object_t object; /* VM object to hold file pages */ 93e9eabf59SPeter Wemm Elf_Shdr *e_shdr; 94e9eabf59SPeter Wemm 95e9eabf59SPeter Wemm Elf_progent *progtab; 96e9eabf59SPeter Wemm int nprogtab; 97e9eabf59SPeter Wemm 98e9eabf59SPeter Wemm Elf_relaent *relatab; 99b474c780SDavid E. O'Brien int nrelatab; 100e9eabf59SPeter Wemm 101e9eabf59SPeter Wemm Elf_relent *reltab; 102b474c780SDavid E. O'Brien int nreltab; 103e9eabf59SPeter Wemm 104e9eabf59SPeter Wemm Elf_Sym *ddbsymtab; /* The symbol table we are using */ 1052d636ab0SPeter Wemm long ddbsymcnt; /* Number of symbols */ 1062d636ab0SPeter Wemm caddr_t ddbstrtab; /* String table */ 1072d636ab0SPeter Wemm long ddbstrcnt; /* number of bytes in string table */ 108e9eabf59SPeter Wemm 109e9eabf59SPeter Wemm caddr_t shstrtab; /* Section name string table */ 110e9eabf59SPeter Wemm long shstrcnt; /* number of bytes in string table */ 111e9eabf59SPeter Wemm 112a2024a3eSJohn Birrell caddr_t ctftab; /* CTF table */ 113a2024a3eSJohn Birrell long ctfcnt; /* number of bytes in CTF table */ 114a2024a3eSJohn Birrell caddr_t ctfoff; /* CTF offset table */ 115a2024a3eSJohn Birrell caddr_t typoff; /* Type offset table */ 116a2024a3eSJohn Birrell long typlen; /* Number of type entries. */ 117a2024a3eSJohn Birrell 118a4f67738SDoug Rabson } *elf_file_t; 119a4f67738SDoug Rabson 120a2024a3eSJohn Birrell #include <kern/kern_ctf.c> 121a2024a3eSJohn Birrell 12254823af2SPeter Wemm static int link_elf_link_preload(linker_class_t cls, 123326e27d8SDoug Rabson const char *, linker_file_t *); 12454823af2SPeter Wemm static int link_elf_link_preload_finish(linker_file_t); 12554823af2SPeter Wemm static int link_elf_load_file(linker_class_t, const char *, linker_file_t *); 126326e27d8SDoug Rabson static int link_elf_lookup_symbol(linker_file_t, const char *, 127326e27d8SDoug Rabson c_linker_sym_t *); 128e9eabf59SPeter Wemm static int link_elf_symbol_values(linker_file_t, c_linker_sym_t, 129e9eabf59SPeter Wemm linker_symval_t *); 130326e27d8SDoug Rabson static int link_elf_search_symbol(linker_file_t, caddr_t value, 131326e27d8SDoug Rabson c_linker_sym_t *sym, long *diffp); 132326e27d8SDoug Rabson 133326e27d8SDoug Rabson static void link_elf_unload_file(linker_file_t); 134f41325dbSPeter Wemm static int link_elf_lookup_set(linker_file_t, const char *, 135f41325dbSPeter Wemm void ***, void ***, int *); 136bb9fe9ddSBrian Feldman static int link_elf_each_function_name(linker_file_t, 137e9eabf59SPeter Wemm int (*)(const char *, void *), void *); 138a2024a3eSJohn Birrell static int link_elf_each_function_nameval(linker_file_t, 139a2024a3eSJohn Birrell linker_function_nameval_callback_t, 140a2024a3eSJohn Birrell void *); 1417251b4bfSJake Burkholder static void link_elf_reloc_local(linker_file_t); 142e76f11f4SAndriy Gapon static long link_elf_symtab_get(linker_file_t, const Elf_Sym **); 14300a5db46SStacey Son static long link_elf_strtab_get(linker_file_t, caddr_t *); 144326e27d8SDoug Rabson 145757686b1SMarcel Moolenaar static Elf_Addr elf_obj_lookup(linker_file_t lf, Elf_Size symidx, int deps); 146e9eabf59SPeter Wemm 147326e27d8SDoug Rabson static kobj_method_t link_elf_methods[] = { 148326e27d8SDoug Rabson KOBJMETHOD(linker_lookup_symbol, link_elf_lookup_symbol), 149326e27d8SDoug Rabson KOBJMETHOD(linker_symbol_values, link_elf_symbol_values), 150326e27d8SDoug Rabson KOBJMETHOD(linker_search_symbol, link_elf_search_symbol), 151326e27d8SDoug Rabson KOBJMETHOD(linker_unload, link_elf_unload_file), 15254823af2SPeter Wemm KOBJMETHOD(linker_load_file, link_elf_load_file), 15354823af2SPeter Wemm KOBJMETHOD(linker_link_preload, link_elf_link_preload), 15454823af2SPeter Wemm KOBJMETHOD(linker_link_preload_finish, link_elf_link_preload_finish), 155f41325dbSPeter Wemm KOBJMETHOD(linker_lookup_set, link_elf_lookup_set), 156bb9fe9ddSBrian Feldman KOBJMETHOD(linker_each_function_name, link_elf_each_function_name), 157a2024a3eSJohn Birrell KOBJMETHOD(linker_each_function_nameval, link_elf_each_function_nameval), 158a2024a3eSJohn Birrell KOBJMETHOD(linker_ctf_get, link_elf_ctf_get), 15900a5db46SStacey Son KOBJMETHOD(linker_symtab_get, link_elf_symtab_get), 16000a5db46SStacey Son KOBJMETHOD(linker_strtab_get, link_elf_strtab_get), 161326e27d8SDoug Rabson { 0, 0 } 162326e27d8SDoug Rabson }; 163326e27d8SDoug Rabson 164326e27d8SDoug Rabson static struct linker_class link_elf_class = { 165326e27d8SDoug Rabson #if ELF_TARG_CLASS == ELFCLASS32 166e9eabf59SPeter Wemm "elf32_obj", 167326e27d8SDoug Rabson #else 168e9eabf59SPeter Wemm "elf64_obj", 169326e27d8SDoug Rabson #endif 170326e27d8SDoug Rabson link_elf_methods, sizeof(struct elf_file) 171326e27d8SDoug Rabson }; 172326e27d8SDoug Rabson 173326e27d8SDoug Rabson static int relocate_file(elf_file_t ef); 174a4f67738SDoug Rabson 175a4f67738SDoug Rabson static void 176552f9f63SEdwin Groothuis link_elf_error(const char *filename, const char *s) 1771720979bSMarcel Moolenaar { 178552f9f63SEdwin Groothuis if (filename == NULL) 1791720979bSMarcel Moolenaar printf("kldload: %s\n", s); 180552f9f63SEdwin Groothuis else 181552f9f63SEdwin Groothuis printf("kldload: %s: %s\n", filename, s); 1821720979bSMarcel Moolenaar } 1831720979bSMarcel Moolenaar 1841720979bSMarcel Moolenaar static void 185a4f67738SDoug Rabson link_elf_init(void *arg) 186a4f67738SDoug Rabson { 187a4f67738SDoug Rabson 188326e27d8SDoug Rabson linker_add_class(&link_elf_class); 189a4f67738SDoug Rabson } 190a4f67738SDoug Rabson 191e9eabf59SPeter Wemm SYSINIT(link_elf_obj, SI_SUB_KLD, SI_ORDER_SECOND, link_elf_init, 0); 192a4f67738SDoug Rabson 193a4f67738SDoug Rabson static int 194e9eabf59SPeter Wemm link_elf_link_preload(linker_class_t cls, const char *filename, 195e9eabf59SPeter Wemm linker_file_t *result) 1962d636ab0SPeter Wemm { 19770b7ffeeSIan Dowse Elf_Ehdr *hdr; 19870b7ffeeSIan Dowse Elf_Shdr *shdr; 19970b7ffeeSIan Dowse Elf_Sym *es; 20070b7ffeeSIan Dowse void *modptr, *baseptr, *sizeptr; 20170b7ffeeSIan Dowse char *type; 20270b7ffeeSIan Dowse elf_file_t ef; 20370b7ffeeSIan Dowse linker_file_t lf; 20470b7ffeeSIan Dowse Elf_Addr off; 20570b7ffeeSIan Dowse int error, i, j, pb, ra, rl, shstrindex, symstrindex, symtabindex; 20670b7ffeeSIan Dowse 20770b7ffeeSIan Dowse /* Look to see if we have the file preloaded */ 20870b7ffeeSIan Dowse modptr = preload_search_by_name(filename); 20970b7ffeeSIan Dowse if (modptr == NULL) 21070b7ffeeSIan Dowse return ENOENT; 21170b7ffeeSIan Dowse 21270b7ffeeSIan Dowse type = (char *)preload_search_info(modptr, MODINFO_TYPE); 21370b7ffeeSIan Dowse baseptr = preload_search_info(modptr, MODINFO_ADDR); 21470b7ffeeSIan Dowse sizeptr = preload_search_info(modptr, MODINFO_SIZE); 21570b7ffeeSIan Dowse hdr = (Elf_Ehdr *)preload_search_info(modptr, MODINFO_METADATA | 21670b7ffeeSIan Dowse MODINFOMD_ELFHDR); 21770b7ffeeSIan Dowse shdr = (Elf_Shdr *)preload_search_info(modptr, MODINFO_METADATA | 21870b7ffeeSIan Dowse MODINFOMD_SHDR); 21970b7ffeeSIan Dowse if (type == NULL || (strcmp(type, "elf" __XSTRING(__ELF_WORD_SIZE) 22070b7ffeeSIan Dowse " obj module") != 0 && 22170b7ffeeSIan Dowse strcmp(type, "elf obj module") != 0)) { 222de78ca7eSPeter Wemm return (EFTYPE); 223de78ca7eSPeter Wemm } 22470b7ffeeSIan Dowse if (baseptr == NULL || sizeptr == NULL || hdr == NULL || 22570b7ffeeSIan Dowse shdr == NULL) 22670b7ffeeSIan Dowse return (EINVAL); 22770b7ffeeSIan Dowse 22870b7ffeeSIan Dowse lf = linker_make_file(filename, &link_elf_class); 22970b7ffeeSIan Dowse if (lf == NULL) 23070b7ffeeSIan Dowse return (ENOMEM); 23170b7ffeeSIan Dowse 23270b7ffeeSIan Dowse ef = (elf_file_t)lf; 23370b7ffeeSIan Dowse ef->preloaded = 1; 23470b7ffeeSIan Dowse ef->address = *(caddr_t *)baseptr; 23570b7ffeeSIan Dowse lf->address = *(caddr_t *)baseptr; 23670b7ffeeSIan Dowse lf->size = *(size_t *)sizeptr; 23770b7ffeeSIan Dowse 23870b7ffeeSIan Dowse if (hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS || 23970b7ffeeSIan Dowse hdr->e_ident[EI_DATA] != ELF_TARG_DATA || 24070b7ffeeSIan Dowse hdr->e_ident[EI_VERSION] != EV_CURRENT || 24170b7ffeeSIan Dowse hdr->e_version != EV_CURRENT || 24270b7ffeeSIan Dowse hdr->e_type != ET_REL || 24370b7ffeeSIan Dowse hdr->e_machine != ELF_TARG_MACH) { 24470b7ffeeSIan Dowse error = EFTYPE; 24570b7ffeeSIan Dowse goto out; 24670b7ffeeSIan Dowse } 24770b7ffeeSIan Dowse ef->e_shdr = shdr; 24870b7ffeeSIan Dowse 24970b7ffeeSIan Dowse /* Scan the section header for information and table sizing. */ 25070b7ffeeSIan Dowse symtabindex = -1; 25170b7ffeeSIan Dowse symstrindex = -1; 25270b7ffeeSIan Dowse for (i = 0; i < hdr->e_shnum; i++) { 25370b7ffeeSIan Dowse switch (shdr[i].sh_type) { 25470b7ffeeSIan Dowse case SHT_PROGBITS: 25570b7ffeeSIan Dowse case SHT_NOBITS: 25670b7ffeeSIan Dowse ef->nprogtab++; 25770b7ffeeSIan Dowse break; 25870b7ffeeSIan Dowse case SHT_SYMTAB: 25970b7ffeeSIan Dowse symtabindex = i; 26070b7ffeeSIan Dowse symstrindex = shdr[i].sh_link; 26170b7ffeeSIan Dowse break; 26270b7ffeeSIan Dowse case SHT_REL: 263b474c780SDavid E. O'Brien ef->nreltab++; 26470b7ffeeSIan Dowse break; 26570b7ffeeSIan Dowse case SHT_RELA: 266b474c780SDavid E. O'Brien ef->nrelatab++; 26770b7ffeeSIan Dowse break; 26870b7ffeeSIan Dowse } 26970b7ffeeSIan Dowse } 27070b7ffeeSIan Dowse 27170b7ffeeSIan Dowse shstrindex = hdr->e_shstrndx; 27270b7ffeeSIan Dowse if (ef->nprogtab == 0 || symstrindex < 0 || 27370b7ffeeSIan Dowse symstrindex >= hdr->e_shnum || 27470b7ffeeSIan Dowse shdr[symstrindex].sh_type != SHT_STRTAB || shstrindex == 0 || 27570b7ffeeSIan Dowse shstrindex >= hdr->e_shnum || 27670b7ffeeSIan Dowse shdr[shstrindex].sh_type != SHT_STRTAB) { 27770b7ffeeSIan Dowse printf("%s: bad/missing section headers\n", filename); 27870b7ffeeSIan Dowse error = ENOEXEC; 27970b7ffeeSIan Dowse goto out; 28070b7ffeeSIan Dowse } 28170b7ffeeSIan Dowse 28270b7ffeeSIan Dowse /* Allocate space for tracking the load chunks */ 28370b7ffeeSIan Dowse if (ef->nprogtab != 0) 28470b7ffeeSIan Dowse ef->progtab = malloc(ef->nprogtab * sizeof(*ef->progtab), 28570b7ffeeSIan Dowse M_LINKER, M_WAITOK | M_ZERO); 286b474c780SDavid E. O'Brien if (ef->nreltab != 0) 287b474c780SDavid E. O'Brien ef->reltab = malloc(ef->nreltab * sizeof(*ef->reltab), 288b474c780SDavid E. O'Brien M_LINKER, M_WAITOK | M_ZERO); 289b474c780SDavid E. O'Brien if (ef->nrelatab != 0) 290b474c780SDavid E. O'Brien ef->relatab = malloc(ef->nrelatab * sizeof(*ef->relatab), 291b474c780SDavid E. O'Brien M_LINKER, M_WAITOK | M_ZERO); 29270b7ffeeSIan Dowse if ((ef->nprogtab != 0 && ef->progtab == NULL) || 293b474c780SDavid E. O'Brien (ef->nreltab != 0 && ef->reltab == NULL) || 294b474c780SDavid E. O'Brien (ef->nrelatab != 0 && ef->relatab == NULL)) { 29570b7ffeeSIan Dowse error = ENOMEM; 29670b7ffeeSIan Dowse goto out; 29770b7ffeeSIan Dowse } 29870b7ffeeSIan Dowse 29970b7ffeeSIan Dowse /* XXX, relocate the sh_addr fields saved by the loader. */ 30070b7ffeeSIan Dowse off = 0; 30170b7ffeeSIan Dowse for (i = 0; i < hdr->e_shnum; i++) { 30270b7ffeeSIan Dowse if (shdr[i].sh_addr != 0 && (off == 0 || shdr[i].sh_addr < off)) 30370b7ffeeSIan Dowse off = shdr[i].sh_addr; 30470b7ffeeSIan Dowse } 30570b7ffeeSIan Dowse for (i = 0; i < hdr->e_shnum; i++) { 30670b7ffeeSIan Dowse if (shdr[i].sh_addr != 0) 30770b7ffeeSIan Dowse shdr[i].sh_addr = shdr[i].sh_addr - off + 30870b7ffeeSIan Dowse (Elf_Addr)ef->address; 30970b7ffeeSIan Dowse } 31070b7ffeeSIan Dowse 31170b7ffeeSIan Dowse ef->ddbsymcnt = shdr[symtabindex].sh_size / sizeof(Elf_Sym); 31270b7ffeeSIan Dowse ef->ddbsymtab = (Elf_Sym *)shdr[symtabindex].sh_addr; 31370b7ffeeSIan Dowse ef->ddbstrcnt = shdr[symstrindex].sh_size; 31470b7ffeeSIan Dowse ef->ddbstrtab = (char *)shdr[symstrindex].sh_addr; 31570b7ffeeSIan Dowse ef->shstrcnt = shdr[shstrindex].sh_size; 31670b7ffeeSIan Dowse ef->shstrtab = (char *)shdr[shstrindex].sh_addr; 31770b7ffeeSIan Dowse 31870b7ffeeSIan Dowse /* Now fill out progtab and the relocation tables. */ 31970b7ffeeSIan Dowse pb = 0; 32070b7ffeeSIan Dowse rl = 0; 32170b7ffeeSIan Dowse ra = 0; 32270b7ffeeSIan Dowse for (i = 0; i < hdr->e_shnum; i++) { 32370b7ffeeSIan Dowse switch (shdr[i].sh_type) { 32470b7ffeeSIan Dowse case SHT_PROGBITS: 32570b7ffeeSIan Dowse case SHT_NOBITS: 32670b7ffeeSIan Dowse ef->progtab[pb].addr = (void *)shdr[i].sh_addr; 32770b7ffeeSIan Dowse if (shdr[i].sh_type == SHT_PROGBITS) 32870b7ffeeSIan Dowse ef->progtab[pb].name = "<<PROGBITS>>"; 32970b7ffeeSIan Dowse else 33070b7ffeeSIan Dowse ef->progtab[pb].name = "<<NOBITS>>"; 33170b7ffeeSIan Dowse ef->progtab[pb].size = shdr[i].sh_size; 33270b7ffeeSIan Dowse ef->progtab[pb].sec = i; 33370b7ffeeSIan Dowse if (ef->shstrtab && shdr[i].sh_name != 0) 33470b7ffeeSIan Dowse ef->progtab[pb].name = 33570b7ffeeSIan Dowse ef->shstrtab + shdr[i].sh_name; 33650c202c5SJeff Roberson if (ef->progtab[pb].name != NULL && 33750c202c5SJeff Roberson !strcmp(ef->progtab[pb].name, "set_pcpu")) { 33850c202c5SJeff Roberson void *dpcpu; 33950c202c5SJeff Roberson 34050c202c5SJeff Roberson dpcpu = dpcpu_alloc(shdr[i].sh_size); 34150c202c5SJeff Roberson if (dpcpu == NULL) { 34250c202c5SJeff Roberson error = ENOSPC; 34350c202c5SJeff Roberson goto out; 34450c202c5SJeff Roberson } 34550c202c5SJeff Roberson memcpy(dpcpu, ef->progtab[pb].addr, 34650c202c5SJeff Roberson ef->progtab[pb].size); 34750c202c5SJeff Roberson dpcpu_copy(dpcpu, shdr[i].sh_size); 34850c202c5SJeff Roberson ef->progtab[pb].addr = dpcpu; 34950c202c5SJeff Roberson } 35070b7ffeeSIan Dowse 35170b7ffeeSIan Dowse /* Update all symbol values with the offset. */ 35270b7ffeeSIan Dowse for (j = 0; j < ef->ddbsymcnt; j++) { 35370b7ffeeSIan Dowse es = &ef->ddbsymtab[j]; 35470b7ffeeSIan Dowse if (es->st_shndx != i) 35570b7ffeeSIan Dowse continue; 35670b7ffeeSIan Dowse es->st_value += (Elf_Addr)ef->progtab[pb].addr; 35770b7ffeeSIan Dowse } 35870b7ffeeSIan Dowse pb++; 35970b7ffeeSIan Dowse break; 36070b7ffeeSIan Dowse case SHT_REL: 36170b7ffeeSIan Dowse ef->reltab[rl].rel = (Elf_Rel *)shdr[i].sh_addr; 36270b7ffeeSIan Dowse ef->reltab[rl].nrel = shdr[i].sh_size / sizeof(Elf_Rel); 36370b7ffeeSIan Dowse ef->reltab[rl].sec = shdr[i].sh_info; 36470b7ffeeSIan Dowse rl++; 36570b7ffeeSIan Dowse break; 36670b7ffeeSIan Dowse case SHT_RELA: 36770b7ffeeSIan Dowse ef->relatab[ra].rela = (Elf_Rela *)shdr[i].sh_addr; 36870b7ffeeSIan Dowse ef->relatab[ra].nrela = 36970b7ffeeSIan Dowse shdr[i].sh_size / sizeof(Elf_Rela); 37070b7ffeeSIan Dowse ef->relatab[ra].sec = shdr[i].sh_info; 37170b7ffeeSIan Dowse ra++; 37270b7ffeeSIan Dowse break; 37370b7ffeeSIan Dowse } 37470b7ffeeSIan Dowse } 37570b7ffeeSIan Dowse if (pb != ef->nprogtab) 37670b7ffeeSIan Dowse panic("lost progbits"); 377b474c780SDavid E. O'Brien if (rl != ef->nreltab) 378b474c780SDavid E. O'Brien panic("lost reltab"); 379b474c780SDavid E. O'Brien if (ra != ef->nrelatab) 380b474c780SDavid E. O'Brien panic("lost relatab"); 38170b7ffeeSIan Dowse 38270b7ffeeSIan Dowse /* Local intra-module relocations */ 38370b7ffeeSIan Dowse link_elf_reloc_local(lf); 38470b7ffeeSIan Dowse 38570b7ffeeSIan Dowse *result = lf; 38670b7ffeeSIan Dowse return (0); 38770b7ffeeSIan Dowse 38870b7ffeeSIan Dowse out: 38970b7ffeeSIan Dowse /* preload not done this way */ 39070b7ffeeSIan Dowse linker_file_unload(lf, LINKER_UNLOAD_FORCE); 39170b7ffeeSIan Dowse return (error); 39270b7ffeeSIan Dowse } 393de78ca7eSPeter Wemm 394de78ca7eSPeter Wemm static int 39554823af2SPeter Wemm link_elf_link_preload_finish(linker_file_t lf) 39654823af2SPeter Wemm { 39770b7ffeeSIan Dowse elf_file_t ef; 39870b7ffeeSIan Dowse int error; 39970b7ffeeSIan Dowse 40070b7ffeeSIan Dowse ef = (elf_file_t)lf; 40170b7ffeeSIan Dowse error = relocate_file(ef); 40270b7ffeeSIan Dowse if (error) 40370b7ffeeSIan Dowse return error; 40470b7ffeeSIan Dowse 40570b7ffeeSIan Dowse /* Notify MD code that a module is being loaded. */ 40670b7ffeeSIan Dowse error = elf_cpu_load_file(lf); 40770b7ffeeSIan Dowse if (error) 40870b7ffeeSIan Dowse return (error); 40970b7ffeeSIan Dowse 41070b7ffeeSIan Dowse return (0); 41154823af2SPeter Wemm } 41254823af2SPeter Wemm 41354823af2SPeter Wemm static int 414c143d6c2SMarcel Moolenaar link_elf_load_file(linker_class_t cls, const char *filename, 415c143d6c2SMarcel Moolenaar linker_file_t *result) 416a4f67738SDoug Rabson { 417a4f67738SDoug Rabson struct nameidata nd; 418b40ce416SJulian Elischer struct thread *td = curthread; /* XXX */ 419caab6e90SPeter Wemm Elf_Ehdr *hdr; 420e9eabf59SPeter Wemm Elf_Shdr *shdr; 421a8774e39SPeter Wemm Elf_Sym *es; 422a8774e39SPeter Wemm int nbytes, i, j; 42320947801SPeter Wemm vm_offset_t mapbase; 424fe3db7c7SDoug Rabson size_t mapsize; 425a4f67738SDoug Rabson int error = 0; 426e6796b67SKirk McKusick int resid, flags; 427a4f67738SDoug Rabson elf_file_t ef; 428a4f67738SDoug Rabson linker_file_t lf; 429ca65d5c7SPeter Wemm int symtabindex; 430ca65d5c7SPeter Wemm int symstrindex; 431e9eabf59SPeter Wemm int shstrindex; 432e9eabf59SPeter Wemm int nsym; 43320947801SPeter Wemm int pb, rl, ra; 434e9eabf59SPeter Wemm int alignmask; 43562d615d5SJohn Baldwin int vfslocked; 436ca65d5c7SPeter Wemm 437ca65d5c7SPeter Wemm shdr = NULL; 438ca65d5c7SPeter Wemm lf = NULL; 439e9eabf59SPeter Wemm mapsize = 0; 440e9eabf59SPeter Wemm hdr = NULL; 441a4f67738SDoug Rabson 44262d615d5SJohn Baldwin NDINIT(&nd, LOOKUP, FOLLOW | MPSAFE, UIO_SYSSPACE, filename, td); 443e6796b67SKirk McKusick flags = FREAD; 4449e223287SKonstantin Belousov error = vn_open(&nd, &flags, 0, NULL); 445a4f67738SDoug Rabson if (error) 446a4f67738SDoug Rabson return error; 44762d615d5SJohn Baldwin vfslocked = NDHASGIANT(&nd); 448762e6b85SEivind Eklund NDFREE(&nd, NDF_ONLY_PNBUF); 4491f49b573SRuslan Ermilov if (nd.ni_vp->v_type != VREG) { 4501f49b573SRuslan Ermilov error = ENOEXEC; 4511f49b573SRuslan Ermilov goto out; 4521f49b573SRuslan Ermilov } 453a3df768bSRobert Watson #ifdef MAC 45430d239bcSRobert Watson error = mac_kld_check_load(td->td_ucred, nd.ni_vp); 455a3df768bSRobert Watson if (error) { 456a3df768bSRobert Watson goto out; 457a3df768bSRobert Watson } 458a3df768bSRobert Watson #endif 459a4f67738SDoug Rabson 460e9eabf59SPeter Wemm /* Read the elf header from the file. */ 461e9eabf59SPeter Wemm hdr = malloc(sizeof(*hdr), M_LINKER, M_WAITOK); 462e9eabf59SPeter Wemm if (hdr == NULL) { 463caab6e90SPeter Wemm error = ENOMEM; 464caab6e90SPeter Wemm goto out; 465caab6e90SPeter Wemm } 466e9eabf59SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, (void *)hdr, sizeof(*hdr), 0, 4679ca43589SRobert Watson UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 4689ca43589SRobert Watson &resid, td); 469a4f67738SDoug Rabson if (error) 470a4f67738SDoug Rabson goto out; 471e9eabf59SPeter Wemm if (resid != 0){ 472e9eabf59SPeter Wemm error = ENOEXEC; 473e9eabf59SPeter Wemm goto out; 474e9eabf59SPeter Wemm } 475a4f67738SDoug Rabson 476caab6e90SPeter Wemm if (!IS_ELF(*hdr)) { 477fe3db7c7SDoug Rabson error = ENOEXEC; 478a4f67738SDoug Rabson goto out; 479fe3db7c7SDoug Rabson } 480fe3db7c7SDoug Rabson 481caab6e90SPeter Wemm if (hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS 482caab6e90SPeter Wemm || hdr->e_ident[EI_DATA] != ELF_TARG_DATA) { 483552f9f63SEdwin Groothuis link_elf_error(filename, "Unsupported file layout"); 484fe3db7c7SDoug Rabson error = ENOEXEC; 485fe3db7c7SDoug Rabson goto out; 486fe3db7c7SDoug Rabson } 487caab6e90SPeter Wemm if (hdr->e_ident[EI_VERSION] != EV_CURRENT 488caab6e90SPeter Wemm || hdr->e_version != EV_CURRENT) { 489552f9f63SEdwin Groothuis link_elf_error(filename, "Unsupported file version"); 490fe3db7c7SDoug Rabson error = ENOEXEC; 491fe3db7c7SDoug Rabson goto out; 492fe3db7c7SDoug Rabson } 493e9eabf59SPeter Wemm if (hdr->e_type != ET_REL) { 494a1d7ce03SAttilio Rao error = ENOSYS; 495fe3db7c7SDoug Rabson goto out; 496fe3db7c7SDoug Rabson } 497caab6e90SPeter Wemm if (hdr->e_machine != ELF_TARG_MACH) { 498552f9f63SEdwin Groothuis link_elf_error(filename, "Unsupported machine"); 499fe3db7c7SDoug Rabson error = ENOEXEC; 500fe3db7c7SDoug Rabson goto out; 501fe3db7c7SDoug Rabson } 502a4f67738SDoug Rabson 503326e27d8SDoug Rabson lf = linker_make_file(filename, &link_elf_class); 504326e27d8SDoug Rabson if (!lf) { 505326e27d8SDoug Rabson error = ENOMEM; 506326e27d8SDoug Rabson goto out; 507326e27d8SDoug Rabson } 508326e27d8SDoug Rabson ef = (elf_file_t) lf; 509e9eabf59SPeter Wemm ef->nprogtab = 0; 510e9eabf59SPeter Wemm ef->e_shdr = 0; 511b474c780SDavid E. O'Brien ef->nreltab = 0; 512b474c780SDavid E. O'Brien ef->nrelatab = 0; 513e9eabf59SPeter Wemm 514e9eabf59SPeter Wemm /* Allocate and read in the section header */ 515e9eabf59SPeter Wemm nbytes = hdr->e_shnum * hdr->e_shentsize; 516e9eabf59SPeter Wemm if (nbytes == 0 || hdr->e_shoff == 0 || 517e9eabf59SPeter Wemm hdr->e_shentsize != sizeof(Elf_Shdr)) { 518e9eabf59SPeter Wemm error = ENOEXEC; 519e9eabf59SPeter Wemm goto out; 520e9eabf59SPeter Wemm } 52120947801SPeter Wemm shdr = malloc(nbytes, M_LINKER, M_WAITOK); 522e9eabf59SPeter Wemm if (shdr == NULL) { 523e9eabf59SPeter Wemm error = ENOMEM; 524e9eabf59SPeter Wemm goto out; 525e9eabf59SPeter Wemm } 526e9eabf59SPeter Wemm ef->e_shdr = shdr; 527e9eabf59SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, (caddr_t)shdr, nbytes, hdr->e_shoff, 528e9eabf59SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, &resid, td); 529e9eabf59SPeter Wemm if (error) 530e9eabf59SPeter Wemm goto out; 531e9eabf59SPeter Wemm if (resid) { 532e9eabf59SPeter Wemm error = ENOEXEC; 533e9eabf59SPeter Wemm goto out; 534e9eabf59SPeter Wemm } 535e9eabf59SPeter Wemm 536e9eabf59SPeter Wemm /* Scan the section header for information and table sizing. */ 537e9eabf59SPeter Wemm nsym = 0; 538e9eabf59SPeter Wemm symtabindex = -1; 539e9eabf59SPeter Wemm symstrindex = -1; 540e9eabf59SPeter Wemm for (i = 0; i < hdr->e_shnum; i++) { 541e9eabf59SPeter Wemm switch (shdr[i].sh_type) { 542e9eabf59SPeter Wemm case SHT_PROGBITS: 543e9eabf59SPeter Wemm case SHT_NOBITS: 54420947801SPeter Wemm ef->nprogtab++; 545e9eabf59SPeter Wemm break; 546e9eabf59SPeter Wemm case SHT_SYMTAB: 547e9eabf59SPeter Wemm nsym++; 548e9eabf59SPeter Wemm symtabindex = i; 549e9eabf59SPeter Wemm symstrindex = shdr[i].sh_link; 550e9eabf59SPeter Wemm break; 551e9eabf59SPeter Wemm case SHT_REL: 552b474c780SDavid E. O'Brien ef->nreltab++; 553e9eabf59SPeter Wemm break; 554e9eabf59SPeter Wemm case SHT_RELA: 555b474c780SDavid E. O'Brien ef->nrelatab++; 556e9eabf59SPeter Wemm break; 557e9eabf59SPeter Wemm case SHT_STRTAB: 558e9eabf59SPeter Wemm break; 559e9eabf59SPeter Wemm } 560e9eabf59SPeter Wemm } 56120947801SPeter Wemm if (ef->nprogtab == 0) { 562552f9f63SEdwin Groothuis link_elf_error(filename, "file has no contents"); 563e9eabf59SPeter Wemm error = ENOEXEC; 564e9eabf59SPeter Wemm goto out; 565e9eabf59SPeter Wemm } 566e9eabf59SPeter Wemm if (nsym != 1) { 567e9eabf59SPeter Wemm /* Only allow one symbol table for now */ 568552f9f63SEdwin Groothuis link_elf_error(filename, "file has no valid symbol table"); 569e9eabf59SPeter Wemm error = ENOEXEC; 570e9eabf59SPeter Wemm goto out; 571e9eabf59SPeter Wemm } 572e9eabf59SPeter Wemm if (symstrindex < 0 || symstrindex > hdr->e_shnum || 573e9eabf59SPeter Wemm shdr[symstrindex].sh_type != SHT_STRTAB) { 574552f9f63SEdwin Groothuis link_elf_error(filename, "file has invalid symbol strings"); 575e9eabf59SPeter Wemm error = ENOEXEC; 576e9eabf59SPeter Wemm goto out; 577e9eabf59SPeter Wemm } 578e9eabf59SPeter Wemm 579e9eabf59SPeter Wemm /* Allocate space for tracking the load chunks */ 580e9eabf59SPeter Wemm if (ef->nprogtab != 0) 58120947801SPeter Wemm ef->progtab = malloc(ef->nprogtab * sizeof(*ef->progtab), 58220947801SPeter Wemm M_LINKER, M_WAITOK | M_ZERO); 583b474c780SDavid E. O'Brien if (ef->nreltab != 0) 584b474c780SDavid E. O'Brien ef->reltab = malloc(ef->nreltab * sizeof(*ef->reltab), 585b474c780SDavid E. O'Brien M_LINKER, M_WAITOK | M_ZERO); 586b474c780SDavid E. O'Brien if (ef->nrelatab != 0) 587b474c780SDavid E. O'Brien ef->relatab = malloc(ef->nrelatab * sizeof(*ef->relatab), 588b474c780SDavid E. O'Brien M_LINKER, M_WAITOK | M_ZERO); 58920947801SPeter Wemm if ((ef->nprogtab != 0 && ef->progtab == NULL) || 590b474c780SDavid E. O'Brien (ef->nreltab != 0 && ef->reltab == NULL) || 591b474c780SDavid E. O'Brien (ef->nrelatab != 0 && ef->relatab == NULL)) { 59220947801SPeter Wemm error = ENOMEM; 59320947801SPeter Wemm goto out; 59420947801SPeter Wemm } 595e9eabf59SPeter Wemm 59620947801SPeter Wemm if (symtabindex == -1) 59720947801SPeter Wemm panic("lost symbol table index"); 59820947801SPeter Wemm /* Allocate space for and load the symbol table */ 599e9eabf59SPeter Wemm ef->ddbsymcnt = shdr[symtabindex].sh_size / sizeof(Elf_Sym); 600e9eabf59SPeter Wemm ef->ddbsymtab = malloc(shdr[symtabindex].sh_size, M_LINKER, M_WAITOK); 60120947801SPeter Wemm if (ef->ddbsymtab == NULL) { 60220947801SPeter Wemm error = ENOMEM; 60320947801SPeter Wemm goto out; 60420947801SPeter Wemm } 60520947801SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, (void *)ef->ddbsymtab, 60620947801SPeter Wemm shdr[symtabindex].sh_size, shdr[symtabindex].sh_offset, 60720947801SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 60820947801SPeter Wemm &resid, td); 60920947801SPeter Wemm if (error) 61020947801SPeter Wemm goto out; 61120947801SPeter Wemm if (resid != 0){ 61220947801SPeter Wemm error = EINVAL; 61320947801SPeter Wemm goto out; 61420947801SPeter Wemm } 615e9eabf59SPeter Wemm 61620947801SPeter Wemm if (symstrindex == -1) 61720947801SPeter Wemm panic("lost symbol string index"); 61820947801SPeter Wemm /* Allocate space for and load the symbol strings */ 619e9eabf59SPeter Wemm ef->ddbstrcnt = shdr[symstrindex].sh_size; 620e9eabf59SPeter Wemm ef->ddbstrtab = malloc(shdr[symstrindex].sh_size, M_LINKER, M_WAITOK); 62120947801SPeter Wemm if (ef->ddbstrtab == NULL) { 622e9eabf59SPeter Wemm error = ENOMEM; 623e9eabf59SPeter Wemm goto out; 624e9eabf59SPeter Wemm } 62520947801SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, ef->ddbstrtab, 62620947801SPeter Wemm shdr[symstrindex].sh_size, shdr[symstrindex].sh_offset, 62720947801SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 62820947801SPeter Wemm &resid, td); 62920947801SPeter Wemm if (error) 63020947801SPeter Wemm goto out; 63120947801SPeter Wemm if (resid != 0){ 63220947801SPeter Wemm error = EINVAL; 63320947801SPeter Wemm goto out; 63420947801SPeter Wemm } 635e9eabf59SPeter Wemm 636e9eabf59SPeter Wemm /* Do we have a string table for the section names? */ 637e9eabf59SPeter Wemm shstrindex = -1; 63820947801SPeter Wemm if (hdr->e_shstrndx != 0 && 63920947801SPeter Wemm shdr[hdr->e_shstrndx].sh_type == SHT_STRTAB) { 640e9eabf59SPeter Wemm shstrindex = hdr->e_shstrndx; 641e9eabf59SPeter Wemm ef->shstrcnt = shdr[shstrindex].sh_size; 64220947801SPeter Wemm ef->shstrtab = malloc(shdr[shstrindex].sh_size, M_LINKER, 64320947801SPeter Wemm M_WAITOK); 644e9eabf59SPeter Wemm if (ef->shstrtab == NULL) { 645e9eabf59SPeter Wemm error = ENOMEM; 646e9eabf59SPeter Wemm goto out; 647e9eabf59SPeter Wemm } 64820947801SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, ef->shstrtab, 64920947801SPeter Wemm shdr[shstrindex].sh_size, shdr[shstrindex].sh_offset, 650e9eabf59SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 651e9eabf59SPeter Wemm &resid, td); 652e9eabf59SPeter Wemm if (error) 653e9eabf59SPeter Wemm goto out; 65420947801SPeter Wemm if (resid != 0){ 65520947801SPeter Wemm error = EINVAL; 65620947801SPeter Wemm goto out; 65720947801SPeter Wemm } 658e9eabf59SPeter Wemm } 659e9eabf59SPeter Wemm 66020947801SPeter Wemm /* Size up code/data(progbits) and bss(nobits). */ 661e9eabf59SPeter Wemm alignmask = 0; 662e9eabf59SPeter Wemm for (i = 0; i < hdr->e_shnum; i++) { 663e9eabf59SPeter Wemm switch (shdr[i].sh_type) { 664e9eabf59SPeter Wemm case SHT_PROGBITS: 665e9eabf59SPeter Wemm case SHT_NOBITS: 666e9eabf59SPeter Wemm alignmask = shdr[i].sh_addralign - 1; 667e9eabf59SPeter Wemm mapsize += alignmask; 668e9eabf59SPeter Wemm mapsize &= ~alignmask; 669e9eabf59SPeter Wemm mapsize += shdr[i].sh_size; 670e9eabf59SPeter Wemm break; 671e9eabf59SPeter Wemm } 672e9eabf59SPeter Wemm } 673e9eabf59SPeter Wemm 674e9eabf59SPeter Wemm /* 675e9eabf59SPeter Wemm * We know how much space we need for the text/data/bss/etc. 676e9eabf59SPeter Wemm * This stuff needs to be in a single chunk so that profiling etc 677e9eabf59SPeter Wemm * can get the bounds and gdb can associate offsets with modules 678e9eabf59SPeter Wemm */ 67920947801SPeter Wemm ef->object = vm_object_allocate(OBJT_DEFAULT, 68020947801SPeter Wemm round_page(mapsize) >> PAGE_SHIFT); 681fe3db7c7SDoug Rabson if (ef->object == NULL) { 682fe3db7c7SDoug Rabson error = ENOMEM; 683fe3db7c7SDoug Rabson goto out; 684fe3db7c7SDoug Rabson } 685fe3db7c7SDoug Rabson ef->address = (caddr_t) vm_map_min(kernel_map); 686ac68d1c9SAlan Cox 687ac68d1c9SAlan Cox /* 688ac68d1c9SAlan Cox * In order to satisfy amd64's architectural requirements on the 689ac68d1c9SAlan Cox * location of code and data in the kernel's address space, request a 690ac68d1c9SAlan Cox * mapping that is above the kernel. 691ac68d1c9SAlan Cox */ 692ac68d1c9SAlan Cox mapbase = KERNBASE; 69320947801SPeter Wemm error = vm_map_find(kernel_map, ef->object, 0, &mapbase, 69420947801SPeter Wemm round_page(mapsize), TRUE, VM_PROT_ALL, VM_PROT_ALL, FALSE); 695fe3db7c7SDoug Rabson if (error) { 696fe3db7c7SDoug Rabson vm_object_deallocate(ef->object); 697326e27d8SDoug Rabson ef->object = 0; 698fe3db7c7SDoug Rabson goto out; 699fe3db7c7SDoug Rabson } 70020947801SPeter Wemm 701e9eabf59SPeter Wemm /* Wire the pages */ 7027f1ef325SAlan Cox error = vm_map_wire(kernel_map, mapbase, 70320947801SPeter Wemm mapbase + round_page(mapsize), 704e9eabf59SPeter Wemm VM_MAP_WIRE_SYSTEM|VM_MAP_WIRE_NOHOLES); 7057f1ef325SAlan Cox if (error != KERN_SUCCESS) { 7067f1ef325SAlan Cox error = ENOMEM; 7077f1ef325SAlan Cox goto out; 7087f1ef325SAlan Cox } 709a4f67738SDoug Rabson 71020947801SPeter Wemm /* Inform the kld system about the situation */ 71120947801SPeter Wemm lf->address = ef->address = (caddr_t)mapbase; 71220947801SPeter Wemm lf->size = mapsize; 713e9eabf59SPeter Wemm 714e9eabf59SPeter Wemm /* 71520947801SPeter Wemm * Now load code/data(progbits), zero bss(nobits), allocate space for 71620947801SPeter Wemm * and load relocs 717e9eabf59SPeter Wemm */ 71820947801SPeter Wemm pb = 0; 71920947801SPeter Wemm rl = 0; 72020947801SPeter Wemm ra = 0; 72120947801SPeter Wemm alignmask = 0; 72220947801SPeter Wemm for (i = 0; i < hdr->e_shnum; i++) { 72320947801SPeter Wemm switch (shdr[i].sh_type) { 72420947801SPeter Wemm case SHT_PROGBITS: 72520947801SPeter Wemm case SHT_NOBITS: 72620947801SPeter Wemm alignmask = shdr[i].sh_addralign - 1; 72720947801SPeter Wemm mapbase += alignmask; 72820947801SPeter Wemm mapbase &= ~alignmask; 72950c202c5SJeff Roberson if (ef->shstrtab && shdr[i].sh_name != 0) 73050c202c5SJeff Roberson ef->progtab[pb].name = 73150c202c5SJeff Roberson ef->shstrtab + shdr[i].sh_name; 73250c202c5SJeff Roberson else if (shdr[i].sh_type == SHT_PROGBITS) 73320947801SPeter Wemm ef->progtab[pb].name = "<<PROGBITS>>"; 73450c202c5SJeff Roberson else 73550c202c5SJeff Roberson ef->progtab[pb].name = "<<NOBITS>>"; 73650c202c5SJeff Roberson if (ef->progtab[pb].name != NULL && 73750c202c5SJeff Roberson !strcmp(ef->progtab[pb].name, "set_pcpu")) 73850c202c5SJeff Roberson ef->progtab[pb].addr = 73950c202c5SJeff Roberson dpcpu_alloc(shdr[i].sh_size); 74050c202c5SJeff Roberson else 74150c202c5SJeff Roberson ef->progtab[pb].addr = 74250c202c5SJeff Roberson (void *)(uintptr_t)mapbase; 74350c202c5SJeff Roberson if (ef->progtab[pb].addr == NULL) { 74450c202c5SJeff Roberson error = ENOSPC; 74550c202c5SJeff Roberson goto out; 74650c202c5SJeff Roberson } 74750c202c5SJeff Roberson ef->progtab[pb].size = shdr[i].sh_size; 74850c202c5SJeff Roberson ef->progtab[pb].sec = i; 74950c202c5SJeff Roberson if (shdr[i].sh_type == SHT_PROGBITS) { 750e9eabf59SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, 75120947801SPeter Wemm ef->progtab[pb].addr, 75220947801SPeter Wemm shdr[i].sh_size, shdr[i].sh_offset, 75320947801SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, 75420947801SPeter Wemm NOCRED, &resid, td); 75520947801SPeter Wemm if (error) 75620947801SPeter Wemm goto out; 75720947801SPeter Wemm if (resid != 0){ 75820947801SPeter Wemm error = EINVAL; 75920947801SPeter Wemm goto out; 76020947801SPeter Wemm } 76150c202c5SJeff Roberson /* Initialize the per-cpu area. */ 76250c202c5SJeff Roberson if (ef->progtab[pb].addr != (void *)mapbase) 76350c202c5SJeff Roberson dpcpu_copy(ef->progtab[pb].addr, 76450c202c5SJeff Roberson shdr[i].sh_size); 76550c202c5SJeff Roberson } else 76620947801SPeter Wemm bzero(ef->progtab[pb].addr, shdr[i].sh_size); 767a8774e39SPeter Wemm 768a8774e39SPeter Wemm /* Update all symbol values with the offset. */ 769a8774e39SPeter Wemm for (j = 0; j < ef->ddbsymcnt; j++) { 770a8774e39SPeter Wemm es = &ef->ddbsymtab[j]; 771a8774e39SPeter Wemm if (es->st_shndx != i) 772a8774e39SPeter Wemm continue; 773a8774e39SPeter Wemm es->st_value += (Elf_Addr)ef->progtab[pb].addr; 774a8774e39SPeter Wemm } 77520947801SPeter Wemm mapbase += shdr[i].sh_size; 77620947801SPeter Wemm pb++; 77720947801SPeter Wemm break; 77820947801SPeter Wemm case SHT_REL: 77920947801SPeter Wemm ef->reltab[rl].rel = malloc(shdr[i].sh_size, M_LINKER, 78020947801SPeter Wemm M_WAITOK); 78120947801SPeter Wemm ef->reltab[rl].nrel = shdr[i].sh_size / sizeof(Elf_Rel); 78220947801SPeter Wemm ef->reltab[rl].sec = shdr[i].sh_info; 78320947801SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, 78420947801SPeter Wemm (void *)ef->reltab[rl].rel, 78520947801SPeter Wemm shdr[i].sh_size, shdr[i].sh_offset, 786e9eabf59SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 787e9eabf59SPeter Wemm &resid, td); 788e9eabf59SPeter Wemm if (error) 789e9eabf59SPeter Wemm goto out; 79020947801SPeter Wemm if (resid != 0){ 79120947801SPeter Wemm error = EINVAL; 79220947801SPeter Wemm goto out; 793e9eabf59SPeter Wemm } 79420947801SPeter Wemm rl++; 79520947801SPeter Wemm break; 79620947801SPeter Wemm case SHT_RELA: 79720947801SPeter Wemm ef->relatab[ra].rela = malloc(shdr[i].sh_size, M_LINKER, 79820947801SPeter Wemm M_WAITOK); 79920947801SPeter Wemm ef->relatab[ra].nrela = 80020947801SPeter Wemm shdr[i].sh_size / sizeof(Elf_Rela); 80120947801SPeter Wemm ef->relatab[ra].sec = shdr[i].sh_info; 802e9eabf59SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, 80320947801SPeter Wemm (void *)ef->relatab[ra].rela, 80420947801SPeter Wemm shdr[i].sh_size, shdr[i].sh_offset, 805e9eabf59SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 806e9eabf59SPeter Wemm &resid, td); 807e9eabf59SPeter Wemm if (error) 808e9eabf59SPeter Wemm goto out; 80920947801SPeter Wemm if (resid != 0){ 81020947801SPeter Wemm error = EINVAL; 81120947801SPeter Wemm goto out; 812e9eabf59SPeter Wemm } 81320947801SPeter Wemm ra++; 81420947801SPeter Wemm break; 81520947801SPeter Wemm } 81620947801SPeter Wemm } 81720947801SPeter Wemm if (pb != ef->nprogtab) 81820947801SPeter Wemm panic("lost progbits"); 819b474c780SDavid E. O'Brien if (rl != ef->nreltab) 820b474c780SDavid E. O'Brien panic("lost reltab"); 821b474c780SDavid E. O'Brien if (ra != ef->nrelatab) 822b474c780SDavid E. O'Brien panic("lost relatab"); 82320947801SPeter Wemm if (mapbase != (vm_offset_t)ef->address + mapsize) 8245b201fdcSPeter Wemm panic("mapbase 0x%lx != address %p + mapsize 0x%lx (0x%lx)\n", 8255b201fdcSPeter Wemm mapbase, ef->address, mapsize, 8265b201fdcSPeter Wemm (vm_offset_t)ef->address + mapsize); 827e9eabf59SPeter Wemm 828e9eabf59SPeter Wemm /* Local intra-module relocations */ 8297251b4bfSJake Burkholder link_elf_reloc_local(lf); 8307251b4bfSJake Burkholder 831e9eabf59SPeter Wemm /* Pull in dependencies */ 8324f7afc20SKonstantin Belousov VOP_UNLOCK(nd.ni_vp, 0); 8337b9716baSIan Dowse error = linker_load_dependencies(lf); 8344f7afc20SKonstantin Belousov vn_lock(nd.ni_vp, LK_EXCLUSIVE | LK_RETRY); 835ca65d5c7SPeter Wemm if (error) 836de78ca7eSPeter Wemm goto out; 837e9eabf59SPeter Wemm 838e9eabf59SPeter Wemm /* External relocations */ 839326e27d8SDoug Rabson error = relocate_file(ef); 840ca65d5c7SPeter Wemm if (error) 841ca65d5c7SPeter Wemm goto out; 842ca65d5c7SPeter Wemm 843e9eabf59SPeter Wemm /* Notify MD code that a module is being loaded. */ 844e9eabf59SPeter Wemm error = elf_cpu_load_file(lf); 845ca65d5c7SPeter Wemm if (error) 846ca65d5c7SPeter Wemm goto out; 847a4f67738SDoug Rabson 848a4f67738SDoug Rabson *result = lf; 849a4f67738SDoug Rabson 850a4f67738SDoug Rabson out: 851ca65d5c7SPeter Wemm if (error && lf) 85265a311fcSPoul-Henning Kamp linker_file_unload(lf, LINKER_UNLOAD_FORCE); 853e9eabf59SPeter Wemm if (hdr) 854e9eabf59SPeter Wemm free(hdr, M_LINKER); 85522db15c0SAttilio Rao VOP_UNLOCK(nd.ni_vp, 0); 856a854ed98SJohn Baldwin vn_close(nd.ni_vp, FREAD, td->td_ucred, td); 85762d615d5SJohn Baldwin VFS_UNLOCK_GIANT(vfslocked); 858a4f67738SDoug Rabson 859a4f67738SDoug Rabson return error; 860a4f67738SDoug Rabson } 861a4f67738SDoug Rabson 862a4f67738SDoug Rabson static void 863de78ca7eSPeter Wemm link_elf_unload_file(linker_file_t file) 864a4f67738SDoug Rabson { 865326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) file; 86620947801SPeter Wemm int i; 867a4f67738SDoug Rabson 8681aeb23cdSMarcel Moolenaar /* Notify MD code that a module is being unloaded. */ 8691aeb23cdSMarcel Moolenaar elf_cpu_unload_file(file); 8701aeb23cdSMarcel Moolenaar 87150c202c5SJeff Roberson if (ef->progtab) { 87250c202c5SJeff Roberson for (i = 0; i < ef->nprogtab; i++) { 87350c202c5SJeff Roberson if (ef->progtab[i].size == 0) 87450c202c5SJeff Roberson continue; 87550c202c5SJeff Roberson if (ef->progtab[i].name == NULL) 87650c202c5SJeff Roberson continue; 87750c202c5SJeff Roberson if (!strcmp(ef->progtab[i].name, "set_pcpu")) 87850c202c5SJeff Roberson dpcpu_free(ef->progtab[i].addr, 87950c202c5SJeff Roberson ef->progtab[i].size); 88050c202c5SJeff Roberson } 88150c202c5SJeff Roberson } 88270b7ffeeSIan Dowse if (ef->preloaded) { 88370b7ffeeSIan Dowse if (ef->reltab) 88470b7ffeeSIan Dowse free(ef->reltab, M_LINKER); 88570b7ffeeSIan Dowse if (ef->relatab) 88670b7ffeeSIan Dowse free(ef->relatab, M_LINKER); 88770b7ffeeSIan Dowse if (ef->progtab) 88870b7ffeeSIan Dowse free(ef->progtab, M_LINKER); 889a2024a3eSJohn Birrell if (ef->ctftab) 890a2024a3eSJohn Birrell free(ef->ctftab, M_LINKER); 891a2024a3eSJohn Birrell if (ef->ctfoff) 892a2024a3eSJohn Birrell free(ef->ctfoff, M_LINKER); 893a2024a3eSJohn Birrell if (ef->typoff) 894a2024a3eSJohn Birrell free(ef->typoff, M_LINKER); 89570b7ffeeSIan Dowse if (file->filename != NULL) 89670b7ffeeSIan Dowse preload_delete_name(file->filename); 89770b7ffeeSIan Dowse /* XXX reclaim module memory? */ 89870b7ffeeSIan Dowse return; 89970b7ffeeSIan Dowse } 90070b7ffeeSIan Dowse 901b474c780SDavid E. O'Brien for (i = 0; i < ef->nreltab; i++) 90220947801SPeter Wemm if (ef->reltab[i].rel) 90320947801SPeter Wemm free(ef->reltab[i].rel, M_LINKER); 904b474c780SDavid E. O'Brien for (i = 0; i < ef->nrelatab; i++) 90520947801SPeter Wemm if (ef->relatab[i].rela) 90620947801SPeter Wemm free(ef->relatab[i].rela, M_LINKER); 90720947801SPeter Wemm if (ef->reltab) 90820947801SPeter Wemm free(ef->reltab, M_LINKER); 90920947801SPeter Wemm if (ef->relatab) 91020947801SPeter Wemm free(ef->relatab, M_LINKER); 91120947801SPeter Wemm if (ef->progtab) 91220947801SPeter Wemm free(ef->progtab, M_LINKER); 91320947801SPeter Wemm 914fe3db7c7SDoug Rabson if (ef->object) { 915fe3db7c7SDoug Rabson vm_map_remove(kernel_map, (vm_offset_t) ef->address, 91620947801SPeter Wemm (vm_offset_t) ef->address + 91720947801SPeter Wemm (ef->object->size << PAGE_SHIFT)); 918fe3db7c7SDoug Rabson } 919e9eabf59SPeter Wemm if (ef->e_shdr) 920e9eabf59SPeter Wemm free(ef->e_shdr, M_LINKER); 921e9eabf59SPeter Wemm if (ef->ddbsymtab) 922e9eabf59SPeter Wemm free(ef->ddbsymtab, M_LINKER); 923e9eabf59SPeter Wemm if (ef->ddbstrtab) 924e9eabf59SPeter Wemm free(ef->ddbstrtab, M_LINKER); 92520947801SPeter Wemm if (ef->shstrtab) 92620947801SPeter Wemm free(ef->shstrtab, M_LINKER); 927a2024a3eSJohn Birrell if (ef->ctftab) 928a2024a3eSJohn Birrell free(ef->ctftab, M_LINKER); 929a2024a3eSJohn Birrell if (ef->ctfoff) 930a2024a3eSJohn Birrell free(ef->ctfoff, M_LINKER); 931a2024a3eSJohn Birrell if (ef->typoff) 932a2024a3eSJohn Birrell free(ef->typoff, M_LINKER); 933de78ca7eSPeter Wemm } 934de78ca7eSPeter Wemm 935fe3db7c7SDoug Rabson static const char * 936757686b1SMarcel Moolenaar symbol_name(elf_file_t ef, Elf_Size r_info) 937a4f67738SDoug Rabson { 938fe3db7c7SDoug Rabson const Elf_Sym *ref; 939a4f67738SDoug Rabson 940aa855a59SPeter Wemm if (ELF_R_SYM(r_info)) { 941e9eabf59SPeter Wemm ref = ef->ddbsymtab + ELF_R_SYM(r_info); 942e9eabf59SPeter Wemm return ef->ddbstrtab + ref->st_name; 943fe3db7c7SDoug Rabson } else 944fe3db7c7SDoug Rabson return NULL; 945a4f67738SDoug Rabson } 946a4f67738SDoug Rabson 947e9eabf59SPeter Wemm static Elf_Addr 948e9eabf59SPeter Wemm findbase(elf_file_t ef, int sec) 949e9eabf59SPeter Wemm { 950e9eabf59SPeter Wemm int i; 951e9eabf59SPeter Wemm Elf_Addr base = 0; 952e9eabf59SPeter Wemm 953e9eabf59SPeter Wemm for (i = 0; i < ef->nprogtab; i++) { 954a8774e39SPeter Wemm if (sec == ef->progtab[i].sec) { 955e9eabf59SPeter Wemm base = (Elf_Addr)ef->progtab[i].addr; 956a8774e39SPeter Wemm break; 957e9eabf59SPeter Wemm } 958a8774e39SPeter Wemm } 959e9eabf59SPeter Wemm return base; 960e9eabf59SPeter Wemm } 961e9eabf59SPeter Wemm 962a4f67738SDoug Rabson static int 963326e27d8SDoug Rabson relocate_file(elf_file_t ef) 964a4f67738SDoug Rabson { 965fe3db7c7SDoug Rabson const Elf_Rel *rellim; 966fe3db7c7SDoug Rabson const Elf_Rel *rel; 967fe3db7c7SDoug Rabson const Elf_Rela *relalim; 968fe3db7c7SDoug Rabson const Elf_Rela *rela; 969aa855a59SPeter Wemm const char *symname; 970e9eabf59SPeter Wemm const Elf_Sym *sym; 971e9eabf59SPeter Wemm int i; 972757686b1SMarcel Moolenaar Elf_Size symidx; 973e9eabf59SPeter Wemm Elf_Addr base; 974e9eabf59SPeter Wemm 975a4f67738SDoug Rabson 976fe3db7c7SDoug Rabson /* Perform relocations without addend if there are any: */ 977b474c780SDavid E. O'Brien for (i = 0; i < ef->nreltab; i++) { 978e9eabf59SPeter Wemm rel = ef->reltab[i].rel; 97920947801SPeter Wemm if (rel == NULL) 98082d0d1a0SPeter Wemm panic("lost a reltab!"); 98120947801SPeter Wemm rellim = rel + ef->reltab[i].nrel; 982e9eabf59SPeter Wemm base = findbase(ef, ef->reltab[i].sec); 983a8774e39SPeter Wemm if (base == 0) 984a8774e39SPeter Wemm panic("lost base for reltab"); 98520947801SPeter Wemm for ( ; rel < rellim; rel++) { 986e9eabf59SPeter Wemm symidx = ELF_R_SYM(rel->r_info); 98720947801SPeter Wemm if (symidx >= ef->ddbsymcnt) 98820947801SPeter Wemm continue; 989e9eabf59SPeter Wemm sym = ef->ddbsymtab + symidx; 99020947801SPeter Wemm /* Local relocs are already done */ 99120947801SPeter Wemm if (ELF_ST_BIND(sym->st_info) == STB_LOCAL) 99220947801SPeter Wemm continue; 99320947801SPeter Wemm if (elf_reloc(&ef->lf, base, rel, ELF_RELOC_REL, 99420947801SPeter Wemm elf_obj_lookup)) { 995aa855a59SPeter Wemm symname = symbol_name(ef, rel->r_info); 99620947801SPeter Wemm printf("link_elf_obj: symbol %s undefined\n", 99720947801SPeter Wemm symname); 998a4f67738SDoug Rabson return ENOENT; 999a13ddfb6SPeter Wemm } 1000aa855a59SPeter Wemm } 1001a4f67738SDoug Rabson } 1002a4f67738SDoug Rabson 1003fe3db7c7SDoug Rabson /* Perform relocations with addend if there are any: */ 1004b474c780SDavid E. O'Brien for (i = 0; i < ef->nrelatab; i++) { 1005e9eabf59SPeter Wemm rela = ef->relatab[i].rela; 100620947801SPeter Wemm if (rela == NULL) 100782d0d1a0SPeter Wemm panic("lost a relatab!"); 100820947801SPeter Wemm relalim = rela + ef->relatab[i].nrela; 1009e9eabf59SPeter Wemm base = findbase(ef, ef->relatab[i].sec); 1010a8774e39SPeter Wemm if (base == 0) 1011a8774e39SPeter Wemm panic("lost base for relatab"); 101220947801SPeter Wemm for ( ; rela < relalim; rela++) { 1013e9eabf59SPeter Wemm symidx = ELF_R_SYM(rela->r_info); 101420947801SPeter Wemm if (symidx >= ef->ddbsymcnt) 101520947801SPeter Wemm continue; 1016e9eabf59SPeter Wemm sym = ef->ddbsymtab + symidx; 101720947801SPeter Wemm /* Local relocs are already done */ 101820947801SPeter Wemm if (ELF_ST_BIND(sym->st_info) == STB_LOCAL) 101920947801SPeter Wemm continue; 102020947801SPeter Wemm if (elf_reloc(&ef->lf, base, rela, ELF_RELOC_RELA, 102120947801SPeter Wemm elf_obj_lookup)) { 1022aa855a59SPeter Wemm symname = symbol_name(ef, rela->r_info); 102320947801SPeter Wemm printf("link_elf_obj: symbol %s undefined\n", 102420947801SPeter Wemm symname); 1025fe3db7c7SDoug Rabson return ENOENT; 1026a13ddfb6SPeter Wemm } 1027e9eabf59SPeter Wemm } 1028e9eabf59SPeter Wemm } 1029a4f67738SDoug Rabson 1030a4f67738SDoug Rabson return 0; 1031a4f67738SDoug Rabson } 1032a4f67738SDoug Rabson 103337c84183SPoul-Henning Kamp static int 1034d254af07SMatthew Dillon link_elf_lookup_symbol(linker_file_t lf, const char *name, c_linker_sym_t *sym) 1035a4f67738SDoug Rabson { 1036326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) lf; 10372d636ab0SPeter Wemm const Elf_Sym *symp; 10382d636ab0SPeter Wemm const char *strp; 1039a4f67738SDoug Rabson int i; 1040a4f67738SDoug Rabson 10412d636ab0SPeter Wemm for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) { 10422d636ab0SPeter Wemm strp = ef->ddbstrtab + symp->st_name; 1043a8774e39SPeter Wemm if (symp->st_shndx != SHN_UNDEF && strcmp(name, strp) == 0) { 1044d254af07SMatthew Dillon *sym = (c_linker_sym_t) symp; 10452d636ab0SPeter Wemm return 0; 10462d636ab0SPeter Wemm } 10472d636ab0SPeter Wemm } 1048a4f67738SDoug Rabson return ENOENT; 1049a4f67738SDoug Rabson } 1050a4f67738SDoug Rabson 1051de78ca7eSPeter Wemm static int 105220947801SPeter Wemm link_elf_symbol_values(linker_file_t lf, c_linker_sym_t sym, 105320947801SPeter Wemm linker_symval_t *symval) 1054a4f67738SDoug Rabson { 1055326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) lf; 10568aef1712SMatthew Dillon const Elf_Sym *es = (const Elf_Sym*) sym; 1057a4f67738SDoug Rabson 10585cf87418SMarcel Moolenaar if (es >= ef->ddbsymtab && es < (ef->ddbsymtab + ef->ddbsymcnt)) { 10592d636ab0SPeter Wemm symval->name = ef->ddbstrtab + es->st_name; 1060a8774e39SPeter Wemm symval->value = (caddr_t)es->st_value; 10612d636ab0SPeter Wemm symval->size = es->st_size; 10622d636ab0SPeter Wemm return 0; 10632d636ab0SPeter Wemm } 10642d636ab0SPeter Wemm return ENOENT; 10652d636ab0SPeter Wemm } 1066a4f67738SDoug Rabson 1067a4f67738SDoug Rabson static int 1068a4f67738SDoug Rabson link_elf_search_symbol(linker_file_t lf, caddr_t value, 1069d254af07SMatthew Dillon c_linker_sym_t *sym, long *diffp) 1070a4f67738SDoug Rabson { 1071326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) lf; 1072586453feSBruce Evans u_long off = (uintptr_t) (void *) value; 1073a4f67738SDoug Rabson u_long diff = off; 1074586453feSBruce Evans u_long st_value; 1075fe3db7c7SDoug Rabson const Elf_Sym *es; 1076fe3db7c7SDoug Rabson const Elf_Sym *best = 0; 1077a4f67738SDoug Rabson int i; 1078a4f67738SDoug Rabson 10792d636ab0SPeter Wemm for (i = 0, es = ef->ddbsymtab; i < ef->ddbsymcnt; i++, es++) { 1080a4f67738SDoug Rabson if (es->st_name == 0) 1081a4f67738SDoug Rabson continue; 1082a8774e39SPeter Wemm st_value = es->st_value; 1083b5abfb70SPeter Wemm if (off >= st_value) { 1084b5abfb70SPeter Wemm if (off - st_value < diff) { 1085b5abfb70SPeter Wemm diff = off - st_value; 1086a4f67738SDoug Rabson best = es; 1087a4f67738SDoug Rabson if (diff == 0) 1088a4f67738SDoug Rabson break; 1089b5abfb70SPeter Wemm } else if (off - st_value == diff) { 1090a4f67738SDoug Rabson best = es; 1091a4f67738SDoug Rabson } 1092a4f67738SDoug Rabson } 1093a4f67738SDoug Rabson } 1094a4f67738SDoug Rabson if (best == 0) 1095a4f67738SDoug Rabson *diffp = off; 1096a4f67738SDoug Rabson else 1097a4f67738SDoug Rabson *diffp = diff; 1098d254af07SMatthew Dillon *sym = (c_linker_sym_t) best; 1099a4f67738SDoug Rabson 1100a4f67738SDoug Rabson return 0; 1101a4f67738SDoug Rabson } 1102f41325dbSPeter Wemm 1103f41325dbSPeter Wemm /* 1104f41325dbSPeter Wemm * Look up a linker set on an ELF system. 1105f41325dbSPeter Wemm */ 1106f41325dbSPeter Wemm static int 1107f41325dbSPeter Wemm link_elf_lookup_set(linker_file_t lf, const char *name, 1108f41325dbSPeter Wemm void ***startp, void ***stopp, int *countp) 1109f41325dbSPeter Wemm { 1110e9eabf59SPeter Wemm elf_file_t ef = (elf_file_t)lf; 1111f41325dbSPeter Wemm void **start, **stop; 1112e9eabf59SPeter Wemm int i, count; 1113f41325dbSPeter Wemm 1114e9eabf59SPeter Wemm /* Relative to section number */ 1115e9eabf59SPeter Wemm for (i = 0; i < ef->nprogtab; i++) { 1116e9eabf59SPeter Wemm if ((strncmp(ef->progtab[i].name, "set_", 4) == 0) && 1117e9eabf59SPeter Wemm strcmp(ef->progtab[i].name + 4, name) == 0) { 1118e9eabf59SPeter Wemm start = (void **)ef->progtab[i].addr; 111920947801SPeter Wemm stop = (void **)((char *)ef->progtab[i].addr + 112020947801SPeter Wemm ef->progtab[i].size); 1121f41325dbSPeter Wemm count = stop - start; 1122f41325dbSPeter Wemm if (startp) 1123f41325dbSPeter Wemm *startp = start; 1124f41325dbSPeter Wemm if (stopp) 1125f41325dbSPeter Wemm *stopp = stop; 1126f41325dbSPeter Wemm if (countp) 1127f41325dbSPeter Wemm *countp = count; 1128e9eabf59SPeter Wemm return (0); 1129e9eabf59SPeter Wemm } 1130e9eabf59SPeter Wemm } 1131e9eabf59SPeter Wemm return (ESRCH); 1132f41325dbSPeter Wemm } 1133bb9fe9ddSBrian Feldman 1134bb9fe9ddSBrian Feldman static int 1135bb9fe9ddSBrian Feldman link_elf_each_function_name(linker_file_t file, 1136e9eabf59SPeter Wemm int (*callback)(const char *, void *), void *opaque) 1137e9eabf59SPeter Wemm { 1138bb9fe9ddSBrian Feldman elf_file_t ef = (elf_file_t)file; 1139bb9fe9ddSBrian Feldman const Elf_Sym *symp; 1140bb9fe9ddSBrian Feldman int i, error; 1141bb9fe9ddSBrian Feldman 1142bb9fe9ddSBrian Feldman /* Exhaustive search */ 1143bb9fe9ddSBrian Feldman for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) { 1144bb9fe9ddSBrian Feldman if (symp->st_value != 0 && 1145bb9fe9ddSBrian Feldman ELF_ST_TYPE(symp->st_info) == STT_FUNC) { 1146bb9fe9ddSBrian Feldman error = callback(ef->ddbstrtab + symp->st_name, opaque); 1147bb9fe9ddSBrian Feldman if (error) 1148bb9fe9ddSBrian Feldman return (error); 1149bb9fe9ddSBrian Feldman } 1150bb9fe9ddSBrian Feldman } 1151bb9fe9ddSBrian Feldman return (0); 1152bb9fe9ddSBrian Feldman } 115384201059SMarcel Moolenaar 1154a2024a3eSJohn Birrell static int 1155a2024a3eSJohn Birrell link_elf_each_function_nameval(linker_file_t file, 1156a2024a3eSJohn Birrell linker_function_nameval_callback_t callback, void *opaque) 1157a2024a3eSJohn Birrell { 1158a2024a3eSJohn Birrell linker_symval_t symval; 1159a2024a3eSJohn Birrell elf_file_t ef = (elf_file_t)file; 1160a2024a3eSJohn Birrell const Elf_Sym* symp; 1161a2024a3eSJohn Birrell int i, error; 1162a2024a3eSJohn Birrell 1163a2024a3eSJohn Birrell /* Exhaustive search */ 1164a2024a3eSJohn Birrell for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) { 1165a2024a3eSJohn Birrell if (symp->st_value != 0 && 1166a2024a3eSJohn Birrell ELF_ST_TYPE(symp->st_info) == STT_FUNC) { 1167a2024a3eSJohn Birrell error = link_elf_symbol_values(file, (c_linker_sym_t) symp, &symval); 1168a2024a3eSJohn Birrell if (error) 1169a2024a3eSJohn Birrell return (error); 1170a2024a3eSJohn Birrell error = callback(file, i, &symval, opaque); 1171a2024a3eSJohn Birrell if (error) 1172a2024a3eSJohn Birrell return (error); 1173a2024a3eSJohn Birrell } 1174a2024a3eSJohn Birrell } 1175a2024a3eSJohn Birrell return (0); 1176a2024a3eSJohn Birrell } 1177a2024a3eSJohn Birrell 1178d297ad16SMarcel Moolenaar /* 1179d297ad16SMarcel Moolenaar * Symbol lookup function that can be used when the symbol index is known (ie 1180d297ad16SMarcel Moolenaar * in relocations). It uses the symbol index instead of doing a fully fledged 1181d297ad16SMarcel Moolenaar * hash table based lookup when such is valid. For example for local symbols. 1182d297ad16SMarcel Moolenaar * This is not only more efficient, it's also more correct. It's not always 1183d297ad16SMarcel Moolenaar * the case that the symbol can be found through the hash table. 1184d297ad16SMarcel Moolenaar */ 1185e9eabf59SPeter Wemm static Elf_Addr 1186757686b1SMarcel Moolenaar elf_obj_lookup(linker_file_t lf, Elf_Size symidx, int deps) 1187d297ad16SMarcel Moolenaar { 1188d297ad16SMarcel Moolenaar elf_file_t ef = (elf_file_t)lf; 1189d297ad16SMarcel Moolenaar const Elf_Sym *sym; 1190d297ad16SMarcel Moolenaar const char *symbol; 1191e9eabf59SPeter Wemm Elf_Addr ret; 1192d297ad16SMarcel Moolenaar 1193d297ad16SMarcel Moolenaar /* Don't even try to lookup the symbol if the index is bogus. */ 1194e9eabf59SPeter Wemm if (symidx >= ef->ddbsymcnt) 1195d297ad16SMarcel Moolenaar return (0); 1196d297ad16SMarcel Moolenaar 1197e9eabf59SPeter Wemm sym = ef->ddbsymtab + symidx; 1198d297ad16SMarcel Moolenaar 11994cec6f5dSPeter Wemm /* Quick answer if there is a definition included. */ 1200a8774e39SPeter Wemm if (sym->st_shndx != SHN_UNDEF) 1201a8774e39SPeter Wemm return (sym->st_value); 12024cec6f5dSPeter Wemm 12034cec6f5dSPeter Wemm /* If we get here, then it is undefined and needs a lookup. */ 12044cec6f5dSPeter Wemm switch (ELF_ST_BIND(sym->st_info)) { 12054cec6f5dSPeter Wemm case STB_LOCAL: 12064cec6f5dSPeter Wemm /* Local, but undefined? huh? */ 12074cec6f5dSPeter Wemm return (0); 1208d297ad16SMarcel Moolenaar 1209e9eabf59SPeter Wemm case STB_GLOBAL: 1210e9eabf59SPeter Wemm /* Relative to Data or Function name */ 1211e9eabf59SPeter Wemm symbol = ef->ddbstrtab + sym->st_name; 1212d297ad16SMarcel Moolenaar 1213d297ad16SMarcel Moolenaar /* Force a lookup failure if the symbol name is bogus. */ 1214d297ad16SMarcel Moolenaar if (*symbol == 0) 1215d297ad16SMarcel Moolenaar return (0); 1216e9eabf59SPeter Wemm ret = ((Elf_Addr)linker_file_lookup_symbol(lf, symbol, deps)); 1217e9eabf59SPeter Wemm return ret; 1218d297ad16SMarcel Moolenaar 1219e9eabf59SPeter Wemm case STB_WEAK: 122020947801SPeter Wemm printf("link_elf_obj: Weak symbols not supported\n"); 1221e9eabf59SPeter Wemm return (0); 1222e9eabf59SPeter Wemm 1223e9eabf59SPeter Wemm default: 1224e9eabf59SPeter Wemm return (0); 1225d297ad16SMarcel Moolenaar } 1226e9eabf59SPeter Wemm } 1227e9eabf59SPeter Wemm 12287251b4bfSJake Burkholder static void 12297226306eSKonstantin Belousov link_elf_fix_link_set(elf_file_t ef) 12307226306eSKonstantin Belousov { 12317226306eSKonstantin Belousov static const char startn[] = "__start_"; 12327226306eSKonstantin Belousov static const char stopn[] = "__stop_"; 12337226306eSKonstantin Belousov Elf_Sym *sym; 12347226306eSKonstantin Belousov const char *sym_name, *linkset_name; 12357226306eSKonstantin Belousov Elf_Addr startp, stopp; 12367226306eSKonstantin Belousov Elf_Size symidx; 12377226306eSKonstantin Belousov int start, i; 12387226306eSKonstantin Belousov 12397226306eSKonstantin Belousov startp = stopp = 0; 12407226306eSKonstantin Belousov for (symidx = 1 /* zero entry is special */; 12417226306eSKonstantin Belousov symidx < ef->ddbsymcnt; symidx++) { 12427226306eSKonstantin Belousov sym = ef->ddbsymtab + symidx; 12437226306eSKonstantin Belousov if (sym->st_shndx != SHN_UNDEF) 12447226306eSKonstantin Belousov continue; 12457226306eSKonstantin Belousov 12467226306eSKonstantin Belousov sym_name = ef->ddbstrtab + sym->st_name; 12477226306eSKonstantin Belousov if (strncmp(sym_name, startn, sizeof(startn) - 1) == 0) { 12487226306eSKonstantin Belousov start = 1; 12497226306eSKonstantin Belousov linkset_name = sym_name + sizeof(startn) - 1; 12507226306eSKonstantin Belousov } 12517226306eSKonstantin Belousov else if (strncmp(sym_name, stopn, sizeof(stopn) - 1) == 0) { 12527226306eSKonstantin Belousov start = 0; 12537226306eSKonstantin Belousov linkset_name = sym_name + sizeof(stopn) - 1; 12547226306eSKonstantin Belousov } 12557226306eSKonstantin Belousov else 12567226306eSKonstantin Belousov continue; 12577226306eSKonstantin Belousov 12587226306eSKonstantin Belousov for (i = 0; i < ef->nprogtab; i++) { 12597226306eSKonstantin Belousov if (strcmp(ef->progtab[i].name, linkset_name) == 0) { 12607226306eSKonstantin Belousov startp = (Elf_Addr)ef->progtab[i].addr; 12617226306eSKonstantin Belousov stopp = (Elf_Addr)(startp + ef->progtab[i].size); 12627226306eSKonstantin Belousov break; 12637226306eSKonstantin Belousov } 12647226306eSKonstantin Belousov } 12657226306eSKonstantin Belousov if (i == ef->nprogtab) 12667226306eSKonstantin Belousov continue; 12677226306eSKonstantin Belousov 12687226306eSKonstantin Belousov sym->st_value = start ? startp : stopp; 12697226306eSKonstantin Belousov sym->st_shndx = i; 12707226306eSKonstantin Belousov } 12717226306eSKonstantin Belousov } 12727226306eSKonstantin Belousov 12737226306eSKonstantin Belousov static void 12747251b4bfSJake Burkholder link_elf_reloc_local(linker_file_t lf) 12757251b4bfSJake Burkholder { 1276e9eabf59SPeter Wemm elf_file_t ef = (elf_file_t)lf; 12777251b4bfSJake Burkholder const Elf_Rel *rellim; 12787251b4bfSJake Burkholder const Elf_Rel *rel; 12797251b4bfSJake Burkholder const Elf_Rela *relalim; 12807251b4bfSJake Burkholder const Elf_Rela *rela; 1281e9eabf59SPeter Wemm const Elf_Sym *sym; 1282e9eabf59SPeter Wemm Elf_Addr base; 1283e9eabf59SPeter Wemm int i; 1284757686b1SMarcel Moolenaar Elf_Size symidx; 1285e9eabf59SPeter Wemm 12867226306eSKonstantin Belousov link_elf_fix_link_set(ef); 12877226306eSKonstantin Belousov 12887251b4bfSJake Burkholder /* Perform relocations without addend if there are any: */ 1289b474c780SDavid E. O'Brien for (i = 0; i < ef->nreltab; i++) { 1290e9eabf59SPeter Wemm rel = ef->reltab[i].rel; 129120947801SPeter Wemm if (rel == NULL) 129282d0d1a0SPeter Wemm panic("lost a reltab!"); 129320947801SPeter Wemm rellim = rel + ef->reltab[i].nrel; 1294e9eabf59SPeter Wemm base = findbase(ef, ef->reltab[i].sec); 1295a8774e39SPeter Wemm if (base == 0) 1296a8774e39SPeter Wemm panic("lost base for reltab"); 129720947801SPeter Wemm for ( ; rel < rellim; rel++) { 1298e9eabf59SPeter Wemm symidx = ELF_R_SYM(rel->r_info); 129920947801SPeter Wemm if (symidx >= ef->ddbsymcnt) 130020947801SPeter Wemm continue; 1301e9eabf59SPeter Wemm sym = ef->ddbsymtab + symidx; 130220947801SPeter Wemm /* Only do local relocs */ 130320947801SPeter Wemm if (ELF_ST_BIND(sym->st_info) != STB_LOCAL) 130420947801SPeter Wemm continue; 130520947801SPeter Wemm elf_reloc_local(lf, base, rel, ELF_RELOC_REL, 130620947801SPeter Wemm elf_obj_lookup); 13077251b4bfSJake Burkholder } 1308e9eabf59SPeter Wemm } 13097251b4bfSJake Burkholder 13107251b4bfSJake Burkholder /* Perform relocations with addend if there are any: */ 1311b474c780SDavid E. O'Brien for (i = 0; i < ef->nrelatab; i++) { 1312e9eabf59SPeter Wemm rela = ef->relatab[i].rela; 131320947801SPeter Wemm if (rela == NULL) 131482d0d1a0SPeter Wemm panic("lost a relatab!"); 131520947801SPeter Wemm relalim = rela + ef->relatab[i].nrela; 1316e9eabf59SPeter Wemm base = findbase(ef, ef->relatab[i].sec); 1317a8774e39SPeter Wemm if (base == 0) 1318a8774e39SPeter Wemm panic("lost base for relatab"); 131920947801SPeter Wemm for ( ; rela < relalim; rela++) { 1320e9eabf59SPeter Wemm symidx = ELF_R_SYM(rela->r_info); 132120947801SPeter Wemm if (symidx >= ef->ddbsymcnt) 132220947801SPeter Wemm continue; 1323e9eabf59SPeter Wemm sym = ef->ddbsymtab + symidx; 132420947801SPeter Wemm /* Only do local relocs */ 132520947801SPeter Wemm if (ELF_ST_BIND(sym->st_info) != STB_LOCAL) 132620947801SPeter Wemm continue; 132720947801SPeter Wemm elf_reloc_local(lf, base, rela, ELF_RELOC_RELA, 132820947801SPeter Wemm elf_obj_lookup); 13297251b4bfSJake Burkholder } 13307251b4bfSJake Burkholder } 1331e9eabf59SPeter Wemm } 133200a5db46SStacey Son 133300a5db46SStacey Son static long 1334e76f11f4SAndriy Gapon link_elf_symtab_get(linker_file_t lf, const Elf_Sym **symtab) 133500a5db46SStacey Son { 133600a5db46SStacey Son elf_file_t ef = (elf_file_t)lf; 133700a5db46SStacey Son 133800a5db46SStacey Son *symtab = ef->ddbsymtab; 133900a5db46SStacey Son 134000a5db46SStacey Son if (*symtab == NULL) 134100a5db46SStacey Son return (0); 134200a5db46SStacey Son 134300a5db46SStacey Son return (ef->ddbsymcnt); 134400a5db46SStacey Son } 134500a5db46SStacey Son 134600a5db46SStacey Son static long 134700a5db46SStacey Son link_elf_strtab_get(linker_file_t lf, caddr_t *strtab) 134800a5db46SStacey Son { 134900a5db46SStacey Son elf_file_t ef = (elf_file_t)lf; 135000a5db46SStacey Son 135100a5db46SStacey Son *strtab = ef->ddbstrtab; 135200a5db46SStacey Son 135300a5db46SStacey Son if (*strtab == NULL) 135400a5db46SStacey Son return (0); 135500a5db46SStacey Son 135600a5db46SStacey Son return (ef->ddbstrcnt); 135700a5db46SStacey Son } 1358