1a4f67738SDoug Rabson /*- 2*8a36da99SPedro F. Giffuni * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3*8a36da99SPedro F. Giffuni * 4326e27d8SDoug Rabson * Copyright (c) 1998-2000 Doug Rabson 5e9eabf59SPeter Wemm * Copyright (c) 2004 Peter Wemm 6a4f67738SDoug Rabson * All rights reserved. 7a4f67738SDoug Rabson * 8a4f67738SDoug Rabson * Redistribution and use in source and binary forms, with or without 9a4f67738SDoug Rabson * modification, are permitted provided that the following conditions 10a4f67738SDoug Rabson * are met: 11a4f67738SDoug Rabson * 1. Redistributions of source code must retain the above copyright 12a4f67738SDoug Rabson * notice, this list of conditions and the following disclaimer. 13a4f67738SDoug Rabson * 2. Redistributions in binary form must reproduce the above copyright 14a4f67738SDoug Rabson * notice, this list of conditions and the following disclaimer in the 15a4f67738SDoug Rabson * documentation and/or other materials provided with the distribution. 16a4f67738SDoug Rabson * 17a4f67738SDoug Rabson * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18a4f67738SDoug Rabson * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19a4f67738SDoug Rabson * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20a4f67738SDoug Rabson * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21a4f67738SDoug Rabson * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22a4f67738SDoug Rabson * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23a4f67738SDoug Rabson * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24a4f67738SDoug Rabson * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25a4f67738SDoug Rabson * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26a4f67738SDoug Rabson * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27a4f67738SDoug Rabson * SUCH DAMAGE. 28a4f67738SDoug Rabson */ 29a4f67738SDoug Rabson 30677b542eSDavid E. O'Brien #include <sys/cdefs.h> 31677b542eSDavid E. O'Brien __FBSDID("$FreeBSD$"); 32677b542eSDavid E. O'Brien 33326e27d8SDoug Rabson #include "opt_ddb.h" 34326e27d8SDoug Rabson 35a4f67738SDoug Rabson #include <sys/param.h> 36a4f67738SDoug Rabson #include <sys/systm.h> 37fb919e4dSMark Murray #include <sys/kernel.h> 38fb919e4dSMark Murray #include <sys/lock.h> 39a4f67738SDoug Rabson #include <sys/malloc.h> 40c0b824f9SDima Dorfman #include <sys/mutex.h> 4162d615d5SJohn Baldwin #include <sys/mount.h> 42a4f67738SDoug Rabson #include <sys/proc.h> 43a4f67738SDoug Rabson #include <sys/namei.h> 44a4f67738SDoug Rabson #include <sys/fcntl.h> 45a4f67738SDoug Rabson #include <sys/vnode.h> 46a4f67738SDoug Rabson #include <sys/linker.h> 47fb919e4dSMark Murray 48a4f67738SDoug Rabson #include <machine/elf.h> 49a4f67738SDoug Rabson 50eddfbb76SRobert Watson #include <net/vnet.h> 51eddfbb76SRobert Watson 52aed55708SRobert Watson #include <security/mac/mac_framework.h> 53aed55708SRobert Watson 54fe3db7c7SDoug Rabson #include <vm/vm.h> 55fe3db7c7SDoug Rabson #include <vm/vm_param.h> 56fe3db7c7SDoug Rabson #include <vm/vm_object.h> 57fe3db7c7SDoug Rabson #include <vm/vm_kern.h> 58fe3db7c7SDoug Rabson #include <vm/vm_extern.h> 59fe3db7c7SDoug Rabson #include <vm/pmap.h> 60fe3db7c7SDoug Rabson #include <vm/vm_map.h> 61fb919e4dSMark Murray 62f9980387SPeter Wemm #include <sys/link_elf.h> 63fe3db7c7SDoug Rabson 64a2024a3eSJohn Birrell #ifdef DDB_CTF 65d9db5225SCraig Rodrigues #include <sys/zlib.h> 66a2024a3eSJohn Birrell #endif 67a2024a3eSJohn Birrell 68326e27d8SDoug Rabson #include "linker_if.h" 69a4f67738SDoug Rabson 70e9eabf59SPeter Wemm typedef struct { 71e9eabf59SPeter Wemm void *addr; 7220947801SPeter Wemm Elf_Off size; 73e9eabf59SPeter Wemm int flags; 74e9eabf59SPeter Wemm int sec; /* Original section */ 75e9eabf59SPeter Wemm char *name; 76e9eabf59SPeter Wemm } Elf_progent; 77e9eabf59SPeter Wemm 78e9eabf59SPeter Wemm typedef struct { 79e9eabf59SPeter Wemm Elf_Rel *rel; 8020947801SPeter Wemm int nrel; 81e9eabf59SPeter Wemm int sec; 82e9eabf59SPeter Wemm } Elf_relent; 83e9eabf59SPeter Wemm 84e9eabf59SPeter Wemm typedef struct { 85e9eabf59SPeter Wemm Elf_Rela *rela; 8620947801SPeter Wemm int nrela; 87e9eabf59SPeter Wemm int sec; 88e9eabf59SPeter Wemm } Elf_relaent; 89e9eabf59SPeter Wemm 90e9eabf59SPeter Wemm 91a4f67738SDoug Rabson typedef struct elf_file { 92326e27d8SDoug Rabson struct linker_file lf; /* Common fields */ 9320947801SPeter Wemm 9470b7ffeeSIan Dowse int preloaded; 95fe3db7c7SDoug Rabson caddr_t address; /* Relocation address */ 96fe3db7c7SDoug Rabson vm_object_t object; /* VM object to hold file pages */ 97e9eabf59SPeter Wemm Elf_Shdr *e_shdr; 98e9eabf59SPeter Wemm 99e9eabf59SPeter Wemm Elf_progent *progtab; 100e9eabf59SPeter Wemm int nprogtab; 101e9eabf59SPeter Wemm 102e9eabf59SPeter Wemm Elf_relaent *relatab; 103b474c780SDavid E. O'Brien int nrelatab; 104e9eabf59SPeter Wemm 105e9eabf59SPeter Wemm Elf_relent *reltab; 106b474c780SDavid E. O'Brien int nreltab; 107e9eabf59SPeter Wemm 108e9eabf59SPeter Wemm Elf_Sym *ddbsymtab; /* The symbol table we are using */ 1092d636ab0SPeter Wemm long ddbsymcnt; /* Number of symbols */ 1102d636ab0SPeter Wemm caddr_t ddbstrtab; /* String table */ 1112d636ab0SPeter Wemm long ddbstrcnt; /* number of bytes in string table */ 112e9eabf59SPeter Wemm 113e9eabf59SPeter Wemm caddr_t shstrtab; /* Section name string table */ 114e9eabf59SPeter Wemm long shstrcnt; /* number of bytes in string table */ 115e9eabf59SPeter Wemm 116a2024a3eSJohn Birrell caddr_t ctftab; /* CTF table */ 117a2024a3eSJohn Birrell long ctfcnt; /* number of bytes in CTF table */ 118a2024a3eSJohn Birrell caddr_t ctfoff; /* CTF offset table */ 119a2024a3eSJohn Birrell caddr_t typoff; /* Type offset table */ 120a2024a3eSJohn Birrell long typlen; /* Number of type entries. */ 121a2024a3eSJohn Birrell 122a4f67738SDoug Rabson } *elf_file_t; 123a4f67738SDoug Rabson 124a2024a3eSJohn Birrell #include <kern/kern_ctf.c> 125a2024a3eSJohn Birrell 12654823af2SPeter Wemm static int link_elf_link_preload(linker_class_t cls, 127326e27d8SDoug Rabson const char *, linker_file_t *); 12854823af2SPeter Wemm static int link_elf_link_preload_finish(linker_file_t); 12954823af2SPeter Wemm static int link_elf_load_file(linker_class_t, const char *, linker_file_t *); 130326e27d8SDoug Rabson static int link_elf_lookup_symbol(linker_file_t, const char *, 131326e27d8SDoug Rabson c_linker_sym_t *); 132e9eabf59SPeter Wemm static int link_elf_symbol_values(linker_file_t, c_linker_sym_t, 133e9eabf59SPeter Wemm linker_symval_t *); 134326e27d8SDoug Rabson static int link_elf_search_symbol(linker_file_t, caddr_t value, 135326e27d8SDoug Rabson c_linker_sym_t *sym, long *diffp); 136326e27d8SDoug Rabson 137326e27d8SDoug Rabson static void link_elf_unload_file(linker_file_t); 138f41325dbSPeter Wemm static int link_elf_lookup_set(linker_file_t, const char *, 139f41325dbSPeter Wemm void ***, void ***, int *); 140bb9fe9ddSBrian Feldman static int link_elf_each_function_name(linker_file_t, 141e9eabf59SPeter Wemm int (*)(const char *, void *), void *); 142a2024a3eSJohn Birrell static int link_elf_each_function_nameval(linker_file_t, 143a2024a3eSJohn Birrell linker_function_nameval_callback_t, 144a2024a3eSJohn Birrell void *); 1453cfce8e4SKonstantin Belousov static int link_elf_reloc_local(linker_file_t); 146e76f11f4SAndriy Gapon static long link_elf_symtab_get(linker_file_t, const Elf_Sym **); 14700a5db46SStacey Son static long link_elf_strtab_get(linker_file_t, caddr_t *); 148326e27d8SDoug Rabson 149cff8c6f2SKonstantin Belousov static int elf_obj_lookup(linker_file_t lf, Elf_Size symidx, int deps, 150cff8c6f2SKonstantin Belousov Elf_Addr *); 151e9eabf59SPeter Wemm 152326e27d8SDoug Rabson static kobj_method_t link_elf_methods[] = { 153326e27d8SDoug Rabson KOBJMETHOD(linker_lookup_symbol, link_elf_lookup_symbol), 154326e27d8SDoug Rabson KOBJMETHOD(linker_symbol_values, link_elf_symbol_values), 155326e27d8SDoug Rabson KOBJMETHOD(linker_search_symbol, link_elf_search_symbol), 156326e27d8SDoug Rabson KOBJMETHOD(linker_unload, link_elf_unload_file), 15754823af2SPeter Wemm KOBJMETHOD(linker_load_file, link_elf_load_file), 15854823af2SPeter Wemm KOBJMETHOD(linker_link_preload, link_elf_link_preload), 15954823af2SPeter Wemm KOBJMETHOD(linker_link_preload_finish, link_elf_link_preload_finish), 160f41325dbSPeter Wemm KOBJMETHOD(linker_lookup_set, link_elf_lookup_set), 161bb9fe9ddSBrian Feldman KOBJMETHOD(linker_each_function_name, link_elf_each_function_name), 162a2024a3eSJohn Birrell KOBJMETHOD(linker_each_function_nameval, link_elf_each_function_nameval), 163a2024a3eSJohn Birrell KOBJMETHOD(linker_ctf_get, link_elf_ctf_get), 16400a5db46SStacey Son KOBJMETHOD(linker_symtab_get, link_elf_symtab_get), 16500a5db46SStacey Son KOBJMETHOD(linker_strtab_get, link_elf_strtab_get), 166326e27d8SDoug Rabson { 0, 0 } 167326e27d8SDoug Rabson }; 168326e27d8SDoug Rabson 169326e27d8SDoug Rabson static struct linker_class link_elf_class = { 170326e27d8SDoug Rabson #if ELF_TARG_CLASS == ELFCLASS32 171e9eabf59SPeter Wemm "elf32_obj", 172326e27d8SDoug Rabson #else 173e9eabf59SPeter Wemm "elf64_obj", 174326e27d8SDoug Rabson #endif 175326e27d8SDoug Rabson link_elf_methods, sizeof(struct elf_file) 176326e27d8SDoug Rabson }; 177326e27d8SDoug Rabson 178326e27d8SDoug Rabson static int relocate_file(elf_file_t ef); 1792832cd54SKonstantin Belousov static void elf_obj_cleanup_globals_cache(elf_file_t); 180a4f67738SDoug Rabson 181a4f67738SDoug Rabson static void 182552f9f63SEdwin Groothuis link_elf_error(const char *filename, const char *s) 1831720979bSMarcel Moolenaar { 184552f9f63SEdwin Groothuis if (filename == NULL) 1851720979bSMarcel Moolenaar printf("kldload: %s\n", s); 186552f9f63SEdwin Groothuis else 187552f9f63SEdwin Groothuis printf("kldload: %s: %s\n", filename, s); 1881720979bSMarcel Moolenaar } 1891720979bSMarcel Moolenaar 1901720979bSMarcel Moolenaar static void 191a4f67738SDoug Rabson link_elf_init(void *arg) 192a4f67738SDoug Rabson { 193a4f67738SDoug Rabson 194326e27d8SDoug Rabson linker_add_class(&link_elf_class); 195a4f67738SDoug Rabson } 196a4f67738SDoug Rabson 197e9eabf59SPeter Wemm SYSINIT(link_elf_obj, SI_SUB_KLD, SI_ORDER_SECOND, link_elf_init, 0); 198a4f67738SDoug Rabson 199a4f67738SDoug Rabson static int 200e9eabf59SPeter Wemm link_elf_link_preload(linker_class_t cls, const char *filename, 201e9eabf59SPeter Wemm linker_file_t *result) 2022d636ab0SPeter Wemm { 20370b7ffeeSIan Dowse Elf_Ehdr *hdr; 20470b7ffeeSIan Dowse Elf_Shdr *shdr; 20570b7ffeeSIan Dowse Elf_Sym *es; 20670b7ffeeSIan Dowse void *modptr, *baseptr, *sizeptr; 20770b7ffeeSIan Dowse char *type; 20870b7ffeeSIan Dowse elf_file_t ef; 20970b7ffeeSIan Dowse linker_file_t lf; 21070b7ffeeSIan Dowse Elf_Addr off; 21170b7ffeeSIan Dowse int error, i, j, pb, ra, rl, shstrindex, symstrindex, symtabindex; 21270b7ffeeSIan Dowse 21370b7ffeeSIan Dowse /* Look to see if we have the file preloaded */ 21470b7ffeeSIan Dowse modptr = preload_search_by_name(filename); 21570b7ffeeSIan Dowse if (modptr == NULL) 21670b7ffeeSIan Dowse return ENOENT; 21770b7ffeeSIan Dowse 21870b7ffeeSIan Dowse type = (char *)preload_search_info(modptr, MODINFO_TYPE); 21970b7ffeeSIan Dowse baseptr = preload_search_info(modptr, MODINFO_ADDR); 22070b7ffeeSIan Dowse sizeptr = preload_search_info(modptr, MODINFO_SIZE); 22170b7ffeeSIan Dowse hdr = (Elf_Ehdr *)preload_search_info(modptr, MODINFO_METADATA | 22270b7ffeeSIan Dowse MODINFOMD_ELFHDR); 22370b7ffeeSIan Dowse shdr = (Elf_Shdr *)preload_search_info(modptr, MODINFO_METADATA | 22470b7ffeeSIan Dowse MODINFOMD_SHDR); 22570b7ffeeSIan Dowse if (type == NULL || (strcmp(type, "elf" __XSTRING(__ELF_WORD_SIZE) 22670b7ffeeSIan Dowse " obj module") != 0 && 22770b7ffeeSIan Dowse strcmp(type, "elf obj module") != 0)) { 228de78ca7eSPeter Wemm return (EFTYPE); 229de78ca7eSPeter Wemm } 23070b7ffeeSIan Dowse if (baseptr == NULL || sizeptr == NULL || hdr == NULL || 23170b7ffeeSIan Dowse shdr == NULL) 23270b7ffeeSIan Dowse return (EINVAL); 23370b7ffeeSIan Dowse 23470b7ffeeSIan Dowse lf = linker_make_file(filename, &link_elf_class); 23570b7ffeeSIan Dowse if (lf == NULL) 23670b7ffeeSIan Dowse return (ENOMEM); 23770b7ffeeSIan Dowse 23870b7ffeeSIan Dowse ef = (elf_file_t)lf; 23970b7ffeeSIan Dowse ef->preloaded = 1; 24070b7ffeeSIan Dowse ef->address = *(caddr_t *)baseptr; 24170b7ffeeSIan Dowse lf->address = *(caddr_t *)baseptr; 24270b7ffeeSIan Dowse lf->size = *(size_t *)sizeptr; 24370b7ffeeSIan Dowse 24470b7ffeeSIan Dowse if (hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS || 24570b7ffeeSIan Dowse hdr->e_ident[EI_DATA] != ELF_TARG_DATA || 24670b7ffeeSIan Dowse hdr->e_ident[EI_VERSION] != EV_CURRENT || 24770b7ffeeSIan Dowse hdr->e_version != EV_CURRENT || 24870b7ffeeSIan Dowse hdr->e_type != ET_REL || 24970b7ffeeSIan Dowse hdr->e_machine != ELF_TARG_MACH) { 25070b7ffeeSIan Dowse error = EFTYPE; 25170b7ffeeSIan Dowse goto out; 25270b7ffeeSIan Dowse } 25370b7ffeeSIan Dowse ef->e_shdr = shdr; 25470b7ffeeSIan Dowse 25570b7ffeeSIan Dowse /* Scan the section header for information and table sizing. */ 25670b7ffeeSIan Dowse symtabindex = -1; 25770b7ffeeSIan Dowse symstrindex = -1; 25870b7ffeeSIan Dowse for (i = 0; i < hdr->e_shnum; i++) { 25970b7ffeeSIan Dowse switch (shdr[i].sh_type) { 26070b7ffeeSIan Dowse case SHT_PROGBITS: 26170b7ffeeSIan Dowse case SHT_NOBITS: 26213f28d96SKonstantin Belousov #ifdef __amd64__ 263b715d9afSKonstantin Belousov case SHT_X86_64_UNWIND: 26413f28d96SKonstantin Belousov #endif 26570b7ffeeSIan Dowse ef->nprogtab++; 26670b7ffeeSIan Dowse break; 26770b7ffeeSIan Dowse case SHT_SYMTAB: 26870b7ffeeSIan Dowse symtabindex = i; 26970b7ffeeSIan Dowse symstrindex = shdr[i].sh_link; 27070b7ffeeSIan Dowse break; 27170b7ffeeSIan Dowse case SHT_REL: 272b474c780SDavid E. O'Brien ef->nreltab++; 27370b7ffeeSIan Dowse break; 27470b7ffeeSIan Dowse case SHT_RELA: 275b474c780SDavid E. O'Brien ef->nrelatab++; 27670b7ffeeSIan Dowse break; 27770b7ffeeSIan Dowse } 27870b7ffeeSIan Dowse } 27970b7ffeeSIan Dowse 28070b7ffeeSIan Dowse shstrindex = hdr->e_shstrndx; 28170b7ffeeSIan Dowse if (ef->nprogtab == 0 || symstrindex < 0 || 28270b7ffeeSIan Dowse symstrindex >= hdr->e_shnum || 28370b7ffeeSIan Dowse shdr[symstrindex].sh_type != SHT_STRTAB || shstrindex == 0 || 28470b7ffeeSIan Dowse shstrindex >= hdr->e_shnum || 28570b7ffeeSIan Dowse shdr[shstrindex].sh_type != SHT_STRTAB) { 28670b7ffeeSIan Dowse printf("%s: bad/missing section headers\n", filename); 28770b7ffeeSIan Dowse error = ENOEXEC; 28870b7ffeeSIan Dowse goto out; 28970b7ffeeSIan Dowse } 29070b7ffeeSIan Dowse 29170b7ffeeSIan Dowse /* Allocate space for tracking the load chunks */ 29270b7ffeeSIan Dowse if (ef->nprogtab != 0) 29370b7ffeeSIan Dowse ef->progtab = malloc(ef->nprogtab * sizeof(*ef->progtab), 29470b7ffeeSIan Dowse M_LINKER, M_WAITOK | M_ZERO); 295b474c780SDavid E. O'Brien if (ef->nreltab != 0) 296b474c780SDavid E. O'Brien ef->reltab = malloc(ef->nreltab * sizeof(*ef->reltab), 297b474c780SDavid E. O'Brien M_LINKER, M_WAITOK | M_ZERO); 298b474c780SDavid E. O'Brien if (ef->nrelatab != 0) 299b474c780SDavid E. O'Brien ef->relatab = malloc(ef->nrelatab * sizeof(*ef->relatab), 300b474c780SDavid E. O'Brien M_LINKER, M_WAITOK | M_ZERO); 30170b7ffeeSIan Dowse if ((ef->nprogtab != 0 && ef->progtab == NULL) || 302b474c780SDavid E. O'Brien (ef->nreltab != 0 && ef->reltab == NULL) || 303b474c780SDavid E. O'Brien (ef->nrelatab != 0 && ef->relatab == NULL)) { 30470b7ffeeSIan Dowse error = ENOMEM; 30570b7ffeeSIan Dowse goto out; 30670b7ffeeSIan Dowse } 30770b7ffeeSIan Dowse 30870b7ffeeSIan Dowse /* XXX, relocate the sh_addr fields saved by the loader. */ 30970b7ffeeSIan Dowse off = 0; 31070b7ffeeSIan Dowse for (i = 0; i < hdr->e_shnum; i++) { 31170b7ffeeSIan Dowse if (shdr[i].sh_addr != 0 && (off == 0 || shdr[i].sh_addr < off)) 31270b7ffeeSIan Dowse off = shdr[i].sh_addr; 31370b7ffeeSIan Dowse } 31470b7ffeeSIan Dowse for (i = 0; i < hdr->e_shnum; i++) { 31570b7ffeeSIan Dowse if (shdr[i].sh_addr != 0) 31670b7ffeeSIan Dowse shdr[i].sh_addr = shdr[i].sh_addr - off + 31770b7ffeeSIan Dowse (Elf_Addr)ef->address; 31870b7ffeeSIan Dowse } 31970b7ffeeSIan Dowse 32070b7ffeeSIan Dowse ef->ddbsymcnt = shdr[symtabindex].sh_size / sizeof(Elf_Sym); 32170b7ffeeSIan Dowse ef->ddbsymtab = (Elf_Sym *)shdr[symtabindex].sh_addr; 32270b7ffeeSIan Dowse ef->ddbstrcnt = shdr[symstrindex].sh_size; 32370b7ffeeSIan Dowse ef->ddbstrtab = (char *)shdr[symstrindex].sh_addr; 32470b7ffeeSIan Dowse ef->shstrcnt = shdr[shstrindex].sh_size; 32570b7ffeeSIan Dowse ef->shstrtab = (char *)shdr[shstrindex].sh_addr; 32670b7ffeeSIan Dowse 32770b7ffeeSIan Dowse /* Now fill out progtab and the relocation tables. */ 32870b7ffeeSIan Dowse pb = 0; 32970b7ffeeSIan Dowse rl = 0; 33070b7ffeeSIan Dowse ra = 0; 33170b7ffeeSIan Dowse for (i = 0; i < hdr->e_shnum; i++) { 33270b7ffeeSIan Dowse switch (shdr[i].sh_type) { 33370b7ffeeSIan Dowse case SHT_PROGBITS: 33470b7ffeeSIan Dowse case SHT_NOBITS: 33513f28d96SKonstantin Belousov #ifdef __amd64__ 336b715d9afSKonstantin Belousov case SHT_X86_64_UNWIND: 33713f28d96SKonstantin Belousov #endif 33870b7ffeeSIan Dowse ef->progtab[pb].addr = (void *)shdr[i].sh_addr; 33970b7ffeeSIan Dowse if (shdr[i].sh_type == SHT_PROGBITS) 34070b7ffeeSIan Dowse ef->progtab[pb].name = "<<PROGBITS>>"; 34113f28d96SKonstantin Belousov #ifdef __amd64__ 342b715d9afSKonstantin Belousov else if (shdr[i].sh_type == SHT_X86_64_UNWIND) 34313f28d96SKonstantin Belousov ef->progtab[pb].name = "<<UNWIND>>"; 34413f28d96SKonstantin Belousov #endif 34570b7ffeeSIan Dowse else 34670b7ffeeSIan Dowse ef->progtab[pb].name = "<<NOBITS>>"; 34770b7ffeeSIan Dowse ef->progtab[pb].size = shdr[i].sh_size; 34870b7ffeeSIan Dowse ef->progtab[pb].sec = i; 34970b7ffeeSIan Dowse if (ef->shstrtab && shdr[i].sh_name != 0) 35070b7ffeeSIan Dowse ef->progtab[pb].name = 35170b7ffeeSIan Dowse ef->shstrtab + shdr[i].sh_name; 35250c202c5SJeff Roberson if (ef->progtab[pb].name != NULL && 3535f67450dSDimitry Andric !strcmp(ef->progtab[pb].name, DPCPU_SETNAME)) { 35450c202c5SJeff Roberson void *dpcpu; 35550c202c5SJeff Roberson 35650c202c5SJeff Roberson dpcpu = dpcpu_alloc(shdr[i].sh_size); 35750c202c5SJeff Roberson if (dpcpu == NULL) { 35850c202c5SJeff Roberson error = ENOSPC; 35950c202c5SJeff Roberson goto out; 36050c202c5SJeff Roberson } 36150c202c5SJeff Roberson memcpy(dpcpu, ef->progtab[pb].addr, 36250c202c5SJeff Roberson ef->progtab[pb].size); 36350c202c5SJeff Roberson dpcpu_copy(dpcpu, shdr[i].sh_size); 36450c202c5SJeff Roberson ef->progtab[pb].addr = dpcpu; 365eddfbb76SRobert Watson #ifdef VIMAGE 366eddfbb76SRobert Watson } else if (ef->progtab[pb].name != NULL && 36717ef1febSRobert Watson !strcmp(ef->progtab[pb].name, VNET_SETNAME)) { 368eddfbb76SRobert Watson void *vnet_data; 369eddfbb76SRobert Watson 370eddfbb76SRobert Watson vnet_data = vnet_data_alloc(shdr[i].sh_size); 371eddfbb76SRobert Watson if (vnet_data == NULL) { 372eddfbb76SRobert Watson error = ENOSPC; 373eddfbb76SRobert Watson goto out; 374eddfbb76SRobert Watson } 375eddfbb76SRobert Watson memcpy(vnet_data, ef->progtab[pb].addr, 376eddfbb76SRobert Watson ef->progtab[pb].size); 377eddfbb76SRobert Watson vnet_data_copy(vnet_data, shdr[i].sh_size); 378eddfbb76SRobert Watson ef->progtab[pb].addr = vnet_data; 379eddfbb76SRobert Watson #endif 3800067051fSMarcel Moolenaar } else if (ef->progtab[pb].name != NULL && 3810067051fSMarcel Moolenaar !strcmp(ef->progtab[pb].name, ".ctors")) { 3820067051fSMarcel Moolenaar lf->ctors_addr = ef->progtab[pb].addr; 3830067051fSMarcel Moolenaar lf->ctors_size = shdr[i].sh_size; 38450c202c5SJeff Roberson } 38570b7ffeeSIan Dowse 38670b7ffeeSIan Dowse /* Update all symbol values with the offset. */ 38770b7ffeeSIan Dowse for (j = 0; j < ef->ddbsymcnt; j++) { 38870b7ffeeSIan Dowse es = &ef->ddbsymtab[j]; 38970b7ffeeSIan Dowse if (es->st_shndx != i) 39070b7ffeeSIan Dowse continue; 39170b7ffeeSIan Dowse es->st_value += (Elf_Addr)ef->progtab[pb].addr; 39270b7ffeeSIan Dowse } 39370b7ffeeSIan Dowse pb++; 39470b7ffeeSIan Dowse break; 39570b7ffeeSIan Dowse case SHT_REL: 39670b7ffeeSIan Dowse ef->reltab[rl].rel = (Elf_Rel *)shdr[i].sh_addr; 39770b7ffeeSIan Dowse ef->reltab[rl].nrel = shdr[i].sh_size / sizeof(Elf_Rel); 39870b7ffeeSIan Dowse ef->reltab[rl].sec = shdr[i].sh_info; 39970b7ffeeSIan Dowse rl++; 40070b7ffeeSIan Dowse break; 40170b7ffeeSIan Dowse case SHT_RELA: 40270b7ffeeSIan Dowse ef->relatab[ra].rela = (Elf_Rela *)shdr[i].sh_addr; 40370b7ffeeSIan Dowse ef->relatab[ra].nrela = 40470b7ffeeSIan Dowse shdr[i].sh_size / sizeof(Elf_Rela); 40570b7ffeeSIan Dowse ef->relatab[ra].sec = shdr[i].sh_info; 40670b7ffeeSIan Dowse ra++; 40770b7ffeeSIan Dowse break; 40870b7ffeeSIan Dowse } 40970b7ffeeSIan Dowse } 4103cfce8e4SKonstantin Belousov if (pb != ef->nprogtab) { 4113cfce8e4SKonstantin Belousov printf("%s: lost progbits\n", filename); 4123cfce8e4SKonstantin Belousov error = ENOEXEC; 4133cfce8e4SKonstantin Belousov goto out; 4143cfce8e4SKonstantin Belousov } 4153cfce8e4SKonstantin Belousov if (rl != ef->nreltab) { 4163cfce8e4SKonstantin Belousov printf("%s: lost reltab\n", filename); 4173cfce8e4SKonstantin Belousov error = ENOEXEC; 4183cfce8e4SKonstantin Belousov goto out; 4193cfce8e4SKonstantin Belousov } 4203cfce8e4SKonstantin Belousov if (ra != ef->nrelatab) { 4213cfce8e4SKonstantin Belousov printf("%s: lost relatab\n", filename); 4223cfce8e4SKonstantin Belousov error = ENOEXEC; 4233cfce8e4SKonstantin Belousov goto out; 4243cfce8e4SKonstantin Belousov } 42570b7ffeeSIan Dowse 42670b7ffeeSIan Dowse /* Local intra-module relocations */ 4273cfce8e4SKonstantin Belousov error = link_elf_reloc_local(lf); 4283cfce8e4SKonstantin Belousov if (error != 0) 4293cfce8e4SKonstantin Belousov goto out; 43070b7ffeeSIan Dowse 43170b7ffeeSIan Dowse *result = lf; 43270b7ffeeSIan Dowse return (0); 43370b7ffeeSIan Dowse 43470b7ffeeSIan Dowse out: 43570b7ffeeSIan Dowse /* preload not done this way */ 43670b7ffeeSIan Dowse linker_file_unload(lf, LINKER_UNLOAD_FORCE); 43770b7ffeeSIan Dowse return (error); 43870b7ffeeSIan Dowse } 439de78ca7eSPeter Wemm 4400067051fSMarcel Moolenaar static void 4410067051fSMarcel Moolenaar link_elf_invoke_ctors(caddr_t addr, size_t size) 4420067051fSMarcel Moolenaar { 4430067051fSMarcel Moolenaar void (**ctor)(void); 4440067051fSMarcel Moolenaar size_t i, cnt; 4450067051fSMarcel Moolenaar 4460067051fSMarcel Moolenaar if (addr == NULL || size == 0) 4470067051fSMarcel Moolenaar return; 4480067051fSMarcel Moolenaar cnt = size / sizeof(*ctor); 4490067051fSMarcel Moolenaar ctor = (void *)addr; 4500067051fSMarcel Moolenaar for (i = 0; i < cnt; i++) { 4510067051fSMarcel Moolenaar if (ctor[i] != NULL) 4520067051fSMarcel Moolenaar (*ctor[i])(); 4530067051fSMarcel Moolenaar } 4540067051fSMarcel Moolenaar } 4550067051fSMarcel Moolenaar 456de78ca7eSPeter Wemm static int 45754823af2SPeter Wemm link_elf_link_preload_finish(linker_file_t lf) 45854823af2SPeter Wemm { 45970b7ffeeSIan Dowse elf_file_t ef; 46070b7ffeeSIan Dowse int error; 46170b7ffeeSIan Dowse 46270b7ffeeSIan Dowse ef = (elf_file_t)lf; 46370b7ffeeSIan Dowse error = relocate_file(ef); 46470b7ffeeSIan Dowse if (error) 46570b7ffeeSIan Dowse return error; 46670b7ffeeSIan Dowse 46770b7ffeeSIan Dowse /* Notify MD code that a module is being loaded. */ 46870b7ffeeSIan Dowse error = elf_cpu_load_file(lf); 46970b7ffeeSIan Dowse if (error) 47070b7ffeeSIan Dowse return (error); 47170b7ffeeSIan Dowse 4720067051fSMarcel Moolenaar /* Invoke .ctors */ 4730067051fSMarcel Moolenaar link_elf_invoke_ctors(lf->ctors_addr, lf->ctors_size); 47470b7ffeeSIan Dowse return (0); 47554823af2SPeter Wemm } 47654823af2SPeter Wemm 47754823af2SPeter Wemm static int 478c143d6c2SMarcel Moolenaar link_elf_load_file(linker_class_t cls, const char *filename, 479c143d6c2SMarcel Moolenaar linker_file_t *result) 480a4f67738SDoug Rabson { 481a344babfSGleb Smirnoff struct nameidata *nd; 482b40ce416SJulian Elischer struct thread *td = curthread; /* XXX */ 483caab6e90SPeter Wemm Elf_Ehdr *hdr; 484e9eabf59SPeter Wemm Elf_Shdr *shdr; 485a8774e39SPeter Wemm Elf_Sym *es; 486a8774e39SPeter Wemm int nbytes, i, j; 48720947801SPeter Wemm vm_offset_t mapbase; 488fe3db7c7SDoug Rabson size_t mapsize; 489a4f67738SDoug Rabson int error = 0; 490526d0bd5SKonstantin Belousov ssize_t resid; 491526d0bd5SKonstantin Belousov int flags; 492a4f67738SDoug Rabson elf_file_t ef; 493a4f67738SDoug Rabson linker_file_t lf; 494ca65d5c7SPeter Wemm int symtabindex; 495ca65d5c7SPeter Wemm int symstrindex; 496e9eabf59SPeter Wemm int shstrindex; 497e9eabf59SPeter Wemm int nsym; 49820947801SPeter Wemm int pb, rl, ra; 499e9eabf59SPeter Wemm int alignmask; 500ca65d5c7SPeter Wemm 501ca65d5c7SPeter Wemm shdr = NULL; 502ca65d5c7SPeter Wemm lf = NULL; 503e9eabf59SPeter Wemm mapsize = 0; 504e9eabf59SPeter Wemm hdr = NULL; 505a4f67738SDoug Rabson 506a344babfSGleb Smirnoff nd = malloc(sizeof(struct nameidata), M_TEMP, M_WAITOK); 507a344babfSGleb Smirnoff NDINIT(nd, LOOKUP, FOLLOW, UIO_SYSSPACE, filename, td); 508e6796b67SKirk McKusick flags = FREAD; 509a344babfSGleb Smirnoff error = vn_open(nd, &flags, 0, NULL); 510a344babfSGleb Smirnoff if (error) { 511a344babfSGleb Smirnoff free(nd, M_TEMP); 512a4f67738SDoug Rabson return error; 513a344babfSGleb Smirnoff } 514a344babfSGleb Smirnoff NDFREE(nd, NDF_ONLY_PNBUF); 515a344babfSGleb Smirnoff if (nd->ni_vp->v_type != VREG) { 5161f49b573SRuslan Ermilov error = ENOEXEC; 5171f49b573SRuslan Ermilov goto out; 5181f49b573SRuslan Ermilov } 519a3df768bSRobert Watson #ifdef MAC 520a344babfSGleb Smirnoff error = mac_kld_check_load(td->td_ucred, nd->ni_vp); 521a3df768bSRobert Watson if (error) { 522a3df768bSRobert Watson goto out; 523a3df768bSRobert Watson } 524a3df768bSRobert Watson #endif 525a4f67738SDoug Rabson 526e9eabf59SPeter Wemm /* Read the elf header from the file. */ 527e9eabf59SPeter Wemm hdr = malloc(sizeof(*hdr), M_LINKER, M_WAITOK); 528a344babfSGleb Smirnoff error = vn_rdwr(UIO_READ, nd->ni_vp, (void *)hdr, sizeof(*hdr), 0, 5299ca43589SRobert Watson UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 5309ca43589SRobert Watson &resid, td); 531a4f67738SDoug Rabson if (error) 532a4f67738SDoug Rabson goto out; 533e9eabf59SPeter Wemm if (resid != 0){ 534e9eabf59SPeter Wemm error = ENOEXEC; 535e9eabf59SPeter Wemm goto out; 536e9eabf59SPeter Wemm } 537a4f67738SDoug Rabson 538caab6e90SPeter Wemm if (!IS_ELF(*hdr)) { 539fe3db7c7SDoug Rabson error = ENOEXEC; 540a4f67738SDoug Rabson goto out; 541fe3db7c7SDoug Rabson } 542fe3db7c7SDoug Rabson 543caab6e90SPeter Wemm if (hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS 544caab6e90SPeter Wemm || hdr->e_ident[EI_DATA] != ELF_TARG_DATA) { 545552f9f63SEdwin Groothuis link_elf_error(filename, "Unsupported file layout"); 546fe3db7c7SDoug Rabson error = ENOEXEC; 547fe3db7c7SDoug Rabson goto out; 548fe3db7c7SDoug Rabson } 549caab6e90SPeter Wemm if (hdr->e_ident[EI_VERSION] != EV_CURRENT 550caab6e90SPeter Wemm || hdr->e_version != EV_CURRENT) { 551552f9f63SEdwin Groothuis link_elf_error(filename, "Unsupported file version"); 552fe3db7c7SDoug Rabson error = ENOEXEC; 553fe3db7c7SDoug Rabson goto out; 554fe3db7c7SDoug Rabson } 555e9eabf59SPeter Wemm if (hdr->e_type != ET_REL) { 556a1d7ce03SAttilio Rao error = ENOSYS; 557fe3db7c7SDoug Rabson goto out; 558fe3db7c7SDoug Rabson } 559caab6e90SPeter Wemm if (hdr->e_machine != ELF_TARG_MACH) { 560552f9f63SEdwin Groothuis link_elf_error(filename, "Unsupported machine"); 561fe3db7c7SDoug Rabson error = ENOEXEC; 562fe3db7c7SDoug Rabson goto out; 563fe3db7c7SDoug Rabson } 564a4f67738SDoug Rabson 565326e27d8SDoug Rabson lf = linker_make_file(filename, &link_elf_class); 566326e27d8SDoug Rabson if (!lf) { 567326e27d8SDoug Rabson error = ENOMEM; 568326e27d8SDoug Rabson goto out; 569326e27d8SDoug Rabson } 570326e27d8SDoug Rabson ef = (elf_file_t) lf; 571e9eabf59SPeter Wemm ef->nprogtab = 0; 572e9eabf59SPeter Wemm ef->e_shdr = 0; 573b474c780SDavid E. O'Brien ef->nreltab = 0; 574b474c780SDavid E. O'Brien ef->nrelatab = 0; 575e9eabf59SPeter Wemm 576e9eabf59SPeter Wemm /* Allocate and read in the section header */ 577e9eabf59SPeter Wemm nbytes = hdr->e_shnum * hdr->e_shentsize; 578e9eabf59SPeter Wemm if (nbytes == 0 || hdr->e_shoff == 0 || 579e9eabf59SPeter Wemm hdr->e_shentsize != sizeof(Elf_Shdr)) { 580e9eabf59SPeter Wemm error = ENOEXEC; 581e9eabf59SPeter Wemm goto out; 582e9eabf59SPeter Wemm } 58320947801SPeter Wemm shdr = malloc(nbytes, M_LINKER, M_WAITOK); 584e9eabf59SPeter Wemm ef->e_shdr = shdr; 585a344babfSGleb Smirnoff error = vn_rdwr(UIO_READ, nd->ni_vp, (caddr_t)shdr, nbytes, 586a344babfSGleb Smirnoff hdr->e_shoff, UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, 587a344babfSGleb Smirnoff NOCRED, &resid, td); 588e9eabf59SPeter Wemm if (error) 589e9eabf59SPeter Wemm goto out; 590e9eabf59SPeter Wemm if (resid) { 591e9eabf59SPeter Wemm error = ENOEXEC; 592e9eabf59SPeter Wemm goto out; 593e9eabf59SPeter Wemm } 594e9eabf59SPeter Wemm 595e9eabf59SPeter Wemm /* Scan the section header for information and table sizing. */ 596e9eabf59SPeter Wemm nsym = 0; 597e9eabf59SPeter Wemm symtabindex = -1; 598e9eabf59SPeter Wemm symstrindex = -1; 599e9eabf59SPeter Wemm for (i = 0; i < hdr->e_shnum; i++) { 600676799a0SAndriy Gapon if (shdr[i].sh_size == 0) 601676799a0SAndriy Gapon continue; 602e9eabf59SPeter Wemm switch (shdr[i].sh_type) { 603e9eabf59SPeter Wemm case SHT_PROGBITS: 604e9eabf59SPeter Wemm case SHT_NOBITS: 60513f28d96SKonstantin Belousov #ifdef __amd64__ 606b715d9afSKonstantin Belousov case SHT_X86_64_UNWIND: 60713f28d96SKonstantin Belousov #endif 60820947801SPeter Wemm ef->nprogtab++; 609e9eabf59SPeter Wemm break; 610e9eabf59SPeter Wemm case SHT_SYMTAB: 611e9eabf59SPeter Wemm nsym++; 612e9eabf59SPeter Wemm symtabindex = i; 613e9eabf59SPeter Wemm symstrindex = shdr[i].sh_link; 614e9eabf59SPeter Wemm break; 615e9eabf59SPeter Wemm case SHT_REL: 616b474c780SDavid E. O'Brien ef->nreltab++; 617e9eabf59SPeter Wemm break; 618e9eabf59SPeter Wemm case SHT_RELA: 619b474c780SDavid E. O'Brien ef->nrelatab++; 620e9eabf59SPeter Wemm break; 621e9eabf59SPeter Wemm case SHT_STRTAB: 622e9eabf59SPeter Wemm break; 623e9eabf59SPeter Wemm } 624e9eabf59SPeter Wemm } 62520947801SPeter Wemm if (ef->nprogtab == 0) { 626552f9f63SEdwin Groothuis link_elf_error(filename, "file has no contents"); 627e9eabf59SPeter Wemm error = ENOEXEC; 628e9eabf59SPeter Wemm goto out; 629e9eabf59SPeter Wemm } 630e9eabf59SPeter Wemm if (nsym != 1) { 631e9eabf59SPeter Wemm /* Only allow one symbol table for now */ 632552f9f63SEdwin Groothuis link_elf_error(filename, "file has no valid symbol table"); 633e9eabf59SPeter Wemm error = ENOEXEC; 634e9eabf59SPeter Wemm goto out; 635e9eabf59SPeter Wemm } 636e9eabf59SPeter Wemm if (symstrindex < 0 || symstrindex > hdr->e_shnum || 637e9eabf59SPeter Wemm shdr[symstrindex].sh_type != SHT_STRTAB) { 638552f9f63SEdwin Groothuis link_elf_error(filename, "file has invalid symbol strings"); 639e9eabf59SPeter Wemm error = ENOEXEC; 640e9eabf59SPeter Wemm goto out; 641e9eabf59SPeter Wemm } 642e9eabf59SPeter Wemm 643e9eabf59SPeter Wemm /* Allocate space for tracking the load chunks */ 644e9eabf59SPeter Wemm if (ef->nprogtab != 0) 64520947801SPeter Wemm ef->progtab = malloc(ef->nprogtab * sizeof(*ef->progtab), 64620947801SPeter Wemm M_LINKER, M_WAITOK | M_ZERO); 647b474c780SDavid E. O'Brien if (ef->nreltab != 0) 648b474c780SDavid E. O'Brien ef->reltab = malloc(ef->nreltab * sizeof(*ef->reltab), 649b474c780SDavid E. O'Brien M_LINKER, M_WAITOK | M_ZERO); 650b474c780SDavid E. O'Brien if (ef->nrelatab != 0) 651b474c780SDavid E. O'Brien ef->relatab = malloc(ef->nrelatab * sizeof(*ef->relatab), 652b474c780SDavid E. O'Brien M_LINKER, M_WAITOK | M_ZERO); 653e9eabf59SPeter Wemm 6543cfce8e4SKonstantin Belousov if (symtabindex == -1) { 6553cfce8e4SKonstantin Belousov link_elf_error(filename, "lost symbol table index"); 6563cfce8e4SKonstantin Belousov error = ENOEXEC; 6573cfce8e4SKonstantin Belousov goto out; 6583cfce8e4SKonstantin Belousov } 65920947801SPeter Wemm /* Allocate space for and load the symbol table */ 660e9eabf59SPeter Wemm ef->ddbsymcnt = shdr[symtabindex].sh_size / sizeof(Elf_Sym); 661e9eabf59SPeter Wemm ef->ddbsymtab = malloc(shdr[symtabindex].sh_size, M_LINKER, M_WAITOK); 662a344babfSGleb Smirnoff error = vn_rdwr(UIO_READ, nd->ni_vp, (void *)ef->ddbsymtab, 66320947801SPeter Wemm shdr[symtabindex].sh_size, shdr[symtabindex].sh_offset, 66420947801SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 66520947801SPeter Wemm &resid, td); 66620947801SPeter Wemm if (error) 66720947801SPeter Wemm goto out; 66820947801SPeter Wemm if (resid != 0){ 66920947801SPeter Wemm error = EINVAL; 67020947801SPeter Wemm goto out; 67120947801SPeter Wemm } 672e9eabf59SPeter Wemm 6733cfce8e4SKonstantin Belousov if (symstrindex == -1) { 6743cfce8e4SKonstantin Belousov link_elf_error(filename, "lost symbol string index"); 6753cfce8e4SKonstantin Belousov error = ENOEXEC; 6763cfce8e4SKonstantin Belousov goto out; 6773cfce8e4SKonstantin Belousov } 67820947801SPeter Wemm /* Allocate space for and load the symbol strings */ 679e9eabf59SPeter Wemm ef->ddbstrcnt = shdr[symstrindex].sh_size; 680e9eabf59SPeter Wemm ef->ddbstrtab = malloc(shdr[symstrindex].sh_size, M_LINKER, M_WAITOK); 681a344babfSGleb Smirnoff error = vn_rdwr(UIO_READ, nd->ni_vp, ef->ddbstrtab, 68220947801SPeter Wemm shdr[symstrindex].sh_size, shdr[symstrindex].sh_offset, 68320947801SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 68420947801SPeter Wemm &resid, td); 68520947801SPeter Wemm if (error) 68620947801SPeter Wemm goto out; 68720947801SPeter Wemm if (resid != 0){ 68820947801SPeter Wemm error = EINVAL; 68920947801SPeter Wemm goto out; 69020947801SPeter Wemm } 691e9eabf59SPeter Wemm 692e9eabf59SPeter Wemm /* Do we have a string table for the section names? */ 693e9eabf59SPeter Wemm shstrindex = -1; 69420947801SPeter Wemm if (hdr->e_shstrndx != 0 && 69520947801SPeter Wemm shdr[hdr->e_shstrndx].sh_type == SHT_STRTAB) { 696e9eabf59SPeter Wemm shstrindex = hdr->e_shstrndx; 697e9eabf59SPeter Wemm ef->shstrcnt = shdr[shstrindex].sh_size; 69820947801SPeter Wemm ef->shstrtab = malloc(shdr[shstrindex].sh_size, M_LINKER, 69920947801SPeter Wemm M_WAITOK); 700a344babfSGleb Smirnoff error = vn_rdwr(UIO_READ, nd->ni_vp, ef->shstrtab, 70120947801SPeter Wemm shdr[shstrindex].sh_size, shdr[shstrindex].sh_offset, 702e9eabf59SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 703e9eabf59SPeter Wemm &resid, td); 704e9eabf59SPeter Wemm if (error) 705e9eabf59SPeter Wemm goto out; 70620947801SPeter Wemm if (resid != 0){ 70720947801SPeter Wemm error = EINVAL; 70820947801SPeter Wemm goto out; 70920947801SPeter Wemm } 710e9eabf59SPeter Wemm } 711e9eabf59SPeter Wemm 71220947801SPeter Wemm /* Size up code/data(progbits) and bss(nobits). */ 713e9eabf59SPeter Wemm alignmask = 0; 714e9eabf59SPeter Wemm for (i = 0; i < hdr->e_shnum; i++) { 715676799a0SAndriy Gapon if (shdr[i].sh_size == 0) 716676799a0SAndriy Gapon continue; 717e9eabf59SPeter Wemm switch (shdr[i].sh_type) { 718e9eabf59SPeter Wemm case SHT_PROGBITS: 719e9eabf59SPeter Wemm case SHT_NOBITS: 72013f28d96SKonstantin Belousov #ifdef __amd64__ 721b715d9afSKonstantin Belousov case SHT_X86_64_UNWIND: 72213f28d96SKonstantin Belousov #endif 723e9eabf59SPeter Wemm alignmask = shdr[i].sh_addralign - 1; 724e9eabf59SPeter Wemm mapsize += alignmask; 725e9eabf59SPeter Wemm mapsize &= ~alignmask; 726e9eabf59SPeter Wemm mapsize += shdr[i].sh_size; 727e9eabf59SPeter Wemm break; 728e9eabf59SPeter Wemm } 729e9eabf59SPeter Wemm } 730e9eabf59SPeter Wemm 731e9eabf59SPeter Wemm /* 732e9eabf59SPeter Wemm * We know how much space we need for the text/data/bss/etc. 733e9eabf59SPeter Wemm * This stuff needs to be in a single chunk so that profiling etc 734e9eabf59SPeter Wemm * can get the bounds and gdb can associate offsets with modules 735e9eabf59SPeter Wemm */ 73620947801SPeter Wemm ef->object = vm_object_allocate(OBJT_DEFAULT, 73720947801SPeter Wemm round_page(mapsize) >> PAGE_SHIFT); 738fe3db7c7SDoug Rabson if (ef->object == NULL) { 739fe3db7c7SDoug Rabson error = ENOMEM; 740fe3db7c7SDoug Rabson goto out; 741fe3db7c7SDoug Rabson } 742fe3db7c7SDoug Rabson ef->address = (caddr_t) vm_map_min(kernel_map); 743ac68d1c9SAlan Cox 744ac68d1c9SAlan Cox /* 745ac68d1c9SAlan Cox * In order to satisfy amd64's architectural requirements on the 746ac68d1c9SAlan Cox * location of code and data in the kernel's address space, request a 747ac68d1c9SAlan Cox * mapping that is above the kernel. 748ac68d1c9SAlan Cox */ 7494104e835SOleksandr Tymoshenko #ifdef __amd64__ 750ac68d1c9SAlan Cox mapbase = KERNBASE; 7514104e835SOleksandr Tymoshenko #else 7524104e835SOleksandr Tymoshenko mapbase = VM_MIN_KERNEL_ADDRESS; 7534104e835SOleksandr Tymoshenko #endif 75420947801SPeter Wemm error = vm_map_find(kernel_map, ef->object, 0, &mapbase, 755edb572a3SJohn Baldwin round_page(mapsize), 0, VMFS_OPTIMAL_SPACE, VM_PROT_ALL, 756edb572a3SJohn Baldwin VM_PROT_ALL, 0); 757fe3db7c7SDoug Rabson if (error) { 758fe3db7c7SDoug Rabson vm_object_deallocate(ef->object); 759326e27d8SDoug Rabson ef->object = 0; 760fe3db7c7SDoug Rabson goto out; 761fe3db7c7SDoug Rabson } 76220947801SPeter Wemm 763e9eabf59SPeter Wemm /* Wire the pages */ 7647f1ef325SAlan Cox error = vm_map_wire(kernel_map, mapbase, 76520947801SPeter Wemm mapbase + round_page(mapsize), 766e9eabf59SPeter Wemm VM_MAP_WIRE_SYSTEM|VM_MAP_WIRE_NOHOLES); 7677f1ef325SAlan Cox if (error != KERN_SUCCESS) { 7687f1ef325SAlan Cox error = ENOMEM; 7697f1ef325SAlan Cox goto out; 7707f1ef325SAlan Cox } 771a4f67738SDoug Rabson 77220947801SPeter Wemm /* Inform the kld system about the situation */ 77320947801SPeter Wemm lf->address = ef->address = (caddr_t)mapbase; 77420947801SPeter Wemm lf->size = mapsize; 775e9eabf59SPeter Wemm 776e9eabf59SPeter Wemm /* 77720947801SPeter Wemm * Now load code/data(progbits), zero bss(nobits), allocate space for 77820947801SPeter Wemm * and load relocs 779e9eabf59SPeter Wemm */ 78020947801SPeter Wemm pb = 0; 78120947801SPeter Wemm rl = 0; 78220947801SPeter Wemm ra = 0; 78320947801SPeter Wemm alignmask = 0; 78420947801SPeter Wemm for (i = 0; i < hdr->e_shnum; i++) { 785676799a0SAndriy Gapon if (shdr[i].sh_size == 0) 786676799a0SAndriy Gapon continue; 78720947801SPeter Wemm switch (shdr[i].sh_type) { 78820947801SPeter Wemm case SHT_PROGBITS: 78920947801SPeter Wemm case SHT_NOBITS: 79013f28d96SKonstantin Belousov #ifdef __amd64__ 791b715d9afSKonstantin Belousov case SHT_X86_64_UNWIND: 79213f28d96SKonstantin Belousov #endif 79320947801SPeter Wemm alignmask = shdr[i].sh_addralign - 1; 79420947801SPeter Wemm mapbase += alignmask; 79520947801SPeter Wemm mapbase &= ~alignmask; 7960067051fSMarcel Moolenaar if (ef->shstrtab != NULL && shdr[i].sh_name != 0) { 79750c202c5SJeff Roberson ef->progtab[pb].name = 79850c202c5SJeff Roberson ef->shstrtab + shdr[i].sh_name; 7990067051fSMarcel Moolenaar if (!strcmp(ef->progtab[pb].name, ".ctors")) { 8000067051fSMarcel Moolenaar lf->ctors_addr = (caddr_t)mapbase; 8010067051fSMarcel Moolenaar lf->ctors_size = shdr[i].sh_size; 8020067051fSMarcel Moolenaar } 8030067051fSMarcel Moolenaar } else if (shdr[i].sh_type == SHT_PROGBITS) 80420947801SPeter Wemm ef->progtab[pb].name = "<<PROGBITS>>"; 80513f28d96SKonstantin Belousov #ifdef __amd64__ 806b715d9afSKonstantin Belousov else if (shdr[i].sh_type == SHT_X86_64_UNWIND) 80713f28d96SKonstantin Belousov ef->progtab[pb].name = "<<UNWIND>>"; 80813f28d96SKonstantin Belousov #endif 80950c202c5SJeff Roberson else 81050c202c5SJeff Roberson ef->progtab[pb].name = "<<NOBITS>>"; 81150c202c5SJeff Roberson if (ef->progtab[pb].name != NULL && 8125f67450dSDimitry Andric !strcmp(ef->progtab[pb].name, DPCPU_SETNAME)) 81350c202c5SJeff Roberson ef->progtab[pb].addr = 81450c202c5SJeff Roberson dpcpu_alloc(shdr[i].sh_size); 815eddfbb76SRobert Watson #ifdef VIMAGE 816eddfbb76SRobert Watson else if (ef->progtab[pb].name != NULL && 81717ef1febSRobert Watson !strcmp(ef->progtab[pb].name, VNET_SETNAME)) 818eddfbb76SRobert Watson ef->progtab[pb].addr = 819eddfbb76SRobert Watson vnet_data_alloc(shdr[i].sh_size); 820eddfbb76SRobert Watson #endif 82150c202c5SJeff Roberson else 82250c202c5SJeff Roberson ef->progtab[pb].addr = 82350c202c5SJeff Roberson (void *)(uintptr_t)mapbase; 82450c202c5SJeff Roberson if (ef->progtab[pb].addr == NULL) { 82550c202c5SJeff Roberson error = ENOSPC; 82650c202c5SJeff Roberson goto out; 82750c202c5SJeff Roberson } 82850c202c5SJeff Roberson ef->progtab[pb].size = shdr[i].sh_size; 82950c202c5SJeff Roberson ef->progtab[pb].sec = i; 83013f28d96SKonstantin Belousov if (shdr[i].sh_type == SHT_PROGBITS 83113f28d96SKonstantin Belousov #ifdef __amd64__ 832b715d9afSKonstantin Belousov || shdr[i].sh_type == SHT_X86_64_UNWIND 83313f28d96SKonstantin Belousov #endif 83413f28d96SKonstantin Belousov ) { 835a344babfSGleb Smirnoff error = vn_rdwr(UIO_READ, nd->ni_vp, 83620947801SPeter Wemm ef->progtab[pb].addr, 83720947801SPeter Wemm shdr[i].sh_size, shdr[i].sh_offset, 83820947801SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, 83920947801SPeter Wemm NOCRED, &resid, td); 84020947801SPeter Wemm if (error) 84120947801SPeter Wemm goto out; 84220947801SPeter Wemm if (resid != 0){ 84320947801SPeter Wemm error = EINVAL; 84420947801SPeter Wemm goto out; 84520947801SPeter Wemm } 846eddfbb76SRobert Watson /* Initialize the per-cpu or vnet area. */ 847eddfbb76SRobert Watson if (ef->progtab[pb].addr != (void *)mapbase && 8485f67450dSDimitry Andric !strcmp(ef->progtab[pb].name, DPCPU_SETNAME)) 84950c202c5SJeff Roberson dpcpu_copy(ef->progtab[pb].addr, 85050c202c5SJeff Roberson shdr[i].sh_size); 851eddfbb76SRobert Watson #ifdef VIMAGE 852eddfbb76SRobert Watson else if (ef->progtab[pb].addr != 853eddfbb76SRobert Watson (void *)mapbase && 85417ef1febSRobert Watson !strcmp(ef->progtab[pb].name, VNET_SETNAME)) 855eddfbb76SRobert Watson vnet_data_copy(ef->progtab[pb].addr, 856eddfbb76SRobert Watson shdr[i].sh_size); 857eddfbb76SRobert Watson #endif 85850c202c5SJeff Roberson } else 85920947801SPeter Wemm bzero(ef->progtab[pb].addr, shdr[i].sh_size); 860a8774e39SPeter Wemm 861a8774e39SPeter Wemm /* Update all symbol values with the offset. */ 862a8774e39SPeter Wemm for (j = 0; j < ef->ddbsymcnt; j++) { 863a8774e39SPeter Wemm es = &ef->ddbsymtab[j]; 864a8774e39SPeter Wemm if (es->st_shndx != i) 865a8774e39SPeter Wemm continue; 866a8774e39SPeter Wemm es->st_value += (Elf_Addr)ef->progtab[pb].addr; 867a8774e39SPeter Wemm } 86820947801SPeter Wemm mapbase += shdr[i].sh_size; 86920947801SPeter Wemm pb++; 87020947801SPeter Wemm break; 87120947801SPeter Wemm case SHT_REL: 87220947801SPeter Wemm ef->reltab[rl].rel = malloc(shdr[i].sh_size, M_LINKER, 87320947801SPeter Wemm M_WAITOK); 87420947801SPeter Wemm ef->reltab[rl].nrel = shdr[i].sh_size / sizeof(Elf_Rel); 87520947801SPeter Wemm ef->reltab[rl].sec = shdr[i].sh_info; 876a344babfSGleb Smirnoff error = vn_rdwr(UIO_READ, nd->ni_vp, 87720947801SPeter Wemm (void *)ef->reltab[rl].rel, 87820947801SPeter Wemm shdr[i].sh_size, shdr[i].sh_offset, 879e9eabf59SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 880e9eabf59SPeter Wemm &resid, td); 881e9eabf59SPeter Wemm if (error) 882e9eabf59SPeter Wemm goto out; 88320947801SPeter Wemm if (resid != 0){ 88420947801SPeter Wemm error = EINVAL; 88520947801SPeter Wemm goto out; 886e9eabf59SPeter Wemm } 88720947801SPeter Wemm rl++; 88820947801SPeter Wemm break; 88920947801SPeter Wemm case SHT_RELA: 89020947801SPeter Wemm ef->relatab[ra].rela = malloc(shdr[i].sh_size, M_LINKER, 89120947801SPeter Wemm M_WAITOK); 89220947801SPeter Wemm ef->relatab[ra].nrela = 89320947801SPeter Wemm shdr[i].sh_size / sizeof(Elf_Rela); 89420947801SPeter Wemm ef->relatab[ra].sec = shdr[i].sh_info; 895a344babfSGleb Smirnoff error = vn_rdwr(UIO_READ, nd->ni_vp, 89620947801SPeter Wemm (void *)ef->relatab[ra].rela, 89720947801SPeter Wemm shdr[i].sh_size, shdr[i].sh_offset, 898e9eabf59SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 899e9eabf59SPeter Wemm &resid, td); 900e9eabf59SPeter Wemm if (error) 901e9eabf59SPeter Wemm goto out; 90220947801SPeter Wemm if (resid != 0){ 90320947801SPeter Wemm error = EINVAL; 90420947801SPeter Wemm goto out; 905e9eabf59SPeter Wemm } 90620947801SPeter Wemm ra++; 90720947801SPeter Wemm break; 90820947801SPeter Wemm } 90920947801SPeter Wemm } 9103cfce8e4SKonstantin Belousov if (pb != ef->nprogtab) { 9113cfce8e4SKonstantin Belousov link_elf_error(filename, "lost progbits"); 9123cfce8e4SKonstantin Belousov error = ENOEXEC; 9133cfce8e4SKonstantin Belousov goto out; 9143cfce8e4SKonstantin Belousov } 9153cfce8e4SKonstantin Belousov if (rl != ef->nreltab) { 9163cfce8e4SKonstantin Belousov link_elf_error(filename, "lost reltab"); 9173cfce8e4SKonstantin Belousov error = ENOEXEC; 9183cfce8e4SKonstantin Belousov goto out; 9193cfce8e4SKonstantin Belousov } 9203cfce8e4SKonstantin Belousov if (ra != ef->nrelatab) { 9213cfce8e4SKonstantin Belousov link_elf_error(filename, "lost relatab"); 9223cfce8e4SKonstantin Belousov error = ENOEXEC; 9233cfce8e4SKonstantin Belousov goto out; 9243cfce8e4SKonstantin Belousov } 9253cfce8e4SKonstantin Belousov if (mapbase != (vm_offset_t)ef->address + mapsize) { 9263cfce8e4SKonstantin Belousov printf( 9273cfce8e4SKonstantin Belousov "%s: mapbase 0x%lx != address %p + mapsize 0x%lx (0x%lx)\n", 9283cfce8e4SKonstantin Belousov filename != NULL ? filename : "<none>", 9296f3c6327SNeel Natu (u_long)mapbase, ef->address, (u_long)mapsize, 9306f3c6327SNeel Natu (u_long)(vm_offset_t)ef->address + mapsize); 9313cfce8e4SKonstantin Belousov error = ENOMEM; 9323cfce8e4SKonstantin Belousov goto out; 9333cfce8e4SKonstantin Belousov } 934e9eabf59SPeter Wemm 935e9eabf59SPeter Wemm /* Local intra-module relocations */ 9363cfce8e4SKonstantin Belousov error = link_elf_reloc_local(lf); 9373cfce8e4SKonstantin Belousov if (error != 0) 9383cfce8e4SKonstantin Belousov goto out; 9397251b4bfSJake Burkholder 940e9eabf59SPeter Wemm /* Pull in dependencies */ 941a344babfSGleb Smirnoff VOP_UNLOCK(nd->ni_vp, 0); 9427b9716baSIan Dowse error = linker_load_dependencies(lf); 943a344babfSGleb Smirnoff vn_lock(nd->ni_vp, LK_EXCLUSIVE | LK_RETRY); 944ca65d5c7SPeter Wemm if (error) 945de78ca7eSPeter Wemm goto out; 946e9eabf59SPeter Wemm 947e9eabf59SPeter Wemm /* External relocations */ 948326e27d8SDoug Rabson error = relocate_file(ef); 949ca65d5c7SPeter Wemm if (error) 950ca65d5c7SPeter Wemm goto out; 951ca65d5c7SPeter Wemm 952e9eabf59SPeter Wemm /* Notify MD code that a module is being loaded. */ 953e9eabf59SPeter Wemm error = elf_cpu_load_file(lf); 954ca65d5c7SPeter Wemm if (error) 955ca65d5c7SPeter Wemm goto out; 956a4f67738SDoug Rabson 9570067051fSMarcel Moolenaar /* Invoke .ctors */ 9580067051fSMarcel Moolenaar link_elf_invoke_ctors(lf->ctors_addr, lf->ctors_size); 9590067051fSMarcel Moolenaar 960a4f67738SDoug Rabson *result = lf; 961a4f67738SDoug Rabson 962a4f67738SDoug Rabson out: 963a344babfSGleb Smirnoff VOP_UNLOCK(nd->ni_vp, 0); 964a344babfSGleb Smirnoff vn_close(nd->ni_vp, FREAD, td->td_ucred, td); 965a344babfSGleb Smirnoff free(nd, M_TEMP); 966ca65d5c7SPeter Wemm if (error && lf) 96765a311fcSPoul-Henning Kamp linker_file_unload(lf, LINKER_UNLOAD_FORCE); 968e9eabf59SPeter Wemm free(hdr, M_LINKER); 969a4f67738SDoug Rabson 970a4f67738SDoug Rabson return error; 971a4f67738SDoug Rabson } 972a4f67738SDoug Rabson 973a4f67738SDoug Rabson static void 974de78ca7eSPeter Wemm link_elf_unload_file(linker_file_t file) 975a4f67738SDoug Rabson { 976326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) file; 97720947801SPeter Wemm int i; 978a4f67738SDoug Rabson 9791aeb23cdSMarcel Moolenaar /* Notify MD code that a module is being unloaded. */ 9801aeb23cdSMarcel Moolenaar elf_cpu_unload_file(file); 9811aeb23cdSMarcel Moolenaar 98250c202c5SJeff Roberson if (ef->progtab) { 98350c202c5SJeff Roberson for (i = 0; i < ef->nprogtab; i++) { 98450c202c5SJeff Roberson if (ef->progtab[i].size == 0) 98550c202c5SJeff Roberson continue; 98650c202c5SJeff Roberson if (ef->progtab[i].name == NULL) 98750c202c5SJeff Roberson continue; 9885f67450dSDimitry Andric if (!strcmp(ef->progtab[i].name, DPCPU_SETNAME)) 98950c202c5SJeff Roberson dpcpu_free(ef->progtab[i].addr, 99050c202c5SJeff Roberson ef->progtab[i].size); 991eddfbb76SRobert Watson #ifdef VIMAGE 99217ef1febSRobert Watson else if (!strcmp(ef->progtab[i].name, VNET_SETNAME)) 993eddfbb76SRobert Watson vnet_data_free(ef->progtab[i].addr, 994eddfbb76SRobert Watson ef->progtab[i].size); 995eddfbb76SRobert Watson #endif 99650c202c5SJeff Roberson } 99750c202c5SJeff Roberson } 99870b7ffeeSIan Dowse if (ef->preloaded) { 99970b7ffeeSIan Dowse free(ef->reltab, M_LINKER); 100070b7ffeeSIan Dowse free(ef->relatab, M_LINKER); 100170b7ffeeSIan Dowse free(ef->progtab, M_LINKER); 1002a2024a3eSJohn Birrell free(ef->ctftab, M_LINKER); 1003a2024a3eSJohn Birrell free(ef->ctfoff, M_LINKER); 1004a2024a3eSJohn Birrell free(ef->typoff, M_LINKER); 100570b7ffeeSIan Dowse if (file->filename != NULL) 100670b7ffeeSIan Dowse preload_delete_name(file->filename); 100770b7ffeeSIan Dowse /* XXX reclaim module memory? */ 100870b7ffeeSIan Dowse return; 100970b7ffeeSIan Dowse } 101070b7ffeeSIan Dowse 1011b474c780SDavid E. O'Brien for (i = 0; i < ef->nreltab; i++) 101220947801SPeter Wemm free(ef->reltab[i].rel, M_LINKER); 1013b474c780SDavid E. O'Brien for (i = 0; i < ef->nrelatab; i++) 101420947801SPeter Wemm free(ef->relatab[i].rela, M_LINKER); 101520947801SPeter Wemm free(ef->reltab, M_LINKER); 101620947801SPeter Wemm free(ef->relatab, M_LINKER); 101720947801SPeter Wemm free(ef->progtab, M_LINKER); 101820947801SPeter Wemm 1019fe3db7c7SDoug Rabson if (ef->object) { 1020fe3db7c7SDoug Rabson vm_map_remove(kernel_map, (vm_offset_t) ef->address, 102120947801SPeter Wemm (vm_offset_t) ef->address + 102220947801SPeter Wemm (ef->object->size << PAGE_SHIFT)); 1023fe3db7c7SDoug Rabson } 1024e9eabf59SPeter Wemm free(ef->e_shdr, M_LINKER); 1025e9eabf59SPeter Wemm free(ef->ddbsymtab, M_LINKER); 1026e9eabf59SPeter Wemm free(ef->ddbstrtab, M_LINKER); 102720947801SPeter Wemm free(ef->shstrtab, M_LINKER); 1028a2024a3eSJohn Birrell free(ef->ctftab, M_LINKER); 1029a2024a3eSJohn Birrell free(ef->ctfoff, M_LINKER); 1030a2024a3eSJohn Birrell free(ef->typoff, M_LINKER); 1031de78ca7eSPeter Wemm } 1032de78ca7eSPeter Wemm 1033fe3db7c7SDoug Rabson static const char * 1034757686b1SMarcel Moolenaar symbol_name(elf_file_t ef, Elf_Size r_info) 1035a4f67738SDoug Rabson { 1036fe3db7c7SDoug Rabson const Elf_Sym *ref; 1037a4f67738SDoug Rabson 1038aa855a59SPeter Wemm if (ELF_R_SYM(r_info)) { 1039e9eabf59SPeter Wemm ref = ef->ddbsymtab + ELF_R_SYM(r_info); 1040e9eabf59SPeter Wemm return ef->ddbstrtab + ref->st_name; 1041fe3db7c7SDoug Rabson } else 1042fe3db7c7SDoug Rabson return NULL; 1043a4f67738SDoug Rabson } 1044a4f67738SDoug Rabson 1045e9eabf59SPeter Wemm static Elf_Addr 1046e9eabf59SPeter Wemm findbase(elf_file_t ef, int sec) 1047e9eabf59SPeter Wemm { 1048e9eabf59SPeter Wemm int i; 1049e9eabf59SPeter Wemm Elf_Addr base = 0; 1050e9eabf59SPeter Wemm 1051e9eabf59SPeter Wemm for (i = 0; i < ef->nprogtab; i++) { 1052a8774e39SPeter Wemm if (sec == ef->progtab[i].sec) { 1053e9eabf59SPeter Wemm base = (Elf_Addr)ef->progtab[i].addr; 1054a8774e39SPeter Wemm break; 1055e9eabf59SPeter Wemm } 1056a8774e39SPeter Wemm } 1057e9eabf59SPeter Wemm return base; 1058e9eabf59SPeter Wemm } 1059e9eabf59SPeter Wemm 1060a4f67738SDoug Rabson static int 1061326e27d8SDoug Rabson relocate_file(elf_file_t ef) 1062a4f67738SDoug Rabson { 1063fe3db7c7SDoug Rabson const Elf_Rel *rellim; 1064fe3db7c7SDoug Rabson const Elf_Rel *rel; 1065fe3db7c7SDoug Rabson const Elf_Rela *relalim; 1066fe3db7c7SDoug Rabson const Elf_Rela *rela; 1067aa855a59SPeter Wemm const char *symname; 1068e9eabf59SPeter Wemm const Elf_Sym *sym; 1069e9eabf59SPeter Wemm int i; 1070757686b1SMarcel Moolenaar Elf_Size symidx; 1071e9eabf59SPeter Wemm Elf_Addr base; 1072e9eabf59SPeter Wemm 1073a4f67738SDoug Rabson 1074fe3db7c7SDoug Rabson /* Perform relocations without addend if there are any: */ 1075b474c780SDavid E. O'Brien for (i = 0; i < ef->nreltab; i++) { 1076e9eabf59SPeter Wemm rel = ef->reltab[i].rel; 10773cfce8e4SKonstantin Belousov if (rel == NULL) { 10783cfce8e4SKonstantin Belousov link_elf_error(ef->lf.filename, "lost a reltab!"); 10793cfce8e4SKonstantin Belousov return (ENOEXEC); 10803cfce8e4SKonstantin Belousov } 108120947801SPeter Wemm rellim = rel + ef->reltab[i].nrel; 1082e9eabf59SPeter Wemm base = findbase(ef, ef->reltab[i].sec); 10833cfce8e4SKonstantin Belousov if (base == 0) { 10843cfce8e4SKonstantin Belousov link_elf_error(ef->lf.filename, "lost base for reltab"); 10853cfce8e4SKonstantin Belousov return (ENOEXEC); 10863cfce8e4SKonstantin Belousov } 108720947801SPeter Wemm for ( ; rel < rellim; rel++) { 1088e9eabf59SPeter Wemm symidx = ELF_R_SYM(rel->r_info); 108920947801SPeter Wemm if (symidx >= ef->ddbsymcnt) 109020947801SPeter Wemm continue; 1091e9eabf59SPeter Wemm sym = ef->ddbsymtab + symidx; 109220947801SPeter Wemm /* Local relocs are already done */ 109320947801SPeter Wemm if (ELF_ST_BIND(sym->st_info) == STB_LOCAL) 109420947801SPeter Wemm continue; 109520947801SPeter Wemm if (elf_reloc(&ef->lf, base, rel, ELF_RELOC_REL, 109620947801SPeter Wemm elf_obj_lookup)) { 1097aa855a59SPeter Wemm symname = symbol_name(ef, rel->r_info); 109820947801SPeter Wemm printf("link_elf_obj: symbol %s undefined\n", 109920947801SPeter Wemm symname); 11003cfce8e4SKonstantin Belousov return (ENOENT); 1101a13ddfb6SPeter Wemm } 1102aa855a59SPeter Wemm } 1103a4f67738SDoug Rabson } 1104a4f67738SDoug Rabson 1105fe3db7c7SDoug Rabson /* Perform relocations with addend if there are any: */ 1106b474c780SDavid E. O'Brien for (i = 0; i < ef->nrelatab; i++) { 1107e9eabf59SPeter Wemm rela = ef->relatab[i].rela; 11083cfce8e4SKonstantin Belousov if (rela == NULL) { 11093cfce8e4SKonstantin Belousov link_elf_error(ef->lf.filename, "lost a relatab!"); 11103cfce8e4SKonstantin Belousov return (ENOEXEC); 11113cfce8e4SKonstantin Belousov } 111220947801SPeter Wemm relalim = rela + ef->relatab[i].nrela; 1113e9eabf59SPeter Wemm base = findbase(ef, ef->relatab[i].sec); 11143cfce8e4SKonstantin Belousov if (base == 0) { 11153cfce8e4SKonstantin Belousov link_elf_error(ef->lf.filename, 11163cfce8e4SKonstantin Belousov "lost base for relatab"); 11173cfce8e4SKonstantin Belousov return (ENOEXEC); 11183cfce8e4SKonstantin Belousov } 111920947801SPeter Wemm for ( ; rela < relalim; rela++) { 1120e9eabf59SPeter Wemm symidx = ELF_R_SYM(rela->r_info); 112120947801SPeter Wemm if (symidx >= ef->ddbsymcnt) 112220947801SPeter Wemm continue; 1123e9eabf59SPeter Wemm sym = ef->ddbsymtab + symidx; 112420947801SPeter Wemm /* Local relocs are already done */ 112520947801SPeter Wemm if (ELF_ST_BIND(sym->st_info) == STB_LOCAL) 112620947801SPeter Wemm continue; 112720947801SPeter Wemm if (elf_reloc(&ef->lf, base, rela, ELF_RELOC_RELA, 112820947801SPeter Wemm elf_obj_lookup)) { 1129aa855a59SPeter Wemm symname = symbol_name(ef, rela->r_info); 113020947801SPeter Wemm printf("link_elf_obj: symbol %s undefined\n", 113120947801SPeter Wemm symname); 11323cfce8e4SKonstantin Belousov return (ENOENT); 1133a13ddfb6SPeter Wemm } 1134e9eabf59SPeter Wemm } 1135e9eabf59SPeter Wemm } 1136a4f67738SDoug Rabson 11372832cd54SKonstantin Belousov /* 1138e3043798SPedro F. Giffuni * Only clean SHN_FBSD_CACHED for successful return. If we 11392832cd54SKonstantin Belousov * modified symbol table for the object but found an 11402832cd54SKonstantin Belousov * unresolved symbol, there is no reason to roll back. 11412832cd54SKonstantin Belousov */ 11422832cd54SKonstantin Belousov elf_obj_cleanup_globals_cache(ef); 11432832cd54SKonstantin Belousov 11443cfce8e4SKonstantin Belousov return (0); 1145a4f67738SDoug Rabson } 1146a4f67738SDoug Rabson 114737c84183SPoul-Henning Kamp static int 1148d254af07SMatthew Dillon link_elf_lookup_symbol(linker_file_t lf, const char *name, c_linker_sym_t *sym) 1149a4f67738SDoug Rabson { 1150326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) lf; 11512d636ab0SPeter Wemm const Elf_Sym *symp; 11522d636ab0SPeter Wemm const char *strp; 1153a4f67738SDoug Rabson int i; 1154a4f67738SDoug Rabson 11552d636ab0SPeter Wemm for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) { 11562d636ab0SPeter Wemm strp = ef->ddbstrtab + symp->st_name; 1157a8774e39SPeter Wemm if (symp->st_shndx != SHN_UNDEF && strcmp(name, strp) == 0) { 1158d254af07SMatthew Dillon *sym = (c_linker_sym_t) symp; 11592d636ab0SPeter Wemm return 0; 11602d636ab0SPeter Wemm } 11612d636ab0SPeter Wemm } 1162a4f67738SDoug Rabson return ENOENT; 1163a4f67738SDoug Rabson } 1164a4f67738SDoug Rabson 1165de78ca7eSPeter Wemm static int 116620947801SPeter Wemm link_elf_symbol_values(linker_file_t lf, c_linker_sym_t sym, 116720947801SPeter Wemm linker_symval_t *symval) 1168a4f67738SDoug Rabson { 1169326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) lf; 11708aef1712SMatthew Dillon const Elf_Sym *es = (const Elf_Sym*) sym; 1171a4f67738SDoug Rabson 11725cf87418SMarcel Moolenaar if (es >= ef->ddbsymtab && es < (ef->ddbsymtab + ef->ddbsymcnt)) { 11732d636ab0SPeter Wemm symval->name = ef->ddbstrtab + es->st_name; 1174a8774e39SPeter Wemm symval->value = (caddr_t)es->st_value; 11752d636ab0SPeter Wemm symval->size = es->st_size; 11762d636ab0SPeter Wemm return 0; 11772d636ab0SPeter Wemm } 11782d636ab0SPeter Wemm return ENOENT; 11792d636ab0SPeter Wemm } 1180a4f67738SDoug Rabson 1181a4f67738SDoug Rabson static int 1182a4f67738SDoug Rabson link_elf_search_symbol(linker_file_t lf, caddr_t value, 1183d254af07SMatthew Dillon c_linker_sym_t *sym, long *diffp) 1184a4f67738SDoug Rabson { 1185326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) lf; 1186586453feSBruce Evans u_long off = (uintptr_t) (void *) value; 1187a4f67738SDoug Rabson u_long diff = off; 1188586453feSBruce Evans u_long st_value; 1189fe3db7c7SDoug Rabson const Elf_Sym *es; 1190b85f65afSPedro F. Giffuni const Elf_Sym *best = NULL; 1191a4f67738SDoug Rabson int i; 1192a4f67738SDoug Rabson 11932d636ab0SPeter Wemm for (i = 0, es = ef->ddbsymtab; i < ef->ddbsymcnt; i++, es++) { 1194a4f67738SDoug Rabson if (es->st_name == 0) 1195a4f67738SDoug Rabson continue; 1196a8774e39SPeter Wemm st_value = es->st_value; 1197b5abfb70SPeter Wemm if (off >= st_value) { 1198b5abfb70SPeter Wemm if (off - st_value < diff) { 1199b5abfb70SPeter Wemm diff = off - st_value; 1200a4f67738SDoug Rabson best = es; 1201a4f67738SDoug Rabson if (diff == 0) 1202a4f67738SDoug Rabson break; 1203b5abfb70SPeter Wemm } else if (off - st_value == diff) { 1204a4f67738SDoug Rabson best = es; 1205a4f67738SDoug Rabson } 1206a4f67738SDoug Rabson } 1207a4f67738SDoug Rabson } 1208b85f65afSPedro F. Giffuni if (best == NULL) 1209a4f67738SDoug Rabson *diffp = off; 1210a4f67738SDoug Rabson else 1211a4f67738SDoug Rabson *diffp = diff; 1212d254af07SMatthew Dillon *sym = (c_linker_sym_t) best; 1213a4f67738SDoug Rabson 1214a4f67738SDoug Rabson return 0; 1215a4f67738SDoug Rabson } 1216f41325dbSPeter Wemm 1217f41325dbSPeter Wemm /* 1218f41325dbSPeter Wemm * Look up a linker set on an ELF system. 1219f41325dbSPeter Wemm */ 1220f41325dbSPeter Wemm static int 1221f41325dbSPeter Wemm link_elf_lookup_set(linker_file_t lf, const char *name, 1222f41325dbSPeter Wemm void ***startp, void ***stopp, int *countp) 1223f41325dbSPeter Wemm { 1224e9eabf59SPeter Wemm elf_file_t ef = (elf_file_t)lf; 1225f41325dbSPeter Wemm void **start, **stop; 1226e9eabf59SPeter Wemm int i, count; 1227f41325dbSPeter Wemm 1228e9eabf59SPeter Wemm /* Relative to section number */ 1229e9eabf59SPeter Wemm for (i = 0; i < ef->nprogtab; i++) { 1230e9eabf59SPeter Wemm if ((strncmp(ef->progtab[i].name, "set_", 4) == 0) && 1231e9eabf59SPeter Wemm strcmp(ef->progtab[i].name + 4, name) == 0) { 1232e9eabf59SPeter Wemm start = (void **)ef->progtab[i].addr; 123320947801SPeter Wemm stop = (void **)((char *)ef->progtab[i].addr + 123420947801SPeter Wemm ef->progtab[i].size); 1235f41325dbSPeter Wemm count = stop - start; 1236f41325dbSPeter Wemm if (startp) 1237f41325dbSPeter Wemm *startp = start; 1238f41325dbSPeter Wemm if (stopp) 1239f41325dbSPeter Wemm *stopp = stop; 1240f41325dbSPeter Wemm if (countp) 1241f41325dbSPeter Wemm *countp = count; 1242e9eabf59SPeter Wemm return (0); 1243e9eabf59SPeter Wemm } 1244e9eabf59SPeter Wemm } 1245e9eabf59SPeter Wemm return (ESRCH); 1246f41325dbSPeter Wemm } 1247bb9fe9ddSBrian Feldman 1248bb9fe9ddSBrian Feldman static int 1249bb9fe9ddSBrian Feldman link_elf_each_function_name(linker_file_t file, 1250e9eabf59SPeter Wemm int (*callback)(const char *, void *), void *opaque) 1251e9eabf59SPeter Wemm { 1252bb9fe9ddSBrian Feldman elf_file_t ef = (elf_file_t)file; 1253bb9fe9ddSBrian Feldman const Elf_Sym *symp; 1254bb9fe9ddSBrian Feldman int i, error; 1255bb9fe9ddSBrian Feldman 1256bb9fe9ddSBrian Feldman /* Exhaustive search */ 1257bb9fe9ddSBrian Feldman for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) { 1258bb9fe9ddSBrian Feldman if (symp->st_value != 0 && 1259bb9fe9ddSBrian Feldman ELF_ST_TYPE(symp->st_info) == STT_FUNC) { 1260bb9fe9ddSBrian Feldman error = callback(ef->ddbstrtab + symp->st_name, opaque); 1261bb9fe9ddSBrian Feldman if (error) 1262bb9fe9ddSBrian Feldman return (error); 1263bb9fe9ddSBrian Feldman } 1264bb9fe9ddSBrian Feldman } 1265bb9fe9ddSBrian Feldman return (0); 1266bb9fe9ddSBrian Feldman } 126784201059SMarcel Moolenaar 1268a2024a3eSJohn Birrell static int 1269a2024a3eSJohn Birrell link_elf_each_function_nameval(linker_file_t file, 1270a2024a3eSJohn Birrell linker_function_nameval_callback_t callback, void *opaque) 1271a2024a3eSJohn Birrell { 1272a2024a3eSJohn Birrell linker_symval_t symval; 1273a2024a3eSJohn Birrell elf_file_t ef = (elf_file_t)file; 1274a2024a3eSJohn Birrell const Elf_Sym* symp; 1275a2024a3eSJohn Birrell int i, error; 1276a2024a3eSJohn Birrell 1277a2024a3eSJohn Birrell /* Exhaustive search */ 1278a2024a3eSJohn Birrell for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) { 1279a2024a3eSJohn Birrell if (symp->st_value != 0 && 1280a2024a3eSJohn Birrell ELF_ST_TYPE(symp->st_info) == STT_FUNC) { 1281a2024a3eSJohn Birrell error = link_elf_symbol_values(file, (c_linker_sym_t) symp, &symval); 1282a2024a3eSJohn Birrell if (error) 1283a2024a3eSJohn Birrell return (error); 1284a2024a3eSJohn Birrell error = callback(file, i, &symval, opaque); 1285a2024a3eSJohn Birrell if (error) 1286a2024a3eSJohn Birrell return (error); 1287a2024a3eSJohn Birrell } 1288a2024a3eSJohn Birrell } 1289a2024a3eSJohn Birrell return (0); 1290a2024a3eSJohn Birrell } 1291a2024a3eSJohn Birrell 12922832cd54SKonstantin Belousov static void 12932832cd54SKonstantin Belousov elf_obj_cleanup_globals_cache(elf_file_t ef) 12942832cd54SKonstantin Belousov { 12952832cd54SKonstantin Belousov Elf_Sym *sym; 12962832cd54SKonstantin Belousov Elf_Size i; 12972832cd54SKonstantin Belousov 12982832cd54SKonstantin Belousov for (i = 0; i < ef->ddbsymcnt; i++) { 12992832cd54SKonstantin Belousov sym = ef->ddbsymtab + i; 13002832cd54SKonstantin Belousov if (sym->st_shndx == SHN_FBSD_CACHED) { 13012832cd54SKonstantin Belousov sym->st_shndx = SHN_UNDEF; 13022832cd54SKonstantin Belousov sym->st_value = 0; 13032832cd54SKonstantin Belousov } 13042832cd54SKonstantin Belousov } 13052832cd54SKonstantin Belousov } 13062832cd54SKonstantin Belousov 1307d297ad16SMarcel Moolenaar /* 1308d297ad16SMarcel Moolenaar * Symbol lookup function that can be used when the symbol index is known (ie 1309d297ad16SMarcel Moolenaar * in relocations). It uses the symbol index instead of doing a fully fledged 1310d297ad16SMarcel Moolenaar * hash table based lookup when such is valid. For example for local symbols. 1311d297ad16SMarcel Moolenaar * This is not only more efficient, it's also more correct. It's not always 1312d297ad16SMarcel Moolenaar * the case that the symbol can be found through the hash table. 1313d297ad16SMarcel Moolenaar */ 1314cff8c6f2SKonstantin Belousov static int 1315cff8c6f2SKonstantin Belousov elf_obj_lookup(linker_file_t lf, Elf_Size symidx, int deps, Elf_Addr *res) 1316d297ad16SMarcel Moolenaar { 1317d297ad16SMarcel Moolenaar elf_file_t ef = (elf_file_t)lf; 13182832cd54SKonstantin Belousov Elf_Sym *sym; 1319d297ad16SMarcel Moolenaar const char *symbol; 1320cff8c6f2SKonstantin Belousov Elf_Addr res1; 1321d297ad16SMarcel Moolenaar 1322d297ad16SMarcel Moolenaar /* Don't even try to lookup the symbol if the index is bogus. */ 1323cff8c6f2SKonstantin Belousov if (symidx >= ef->ddbsymcnt) { 1324cff8c6f2SKonstantin Belousov *res = 0; 1325cff8c6f2SKonstantin Belousov return (EINVAL); 1326cff8c6f2SKonstantin Belousov } 1327d297ad16SMarcel Moolenaar 1328e9eabf59SPeter Wemm sym = ef->ddbsymtab + symidx; 1329d297ad16SMarcel Moolenaar 13304cec6f5dSPeter Wemm /* Quick answer if there is a definition included. */ 1331cff8c6f2SKonstantin Belousov if (sym->st_shndx != SHN_UNDEF) { 1332cff8c6f2SKonstantin Belousov *res = sym->st_value; 1333cff8c6f2SKonstantin Belousov return (0); 1334cff8c6f2SKonstantin Belousov } 13354cec6f5dSPeter Wemm 13364cec6f5dSPeter Wemm /* If we get here, then it is undefined and needs a lookup. */ 13374cec6f5dSPeter Wemm switch (ELF_ST_BIND(sym->st_info)) { 13384cec6f5dSPeter Wemm case STB_LOCAL: 13394cec6f5dSPeter Wemm /* Local, but undefined? huh? */ 1340cff8c6f2SKonstantin Belousov *res = 0; 1341cff8c6f2SKonstantin Belousov return (EINVAL); 1342d297ad16SMarcel Moolenaar 1343e9eabf59SPeter Wemm case STB_GLOBAL: 1344cff8c6f2SKonstantin Belousov case STB_WEAK: 1345e9eabf59SPeter Wemm /* Relative to Data or Function name */ 1346e9eabf59SPeter Wemm symbol = ef->ddbstrtab + sym->st_name; 1347d297ad16SMarcel Moolenaar 1348d297ad16SMarcel Moolenaar /* Force a lookup failure if the symbol name is bogus. */ 1349cff8c6f2SKonstantin Belousov if (*symbol == 0) { 1350cff8c6f2SKonstantin Belousov *res = 0; 1351cff8c6f2SKonstantin Belousov return (EINVAL); 1352cff8c6f2SKonstantin Belousov } 1353cff8c6f2SKonstantin Belousov res1 = (Elf_Addr)linker_file_lookup_symbol(lf, symbol, deps); 13542832cd54SKonstantin Belousov 13552832cd54SKonstantin Belousov /* 13562832cd54SKonstantin Belousov * Cache global lookups during module relocation. The failure 13572832cd54SKonstantin Belousov * case is particularly expensive for callers, who must scan 13582832cd54SKonstantin Belousov * through the entire globals table doing strcmp(). Cache to 13592832cd54SKonstantin Belousov * avoid doing such work repeatedly. 13602832cd54SKonstantin Belousov * 13612832cd54SKonstantin Belousov * After relocation is complete, undefined globals will be 13622832cd54SKonstantin Belousov * restored to SHN_UNDEF in elf_obj_cleanup_globals_cache(), 13632832cd54SKonstantin Belousov * above. 13642832cd54SKonstantin Belousov */ 1365cff8c6f2SKonstantin Belousov if (res1 != 0) { 13662832cd54SKonstantin Belousov sym->st_shndx = SHN_FBSD_CACHED; 1367cff8c6f2SKonstantin Belousov sym->st_value = res1; 1368cff8c6f2SKonstantin Belousov *res = res1; 1369e9eabf59SPeter Wemm return (0); 1370cff8c6f2SKonstantin Belousov } else if (ELF_ST_BIND(sym->st_info) == STB_WEAK) { 1371cff8c6f2SKonstantin Belousov sym->st_value = 0; 1372cff8c6f2SKonstantin Belousov *res = 0; 1373cff8c6f2SKonstantin Belousov return (0); 1374cff8c6f2SKonstantin Belousov } 1375cff8c6f2SKonstantin Belousov return (EINVAL); 1376e9eabf59SPeter Wemm 1377e9eabf59SPeter Wemm default: 1378cff8c6f2SKonstantin Belousov return (EINVAL); 1379d297ad16SMarcel Moolenaar } 1380e9eabf59SPeter Wemm } 1381e9eabf59SPeter Wemm 13827251b4bfSJake Burkholder static void 13837226306eSKonstantin Belousov link_elf_fix_link_set(elf_file_t ef) 13847226306eSKonstantin Belousov { 13857226306eSKonstantin Belousov static const char startn[] = "__start_"; 13867226306eSKonstantin Belousov static const char stopn[] = "__stop_"; 13877226306eSKonstantin Belousov Elf_Sym *sym; 13887226306eSKonstantin Belousov const char *sym_name, *linkset_name; 13897226306eSKonstantin Belousov Elf_Addr startp, stopp; 13907226306eSKonstantin Belousov Elf_Size symidx; 13917226306eSKonstantin Belousov int start, i; 13927226306eSKonstantin Belousov 13937226306eSKonstantin Belousov startp = stopp = 0; 13947226306eSKonstantin Belousov for (symidx = 1 /* zero entry is special */; 13957226306eSKonstantin Belousov symidx < ef->ddbsymcnt; symidx++) { 13967226306eSKonstantin Belousov sym = ef->ddbsymtab + symidx; 13977226306eSKonstantin Belousov if (sym->st_shndx != SHN_UNDEF) 13987226306eSKonstantin Belousov continue; 13997226306eSKonstantin Belousov 14007226306eSKonstantin Belousov sym_name = ef->ddbstrtab + sym->st_name; 14017226306eSKonstantin Belousov if (strncmp(sym_name, startn, sizeof(startn) - 1) == 0) { 14027226306eSKonstantin Belousov start = 1; 14037226306eSKonstantin Belousov linkset_name = sym_name + sizeof(startn) - 1; 14047226306eSKonstantin Belousov } 14057226306eSKonstantin Belousov else if (strncmp(sym_name, stopn, sizeof(stopn) - 1) == 0) { 14067226306eSKonstantin Belousov start = 0; 14077226306eSKonstantin Belousov linkset_name = sym_name + sizeof(stopn) - 1; 14087226306eSKonstantin Belousov } 14097226306eSKonstantin Belousov else 14107226306eSKonstantin Belousov continue; 14117226306eSKonstantin Belousov 14127226306eSKonstantin Belousov for (i = 0; i < ef->nprogtab; i++) { 14137226306eSKonstantin Belousov if (strcmp(ef->progtab[i].name, linkset_name) == 0) { 14147226306eSKonstantin Belousov startp = (Elf_Addr)ef->progtab[i].addr; 14157226306eSKonstantin Belousov stopp = (Elf_Addr)(startp + ef->progtab[i].size); 14167226306eSKonstantin Belousov break; 14177226306eSKonstantin Belousov } 14187226306eSKonstantin Belousov } 14197226306eSKonstantin Belousov if (i == ef->nprogtab) 14207226306eSKonstantin Belousov continue; 14217226306eSKonstantin Belousov 14227226306eSKonstantin Belousov sym->st_value = start ? startp : stopp; 14237226306eSKonstantin Belousov sym->st_shndx = i; 14247226306eSKonstantin Belousov } 14257226306eSKonstantin Belousov } 14267226306eSKonstantin Belousov 14273cfce8e4SKonstantin Belousov static int 14287251b4bfSJake Burkholder link_elf_reloc_local(linker_file_t lf) 14297251b4bfSJake Burkholder { 1430e9eabf59SPeter Wemm elf_file_t ef = (elf_file_t)lf; 14317251b4bfSJake Burkholder const Elf_Rel *rellim; 14327251b4bfSJake Burkholder const Elf_Rel *rel; 14337251b4bfSJake Burkholder const Elf_Rela *relalim; 14347251b4bfSJake Burkholder const Elf_Rela *rela; 1435e9eabf59SPeter Wemm const Elf_Sym *sym; 1436e9eabf59SPeter Wemm Elf_Addr base; 1437e9eabf59SPeter Wemm int i; 1438757686b1SMarcel Moolenaar Elf_Size symidx; 1439e9eabf59SPeter Wemm 14407226306eSKonstantin Belousov link_elf_fix_link_set(ef); 14417226306eSKonstantin Belousov 14427251b4bfSJake Burkholder /* Perform relocations without addend if there are any: */ 1443b474c780SDavid E. O'Brien for (i = 0; i < ef->nreltab; i++) { 1444e9eabf59SPeter Wemm rel = ef->reltab[i].rel; 14453cfce8e4SKonstantin Belousov if (rel == NULL) { 14463cfce8e4SKonstantin Belousov link_elf_error(ef->lf.filename, "lost a reltab"); 14473cfce8e4SKonstantin Belousov return (ENOEXEC); 14483cfce8e4SKonstantin Belousov } 144920947801SPeter Wemm rellim = rel + ef->reltab[i].nrel; 1450e9eabf59SPeter Wemm base = findbase(ef, ef->reltab[i].sec); 14513cfce8e4SKonstantin Belousov if (base == 0) { 14523cfce8e4SKonstantin Belousov link_elf_error(ef->lf.filename, "lost base for reltab"); 14533cfce8e4SKonstantin Belousov return (ENOEXEC); 14543cfce8e4SKonstantin Belousov } 145520947801SPeter Wemm for ( ; rel < rellim; rel++) { 1456e9eabf59SPeter Wemm symidx = ELF_R_SYM(rel->r_info); 145720947801SPeter Wemm if (symidx >= ef->ddbsymcnt) 145820947801SPeter Wemm continue; 1459e9eabf59SPeter Wemm sym = ef->ddbsymtab + symidx; 146020947801SPeter Wemm /* Only do local relocs */ 146120947801SPeter Wemm if (ELF_ST_BIND(sym->st_info) != STB_LOCAL) 146220947801SPeter Wemm continue; 146320947801SPeter Wemm elf_reloc_local(lf, base, rel, ELF_RELOC_REL, 146420947801SPeter Wemm elf_obj_lookup); 14657251b4bfSJake Burkholder } 1466e9eabf59SPeter Wemm } 14677251b4bfSJake Burkholder 14687251b4bfSJake Burkholder /* Perform relocations with addend if there are any: */ 1469b474c780SDavid E. O'Brien for (i = 0; i < ef->nrelatab; i++) { 1470e9eabf59SPeter Wemm rela = ef->relatab[i].rela; 14713cfce8e4SKonstantin Belousov if (rela == NULL) { 14723cfce8e4SKonstantin Belousov link_elf_error(ef->lf.filename, "lost a relatab!"); 14733cfce8e4SKonstantin Belousov return (ENOEXEC); 14743cfce8e4SKonstantin Belousov } 147520947801SPeter Wemm relalim = rela + ef->relatab[i].nrela; 1476e9eabf59SPeter Wemm base = findbase(ef, ef->relatab[i].sec); 14773cfce8e4SKonstantin Belousov if (base == 0) { 14783cfce8e4SKonstantin Belousov link_elf_error(ef->lf.filename, "lost base for reltab"); 14793cfce8e4SKonstantin Belousov return (ENOEXEC); 14803cfce8e4SKonstantin Belousov } 148120947801SPeter Wemm for ( ; rela < relalim; rela++) { 1482e9eabf59SPeter Wemm symidx = ELF_R_SYM(rela->r_info); 148320947801SPeter Wemm if (symidx >= ef->ddbsymcnt) 148420947801SPeter Wemm continue; 1485e9eabf59SPeter Wemm sym = ef->ddbsymtab + symidx; 148620947801SPeter Wemm /* Only do local relocs */ 148720947801SPeter Wemm if (ELF_ST_BIND(sym->st_info) != STB_LOCAL) 148820947801SPeter Wemm continue; 148920947801SPeter Wemm elf_reloc_local(lf, base, rela, ELF_RELOC_RELA, 149020947801SPeter Wemm elf_obj_lookup); 14917251b4bfSJake Burkholder } 14927251b4bfSJake Burkholder } 14933cfce8e4SKonstantin Belousov return (0); 1494e9eabf59SPeter Wemm } 149500a5db46SStacey Son 149600a5db46SStacey Son static long 1497e76f11f4SAndriy Gapon link_elf_symtab_get(linker_file_t lf, const Elf_Sym **symtab) 149800a5db46SStacey Son { 149900a5db46SStacey Son elf_file_t ef = (elf_file_t)lf; 150000a5db46SStacey Son 150100a5db46SStacey Son *symtab = ef->ddbsymtab; 150200a5db46SStacey Son 150300a5db46SStacey Son if (*symtab == NULL) 150400a5db46SStacey Son return (0); 150500a5db46SStacey Son 150600a5db46SStacey Son return (ef->ddbsymcnt); 150700a5db46SStacey Son } 150800a5db46SStacey Son 150900a5db46SStacey Son static long 151000a5db46SStacey Son link_elf_strtab_get(linker_file_t lf, caddr_t *strtab) 151100a5db46SStacey Son { 151200a5db46SStacey Son elf_file_t ef = (elf_file_t)lf; 151300a5db46SStacey Son 151400a5db46SStacey Son *strtab = ef->ddbstrtab; 151500a5db46SStacey Son 151600a5db46SStacey Son if (*strtab == NULL) 151700a5db46SStacey Son return (0); 151800a5db46SStacey Son 151900a5db46SStacey Son return (ef->ddbstrcnt); 152000a5db46SStacey Son } 1521