1a4f67738SDoug Rabson /*- 28a36da99SPedro F. Giffuni * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 38a36da99SPedro F. Giffuni * 4326e27d8SDoug Rabson * Copyright (c) 1998-2000 Doug Rabson 5a4f67738SDoug Rabson * All rights reserved. 6a4f67738SDoug Rabson * 7a4f67738SDoug Rabson * Redistribution and use in source and binary forms, with or without 8a4f67738SDoug Rabson * modification, are permitted provided that the following conditions 9a4f67738SDoug Rabson * are met: 10a4f67738SDoug Rabson * 1. Redistributions of source code must retain the above copyright 11a4f67738SDoug Rabson * notice, this list of conditions and the following disclaimer. 12a4f67738SDoug Rabson * 2. Redistributions in binary form must reproduce the above copyright 13a4f67738SDoug Rabson * notice, this list of conditions and the following disclaimer in the 14a4f67738SDoug Rabson * documentation and/or other materials provided with the distribution. 15a4f67738SDoug Rabson * 16a4f67738SDoug Rabson * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17a4f67738SDoug Rabson * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18a4f67738SDoug Rabson * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19a4f67738SDoug Rabson * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20a4f67738SDoug Rabson * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21a4f67738SDoug Rabson * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22a4f67738SDoug Rabson * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23a4f67738SDoug Rabson * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24a4f67738SDoug Rabson * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25a4f67738SDoug Rabson * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26a4f67738SDoug Rabson * SUCH DAMAGE. 27a4f67738SDoug Rabson */ 28a4f67738SDoug Rabson 29677b542eSDavid E. O'Brien #include <sys/cdefs.h> 30677b542eSDavid E. O'Brien __FBSDID("$FreeBSD$"); 31677b542eSDavid E. O'Brien 32a2024a3eSJohn Birrell #include "opt_ddb.h" 33ecb01c64SMarcel Moolenaar #include "opt_gdb.h" 34326e27d8SDoug Rabson 35a4f67738SDoug Rabson #include <sys/param.h> 36a4f67738SDoug Rabson #include <sys/systm.h> 375ad6c3b1SBruce Evans #ifdef GPROF 385ad6c3b1SBruce Evans #include <sys/gmon.h> 395ad6c3b1SBruce Evans #endif 40fb919e4dSMark Murray #include <sys/kernel.h> 41fb919e4dSMark Murray #include <sys/lock.h> 42a4f67738SDoug Rabson #include <sys/malloc.h> 43c0b824f9SDima Dorfman #include <sys/mutex.h> 4462d615d5SJohn Baldwin #include <sys/mount.h> 4550c202c5SJeff Roberson #include <sys/pcpu.h> 46a4f67738SDoug Rabson #include <sys/proc.h> 47a4f67738SDoug Rabson #include <sys/namei.h> 48a4f67738SDoug Rabson #include <sys/fcntl.h> 49a4f67738SDoug Rabson #include <sys/vnode.h> 50a4f67738SDoug Rabson #include <sys/linker.h> 51fb919e4dSMark Murray 52a4f67738SDoug Rabson #include <machine/elf.h> 53a4f67738SDoug Rabson 54eddfbb76SRobert Watson #include <net/vnet.h> 55eddfbb76SRobert Watson 56aed55708SRobert Watson #include <security/mac/mac_framework.h> 57aed55708SRobert Watson 58fe3db7c7SDoug Rabson #include <vm/vm.h> 59fe3db7c7SDoug Rabson #include <vm/vm_param.h> 60d1f088daSPeter Wemm #ifdef SPARSE_MAPPING 61fe3db7c7SDoug Rabson #include <vm/vm_object.h> 62fe3db7c7SDoug Rabson #include <vm/vm_kern.h> 63fe3db7c7SDoug Rabson #include <vm/vm_extern.h> 64d1f088daSPeter Wemm #endif 65fe3db7c7SDoug Rabson #include <vm/pmap.h> 66fe3db7c7SDoug Rabson #include <vm/vm_map.h> 67fb919e4dSMark Murray 68f9980387SPeter Wemm #include <sys/link_elf.h> 69fe3db7c7SDoug Rabson 70a2024a3eSJohn Birrell #ifdef DDB_CTF 71d9db5225SCraig Rodrigues #include <sys/zlib.h> 72a2024a3eSJohn Birrell #endif 73a2024a3eSJohn Birrell 74326e27d8SDoug Rabson #include "linker_if.h" 75a4f67738SDoug Rabson 761a330eb0SPeter Wemm #define MAXSEGS 4 771a330eb0SPeter Wemm 784f2945f8SDavid E. O'Brien typedef struct elf_file { 794f2945f8SDavid E. O'Brien struct linker_file lf; /* Common fields */ 804f2945f8SDavid E. O'Brien int preloaded; /* Was file pre-loaded */ 814f2945f8SDavid E. O'Brien caddr_t address; /* Relocation address */ 824f2945f8SDavid E. O'Brien #ifdef SPARSE_MAPPING 834f2945f8SDavid E. O'Brien vm_object_t object; /* VM object to hold file pages */ 844f2945f8SDavid E. O'Brien #endif 854f2945f8SDavid E. O'Brien Elf_Dyn *dynamic; /* Symbol table etc. */ 864f2945f8SDavid E. O'Brien Elf_Hashelt nbuckets; /* DT_HASH info */ 874f2945f8SDavid E. O'Brien Elf_Hashelt nchains; 884f2945f8SDavid E. O'Brien const Elf_Hashelt *buckets; 894f2945f8SDavid E. O'Brien const Elf_Hashelt *chains; 904f2945f8SDavid E. O'Brien caddr_t hash; 914f2945f8SDavid E. O'Brien caddr_t strtab; /* DT_STRTAB */ 924f2945f8SDavid E. O'Brien int strsz; /* DT_STRSZ */ 934f2945f8SDavid E. O'Brien const Elf_Sym *symtab; /* DT_SYMTAB */ 944f2945f8SDavid E. O'Brien Elf_Addr *got; /* DT_PLTGOT */ 954f2945f8SDavid E. O'Brien const Elf_Rel *pltrel; /* DT_JMPREL */ 964f2945f8SDavid E. O'Brien int pltrelsize; /* DT_PLTRELSZ */ 974f2945f8SDavid E. O'Brien const Elf_Rela *pltrela; /* DT_JMPREL */ 984f2945f8SDavid E. O'Brien int pltrelasize; /* DT_PLTRELSZ */ 994f2945f8SDavid E. O'Brien const Elf_Rel *rel; /* DT_REL */ 1004f2945f8SDavid E. O'Brien int relsize; /* DT_RELSZ */ 1014f2945f8SDavid E. O'Brien const Elf_Rela *rela; /* DT_RELA */ 1024f2945f8SDavid E. O'Brien int relasize; /* DT_RELASZ */ 1034f2945f8SDavid E. O'Brien caddr_t modptr; 1044f2945f8SDavid E. O'Brien const Elf_Sym *ddbsymtab; /* The symbol table we are using */ 1054f2945f8SDavid E. O'Brien long ddbsymcnt; /* Number of symbols */ 1064f2945f8SDavid E. O'Brien caddr_t ddbstrtab; /* String table */ 1074f2945f8SDavid E. O'Brien long ddbstrcnt; /* number of bytes in string table */ 1084f2945f8SDavid E. O'Brien caddr_t symbase; /* malloc'ed symbold base */ 1094f2945f8SDavid E. O'Brien caddr_t strbase; /* malloc'ed string base */ 1104f2945f8SDavid E. O'Brien caddr_t ctftab; /* CTF table */ 1114f2945f8SDavid E. O'Brien long ctfcnt; /* number of bytes in CTF table */ 1124f2945f8SDavid E. O'Brien caddr_t ctfoff; /* CTF offset table */ 1134f2945f8SDavid E. O'Brien caddr_t typoff; /* Type offset table */ 1144f2945f8SDavid E. O'Brien long typlen; /* Number of type entries. */ 11550c202c5SJeff Roberson Elf_Addr pcpu_start; /* Pre-relocation pcpu set start. */ 11650c202c5SJeff Roberson Elf_Addr pcpu_stop; /* Pre-relocation pcpu set stop. */ 11750c202c5SJeff Roberson Elf_Addr pcpu_base; /* Relocated pcpu set address. */ 118eddfbb76SRobert Watson #ifdef VIMAGE 119eddfbb76SRobert Watson Elf_Addr vnet_start; /* Pre-relocation vnet set start. */ 120eddfbb76SRobert Watson Elf_Addr vnet_stop; /* Pre-relocation vnet set stop. */ 121eddfbb76SRobert Watson Elf_Addr vnet_base; /* Relocated vnet set address. */ 122eddfbb76SRobert Watson #endif 1234f2945f8SDavid E. O'Brien #ifdef GDB 1244f2945f8SDavid E. O'Brien struct link_map gdb; /* hooks for gdb */ 1254f2945f8SDavid E. O'Brien #endif 1264f2945f8SDavid E. O'Brien } *elf_file_t; 1274f2945f8SDavid E. O'Brien 12847813f5dSMikolaj Golub struct elf_set { 12947813f5dSMikolaj Golub Elf_Addr es_start; 13047813f5dSMikolaj Golub Elf_Addr es_stop; 13147813f5dSMikolaj Golub Elf_Addr es_base; 13247813f5dSMikolaj Golub TAILQ_ENTRY(elf_set) es_link; 13347813f5dSMikolaj Golub }; 13447813f5dSMikolaj Golub 13547813f5dSMikolaj Golub TAILQ_HEAD(elf_set_head, elf_set); 13647813f5dSMikolaj Golub 137a2024a3eSJohn Birrell #include <kern/kern_ctf.c> 138a2024a3eSJohn Birrell 139c143d6c2SMarcel Moolenaar static int link_elf_link_common_finish(linker_file_t); 14054823af2SPeter Wemm static int link_elf_link_preload(linker_class_t cls, 141326e27d8SDoug Rabson const char *, linker_file_t *); 14254823af2SPeter Wemm static int link_elf_link_preload_finish(linker_file_t); 1432f22b3ffSMatthew D Fleming static int link_elf_load_file(linker_class_t, const char *, 1442f22b3ffSMatthew D Fleming linker_file_t *); 145326e27d8SDoug Rabson static int link_elf_lookup_symbol(linker_file_t, const char *, 146326e27d8SDoug Rabson c_linker_sym_t *); 1472f22b3ffSMatthew D Fleming static int link_elf_symbol_values(linker_file_t, c_linker_sym_t, 1482f22b3ffSMatthew D Fleming linker_symval_t *); 1492f22b3ffSMatthew D Fleming static int link_elf_search_symbol(linker_file_t, caddr_t, 1502f22b3ffSMatthew D Fleming c_linker_sym_t *, long *); 151326e27d8SDoug Rabson 152326e27d8SDoug Rabson static void link_elf_unload_file(linker_file_t); 15354823af2SPeter Wemm static void link_elf_unload_preload(linker_file_t); 154f41325dbSPeter Wemm static int link_elf_lookup_set(linker_file_t, const char *, 155f41325dbSPeter Wemm void ***, void ***, int *); 156bb9fe9ddSBrian Feldman static int link_elf_each_function_name(linker_file_t, 1572f22b3ffSMatthew D Fleming int (*)(const char *, void *), void *); 158a2024a3eSJohn Birrell static int link_elf_each_function_nameval(linker_file_t, 1592f22b3ffSMatthew D Fleming linker_function_nameval_callback_t, void *); 1607251b4bfSJake Burkholder static void link_elf_reloc_local(linker_file_t); 16100a5db46SStacey Son static long link_elf_symtab_get(linker_file_t, const Elf_Sym **); 16200a5db46SStacey Son static long link_elf_strtab_get(linker_file_t, caddr_t *); 163cff8c6f2SKonstantin Belousov static int elf_lookup(linker_file_t, Elf_Size, int, Elf_Addr *); 164326e27d8SDoug Rabson 165326e27d8SDoug Rabson static kobj_method_t link_elf_methods[] = { 166326e27d8SDoug Rabson KOBJMETHOD(linker_lookup_symbol, link_elf_lookup_symbol), 167326e27d8SDoug Rabson KOBJMETHOD(linker_symbol_values, link_elf_symbol_values), 168326e27d8SDoug Rabson KOBJMETHOD(linker_search_symbol, link_elf_search_symbol), 169326e27d8SDoug Rabson KOBJMETHOD(linker_unload, link_elf_unload_file), 17054823af2SPeter Wemm KOBJMETHOD(linker_load_file, link_elf_load_file), 17154823af2SPeter Wemm KOBJMETHOD(linker_link_preload, link_elf_link_preload), 17254823af2SPeter Wemm KOBJMETHOD(linker_link_preload_finish, link_elf_link_preload_finish), 173f41325dbSPeter Wemm KOBJMETHOD(linker_lookup_set, link_elf_lookup_set), 174bb9fe9ddSBrian Feldman KOBJMETHOD(linker_each_function_name, link_elf_each_function_name), 175a2024a3eSJohn Birrell KOBJMETHOD(linker_each_function_nameval, link_elf_each_function_nameval), 176a2024a3eSJohn Birrell KOBJMETHOD(linker_ctf_get, link_elf_ctf_get), 17700a5db46SStacey Son KOBJMETHOD(linker_symtab_get, link_elf_symtab_get), 17800a5db46SStacey Son KOBJMETHOD(linker_strtab_get, link_elf_strtab_get), 179326e27d8SDoug Rabson { 0, 0 } 180326e27d8SDoug Rabson }; 181326e27d8SDoug Rabson 182326e27d8SDoug Rabson static struct linker_class link_elf_class = { 183326e27d8SDoug Rabson #if ELF_TARG_CLASS == ELFCLASS32 184326e27d8SDoug Rabson "elf32", 185326e27d8SDoug Rabson #else 186326e27d8SDoug Rabson "elf64", 187326e27d8SDoug Rabson #endif 188326e27d8SDoug Rabson link_elf_methods, sizeof(struct elf_file) 189326e27d8SDoug Rabson }; 190326e27d8SDoug Rabson 19136716fe2SMark Johnston typedef int (*elf_reloc_fn)(linker_file_t lf, Elf_Addr relocbase, 19236716fe2SMark Johnston const void *data, int type, elf_lookup_fn lookup); 19336716fe2SMark Johnston 1942f22b3ffSMatthew D Fleming static int parse_dynamic(elf_file_t); 1952f22b3ffSMatthew D Fleming static int relocate_file(elf_file_t); 19636716fe2SMark Johnston static int relocate_file1(elf_file_t ef, elf_lookup_fn lookup, 19736716fe2SMark Johnston elf_reloc_fn reloc, bool ifuncs); 1982f22b3ffSMatthew D Fleming static int link_elf_preload_parse_symbols(elf_file_t); 199326e27d8SDoug Rabson 20047813f5dSMikolaj Golub static struct elf_set_head set_pcpu_list; 20147813f5dSMikolaj Golub #ifdef VIMAGE 20247813f5dSMikolaj Golub static struct elf_set_head set_vnet_list; 20347813f5dSMikolaj Golub #endif 20447813f5dSMikolaj Golub 20547813f5dSMikolaj Golub static void 20647813f5dSMikolaj Golub elf_set_add(struct elf_set_head *list, Elf_Addr start, Elf_Addr stop, Elf_Addr base) 20747813f5dSMikolaj Golub { 20847813f5dSMikolaj Golub struct elf_set *set, *iter; 20947813f5dSMikolaj Golub 21047813f5dSMikolaj Golub set = malloc(sizeof(*set), M_LINKER, M_WAITOK); 21147813f5dSMikolaj Golub set->es_start = start; 21247813f5dSMikolaj Golub set->es_stop = stop; 21347813f5dSMikolaj Golub set->es_base = base; 21447813f5dSMikolaj Golub 21547813f5dSMikolaj Golub TAILQ_FOREACH(iter, list, es_link) { 21647813f5dSMikolaj Golub 21747813f5dSMikolaj Golub KASSERT((set->es_start < iter->es_start && set->es_stop < iter->es_stop) || 21847813f5dSMikolaj Golub (set->es_start > iter->es_start && set->es_stop > iter->es_stop), 21947813f5dSMikolaj Golub ("linker sets intersection: to insert: 0x%jx-0x%jx; inserted: 0x%jx-0x%jx", 22047813f5dSMikolaj Golub (uintmax_t)set->es_start, (uintmax_t)set->es_stop, 22147813f5dSMikolaj Golub (uintmax_t)iter->es_start, (uintmax_t)iter->es_stop)); 22247813f5dSMikolaj Golub 22347813f5dSMikolaj Golub if (iter->es_start > set->es_start) { 22447813f5dSMikolaj Golub TAILQ_INSERT_BEFORE(iter, set, es_link); 22547813f5dSMikolaj Golub break; 22647813f5dSMikolaj Golub } 22747813f5dSMikolaj Golub } 22847813f5dSMikolaj Golub 22947813f5dSMikolaj Golub if (iter == NULL) 23047813f5dSMikolaj Golub TAILQ_INSERT_TAIL(list, set, es_link); 23147813f5dSMikolaj Golub } 23247813f5dSMikolaj Golub 23347813f5dSMikolaj Golub static int 23447813f5dSMikolaj Golub elf_set_find(struct elf_set_head *list, Elf_Addr addr, Elf_Addr *start, Elf_Addr *base) 23547813f5dSMikolaj Golub { 23647813f5dSMikolaj Golub struct elf_set *set; 23747813f5dSMikolaj Golub 23847813f5dSMikolaj Golub TAILQ_FOREACH(set, list, es_link) { 23947813f5dSMikolaj Golub if (addr < set->es_start) 24047813f5dSMikolaj Golub return (0); 24147813f5dSMikolaj Golub if (addr < set->es_stop) { 24247813f5dSMikolaj Golub *start = set->es_start; 24347813f5dSMikolaj Golub *base = set->es_base; 24447813f5dSMikolaj Golub return (1); 24547813f5dSMikolaj Golub } 24647813f5dSMikolaj Golub } 24747813f5dSMikolaj Golub 24847813f5dSMikolaj Golub return (0); 24947813f5dSMikolaj Golub } 25047813f5dSMikolaj Golub 25147813f5dSMikolaj Golub static void 25247813f5dSMikolaj Golub elf_set_delete(struct elf_set_head *list, Elf_Addr start) 25347813f5dSMikolaj Golub { 25447813f5dSMikolaj Golub struct elf_set *set; 25547813f5dSMikolaj Golub 25647813f5dSMikolaj Golub TAILQ_FOREACH(set, list, es_link) { 25747813f5dSMikolaj Golub if (start < set->es_start) 25847813f5dSMikolaj Golub break; 25947813f5dSMikolaj Golub if (start == set->es_start) { 26047813f5dSMikolaj Golub TAILQ_REMOVE(list, set, es_link); 26147813f5dSMikolaj Golub free(set, M_LINKER); 26247813f5dSMikolaj Golub return; 26347813f5dSMikolaj Golub } 26447813f5dSMikolaj Golub } 26547813f5dSMikolaj Golub KASSERT(0, ("deleting unknown linker set (start = 0x%jx)", 26647813f5dSMikolaj Golub (uintmax_t)start)); 26747813f5dSMikolaj Golub } 26847813f5dSMikolaj Golub 269ecb01c64SMarcel Moolenaar #ifdef GDB 2702f22b3ffSMatthew D Fleming static void r_debug_state(struct r_debug *, struct link_map *); 271326e27d8SDoug Rabson 272326e27d8SDoug Rabson /* 273326e27d8SDoug Rabson * A list of loaded modules for GDB to use for loading symbols. 274326e27d8SDoug Rabson */ 275326e27d8SDoug Rabson struct r_debug r_debug; 276326e27d8SDoug Rabson 2772f22b3ffSMatthew D Fleming #define GDB_STATE(s) do { \ 2782f22b3ffSMatthew D Fleming r_debug.r_state = s; r_debug_state(NULL, NULL); \ 2792f22b3ffSMatthew D Fleming } while (0) 280326e27d8SDoug Rabson 281326e27d8SDoug Rabson /* 282326e27d8SDoug Rabson * Function for the debugger to set a breakpoint on to gain control. 283326e27d8SDoug Rabson */ 28437c84183SPoul-Henning Kamp static void 285ca29467eSJohn Baldwin r_debug_state(struct r_debug *dummy_one __unused, 286ca29467eSJohn Baldwin struct link_map *dummy_two __unused) 287326e27d8SDoug Rabson { 288326e27d8SDoug Rabson } 289326e27d8SDoug Rabson 2901720979bSMarcel Moolenaar static void 2911720979bSMarcel Moolenaar link_elf_add_gdb(struct link_map *l) 2921720979bSMarcel Moolenaar { 2931720979bSMarcel Moolenaar struct link_map *prev; 2941720979bSMarcel Moolenaar 295c143d6c2SMarcel Moolenaar l->l_next = NULL; 296c143d6c2SMarcel Moolenaar 297c143d6c2SMarcel Moolenaar if (r_debug.r_map == NULL) { 298c143d6c2SMarcel Moolenaar /* Add first. */ 299c143d6c2SMarcel Moolenaar l->l_prev = NULL; 300c143d6c2SMarcel Moolenaar r_debug.r_map = l; 301c143d6c2SMarcel Moolenaar } else { 302c143d6c2SMarcel Moolenaar /* Append to list. */ 3032f22b3ffSMatthew D Fleming for (prev = r_debug.r_map; 3042f22b3ffSMatthew D Fleming prev->l_next != NULL; 3052f22b3ffSMatthew D Fleming prev = prev->l_next) 3061720979bSMarcel Moolenaar ; 3071720979bSMarcel Moolenaar l->l_prev = prev; 3081720979bSMarcel Moolenaar prev->l_next = l; 3091720979bSMarcel Moolenaar } 310c143d6c2SMarcel Moolenaar } 3111720979bSMarcel Moolenaar 3121720979bSMarcel Moolenaar static void 3131720979bSMarcel Moolenaar link_elf_delete_gdb(struct link_map *l) 3141720979bSMarcel Moolenaar { 3151720979bSMarcel Moolenaar if (l->l_prev == NULL) { 316c143d6c2SMarcel Moolenaar /* Remove first. */ 3171720979bSMarcel Moolenaar if ((r_debug.r_map = l->l_next) != NULL) 3181720979bSMarcel Moolenaar l->l_next->l_prev = NULL; 319c143d6c2SMarcel Moolenaar } else { 320c143d6c2SMarcel Moolenaar /* Remove any but first. */ 3211720979bSMarcel Moolenaar if ((l->l_prev->l_next = l->l_next) != NULL) 3221720979bSMarcel Moolenaar l->l_next->l_prev = l->l_prev; 3231720979bSMarcel Moolenaar } 324c143d6c2SMarcel Moolenaar } 325ecb01c64SMarcel Moolenaar #endif /* GDB */ 326a4f67738SDoug Rabson 3274f2945f8SDavid E. O'Brien /* 3284f2945f8SDavid E. O'Brien * The kernel symbol table starts here. 3294f2945f8SDavid E. O'Brien */ 3304f2945f8SDavid E. O'Brien extern struct _dynamic _DYNAMIC; 3314f2945f8SDavid E. O'Brien 332a4f67738SDoug Rabson static void 333552f9f63SEdwin Groothuis link_elf_error(const char *filename, const char *s) 3341720979bSMarcel Moolenaar { 335552f9f63SEdwin Groothuis if (filename == NULL) 3361720979bSMarcel Moolenaar printf("kldload: %s\n", s); 337552f9f63SEdwin Groothuis else 338552f9f63SEdwin Groothuis printf("kldload: %s: %s\n", filename, s); 3391720979bSMarcel Moolenaar } 3401720979bSMarcel Moolenaar 3410067051fSMarcel Moolenaar static void 3420067051fSMarcel Moolenaar link_elf_invoke_ctors(caddr_t addr, size_t size) 3430067051fSMarcel Moolenaar { 3440067051fSMarcel Moolenaar void (**ctor)(void); 3450067051fSMarcel Moolenaar size_t i, cnt; 3460067051fSMarcel Moolenaar 3470067051fSMarcel Moolenaar if (addr == NULL || size == 0) 3480067051fSMarcel Moolenaar return; 3490067051fSMarcel Moolenaar cnt = size / sizeof(*ctor); 3500067051fSMarcel Moolenaar ctor = (void *)addr; 3510067051fSMarcel Moolenaar for (i = 0; i < cnt; i++) { 3520067051fSMarcel Moolenaar if (ctor[i] != NULL) 3530067051fSMarcel Moolenaar (*ctor[i])(); 3540067051fSMarcel Moolenaar } 3550067051fSMarcel Moolenaar } 3560067051fSMarcel Moolenaar 357c143d6c2SMarcel Moolenaar /* 358c143d6c2SMarcel Moolenaar * Actions performed after linking/loading both the preloaded kernel and any 359c143d6c2SMarcel Moolenaar * modules; whether preloaded or dynamicly loaded. 360c143d6c2SMarcel Moolenaar */ 361c143d6c2SMarcel Moolenaar static int 362c143d6c2SMarcel Moolenaar link_elf_link_common_finish(linker_file_t lf) 363c143d6c2SMarcel Moolenaar { 364ecb01c64SMarcel Moolenaar #ifdef GDB 365c143d6c2SMarcel Moolenaar elf_file_t ef = (elf_file_t)lf; 366c143d6c2SMarcel Moolenaar char *newfilename; 367c143d6c2SMarcel Moolenaar #endif 3681aeb23cdSMarcel Moolenaar int error; 3691aeb23cdSMarcel Moolenaar 3701aeb23cdSMarcel Moolenaar /* Notify MD code that a module is being loaded. */ 3711aeb23cdSMarcel Moolenaar error = elf_cpu_load_file(lf); 3722f22b3ffSMatthew D Fleming if (error != 0) 3731aeb23cdSMarcel Moolenaar return (error); 374c143d6c2SMarcel Moolenaar 375ecb01c64SMarcel Moolenaar #ifdef GDB 376c143d6c2SMarcel Moolenaar GDB_STATE(RT_ADD); 377c143d6c2SMarcel Moolenaar ef->gdb.l_addr = lf->address; 378a163d034SWarner Losh newfilename = malloc(strlen(lf->filename) + 1, M_LINKER, M_WAITOK); 379c143d6c2SMarcel Moolenaar strcpy(newfilename, lf->filename); 380c143d6c2SMarcel Moolenaar ef->gdb.l_name = newfilename; 381c143d6c2SMarcel Moolenaar ef->gdb.l_ld = ef->dynamic; 382c143d6c2SMarcel Moolenaar link_elf_add_gdb(&ef->gdb); 383c143d6c2SMarcel Moolenaar GDB_STATE(RT_CONSISTENT); 384c143d6c2SMarcel Moolenaar #endif 385c143d6c2SMarcel Moolenaar 3860067051fSMarcel Moolenaar /* Invoke .ctors */ 3870067051fSMarcel Moolenaar link_elf_invoke_ctors(lf->ctors_addr, lf->ctors_size); 388c143d6c2SMarcel Moolenaar return (0); 389c143d6c2SMarcel Moolenaar } 390c143d6c2SMarcel Moolenaar 391ee900504SNathan Whitehorn extern vm_offset_t __startkernel, __endkernel; 392c6014c73SNathan Whitehorn 3931720979bSMarcel Moolenaar static void 394a4f67738SDoug Rabson link_elf_init(void* arg) 395a4f67738SDoug Rabson { 396de78ca7eSPeter Wemm Elf_Dyn *dp; 3970067051fSMarcel Moolenaar Elf_Addr *ctors_addrp; 3980067051fSMarcel Moolenaar Elf_Size *ctors_sizep; 399de78ca7eSPeter Wemm caddr_t modptr, baseptr, sizeptr; 400de78ca7eSPeter Wemm elf_file_t ef; 401de78ca7eSPeter Wemm char *modname; 402a4f67738SDoug Rabson 403326e27d8SDoug Rabson linker_add_class(&link_elf_class); 404a4f67738SDoug Rabson 405de78ca7eSPeter Wemm dp = (Elf_Dyn *)&_DYNAMIC; 406de78ca7eSPeter Wemm modname = NULL; 40767db8b23SPeter Wemm modptr = preload_search_by_type("elf" __XSTRING(__ELF_WORD_SIZE) " kernel"); 40867db8b23SPeter Wemm if (modptr == NULL) 409de78ca7eSPeter Wemm modptr = preload_search_by_type("elf kernel"); 410de78ca7eSPeter Wemm modname = (char *)preload_search_info(modptr, MODINFO_NAME); 411de78ca7eSPeter Wemm if (modname == NULL) 412de78ca7eSPeter Wemm modname = "kernel"; 413326e27d8SDoug Rabson linker_kernel_file = linker_make_file(modname, &link_elf_class); 414a4f67738SDoug Rabson if (linker_kernel_file == NULL) 4152f22b3ffSMatthew D Fleming panic("%s: Can't create linker structures for kernel", 4162f22b3ffSMatthew D Fleming __func__); 417326e27d8SDoug Rabson 418326e27d8SDoug Rabson ef = (elf_file_t) linker_kernel_file; 41954823af2SPeter Wemm ef->preloaded = 1; 4205c845fdeSNathan Whitehorn #ifdef __powerpc__ 421c6014c73SNathan Whitehorn ef->address = (caddr_t) (__startkernel - KERNBASE); 422c6014c73SNathan Whitehorn #else 423326e27d8SDoug Rabson ef->address = 0; 424c6014c73SNathan Whitehorn #endif 425326e27d8SDoug Rabson #ifdef SPARSE_MAPPING 426326e27d8SDoug Rabson ef->object = 0; 427326e27d8SDoug Rabson #endif 428326e27d8SDoug Rabson ef->dynamic = dp; 429326e27d8SDoug Rabson 4302f22b3ffSMatthew D Fleming if (dp != NULL) 431326e27d8SDoug Rabson parse_dynamic(ef); 432ee900504SNathan Whitehorn #ifdef __powerpc__ 433ee900504SNathan Whitehorn linker_kernel_file->address = (caddr_t)__startkernel; 434ee900504SNathan Whitehorn linker_kernel_file->size = (intptr_t)(__endkernel - __startkernel); 435ee900504SNathan Whitehorn #else 436c6014c73SNathan Whitehorn linker_kernel_file->address += KERNBASE; 437d009ccfaSBruce Evans linker_kernel_file->size = -(intptr_t)linker_kernel_file->address; 438ee900504SNathan Whitehorn #endif 439de78ca7eSPeter Wemm 4402f22b3ffSMatthew D Fleming if (modptr != NULL) { 4412d636ab0SPeter Wemm ef->modptr = modptr; 442de78ca7eSPeter Wemm baseptr = preload_search_info(modptr, MODINFO_ADDR); 4432f22b3ffSMatthew D Fleming if (baseptr != NULL) 444de78ca7eSPeter Wemm linker_kernel_file->address = *(caddr_t *)baseptr; 445de78ca7eSPeter Wemm sizeptr = preload_search_info(modptr, MODINFO_SIZE); 4462f22b3ffSMatthew D Fleming if (sizeptr != NULL) 447de78ca7eSPeter Wemm linker_kernel_file->size = *(size_t *)sizeptr; 4480067051fSMarcel Moolenaar ctors_addrp = (Elf_Addr *)preload_search_info(modptr, 4490067051fSMarcel Moolenaar MODINFO_METADATA | MODINFOMD_CTORS_ADDR); 4500067051fSMarcel Moolenaar ctors_sizep = (Elf_Size *)preload_search_info(modptr, 4510067051fSMarcel Moolenaar MODINFO_METADATA | MODINFOMD_CTORS_SIZE); 4520067051fSMarcel Moolenaar if (ctors_addrp != NULL && ctors_sizep != NULL) { 453853a17adSEnji Cooper linker_kernel_file->ctors_addr = ef->address + 4540067051fSMarcel Moolenaar *ctors_addrp; 4550067051fSMarcel Moolenaar linker_kernel_file->ctors_size = *ctors_sizep; 4560067051fSMarcel Moolenaar } 457de78ca7eSPeter Wemm } 45854823af2SPeter Wemm (void)link_elf_preload_parse_symbols(ef); 459326e27d8SDoug Rabson 460ecb01c64SMarcel Moolenaar #ifdef GDB 461c143d6c2SMarcel Moolenaar r_debug.r_map = NULL; 462326e27d8SDoug Rabson r_debug.r_brk = r_debug_state; 463326e27d8SDoug Rabson r_debug.r_state = RT_CONSISTENT; 464326e27d8SDoug Rabson #endif 465c143d6c2SMarcel Moolenaar 466c143d6c2SMarcel Moolenaar (void)link_elf_link_common_finish(linker_kernel_file); 46759800afcSJohn Baldwin linker_kernel_file->flags |= LINKER_FILE_LINKED; 46847813f5dSMikolaj Golub TAILQ_INIT(&set_pcpu_list); 46947813f5dSMikolaj Golub #ifdef VIMAGE 47047813f5dSMikolaj Golub TAILQ_INIT(&set_vnet_list); 47147813f5dSMikolaj Golub #endif 472a4f67738SDoug Rabson } 473a4f67738SDoug Rabson 474891cf3edSEd Maste SYSINIT(link_elf, SI_SUB_KLD, SI_ORDER_THIRD, link_elf_init, NULL); 475a4f67738SDoug Rabson 476a4f67738SDoug Rabson static int 47754823af2SPeter Wemm link_elf_preload_parse_symbols(elf_file_t ef) 4782d636ab0SPeter Wemm { 4792d636ab0SPeter Wemm caddr_t pointer; 4802d636ab0SPeter Wemm caddr_t ssym, esym, base; 4812d636ab0SPeter Wemm caddr_t strtab; 4822d636ab0SPeter Wemm int strcnt; 4832d636ab0SPeter Wemm Elf_Sym *symtab; 4842d636ab0SPeter Wemm int symcnt; 4852d636ab0SPeter Wemm 486ca65d5c7SPeter Wemm if (ef->modptr == NULL) 4872f22b3ffSMatthew D Fleming return (0); 4882f22b3ffSMatthew D Fleming pointer = preload_search_info(ef->modptr, 4892f22b3ffSMatthew D Fleming MODINFO_METADATA | MODINFOMD_SSYM); 4902d636ab0SPeter Wemm if (pointer == NULL) 4912f22b3ffSMatthew D Fleming return (0); 4922d636ab0SPeter Wemm ssym = *(caddr_t *)pointer; 4932f22b3ffSMatthew D Fleming pointer = preload_search_info(ef->modptr, 4942f22b3ffSMatthew D Fleming MODINFO_METADATA | MODINFOMD_ESYM); 4952d636ab0SPeter Wemm if (pointer == NULL) 4962f22b3ffSMatthew D Fleming return (0); 4972d636ab0SPeter Wemm esym = *(caddr_t *)pointer; 4982d636ab0SPeter Wemm 4992d636ab0SPeter Wemm base = ssym; 5002d636ab0SPeter Wemm 5012d636ab0SPeter Wemm symcnt = *(long *)base; 5022d636ab0SPeter Wemm base += sizeof(long); 5032d636ab0SPeter Wemm symtab = (Elf_Sym *)base; 5042d636ab0SPeter Wemm base += roundup(symcnt, sizeof(long)); 5052d636ab0SPeter Wemm 5062d636ab0SPeter Wemm if (base > esym || base < ssym) { 5072d636ab0SPeter Wemm printf("Symbols are corrupt!\n"); 5082f22b3ffSMatthew D Fleming return (EINVAL); 5092d636ab0SPeter Wemm } 5102d636ab0SPeter Wemm 5112d636ab0SPeter Wemm strcnt = *(long *)base; 5122d636ab0SPeter Wemm base += sizeof(long); 5132d636ab0SPeter Wemm strtab = base; 5142d636ab0SPeter Wemm base += roundup(strcnt, sizeof(long)); 5152d636ab0SPeter Wemm 5162d636ab0SPeter Wemm if (base > esym || base < ssym) { 5172d636ab0SPeter Wemm printf("Symbols are corrupt!\n"); 5182f22b3ffSMatthew D Fleming return (EINVAL); 5192d636ab0SPeter Wemm } 5202d636ab0SPeter Wemm 5212d636ab0SPeter Wemm ef->ddbsymtab = symtab; 5222d636ab0SPeter Wemm ef->ddbsymcnt = symcnt / sizeof(Elf_Sym); 5232d636ab0SPeter Wemm ef->ddbstrtab = strtab; 5242d636ab0SPeter Wemm ef->ddbstrcnt = strcnt; 5252d636ab0SPeter Wemm 5262f22b3ffSMatthew D Fleming return (0); 5272d636ab0SPeter Wemm } 5282d636ab0SPeter Wemm 5292d636ab0SPeter Wemm static int 530326e27d8SDoug Rabson parse_dynamic(elf_file_t ef) 531a4f67738SDoug Rabson { 532326e27d8SDoug Rabson Elf_Dyn *dp; 533fe3db7c7SDoug Rabson int plttype = DT_REL; 534a4f67738SDoug Rabson 535a4f67738SDoug Rabson for (dp = ef->dynamic; dp->d_tag != DT_NULL; dp++) { 536a4f67738SDoug Rabson switch (dp->d_tag) { 537a4f67738SDoug Rabson case DT_HASH: 538a4f67738SDoug Rabson { 539a4f67738SDoug Rabson /* From src/libexec/rtld-elf/rtld.c */ 5407e510298SJake Burkholder const Elf_Hashelt *hashtab = (const Elf_Hashelt *) 541a4f67738SDoug Rabson (ef->address + dp->d_un.d_ptr); 542a4f67738SDoug Rabson ef->nbuckets = hashtab[0]; 543a4f67738SDoug Rabson ef->nchains = hashtab[1]; 544a4f67738SDoug Rabson ef->buckets = hashtab + 2; 545a4f67738SDoug Rabson ef->chains = ef->buckets + ef->nbuckets; 546a4f67738SDoug Rabson break; 547a4f67738SDoug Rabson } 548a4f67738SDoug Rabson case DT_STRTAB: 549fe3db7c7SDoug Rabson ef->strtab = (caddr_t) (ef->address + dp->d_un.d_ptr); 550a4f67738SDoug Rabson break; 5512d636ab0SPeter Wemm case DT_STRSZ: 5522d636ab0SPeter Wemm ef->strsz = dp->d_un.d_val; 5532d636ab0SPeter Wemm break; 554a4f67738SDoug Rabson case DT_SYMTAB: 555fe3db7c7SDoug Rabson ef->symtab = (Elf_Sym*) (ef->address + dp->d_un.d_ptr); 556a4f67738SDoug Rabson break; 557a4f67738SDoug Rabson case DT_SYMENT: 558a4f67738SDoug Rabson if (dp->d_un.d_val != sizeof(Elf_Sym)) 5592f22b3ffSMatthew D Fleming return (ENOEXEC); 560fe3db7c7SDoug Rabson break; 561fe3db7c7SDoug Rabson case DT_PLTGOT: 562fe3db7c7SDoug Rabson ef->got = (Elf_Addr *) (ef->address + dp->d_un.d_ptr); 563fe3db7c7SDoug Rabson break; 564fe3db7c7SDoug Rabson case DT_REL: 565fe3db7c7SDoug Rabson ef->rel = (const Elf_Rel *) (ef->address + dp->d_un.d_ptr); 566fe3db7c7SDoug Rabson break; 567fe3db7c7SDoug Rabson case DT_RELSZ: 568fe3db7c7SDoug Rabson ef->relsize = dp->d_un.d_val; 569fe3db7c7SDoug Rabson break; 570fe3db7c7SDoug Rabson case DT_RELENT: 571fe3db7c7SDoug Rabson if (dp->d_un.d_val != sizeof(Elf_Rel)) 5722f22b3ffSMatthew D Fleming return (ENOEXEC); 573fe3db7c7SDoug Rabson break; 574fe3db7c7SDoug Rabson case DT_JMPREL: 575fe3db7c7SDoug Rabson ef->pltrel = (const Elf_Rel *) (ef->address + dp->d_un.d_ptr); 576fe3db7c7SDoug Rabson break; 577fe3db7c7SDoug Rabson case DT_PLTRELSZ: 578fe3db7c7SDoug Rabson ef->pltrelsize = dp->d_un.d_val; 579fe3db7c7SDoug Rabson break; 580fe3db7c7SDoug Rabson case DT_RELA: 581fe3db7c7SDoug Rabson ef->rela = (const Elf_Rela *) (ef->address + dp->d_un.d_ptr); 582fe3db7c7SDoug Rabson break; 583fe3db7c7SDoug Rabson case DT_RELASZ: 584fe3db7c7SDoug Rabson ef->relasize = dp->d_un.d_val; 585fe3db7c7SDoug Rabson break; 586fe3db7c7SDoug Rabson case DT_RELAENT: 587fe3db7c7SDoug Rabson if (dp->d_un.d_val != sizeof(Elf_Rela)) 5882f22b3ffSMatthew D Fleming return (ENOEXEC); 589fe3db7c7SDoug Rabson break; 590fe3db7c7SDoug Rabson case DT_PLTREL: 591fe3db7c7SDoug Rabson plttype = dp->d_un.d_val; 592fe3db7c7SDoug Rabson if (plttype != DT_REL && plttype != DT_RELA) 5932f22b3ffSMatthew D Fleming return (ENOEXEC); 594fe3db7c7SDoug Rabson break; 595ecb01c64SMarcel Moolenaar #ifdef GDB 596326e27d8SDoug Rabson case DT_DEBUG: 597326e27d8SDoug Rabson dp->d_un.d_ptr = (Elf_Addr)&r_debug; 598326e27d8SDoug Rabson break; 599326e27d8SDoug Rabson #endif 600a4f67738SDoug Rabson } 601a4f67738SDoug Rabson } 602fe3db7c7SDoug Rabson 603fe3db7c7SDoug Rabson if (plttype == DT_RELA) { 604fe3db7c7SDoug Rabson ef->pltrela = (const Elf_Rela *)ef->pltrel; 605fe3db7c7SDoug Rabson ef->pltrel = NULL; 606fe3db7c7SDoug Rabson ef->pltrelasize = ef->pltrelsize; 607fe3db7c7SDoug Rabson ef->pltrelsize = 0; 608fe3db7c7SDoug Rabson } 609fe3db7c7SDoug Rabson 6102d636ab0SPeter Wemm ef->ddbsymtab = ef->symtab; 6112d636ab0SPeter Wemm ef->ddbsymcnt = ef->nchains; 6122d636ab0SPeter Wemm ef->ddbstrtab = ef->strtab; 6132d636ab0SPeter Wemm ef->ddbstrcnt = ef->strsz; 6142d636ab0SPeter Wemm 6152f22b3ffSMatthew D Fleming return (0); 616a4f67738SDoug Rabson } 617a4f67738SDoug Rabson 618a4f67738SDoug Rabson static int 61950c202c5SJeff Roberson parse_dpcpu(elf_file_t ef) 62050c202c5SJeff Roberson { 6219ae7bc39SBjoern A. Zeeb int error, size; 62250c202c5SJeff Roberson 62350c202c5SJeff Roberson ef->pcpu_start = 0; 62450c202c5SJeff Roberson ef->pcpu_stop = 0; 62550c202c5SJeff Roberson error = link_elf_lookup_set(&ef->lf, "pcpu", (void ***)&ef->pcpu_start, 6269ae7bc39SBjoern A. Zeeb (void ***)&ef->pcpu_stop, NULL); 62750c202c5SJeff Roberson /* Error just means there is no pcpu set to relocate. */ 6282f22b3ffSMatthew D Fleming if (error != 0) 62950c202c5SJeff Roberson return (0); 6309ae7bc39SBjoern A. Zeeb size = (uintptr_t)ef->pcpu_stop - (uintptr_t)ef->pcpu_start; 6319ae7bc39SBjoern A. Zeeb /* Empty set? */ 6329ae7bc39SBjoern A. Zeeb if (size < 1) 6339ae7bc39SBjoern A. Zeeb return (0); 63450c202c5SJeff Roberson /* 6352f22b3ffSMatthew D Fleming * Allocate space in the primary pcpu area. Copy in our 6362f22b3ffSMatthew D Fleming * initialization from the data section and then initialize 6372f22b3ffSMatthew D Fleming * all per-cpu storage from that. 63850c202c5SJeff Roberson */ 6399ae7bc39SBjoern A. Zeeb ef->pcpu_base = (Elf_Addr)(uintptr_t)dpcpu_alloc(size); 640*0f823b64SBjoern A. Zeeb if (ef->pcpu_base == 0) { 641*0f823b64SBjoern A. Zeeb printf("%s: pcpu module space is out of space; " 642*0f823b64SBjoern A. Zeeb "cannot allocate %d for %s\n", 643*0f823b64SBjoern A. Zeeb __func__, size, ef->lf.pathname); 64450c202c5SJeff Roberson return (ENOSPC); 645*0f823b64SBjoern A. Zeeb } 6469ae7bc39SBjoern A. Zeeb memcpy((void *)ef->pcpu_base, (void *)ef->pcpu_start, size); 6479ae7bc39SBjoern A. Zeeb dpcpu_copy((void *)ef->pcpu_base, size); 64847813f5dSMikolaj Golub elf_set_add(&set_pcpu_list, ef->pcpu_start, ef->pcpu_stop, 64947813f5dSMikolaj Golub ef->pcpu_base); 65050c202c5SJeff Roberson 65150c202c5SJeff Roberson return (0); 65250c202c5SJeff Roberson } 65350c202c5SJeff Roberson 654eddfbb76SRobert Watson #ifdef VIMAGE 655eddfbb76SRobert Watson static int 656eddfbb76SRobert Watson parse_vnet(elf_file_t ef) 657eddfbb76SRobert Watson { 6589ae7bc39SBjoern A. Zeeb int error, size; 659eddfbb76SRobert Watson 660eddfbb76SRobert Watson ef->vnet_start = 0; 661eddfbb76SRobert Watson ef->vnet_stop = 0; 662eddfbb76SRobert Watson error = link_elf_lookup_set(&ef->lf, "vnet", (void ***)&ef->vnet_start, 6639ae7bc39SBjoern A. Zeeb (void ***)&ef->vnet_stop, NULL); 664eddfbb76SRobert Watson /* Error just means there is no vnet data set to relocate. */ 6652f22b3ffSMatthew D Fleming if (error != 0) 666eddfbb76SRobert Watson return (0); 6679ae7bc39SBjoern A. Zeeb size = (uintptr_t)ef->vnet_stop - (uintptr_t)ef->vnet_start; 6689ae7bc39SBjoern A. Zeeb /* Empty set? */ 6699ae7bc39SBjoern A. Zeeb if (size < 1) 6709ae7bc39SBjoern A. Zeeb return (0); 671eddfbb76SRobert Watson /* 6722f22b3ffSMatthew D Fleming * Allocate space in the primary vnet area. Copy in our 6732f22b3ffSMatthew D Fleming * initialization from the data section and then initialize 6742f22b3ffSMatthew D Fleming * all per-vnet storage from that. 675eddfbb76SRobert Watson */ 6769ae7bc39SBjoern A. Zeeb ef->vnet_base = (Elf_Addr)(uintptr_t)vnet_data_alloc(size); 677*0f823b64SBjoern A. Zeeb if (ef->vnet_base == 0) { 678*0f823b64SBjoern A. Zeeb printf("%s: vnet module space is out of space; " 679*0f823b64SBjoern A. Zeeb "cannot allocate %d for %s\n", 680*0f823b64SBjoern A. Zeeb __func__, size, ef->lf.pathname); 681eddfbb76SRobert Watson return (ENOSPC); 682*0f823b64SBjoern A. Zeeb } 6839ae7bc39SBjoern A. Zeeb memcpy((void *)ef->vnet_base, (void *)ef->vnet_start, size); 6849ae7bc39SBjoern A. Zeeb vnet_data_copy((void *)ef->vnet_base, size); 68547813f5dSMikolaj Golub elf_set_add(&set_vnet_list, ef->vnet_start, ef->vnet_stop, 68647813f5dSMikolaj Golub ef->vnet_base); 687eddfbb76SRobert Watson 688eddfbb76SRobert Watson return (0); 689eddfbb76SRobert Watson } 690eddfbb76SRobert Watson #endif 691eddfbb76SRobert Watson 69250c202c5SJeff Roberson static int 69354823af2SPeter Wemm link_elf_link_preload(linker_class_t cls, 694326e27d8SDoug Rabson const char* filename, linker_file_t *result) 695de78ca7eSPeter Wemm { 6960067051fSMarcel Moolenaar Elf_Addr *ctors_addrp; 6970067051fSMarcel Moolenaar Elf_Size *ctors_sizep; 698de78ca7eSPeter Wemm caddr_t modptr, baseptr, sizeptr, dynptr; 699de78ca7eSPeter Wemm char *type; 700de78ca7eSPeter Wemm elf_file_t ef; 701de78ca7eSPeter Wemm linker_file_t lf; 702de78ca7eSPeter Wemm int error; 703de78ca7eSPeter Wemm vm_offset_t dp; 704de78ca7eSPeter Wemm 70554823af2SPeter Wemm /* Look to see if we have the file preloaded */ 706de78ca7eSPeter Wemm modptr = preload_search_by_name(filename); 707de78ca7eSPeter Wemm if (modptr == NULL) 7082f22b3ffSMatthew D Fleming return (ENOENT); 709de78ca7eSPeter Wemm 710de78ca7eSPeter Wemm type = (char *)preload_search_info(modptr, MODINFO_TYPE); 711de78ca7eSPeter Wemm baseptr = preload_search_info(modptr, MODINFO_ADDR); 712de78ca7eSPeter Wemm sizeptr = preload_search_info(modptr, MODINFO_SIZE); 7132f22b3ffSMatthew D Fleming dynptr = preload_search_info(modptr, 7142f22b3ffSMatthew D Fleming MODINFO_METADATA | MODINFOMD_DYNAMIC); 71567db8b23SPeter Wemm if (type == NULL || 71667db8b23SPeter Wemm (strcmp(type, "elf" __XSTRING(__ELF_WORD_SIZE) " module") != 0 && 71767db8b23SPeter Wemm strcmp(type, "elf module") != 0)) 718de78ca7eSPeter Wemm return (EFTYPE); 719de78ca7eSPeter Wemm if (baseptr == NULL || sizeptr == NULL || dynptr == NULL) 720de78ca7eSPeter Wemm return (EINVAL); 721de78ca7eSPeter Wemm 722326e27d8SDoug Rabson lf = linker_make_file(filename, &link_elf_class); 7232f22b3ffSMatthew D Fleming if (lf == NULL) 7242f22b3ffSMatthew D Fleming return (ENOMEM); 725326e27d8SDoug Rabson 726326e27d8SDoug Rabson ef = (elf_file_t) lf; 727326e27d8SDoug Rabson ef->preloaded = 1; 728ca65d5c7SPeter Wemm ef->modptr = modptr; 729de78ca7eSPeter Wemm ef->address = *(caddr_t *)baseptr; 730de78ca7eSPeter Wemm #ifdef SPARSE_MAPPING 731de78ca7eSPeter Wemm ef->object = 0; 732de78ca7eSPeter Wemm #endif 733de78ca7eSPeter Wemm dp = (vm_offset_t)ef->address + *(vm_offset_t *)dynptr; 734de78ca7eSPeter Wemm ef->dynamic = (Elf_Dyn *)dp; 735de78ca7eSPeter Wemm lf->address = ef->address; 736de78ca7eSPeter Wemm lf->size = *(size_t *)sizeptr; 737de78ca7eSPeter Wemm 7380067051fSMarcel Moolenaar ctors_addrp = (Elf_Addr *)preload_search_info(modptr, 7390067051fSMarcel Moolenaar MODINFO_METADATA | MODINFOMD_CTORS_ADDR); 7400067051fSMarcel Moolenaar ctors_sizep = (Elf_Size *)preload_search_info(modptr, 7410067051fSMarcel Moolenaar MODINFO_METADATA | MODINFOMD_CTORS_SIZE); 7420067051fSMarcel Moolenaar if (ctors_addrp != NULL && ctors_sizep != NULL) { 7430067051fSMarcel Moolenaar lf->ctors_addr = ef->address + *ctors_addrp; 7440067051fSMarcel Moolenaar lf->ctors_size = *ctors_sizep; 7450067051fSMarcel Moolenaar } 7460067051fSMarcel Moolenaar 747326e27d8SDoug Rabson error = parse_dynamic(ef); 74850c202c5SJeff Roberson if (error == 0) 74950c202c5SJeff Roberson error = parse_dpcpu(ef); 750eddfbb76SRobert Watson #ifdef VIMAGE 751eddfbb76SRobert Watson if (error == 0) 752eddfbb76SRobert Watson error = parse_vnet(ef); 753eddfbb76SRobert Watson #endif 7542f22b3ffSMatthew D Fleming if (error != 0) { 75565a311fcSPoul-Henning Kamp linker_file_unload(lf, LINKER_UNLOAD_FORCE); 7562f22b3ffSMatthew D Fleming return (error); 757de78ca7eSPeter Wemm } 7587251b4bfSJake Burkholder link_elf_reloc_local(lf); 759de78ca7eSPeter Wemm *result = lf; 760de78ca7eSPeter Wemm return (0); 761de78ca7eSPeter Wemm } 762de78ca7eSPeter Wemm 763de78ca7eSPeter Wemm static int 76454823af2SPeter Wemm link_elf_link_preload_finish(linker_file_t lf) 76554823af2SPeter Wemm { 76654823af2SPeter Wemm elf_file_t ef; 76754823af2SPeter Wemm int error; 76854823af2SPeter Wemm 76954823af2SPeter Wemm ef = (elf_file_t) lf; 77054823af2SPeter Wemm error = relocate_file(ef); 7712f22b3ffSMatthew D Fleming if (error != 0) 7722f22b3ffSMatthew D Fleming return (error); 77354823af2SPeter Wemm (void)link_elf_preload_parse_symbols(ef); 77454823af2SPeter Wemm 775c143d6c2SMarcel Moolenaar return (link_elf_link_common_finish(lf)); 77654823af2SPeter Wemm } 77754823af2SPeter Wemm 77854823af2SPeter Wemm static int 779c143d6c2SMarcel Moolenaar link_elf_load_file(linker_class_t cls, const char* filename, 780c143d6c2SMarcel Moolenaar linker_file_t* result) 781a4f67738SDoug Rabson { 782a4f67738SDoug Rabson struct nameidata nd; 783b40ce416SJulian Elischer struct thread* td = curthread; /* XXX */ 784caab6e90SPeter Wemm Elf_Ehdr *hdr; 785caab6e90SPeter Wemm caddr_t firstpage; 786fe3db7c7SDoug Rabson int nbytes, i; 787fe3db7c7SDoug Rabson Elf_Phdr *phdr; 788fe3db7c7SDoug Rabson Elf_Phdr *phlimit; 7891a330eb0SPeter Wemm Elf_Phdr *segs[MAXSEGS]; 790fe3db7c7SDoug Rabson int nsegs; 791fe3db7c7SDoug Rabson Elf_Phdr *phdyn; 792fe3db7c7SDoug Rabson caddr_t mapbase; 793fe3db7c7SDoug Rabson size_t mapsize; 794fe3db7c7SDoug Rabson Elf_Addr base_vaddr; 795fe3db7c7SDoug Rabson Elf_Addr base_vlimit; 796a4f67738SDoug Rabson int error = 0; 797526d0bd5SKonstantin Belousov ssize_t resid; 798526d0bd5SKonstantin Belousov int flags; 799a4f67738SDoug Rabson elf_file_t ef; 800a4f67738SDoug Rabson linker_file_t lf; 801ca65d5c7SPeter Wemm Elf_Shdr *shdr; 802ca65d5c7SPeter Wemm int symtabindex; 803ca65d5c7SPeter Wemm int symstrindex; 8040067051fSMarcel Moolenaar int shstrindex; 805ca65d5c7SPeter Wemm int symcnt; 806ca65d5c7SPeter Wemm int strcnt; 8070067051fSMarcel Moolenaar char *shstrs; 808ca65d5c7SPeter Wemm 809ca65d5c7SPeter Wemm shdr = NULL; 810ca65d5c7SPeter Wemm lf = NULL; 8110067051fSMarcel Moolenaar shstrs = NULL; 812a4f67738SDoug Rabson 8135050aa86SKonstantin Belousov NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, filename, td); 814e6796b67SKirk McKusick flags = FREAD; 8159e223287SKonstantin Belousov error = vn_open(&nd, &flags, 0, NULL); 8162f22b3ffSMatthew D Fleming if (error != 0) 8172f22b3ffSMatthew D Fleming return (error); 818762e6b85SEivind Eklund NDFREE(&nd, NDF_ONLY_PNBUF); 8191f49b573SRuslan Ermilov if (nd.ni_vp->v_type != VREG) { 8201f49b573SRuslan Ermilov error = ENOEXEC; 8211f49b573SRuslan Ermilov firstpage = NULL; 8221f49b573SRuslan Ermilov goto out; 8231f49b573SRuslan Ermilov } 824a3df768bSRobert Watson #ifdef MAC 82530d239bcSRobert Watson error = mac_kld_check_load(curthread->td_ucred, nd.ni_vp); 8262f22b3ffSMatthew D Fleming if (error != 0) { 827a3df768bSRobert Watson firstpage = NULL; 828a3df768bSRobert Watson goto out; 829a3df768bSRobert Watson } 830a3df768bSRobert Watson #endif 831a4f67738SDoug Rabson 832a4f67738SDoug Rabson /* 833fe3db7c7SDoug Rabson * Read the elf header from the file. 834a4f67738SDoug Rabson */ 835a163d034SWarner Losh firstpage = malloc(PAGE_SIZE, M_LINKER, M_WAITOK); 836caab6e90SPeter Wemm hdr = (Elf_Ehdr *)firstpage; 837caab6e90SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, firstpage, PAGE_SIZE, 0, 8389ca43589SRobert Watson UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 8399ca43589SRobert Watson &resid, td); 840caab6e90SPeter Wemm nbytes = PAGE_SIZE - resid; 8412f22b3ffSMatthew D Fleming if (error != 0) 842a4f67738SDoug Rabson goto out; 843a4f67738SDoug Rabson 844caab6e90SPeter Wemm if (!IS_ELF(*hdr)) { 845fe3db7c7SDoug Rabson error = ENOEXEC; 846a4f67738SDoug Rabson goto out; 847fe3db7c7SDoug Rabson } 848fe3db7c7SDoug Rabson 8492f22b3ffSMatthew D Fleming if (hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS || 8502f22b3ffSMatthew D Fleming hdr->e_ident[EI_DATA] != ELF_TARG_DATA) { 851552f9f63SEdwin Groothuis link_elf_error(filename, "Unsupported file layout"); 852fe3db7c7SDoug Rabson error = ENOEXEC; 853fe3db7c7SDoug Rabson goto out; 854fe3db7c7SDoug Rabson } 8552f22b3ffSMatthew D Fleming if (hdr->e_ident[EI_VERSION] != EV_CURRENT || 8562f22b3ffSMatthew D Fleming hdr->e_version != EV_CURRENT) { 857552f9f63SEdwin Groothuis link_elf_error(filename, "Unsupported file version"); 858fe3db7c7SDoug Rabson error = ENOEXEC; 859fe3db7c7SDoug Rabson goto out; 860fe3db7c7SDoug Rabson } 861caab6e90SPeter Wemm if (hdr->e_type != ET_EXEC && hdr->e_type != ET_DYN) { 862a1d7ce03SAttilio Rao error = ENOSYS; 863fe3db7c7SDoug Rabson goto out; 864fe3db7c7SDoug Rabson } 865caab6e90SPeter Wemm if (hdr->e_machine != ELF_TARG_MACH) { 866552f9f63SEdwin Groothuis link_elf_error(filename, "Unsupported machine"); 867fe3db7c7SDoug Rabson error = ENOEXEC; 868fe3db7c7SDoug Rabson goto out; 869fe3db7c7SDoug Rabson } 870a4f67738SDoug Rabson 871a4f67738SDoug Rabson /* 8722f22b3ffSMatthew D Fleming * We rely on the program header being in the first page. 8732f22b3ffSMatthew D Fleming * This is not strictly required by the ABI specification, but 8742f22b3ffSMatthew D Fleming * it seems to always true in practice. And, it simplifies 8752f22b3ffSMatthew D Fleming * things considerably. 876a4f67738SDoug Rabson */ 877caab6e90SPeter Wemm if (!((hdr->e_phentsize == sizeof(Elf_Phdr)) && 878caab6e90SPeter Wemm (hdr->e_phoff + hdr->e_phnum*sizeof(Elf_Phdr) <= PAGE_SIZE) && 879caab6e90SPeter Wemm (hdr->e_phoff + hdr->e_phnum*sizeof(Elf_Phdr) <= nbytes))) 880552f9f63SEdwin Groothuis link_elf_error(filename, "Unreadable program headers"); 881fe3db7c7SDoug Rabson 882fe3db7c7SDoug Rabson /* 883fe3db7c7SDoug Rabson * Scan the program header entries, and save key information. 884fe3db7c7SDoug Rabson * 885fe3db7c7SDoug Rabson * We rely on there being exactly two load segments, text and data, 886fe3db7c7SDoug Rabson * in that order. 887fe3db7c7SDoug Rabson */ 888caab6e90SPeter Wemm phdr = (Elf_Phdr *) (firstpage + hdr->e_phoff); 889caab6e90SPeter Wemm phlimit = phdr + hdr->e_phnum; 890fe3db7c7SDoug Rabson nsegs = 0; 891fe3db7c7SDoug Rabson phdyn = NULL; 892fe3db7c7SDoug Rabson while (phdr < phlimit) { 893fe3db7c7SDoug Rabson switch (phdr->p_type) { 894fe3db7c7SDoug Rabson case PT_LOAD: 8951a330eb0SPeter Wemm if (nsegs == MAXSEGS) { 896552f9f63SEdwin Groothuis link_elf_error(filename, "Too many sections"); 897fe3db7c7SDoug Rabson error = ENOEXEC; 898fe3db7c7SDoug Rabson goto out; 899fe3db7c7SDoug Rabson } 90087b1831fSPoul-Henning Kamp /* 90187b1831fSPoul-Henning Kamp * XXX: We just trust they come in right order ?? 90287b1831fSPoul-Henning Kamp */ 903fe3db7c7SDoug Rabson segs[nsegs] = phdr; 904fe3db7c7SDoug Rabson ++nsegs; 905fe3db7c7SDoug Rabson break; 906fe3db7c7SDoug Rabson 907fe3db7c7SDoug Rabson case PT_DYNAMIC: 908fe3db7c7SDoug Rabson phdyn = phdr; 909fe3db7c7SDoug Rabson break; 9109548091bSBoris Popov 9119548091bSBoris Popov case PT_INTERP: 912a1d7ce03SAttilio Rao error = ENOSYS; 9139548091bSBoris Popov goto out; 914fe3db7c7SDoug Rabson } 915fe3db7c7SDoug Rabson 916fe3db7c7SDoug Rabson ++phdr; 917fe3db7c7SDoug Rabson } 918fe3db7c7SDoug Rabson if (phdyn == NULL) { 919552f9f63SEdwin Groothuis link_elf_error(filename, "Object is not dynamically-linked"); 920fe3db7c7SDoug Rabson error = ENOEXEC; 921fe3db7c7SDoug Rabson goto out; 922fe3db7c7SDoug Rabson } 9231a330eb0SPeter Wemm if (nsegs == 0) { 924552f9f63SEdwin Groothuis link_elf_error(filename, "No sections"); 92587b1831fSPoul-Henning Kamp error = ENOEXEC; 92687b1831fSPoul-Henning Kamp goto out; 92787b1831fSPoul-Henning Kamp } 928fe3db7c7SDoug Rabson 929fe3db7c7SDoug Rabson /* 9302f22b3ffSMatthew D Fleming * Allocate the entire address space of the object, to stake 9312f22b3ffSMatthew D Fleming * out our contiguous region, and to establish the base 9322f22b3ffSMatthew D Fleming * address for relocation. 933fe3db7c7SDoug Rabson */ 934fe3db7c7SDoug Rabson base_vaddr = trunc_page(segs[0]->p_vaddr); 9351a330eb0SPeter Wemm base_vlimit = round_page(segs[nsegs - 1]->p_vaddr + 9361a330eb0SPeter Wemm segs[nsegs - 1]->p_memsz); 937fe3db7c7SDoug Rabson mapsize = base_vlimit - base_vaddr; 938fe3db7c7SDoug Rabson 939326e27d8SDoug Rabson lf = linker_make_file(filename, &link_elf_class); 9402f22b3ffSMatthew D Fleming if (lf == NULL) { 941326e27d8SDoug Rabson error = ENOMEM; 942326e27d8SDoug Rabson goto out; 943326e27d8SDoug Rabson } 944326e27d8SDoug Rabson 945326e27d8SDoug Rabson ef = (elf_file_t) lf; 946fe3db7c7SDoug Rabson #ifdef SPARSE_MAPPING 947fe3db7c7SDoug Rabson ef->object = vm_object_allocate(OBJT_DEFAULT, mapsize >> PAGE_SHIFT); 948fe3db7c7SDoug Rabson if (ef->object == NULL) { 949fe3db7c7SDoug Rabson error = ENOMEM; 950fe3db7c7SDoug Rabson goto out; 951fe3db7c7SDoug Rabson } 952fe3db7c7SDoug Rabson ef->address = (caddr_t) vm_map_min(kernel_map); 953fe3db7c7SDoug Rabson error = vm_map_find(kernel_map, ef->object, 0, 954edb572a3SJohn Baldwin (vm_offset_t *) &ef->address, mapsize, 0, VMFS_OPTIMAL_SPACE, 955fe3db7c7SDoug Rabson VM_PROT_ALL, VM_PROT_ALL, 0); 9562f22b3ffSMatthew D Fleming if (error != 0) { 957fe3db7c7SDoug Rabson vm_object_deallocate(ef->object); 958326e27d8SDoug Rabson ef->object = 0; 959fe3db7c7SDoug Rabson goto out; 960fe3db7c7SDoug Rabson } 961fe3db7c7SDoug Rabson #else 96278bcf87eSOlivier Houchard ef->address = malloc(mapsize, M_LINKER, M_EXEC | M_WAITOK); 963fe3db7c7SDoug Rabson #endif 964fe3db7c7SDoug Rabson mapbase = ef->address; 965a4f67738SDoug Rabson 966a4f67738SDoug Rabson /* 967a4f67738SDoug Rabson * Read the text and data sections and zero the bss. 968a4f67738SDoug Rabson */ 9691a330eb0SPeter Wemm for (i = 0; i < nsegs; i++) { 970fe3db7c7SDoug Rabson caddr_t segbase = mapbase + segs[i]->p_vaddr - base_vaddr; 971fe3db7c7SDoug Rabson error = vn_rdwr(UIO_READ, nd.ni_vp, 972fe3db7c7SDoug Rabson segbase, segs[i]->p_filesz, segs[i]->p_offset, 9739ca43589SRobert Watson UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 9749ca43589SRobert Watson &resid, td); 9752f22b3ffSMatthew D Fleming if (error != 0) 976a4f67738SDoug Rabson goto out; 977fe3db7c7SDoug Rabson bzero(segbase + segs[i]->p_filesz, 978fe3db7c7SDoug Rabson segs[i]->p_memsz - segs[i]->p_filesz); 97941673965SAlan Cox 98041673965SAlan Cox #ifdef SPARSE_MAPPING 98141673965SAlan Cox /* 98241673965SAlan Cox * Wire down the pages 98341673965SAlan Cox */ 9845d3043ceSAlan Cox error = vm_map_wire(kernel_map, 98541673965SAlan Cox (vm_offset_t) segbase, 98641673965SAlan Cox (vm_offset_t) segbase + segs[i]->p_memsz, 98741673965SAlan Cox VM_MAP_WIRE_SYSTEM|VM_MAP_WIRE_NOHOLES); 9885d3043ceSAlan Cox if (error != KERN_SUCCESS) { 9895d3043ceSAlan Cox error = ENOMEM; 9905d3043ceSAlan Cox goto out; 9915d3043ceSAlan Cox } 99241673965SAlan Cox #endif 993fe3db7c7SDoug Rabson } 994fe3db7c7SDoug Rabson 995f99502a4SBrian Feldman #ifdef GPROF 996f99502a4SBrian Feldman /* Update profiling information with the new text segment. */ 99770f37788SJohn Baldwin mtx_lock(&Giant); 998853a17adSEnji Cooper kmupetext((uintfptr_t)(mapbase + segs[0]->p_vaddr - base_vaddr + 999f99502a4SBrian Feldman segs[0]->p_memsz)); 100070f37788SJohn Baldwin mtx_unlock(&Giant); 1001f99502a4SBrian Feldman #endif 1002f99502a4SBrian Feldman 1003326e27d8SDoug Rabson ef->dynamic = (Elf_Dyn *) (mapbase + phdyn->p_vaddr - base_vaddr); 1004a4f67738SDoug Rabson 1005a4f67738SDoug Rabson lf->address = ef->address; 1006fe3db7c7SDoug Rabson lf->size = mapsize; 1007a4f67738SDoug Rabson 1008326e27d8SDoug Rabson error = parse_dynamic(ef); 10092f22b3ffSMatthew D Fleming if (error != 0) 1010de78ca7eSPeter Wemm goto out; 101150c202c5SJeff Roberson error = parse_dpcpu(ef); 10122f22b3ffSMatthew D Fleming if (error != 0) 101350c202c5SJeff Roberson goto out; 1014eddfbb76SRobert Watson #ifdef VIMAGE 1015eddfbb76SRobert Watson error = parse_vnet(ef); 10162f22b3ffSMatthew D Fleming if (error != 0) 1017eddfbb76SRobert Watson goto out; 1018eddfbb76SRobert Watson #endif 10197251b4bfSJake Burkholder link_elf_reloc_local(lf); 10207251b4bfSJake Burkholder 10214f7afc20SKonstantin Belousov VOP_UNLOCK(nd.ni_vp, 0); 10227b9716baSIan Dowse error = linker_load_dependencies(lf); 10234f7afc20SKonstantin Belousov vn_lock(nd.ni_vp, LK_EXCLUSIVE | LK_RETRY); 10242f22b3ffSMatthew D Fleming if (error != 0) 1025de78ca7eSPeter Wemm goto out; 1026326e27d8SDoug Rabson error = relocate_file(ef); 10272f22b3ffSMatthew D Fleming if (error != 0) 1028ca65d5c7SPeter Wemm goto out; 1029ca65d5c7SPeter Wemm 10302f22b3ffSMatthew D Fleming /* 10312f22b3ffSMatthew D Fleming * Try and load the symbol table if it's present. (you can 10322f22b3ffSMatthew D Fleming * strip it!) 10332f22b3ffSMatthew D Fleming */ 1034caab6e90SPeter Wemm nbytes = hdr->e_shnum * hdr->e_shentsize; 1035caab6e90SPeter Wemm if (nbytes == 0 || hdr->e_shoff == 0) 1036ca65d5c7SPeter Wemm goto nosyms; 1037a163d034SWarner Losh shdr = malloc(nbytes, M_LINKER, M_WAITOK | M_ZERO); 1038ca65d5c7SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, 1039caab6e90SPeter Wemm (caddr_t)shdr, nbytes, hdr->e_shoff, 10409ca43589SRobert Watson UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 10419ca43589SRobert Watson &resid, td); 10422f22b3ffSMatthew D Fleming if (error != 0) 1043ca65d5c7SPeter Wemm goto out; 10440067051fSMarcel Moolenaar 10450067051fSMarcel Moolenaar /* Read section string table */ 10460067051fSMarcel Moolenaar shstrindex = hdr->e_shstrndx; 10470067051fSMarcel Moolenaar if (shstrindex != 0 && shdr[shstrindex].sh_type == SHT_STRTAB && 10480067051fSMarcel Moolenaar shdr[shstrindex].sh_size != 0) { 10490067051fSMarcel Moolenaar nbytes = shdr[shstrindex].sh_size; 10500067051fSMarcel Moolenaar shstrs = malloc(nbytes, M_LINKER, M_WAITOK | M_ZERO); 10510067051fSMarcel Moolenaar error = vn_rdwr(UIO_READ, nd.ni_vp, (caddr_t)shstrs, nbytes, 10520067051fSMarcel Moolenaar shdr[shstrindex].sh_offset, UIO_SYSSPACE, IO_NODELOCKED, 10530067051fSMarcel Moolenaar td->td_ucred, NOCRED, &resid, td); 10540067051fSMarcel Moolenaar if (error) 10550067051fSMarcel Moolenaar goto out; 10560067051fSMarcel Moolenaar } 10570067051fSMarcel Moolenaar 1058ca65d5c7SPeter Wemm symtabindex = -1; 1059ca65d5c7SPeter Wemm symstrindex = -1; 1060caab6e90SPeter Wemm for (i = 0; i < hdr->e_shnum; i++) { 1061ca65d5c7SPeter Wemm if (shdr[i].sh_type == SHT_SYMTAB) { 1062ca65d5c7SPeter Wemm symtabindex = i; 1063ca65d5c7SPeter Wemm symstrindex = shdr[i].sh_link; 10640067051fSMarcel Moolenaar } else if (shstrs != NULL && shdr[i].sh_name != 0 && 10650067051fSMarcel Moolenaar strcmp(shstrs + shdr[i].sh_name, ".ctors") == 0) { 10660067051fSMarcel Moolenaar /* Record relocated address and size of .ctors. */ 10670067051fSMarcel Moolenaar lf->ctors_addr = mapbase + shdr[i].sh_addr - base_vaddr; 10680067051fSMarcel Moolenaar lf->ctors_size = shdr[i].sh_size; 1069ca65d5c7SPeter Wemm } 1070ca65d5c7SPeter Wemm } 1071ca65d5c7SPeter Wemm if (symtabindex < 0 || symstrindex < 0) 1072ca65d5c7SPeter Wemm goto nosyms; 1073ca65d5c7SPeter Wemm 1074ca65d5c7SPeter Wemm symcnt = shdr[symtabindex].sh_size; 1075a163d034SWarner Losh ef->symbase = malloc(symcnt, M_LINKER, M_WAITOK); 1076ca65d5c7SPeter Wemm strcnt = shdr[symstrindex].sh_size; 1077a163d034SWarner Losh ef->strbase = malloc(strcnt, M_LINKER, M_WAITOK); 1078ca65d5c7SPeter Wemm 1079ca65d5c7SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, 1080ca65d5c7SPeter Wemm ef->symbase, symcnt, shdr[symtabindex].sh_offset, 10819ca43589SRobert Watson UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 10829ca43589SRobert Watson &resid, td); 10832f22b3ffSMatthew D Fleming if (error != 0) 1084ca65d5c7SPeter Wemm goto out; 1085ca65d5c7SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, 1086ca65d5c7SPeter Wemm ef->strbase, strcnt, shdr[symstrindex].sh_offset, 10879ca43589SRobert Watson UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 10889ca43589SRobert Watson &resid, td); 10892f22b3ffSMatthew D Fleming if (error != 0) 1090ca65d5c7SPeter Wemm goto out; 1091ca65d5c7SPeter Wemm 1092ca65d5c7SPeter Wemm ef->ddbsymcnt = symcnt / sizeof(Elf_Sym); 1093ca65d5c7SPeter Wemm ef->ddbsymtab = (const Elf_Sym *)ef->symbase; 1094ca65d5c7SPeter Wemm ef->ddbstrcnt = strcnt; 1095ca65d5c7SPeter Wemm ef->ddbstrtab = ef->strbase; 1096ca65d5c7SPeter Wemm 10978a710317SMarcel Moolenaar nosyms: 1098c143d6c2SMarcel Moolenaar error = link_elf_link_common_finish(lf); 10992f22b3ffSMatthew D Fleming if (error != 0) 1100c143d6c2SMarcel Moolenaar goto out; 1101326e27d8SDoug Rabson 1102a4f67738SDoug Rabson *result = lf; 1103a4f67738SDoug Rabson 1104a4f67738SDoug Rabson out: 1105f1d2d305SKonstantin Belousov VOP_UNLOCK(nd.ni_vp, 0); 1106f1d2d305SKonstantin Belousov vn_close(nd.ni_vp, FREAD, td->td_ucred, td); 11072f22b3ffSMatthew D Fleming if (error != 0 && lf != NULL) 110865a311fcSPoul-Henning Kamp linker_file_unload(lf, LINKER_UNLOAD_FORCE); 1109ca65d5c7SPeter Wemm free(shdr, M_LINKER); 1110caab6e90SPeter Wemm free(firstpage, M_LINKER); 11110067051fSMarcel Moolenaar free(shstrs, M_LINKER); 1112a4f67738SDoug Rabson 11132f22b3ffSMatthew D Fleming return (error); 1114a4f67738SDoug Rabson } 1115a4f67738SDoug Rabson 111650c202c5SJeff Roberson Elf_Addr 111750c202c5SJeff Roberson elf_relocaddr(linker_file_t lf, Elf_Addr x) 111850c202c5SJeff Roberson { 111950c202c5SJeff Roberson elf_file_t ef; 112050c202c5SJeff Roberson 112150c202c5SJeff Roberson ef = (elf_file_t)lf; 112250c202c5SJeff Roberson if (x >= ef->pcpu_start && x < ef->pcpu_stop) 112350c202c5SJeff Roberson return ((x - ef->pcpu_start) + ef->pcpu_base); 1124eddfbb76SRobert Watson #ifdef VIMAGE 1125eddfbb76SRobert Watson if (x >= ef->vnet_start && x < ef->vnet_stop) 1126eddfbb76SRobert Watson return ((x - ef->vnet_start) + ef->vnet_base); 1127eddfbb76SRobert Watson #endif 112850c202c5SJeff Roberson return (x); 112950c202c5SJeff Roberson } 113050c202c5SJeff Roberson 113150c202c5SJeff Roberson 1132a4f67738SDoug Rabson static void 1133de78ca7eSPeter Wemm link_elf_unload_file(linker_file_t file) 1134a4f67738SDoug Rabson { 1135326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) file; 1136a4f67738SDoug Rabson 11372f22b3ffSMatthew D Fleming if (ef->pcpu_base != 0) { 11382f22b3ffSMatthew D Fleming dpcpu_free((void *)ef->pcpu_base, 11392f22b3ffSMatthew D Fleming ef->pcpu_stop - ef->pcpu_start); 114047813f5dSMikolaj Golub elf_set_delete(&set_pcpu_list, ef->pcpu_start); 114150c202c5SJeff Roberson } 1142eddfbb76SRobert Watson #ifdef VIMAGE 11432f22b3ffSMatthew D Fleming if (ef->vnet_base != 0) { 11442f22b3ffSMatthew D Fleming vnet_data_free((void *)ef->vnet_base, 11452f22b3ffSMatthew D Fleming ef->vnet_stop - ef->vnet_start); 114647813f5dSMikolaj Golub elf_set_delete(&set_vnet_list, ef->vnet_start); 1147eddfbb76SRobert Watson } 1148eddfbb76SRobert Watson #endif 1149ecb01c64SMarcel Moolenaar #ifdef GDB 11502f22b3ffSMatthew D Fleming if (ef->gdb.l_ld != NULL) { 1151326e27d8SDoug Rabson GDB_STATE(RT_DELETE); 1152ed6c3888SPeter Wemm free((void *)(uintptr_t)ef->gdb.l_name, M_LINKER); 1153326e27d8SDoug Rabson link_elf_delete_gdb(&ef->gdb); 1154326e27d8SDoug Rabson GDB_STATE(RT_CONSISTENT); 1155326e27d8SDoug Rabson } 1156326e27d8SDoug Rabson #endif 1157326e27d8SDoug Rabson 11581aeb23cdSMarcel Moolenaar /* Notify MD code that a module is being unloaded. */ 11591aeb23cdSMarcel Moolenaar elf_cpu_unload_file(file); 11601aeb23cdSMarcel Moolenaar 1161326e27d8SDoug Rabson if (ef->preloaded) { 116254823af2SPeter Wemm link_elf_unload_preload(file); 1163326e27d8SDoug Rabson return; 1164326e27d8SDoug Rabson } 1165c143d6c2SMarcel Moolenaar 1166fe3db7c7SDoug Rabson #ifdef SPARSE_MAPPING 11672f22b3ffSMatthew D Fleming if (ef->object != NULL) { 1168fe3db7c7SDoug Rabson vm_map_remove(kernel_map, (vm_offset_t) ef->address, 1169fe3db7c7SDoug Rabson (vm_offset_t) ef->address 1170fe3db7c7SDoug Rabson + (ef->object->size << PAGE_SHIFT)); 1171fe3db7c7SDoug Rabson } 1172fe3db7c7SDoug Rabson #else 1173a4f67738SDoug Rabson free(ef->address, M_LINKER); 1174fe3db7c7SDoug Rabson #endif 1175ca65d5c7SPeter Wemm free(ef->symbase, M_LINKER); 1176ca65d5c7SPeter Wemm free(ef->strbase, M_LINKER); 1177a2024a3eSJohn Birrell free(ef->ctftab, M_LINKER); 1178a2024a3eSJohn Birrell free(ef->ctfoff, M_LINKER); 1179a2024a3eSJohn Birrell free(ef->typoff, M_LINKER); 1180a4f67738SDoug Rabson } 1181a4f67738SDoug Rabson 1182de78ca7eSPeter Wemm static void 118354823af2SPeter Wemm link_elf_unload_preload(linker_file_t file) 1184de78ca7eSPeter Wemm { 118573624a80SMark Johnston if (file->pathname != NULL) 118673624a80SMark Johnston preload_delete_name(file->pathname); 1187de78ca7eSPeter Wemm } 1188de78ca7eSPeter Wemm 1189fe3db7c7SDoug Rabson static const char * 1190757686b1SMarcel Moolenaar symbol_name(elf_file_t ef, Elf_Size r_info) 1191a4f67738SDoug Rabson { 1192fe3db7c7SDoug Rabson const Elf_Sym *ref; 1193a4f67738SDoug Rabson 1194aa855a59SPeter Wemm if (ELF_R_SYM(r_info)) { 1195aa855a59SPeter Wemm ref = ef->symtab + ELF_R_SYM(r_info); 11962f22b3ffSMatthew D Fleming return (ef->strtab + ref->st_name); 11972f22b3ffSMatthew D Fleming } 11982f22b3ffSMatthew D Fleming return (NULL); 1199a4f67738SDoug Rabson } 1200a4f67738SDoug Rabson 1201a4f67738SDoug Rabson static int 120236716fe2SMark Johnston symbol_type(elf_file_t ef, Elf_Size r_info) 1203a4f67738SDoug Rabson { 120436716fe2SMark Johnston const Elf_Sym *ref; 120536716fe2SMark Johnston 120636716fe2SMark Johnston if (ELF_R_SYM(r_info)) { 120736716fe2SMark Johnston ref = ef->symtab + ELF_R_SYM(r_info); 120836716fe2SMark Johnston return (ELF_ST_TYPE(ref->st_info)); 120936716fe2SMark Johnston } 121036716fe2SMark Johnston return (STT_NOTYPE); 121136716fe2SMark Johnston } 121236716fe2SMark Johnston 121336716fe2SMark Johnston static int 121436716fe2SMark Johnston relocate_file1(elf_file_t ef, elf_lookup_fn lookup, elf_reloc_fn reloc, 121536716fe2SMark Johnston bool ifuncs) 121636716fe2SMark Johnston { 1217fe3db7c7SDoug Rabson const Elf_Rel *rel; 1218fe3db7c7SDoug Rabson const Elf_Rela *rela; 1219aa855a59SPeter Wemm const char *symname; 1220a4f67738SDoug Rabson 122136716fe2SMark Johnston #define APPLY_RELOCS(iter, tbl, tblsize, type) do { \ 122236716fe2SMark Johnston for ((iter) = (tbl); (iter) != NULL && \ 122336716fe2SMark Johnston (iter) < (tbl) + (tblsize) / sizeof(*(iter)); (iter)++) { \ 122436716fe2SMark Johnston if ((symbol_type(ef, (iter)->r_info) == \ 122536716fe2SMark Johnston STT_GNU_IFUNC || \ 122636716fe2SMark Johnston elf_is_ifunc_reloc((iter)->r_info)) != ifuncs) \ 122736716fe2SMark Johnston continue; \ 122836716fe2SMark Johnston if (reloc(&ef->lf, (Elf_Addr)ef->address, \ 122936716fe2SMark Johnston (iter), (type), lookup)) { \ 123036716fe2SMark Johnston symname = symbol_name(ef, (iter)->r_info); \ 123136716fe2SMark Johnston printf("link_elf: symbol %s undefined\n", \ 123236716fe2SMark Johnston symname); \ 123336716fe2SMark Johnston return (ENOENT); \ 123436716fe2SMark Johnston } \ 123536716fe2SMark Johnston } \ 123636716fe2SMark Johnston } while (0) 1237a4f67738SDoug Rabson 123836716fe2SMark Johnston APPLY_RELOCS(rel, ef->rel, ef->relsize, ELF_RELOC_REL); 123936716fe2SMark Johnston APPLY_RELOCS(rela, ef->rela, ef->relasize, ELF_RELOC_RELA); 124036716fe2SMark Johnston APPLY_RELOCS(rel, ef->pltrel, ef->pltrelsize, ELF_RELOC_REL); 124136716fe2SMark Johnston APPLY_RELOCS(rela, ef->pltrela, ef->pltrelasize, ELF_RELOC_RELA); 1242a4f67738SDoug Rabson 124336716fe2SMark Johnston #undef APPLY_RELOCS 1244a4f67738SDoug Rabson 12452f22b3ffSMatthew D Fleming return (0); 1246a4f67738SDoug Rabson } 1247a4f67738SDoug Rabson 12487035cf14SKonstantin Belousov static int 12497035cf14SKonstantin Belousov relocate_file(elf_file_t ef) 12507035cf14SKonstantin Belousov { 125136716fe2SMark Johnston int error; 12527035cf14SKonstantin Belousov 125336716fe2SMark Johnston error = relocate_file1(ef, elf_lookup, elf_reloc, false); 125436716fe2SMark Johnston if (error == 0) 125536716fe2SMark Johnston error = relocate_file1(ef, elf_lookup, elf_reloc, true); 125636716fe2SMark Johnston return (error); 12577035cf14SKonstantin Belousov } 12587035cf14SKonstantin Belousov 1259fe3db7c7SDoug Rabson /* 1260fe3db7c7SDoug Rabson * Hash function for symbol table lookup. Don't even think about changing 1261fe3db7c7SDoug Rabson * this. It is specified by the System V ABI. 1262fe3db7c7SDoug Rabson */ 1263fe3db7c7SDoug Rabson static unsigned long 1264fe3db7c7SDoug Rabson elf_hash(const char *name) 1265a4f67738SDoug Rabson { 1266fe3db7c7SDoug Rabson const unsigned char *p = (const unsigned char *) name; 1267fe3db7c7SDoug Rabson unsigned long h = 0; 1268fe3db7c7SDoug Rabson unsigned long g; 1269a4f67738SDoug Rabson 1270fe3db7c7SDoug Rabson while (*p != '\0') { 1271fe3db7c7SDoug Rabson h = (h << 4) + *p++; 1272fe3db7c7SDoug Rabson if ((g = h & 0xf0000000) != 0) 1273fe3db7c7SDoug Rabson h ^= g >> 24; 1274fe3db7c7SDoug Rabson h &= ~g; 1275a4f67738SDoug Rabson } 12762f22b3ffSMatthew D Fleming return (h); 1277fe3db7c7SDoug Rabson } 1278a4f67738SDoug Rabson 127937c84183SPoul-Henning Kamp static int 1280d254af07SMatthew Dillon link_elf_lookup_symbol(linker_file_t lf, const char *name, c_linker_sym_t *sym) 1281a4f67738SDoug Rabson { 1282326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) lf; 1283fe3db7c7SDoug Rabson unsigned long symnum; 12842d636ab0SPeter Wemm const Elf_Sym* symp; 12852d636ab0SPeter Wemm const char *strp; 1286fe3db7c7SDoug Rabson unsigned long hash; 1287a4f67738SDoug Rabson int i; 1288a4f67738SDoug Rabson 1289f6494f2eSJohn Baldwin /* If we don't have a hash, bail. */ 1290f6494f2eSJohn Baldwin if (ef->buckets == NULL || ef->nbuckets == 0) { 1291f6494f2eSJohn Baldwin printf("link_elf_lookup_symbol: missing symbol hash table\n"); 12922f22b3ffSMatthew D Fleming return (ENOENT); 1293f6494f2eSJohn Baldwin } 1294f6494f2eSJohn Baldwin 12952d636ab0SPeter Wemm /* First, search hashed global symbols */ 1296fe3db7c7SDoug Rabson hash = elf_hash(name); 1297fe3db7c7SDoug Rabson symnum = ef->buckets[hash % ef->nbuckets]; 1298fe3db7c7SDoug Rabson 1299fe3db7c7SDoug Rabson while (symnum != STN_UNDEF) { 1300fe3db7c7SDoug Rabson if (symnum >= ef->nchains) { 13012f22b3ffSMatthew D Fleming printf("%s: corrupt symbol table\n", __func__); 13022f22b3ffSMatthew D Fleming return (ENOENT); 1303a4f67738SDoug Rabson } 1304fe3db7c7SDoug Rabson 1305fe3db7c7SDoug Rabson symp = ef->symtab + symnum; 1306fe3db7c7SDoug Rabson if (symp->st_name == 0) { 13072f22b3ffSMatthew D Fleming printf("%s: corrupt symbol table\n", __func__); 13082f22b3ffSMatthew D Fleming return (ENOENT); 1309fe3db7c7SDoug Rabson } 1310fe3db7c7SDoug Rabson 1311fe3db7c7SDoug Rabson strp = ef->strtab + symp->st_name; 1312fe3db7c7SDoug Rabson 1313fe3db7c7SDoug Rabson if (strcmp(name, strp) == 0) { 1314fe3db7c7SDoug Rabson if (symp->st_shndx != SHN_UNDEF || 1315fe3db7c7SDoug Rabson (symp->st_value != 0 && 13167035cf14SKonstantin Belousov (ELF_ST_TYPE(symp->st_info) == STT_FUNC || 13177035cf14SKonstantin Belousov ELF_ST_TYPE(symp->st_info) == STT_GNU_IFUNC))) { 1318d254af07SMatthew Dillon *sym = (c_linker_sym_t) symp; 13192f22b3ffSMatthew D Fleming return (0); 13202f22b3ffSMatthew D Fleming } 13212f22b3ffSMatthew D Fleming return (ENOENT); 1322fe3db7c7SDoug Rabson } 1323fe3db7c7SDoug Rabson 1324fe3db7c7SDoug Rabson symnum = ef->chains[symnum]; 1325a4f67738SDoug Rabson } 1326a4f67738SDoug Rabson 13272d636ab0SPeter Wemm /* If we have not found it, look at the full table (if loaded) */ 13282d636ab0SPeter Wemm if (ef->symtab == ef->ddbsymtab) 13292f22b3ffSMatthew D Fleming return (ENOENT); 13302d636ab0SPeter Wemm 13312d636ab0SPeter Wemm /* Exhaustive search */ 13322d636ab0SPeter Wemm for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) { 13332d636ab0SPeter Wemm strp = ef->ddbstrtab + symp->st_name; 13342d636ab0SPeter Wemm if (strcmp(name, strp) == 0) { 13352d636ab0SPeter Wemm if (symp->st_shndx != SHN_UNDEF || 13362d636ab0SPeter Wemm (symp->st_value != 0 && 13377035cf14SKonstantin Belousov (ELF_ST_TYPE(symp->st_info) == STT_FUNC || 13387035cf14SKonstantin Belousov ELF_ST_TYPE(symp->st_info) == STT_GNU_IFUNC))) { 1339d254af07SMatthew Dillon *sym = (c_linker_sym_t) symp; 13402f22b3ffSMatthew D Fleming return (0); 13412f22b3ffSMatthew D Fleming } 13422f22b3ffSMatthew D Fleming return (ENOENT); 13432d636ab0SPeter Wemm } 13442d636ab0SPeter Wemm } 13452d636ab0SPeter Wemm 13462f22b3ffSMatthew D Fleming return (ENOENT); 1347a4f67738SDoug Rabson } 1348a4f67738SDoug Rabson 1349de78ca7eSPeter Wemm static int 13502f22b3ffSMatthew D Fleming link_elf_symbol_values(linker_file_t lf, c_linker_sym_t sym, 13512f22b3ffSMatthew D Fleming linker_symval_t *symval) 1352a4f67738SDoug Rabson { 13537035cf14SKonstantin Belousov elf_file_t ef; 13547035cf14SKonstantin Belousov const Elf_Sym *es; 13557035cf14SKonstantin Belousov caddr_t val; 1356a4f67738SDoug Rabson 13577035cf14SKonstantin Belousov ef = (elf_file_t)lf; 13587035cf14SKonstantin Belousov es = (const Elf_Sym *)sym; 13595cf87418SMarcel Moolenaar if (es >= ef->symtab && es < (ef->symtab + ef->nchains)) { 1360a4f67738SDoug Rabson symval->name = ef->strtab + es->st_name; 13617035cf14SKonstantin Belousov val = (caddr_t)ef->address + es->st_value; 13627035cf14SKonstantin Belousov if (ELF_ST_TYPE(es->st_info) == STT_GNU_IFUNC) 13637035cf14SKonstantin Belousov val = ((caddr_t (*)(void))val)(); 13647035cf14SKonstantin Belousov symval->value = val; 1365a4f67738SDoug Rabson symval->size = es->st_size; 13662f22b3ffSMatthew D Fleming return (0); 1367a4f67738SDoug Rabson } 13682d636ab0SPeter Wemm if (ef->symtab == ef->ddbsymtab) 13692f22b3ffSMatthew D Fleming return (ENOENT); 13705cf87418SMarcel Moolenaar if (es >= ef->ddbsymtab && es < (ef->ddbsymtab + ef->ddbsymcnt)) { 13712d636ab0SPeter Wemm symval->name = ef->ddbstrtab + es->st_name; 13727035cf14SKonstantin Belousov val = (caddr_t)ef->address + es->st_value; 13737035cf14SKonstantin Belousov if (ELF_ST_TYPE(es->st_info) == STT_GNU_IFUNC) 13747035cf14SKonstantin Belousov val = ((caddr_t (*)(void))val)(); 13757035cf14SKonstantin Belousov symval->value = val; 13762d636ab0SPeter Wemm symval->size = es->st_size; 13772f22b3ffSMatthew D Fleming return (0); 13782d636ab0SPeter Wemm } 13792f22b3ffSMatthew D Fleming return (ENOENT); 13802d636ab0SPeter Wemm } 1381a4f67738SDoug Rabson 1382a4f67738SDoug Rabson static int 1383a4f67738SDoug Rabson link_elf_search_symbol(linker_file_t lf, caddr_t value, 1384d254af07SMatthew Dillon c_linker_sym_t *sym, long *diffp) 1385a4f67738SDoug Rabson { 1386326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) lf; 1387586453feSBruce Evans u_long off = (uintptr_t) (void *) value; 1388a4f67738SDoug Rabson u_long diff = off; 1389586453feSBruce Evans u_long st_value; 1390fe3db7c7SDoug Rabson const Elf_Sym* es; 1391b85f65afSPedro F. Giffuni const Elf_Sym* best = NULL; 1392a4f67738SDoug Rabson int i; 1393a4f67738SDoug Rabson 13942d636ab0SPeter Wemm for (i = 0, es = ef->ddbsymtab; i < ef->ddbsymcnt; i++, es++) { 1395a4f67738SDoug Rabson if (es->st_name == 0) 1396a4f67738SDoug Rabson continue; 1397586453feSBruce Evans st_value = es->st_value + (uintptr_t) (void *) ef->address; 1398b5abfb70SPeter Wemm if (off >= st_value) { 1399b5abfb70SPeter Wemm if (off - st_value < diff) { 1400b5abfb70SPeter Wemm diff = off - st_value; 1401a4f67738SDoug Rabson best = es; 1402a4f67738SDoug Rabson if (diff == 0) 1403a4f67738SDoug Rabson break; 1404b5abfb70SPeter Wemm } else if (off - st_value == diff) { 1405a4f67738SDoug Rabson best = es; 1406a4f67738SDoug Rabson } 1407a4f67738SDoug Rabson } 1408a4f67738SDoug Rabson } 1409b85f65afSPedro F. Giffuni if (best == NULL) 1410a4f67738SDoug Rabson *diffp = off; 1411a4f67738SDoug Rabson else 1412a4f67738SDoug Rabson *diffp = diff; 1413d254af07SMatthew Dillon *sym = (c_linker_sym_t) best; 1414a4f67738SDoug Rabson 14152f22b3ffSMatthew D Fleming return (0); 1416a4f67738SDoug Rabson } 1417f41325dbSPeter Wemm 1418f41325dbSPeter Wemm /* 1419f41325dbSPeter Wemm * Look up a linker set on an ELF system. 1420f41325dbSPeter Wemm */ 1421f41325dbSPeter Wemm static int 1422f41325dbSPeter Wemm link_elf_lookup_set(linker_file_t lf, const char *name, 1423f41325dbSPeter Wemm void ***startp, void ***stopp, int *countp) 1424f41325dbSPeter Wemm { 1425f41325dbSPeter Wemm c_linker_sym_t sym; 1426f41325dbSPeter Wemm linker_symval_t symval; 1427f41325dbSPeter Wemm char *setsym; 1428f41325dbSPeter Wemm void **start, **stop; 1429f41325dbSPeter Wemm int len, error = 0, count; 1430f41325dbSPeter Wemm 1431f41325dbSPeter Wemm len = strlen(name) + sizeof("__start_set_"); /* sizeof includes \0 */ 1432a163d034SWarner Losh setsym = malloc(len, M_LINKER, M_WAITOK); 1433f41325dbSPeter Wemm 1434f41325dbSPeter Wemm /* get address of first entry */ 1435f41325dbSPeter Wemm snprintf(setsym, len, "%s%s", "__start_set_", name); 1436f41325dbSPeter Wemm error = link_elf_lookup_symbol(lf, setsym, &sym); 14372f22b3ffSMatthew D Fleming if (error != 0) 1438f41325dbSPeter Wemm goto out; 1439f41325dbSPeter Wemm link_elf_symbol_values(lf, sym, &symval); 1440f41325dbSPeter Wemm if (symval.value == 0) { 1441f41325dbSPeter Wemm error = ESRCH; 1442f41325dbSPeter Wemm goto out; 1443f41325dbSPeter Wemm } 1444f41325dbSPeter Wemm start = (void **)symval.value; 1445f41325dbSPeter Wemm 1446f41325dbSPeter Wemm /* get address of last entry */ 1447f41325dbSPeter Wemm snprintf(setsym, len, "%s%s", "__stop_set_", name); 1448f41325dbSPeter Wemm error = link_elf_lookup_symbol(lf, setsym, &sym); 14492f22b3ffSMatthew D Fleming if (error != 0) 1450f41325dbSPeter Wemm goto out; 1451f41325dbSPeter Wemm link_elf_symbol_values(lf, sym, &symval); 1452f41325dbSPeter Wemm if (symval.value == 0) { 1453f41325dbSPeter Wemm error = ESRCH; 1454f41325dbSPeter Wemm goto out; 1455f41325dbSPeter Wemm } 1456f41325dbSPeter Wemm stop = (void **)symval.value; 1457f41325dbSPeter Wemm 1458f41325dbSPeter Wemm /* and the number of entries */ 1459f41325dbSPeter Wemm count = stop - start; 1460f41325dbSPeter Wemm 1461f41325dbSPeter Wemm /* and copy out */ 14622f22b3ffSMatthew D Fleming if (startp != NULL) 1463f41325dbSPeter Wemm *startp = start; 14642f22b3ffSMatthew D Fleming if (stopp != NULL) 1465f41325dbSPeter Wemm *stopp = stop; 14662f22b3ffSMatthew D Fleming if (countp != NULL) 1467f41325dbSPeter Wemm *countp = count; 1468f41325dbSPeter Wemm 1469f41325dbSPeter Wemm out: 1470f41325dbSPeter Wemm free(setsym, M_LINKER); 14712f22b3ffSMatthew D Fleming return (error); 1472f41325dbSPeter Wemm } 1473bb9fe9ddSBrian Feldman 1474bb9fe9ddSBrian Feldman static int 1475bb9fe9ddSBrian Feldman link_elf_each_function_name(linker_file_t file, 14762f22b3ffSMatthew D Fleming int (*callback)(const char *, void *), void *opaque) 14772f22b3ffSMatthew D Fleming { 1478bb9fe9ddSBrian Feldman elf_file_t ef = (elf_file_t)file; 1479bb9fe9ddSBrian Feldman const Elf_Sym *symp; 1480bb9fe9ddSBrian Feldman int i, error; 1481bb9fe9ddSBrian Feldman 1482bb9fe9ddSBrian Feldman /* Exhaustive search */ 1483bb9fe9ddSBrian Feldman for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) { 1484bb9fe9ddSBrian Feldman if (symp->st_value != 0 && 14857035cf14SKonstantin Belousov (ELF_ST_TYPE(symp->st_info) == STT_FUNC || 14867035cf14SKonstantin Belousov ELF_ST_TYPE(symp->st_info) == STT_GNU_IFUNC)) { 1487bb9fe9ddSBrian Feldman error = callback(ef->ddbstrtab + symp->st_name, opaque); 14882f22b3ffSMatthew D Fleming if (error != 0) 1489bb9fe9ddSBrian Feldman return (error); 1490bb9fe9ddSBrian Feldman } 1491bb9fe9ddSBrian Feldman } 1492bb9fe9ddSBrian Feldman return (0); 1493bb9fe9ddSBrian Feldman } 149484201059SMarcel Moolenaar 1495a2024a3eSJohn Birrell static int 1496a2024a3eSJohn Birrell link_elf_each_function_nameval(linker_file_t file, 1497a2024a3eSJohn Birrell linker_function_nameval_callback_t callback, void *opaque) 1498a2024a3eSJohn Birrell { 1499a2024a3eSJohn Birrell linker_symval_t symval; 1500a2024a3eSJohn Birrell elf_file_t ef = (elf_file_t)file; 1501a2024a3eSJohn Birrell const Elf_Sym* symp; 1502a2024a3eSJohn Birrell int i, error; 1503a2024a3eSJohn Birrell 1504a2024a3eSJohn Birrell /* Exhaustive search */ 1505a2024a3eSJohn Birrell for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) { 1506a2024a3eSJohn Birrell if (symp->st_value != 0 && 15077035cf14SKonstantin Belousov (ELF_ST_TYPE(symp->st_info) == STT_FUNC || 15087035cf14SKonstantin Belousov ELF_ST_TYPE(symp->st_info) == STT_GNU_IFUNC)) { 15092f22b3ffSMatthew D Fleming error = link_elf_symbol_values(file, 15102f22b3ffSMatthew D Fleming (c_linker_sym_t) symp, &symval); 15112f22b3ffSMatthew D Fleming if (error != 0) 1512a2024a3eSJohn Birrell return (error); 1513a2024a3eSJohn Birrell error = callback(file, i, &symval, opaque); 15142f22b3ffSMatthew D Fleming if (error != 0) 1515a2024a3eSJohn Birrell return (error); 1516a2024a3eSJohn Birrell } 1517a2024a3eSJohn Birrell } 1518a2024a3eSJohn Birrell return (0); 1519a2024a3eSJohn Birrell } 1520a2024a3eSJohn Birrell 1521169d513cSJake Burkholder const Elf_Sym * 1522757686b1SMarcel Moolenaar elf_get_sym(linker_file_t lf, Elf_Size symidx) 1523169d513cSJake Burkholder { 1524169d513cSJake Burkholder elf_file_t ef = (elf_file_t)lf; 1525169d513cSJake Burkholder 1526169d513cSJake Burkholder if (symidx >= ef->nchains) 1527169d513cSJake Burkholder return (NULL); 1528169d513cSJake Burkholder return (ef->symtab + symidx); 1529169d513cSJake Burkholder } 1530169d513cSJake Burkholder 153147f75012SMarcel Moolenaar const char * 1532757686b1SMarcel Moolenaar elf_get_symname(linker_file_t lf, Elf_Size symidx) 153347f75012SMarcel Moolenaar { 153447f75012SMarcel Moolenaar elf_file_t ef = (elf_file_t)lf; 153547f75012SMarcel Moolenaar const Elf_Sym *sym; 153647f75012SMarcel Moolenaar 153747f75012SMarcel Moolenaar if (symidx >= ef->nchains) 153847f75012SMarcel Moolenaar return (NULL); 153947f75012SMarcel Moolenaar sym = ef->symtab + symidx; 154047f75012SMarcel Moolenaar return (ef->strtab + sym->st_name); 154147f75012SMarcel Moolenaar } 154247f75012SMarcel Moolenaar 1543d297ad16SMarcel Moolenaar /* 1544d297ad16SMarcel Moolenaar * Symbol lookup function that can be used when the symbol index is known (ie 1545d297ad16SMarcel Moolenaar * in relocations). It uses the symbol index instead of doing a fully fledged 1546d297ad16SMarcel Moolenaar * hash table based lookup when such is valid. For example for local symbols. 1547d297ad16SMarcel Moolenaar * This is not only more efficient, it's also more correct. It's not always 1548d297ad16SMarcel Moolenaar * the case that the symbol can be found through the hash table. 1549d297ad16SMarcel Moolenaar */ 1550cff8c6f2SKonstantin Belousov static int 1551cff8c6f2SKonstantin Belousov elf_lookup(linker_file_t lf, Elf_Size symidx, int deps, Elf_Addr *res) 1552d297ad16SMarcel Moolenaar { 1553d297ad16SMarcel Moolenaar elf_file_t ef = (elf_file_t)lf; 1554d297ad16SMarcel Moolenaar const Elf_Sym *sym; 1555d297ad16SMarcel Moolenaar const char *symbol; 155647813f5dSMikolaj Golub Elf_Addr addr, start, base; 1557d297ad16SMarcel Moolenaar 1558d297ad16SMarcel Moolenaar /* Don't even try to lookup the symbol if the index is bogus. */ 1559cff8c6f2SKonstantin Belousov if (symidx >= ef->nchains) { 1560cff8c6f2SKonstantin Belousov *res = 0; 1561cff8c6f2SKonstantin Belousov return (EINVAL); 1562cff8c6f2SKonstantin Belousov } 1563d297ad16SMarcel Moolenaar 1564d297ad16SMarcel Moolenaar sym = ef->symtab + symidx; 1565d297ad16SMarcel Moolenaar 1566d297ad16SMarcel Moolenaar /* 1567d297ad16SMarcel Moolenaar * Don't do a full lookup when the symbol is local. It may even 1568d297ad16SMarcel Moolenaar * fail because it may not be found through the hash table. 1569d297ad16SMarcel Moolenaar */ 1570d297ad16SMarcel Moolenaar if (ELF_ST_BIND(sym->st_info) == STB_LOCAL) { 1571d297ad16SMarcel Moolenaar /* Force lookup failure when we have an insanity. */ 1572cff8c6f2SKonstantin Belousov if (sym->st_shndx == SHN_UNDEF || sym->st_value == 0) { 1573cff8c6f2SKonstantin Belousov *res = 0; 1574cff8c6f2SKonstantin Belousov return (EINVAL); 1575cff8c6f2SKonstantin Belousov } 1576cff8c6f2SKonstantin Belousov *res = ((Elf_Addr)ef->address + sym->st_value); 1577d297ad16SMarcel Moolenaar return (0); 1578d297ad16SMarcel Moolenaar } 1579d297ad16SMarcel Moolenaar 1580d297ad16SMarcel Moolenaar /* 1581d297ad16SMarcel Moolenaar * XXX we can avoid doing a hash table based lookup for global 1582d297ad16SMarcel Moolenaar * symbols as well. This however is not always valid, so we'll 1583d297ad16SMarcel Moolenaar * just do it the hard way for now. Performance tweaks can 1584d297ad16SMarcel Moolenaar * always be added. 1585d297ad16SMarcel Moolenaar */ 1586d297ad16SMarcel Moolenaar 1587d297ad16SMarcel Moolenaar symbol = ef->strtab + sym->st_name; 1588d297ad16SMarcel Moolenaar 1589d297ad16SMarcel Moolenaar /* Force a lookup failure if the symbol name is bogus. */ 1590cff8c6f2SKonstantin Belousov if (*symbol == 0) { 1591cff8c6f2SKonstantin Belousov *res = 0; 1592cff8c6f2SKonstantin Belousov return (EINVAL); 1593cff8c6f2SKonstantin Belousov } 1594d297ad16SMarcel Moolenaar 159547813f5dSMikolaj Golub addr = ((Elf_Addr)linker_file_lookup_symbol(lf, symbol, deps)); 1596e8e0fac5SMark Johnston if (addr == 0 && ELF_ST_BIND(sym->st_info) != STB_WEAK) { 1597e8e0fac5SMark Johnston *res = 0; 1598e8e0fac5SMark Johnston return (EINVAL); 1599e8e0fac5SMark Johnston } 160047813f5dSMikolaj Golub 160147813f5dSMikolaj Golub if (elf_set_find(&set_pcpu_list, addr, &start, &base)) 160247813f5dSMikolaj Golub addr = addr - start + base; 160347813f5dSMikolaj Golub #ifdef VIMAGE 160447813f5dSMikolaj Golub else if (elf_set_find(&set_vnet_list, addr, &start, &base)) 160547813f5dSMikolaj Golub addr = addr - start + base; 160647813f5dSMikolaj Golub #endif 1607cff8c6f2SKonstantin Belousov *res = addr; 1608cff8c6f2SKonstantin Belousov return (0); 1609d297ad16SMarcel Moolenaar } 16107251b4bfSJake Burkholder 16117251b4bfSJake Burkholder static void 16127251b4bfSJake Burkholder link_elf_reloc_local(linker_file_t lf) 16137251b4bfSJake Burkholder { 16147251b4bfSJake Burkholder const Elf_Rel *rellim; 16157251b4bfSJake Burkholder const Elf_Rel *rel; 16167251b4bfSJake Burkholder const Elf_Rela *relalim; 16177251b4bfSJake Burkholder const Elf_Rela *rela; 16187251b4bfSJake Burkholder elf_file_t ef = (elf_file_t)lf; 16197251b4bfSJake Burkholder 16207251b4bfSJake Burkholder /* Perform relocations without addend if there are any: */ 16217251b4bfSJake Burkholder if ((rel = ef->rel) != NULL) { 16227251b4bfSJake Burkholder rellim = (const Elf_Rel *)((const char *)ef->rel + ef->relsize); 16237251b4bfSJake Burkholder while (rel < rellim) { 16242f22b3ffSMatthew D Fleming elf_reloc_local(lf, (Elf_Addr)ef->address, rel, 16252f22b3ffSMatthew D Fleming ELF_RELOC_REL, elf_lookup); 16267251b4bfSJake Burkholder rel++; 16277251b4bfSJake Burkholder } 16287251b4bfSJake Burkholder } 16297251b4bfSJake Burkholder 16307251b4bfSJake Burkholder /* Perform relocations with addend if there are any: */ 16317251b4bfSJake Burkholder if ((rela = ef->rela) != NULL) { 16322f22b3ffSMatthew D Fleming relalim = (const Elf_Rela *) 16332f22b3ffSMatthew D Fleming ((const char *)ef->rela + ef->relasize); 16347251b4bfSJake Burkholder while (rela < relalim) { 16352f22b3ffSMatthew D Fleming elf_reloc_local(lf, (Elf_Addr)ef->address, rela, 16362f22b3ffSMatthew D Fleming ELF_RELOC_RELA, elf_lookup); 16377251b4bfSJake Burkholder rela++; 16387251b4bfSJake Burkholder } 16397251b4bfSJake Burkholder } 16407251b4bfSJake Burkholder } 164100a5db46SStacey Son 164200a5db46SStacey Son static long 164300a5db46SStacey Son link_elf_symtab_get(linker_file_t lf, const Elf_Sym **symtab) 164400a5db46SStacey Son { 164500a5db46SStacey Son elf_file_t ef = (elf_file_t)lf; 164600a5db46SStacey Son 164700a5db46SStacey Son *symtab = ef->ddbsymtab; 164800a5db46SStacey Son 164900a5db46SStacey Son if (*symtab == NULL) 165000a5db46SStacey Son return (0); 165100a5db46SStacey Son 165200a5db46SStacey Son return (ef->ddbsymcnt); 165300a5db46SStacey Son } 165400a5db46SStacey Son 165500a5db46SStacey Son static long 165600a5db46SStacey Son link_elf_strtab_get(linker_file_t lf, caddr_t *strtab) 165700a5db46SStacey Son { 165800a5db46SStacey Son elf_file_t ef = (elf_file_t)lf; 165900a5db46SStacey Son 166000a5db46SStacey Son *strtab = ef->ddbstrtab; 166100a5db46SStacey Son 166200a5db46SStacey Son if (*strtab == NULL) 166300a5db46SStacey Son return (0); 166400a5db46SStacey Son 166500a5db46SStacey Son return (ef->ddbstrcnt); 166600a5db46SStacey Son } 16677035cf14SKonstantin Belousov 16688696dcdaSAndrew Turner #if defined(__i386__) || defined(__amd64__) || defined(__aarch64__) 166936716fe2SMark Johnston /* 167036716fe2SMark Johnston * Use this lookup routine when performing relocations early during boot. 167136716fe2SMark Johnston * The generic lookup routine depends on kobj, which is not initialized 167236716fe2SMark Johnston * at that point. 167336716fe2SMark Johnston */ 167436716fe2SMark Johnston static int 167536716fe2SMark Johnston elf_lookup_ifunc(linker_file_t lf, Elf_Size symidx, int deps __unused, 167636716fe2SMark Johnston Elf_Addr *res) 167736716fe2SMark Johnston { 167836716fe2SMark Johnston elf_file_t ef; 167936716fe2SMark Johnston const Elf_Sym *symp; 168036716fe2SMark Johnston caddr_t val; 168136716fe2SMark Johnston 168236716fe2SMark Johnston ef = (elf_file_t)lf; 168336716fe2SMark Johnston symp = ef->symtab + symidx; 168436716fe2SMark Johnston if (ELF_ST_TYPE(symp->st_info) == STT_GNU_IFUNC) { 168536716fe2SMark Johnston val = (caddr_t)ef->address + symp->st_value; 168636716fe2SMark Johnston *res = ((Elf_Addr (*)(void))val)(); 168736716fe2SMark Johnston return (0); 168836716fe2SMark Johnston } 168936716fe2SMark Johnston return (ENOENT); 169036716fe2SMark Johnston } 169136716fe2SMark Johnston 16927035cf14SKonstantin Belousov void 16937035cf14SKonstantin Belousov link_elf_ireloc(caddr_t kmdp) 16947035cf14SKonstantin Belousov { 16957035cf14SKonstantin Belousov struct elf_file eff; 16967035cf14SKonstantin Belousov elf_file_t ef; 16977035cf14SKonstantin Belousov 16987035cf14SKonstantin Belousov ef = &eff; 169955c9d75eSKonstantin Belousov 17003f102f58SMateusz Guzik bzero_early(ef, sizeof(*ef)); 170155c9d75eSKonstantin Belousov 17027035cf14SKonstantin Belousov ef->modptr = kmdp; 17037035cf14SKonstantin Belousov ef->dynamic = (Elf_Dyn *)&_DYNAMIC; 17047035cf14SKonstantin Belousov parse_dynamic(ef); 17057035cf14SKonstantin Belousov ef->address = 0; 17067035cf14SKonstantin Belousov link_elf_preload_parse_symbols(ef); 170736716fe2SMark Johnston relocate_file1(ef, elf_lookup_ifunc, elf_reloc, true); 17087035cf14SKonstantin Belousov } 17097035cf14SKonstantin Belousov #endif 1710