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 191*36716fe2SMark Johnston typedef int (*elf_reloc_fn)(linker_file_t lf, Elf_Addr relocbase, 192*36716fe2SMark Johnston const void *data, int type, elf_lookup_fn lookup); 193*36716fe2SMark Johnston 1942f22b3ffSMatthew D Fleming static int parse_dynamic(elf_file_t); 1952f22b3ffSMatthew D Fleming static int relocate_file(elf_file_t); 196*36716fe2SMark Johnston static int relocate_file1(elf_file_t ef, elf_lookup_fn lookup, 197*36716fe2SMark 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 { 62150c202c5SJeff Roberson int count; 62250c202c5SJeff Roberson int error; 62350c202c5SJeff Roberson 62450c202c5SJeff Roberson ef->pcpu_start = 0; 62550c202c5SJeff Roberson ef->pcpu_stop = 0; 62650c202c5SJeff Roberson error = link_elf_lookup_set(&ef->lf, "pcpu", (void ***)&ef->pcpu_start, 62750c202c5SJeff Roberson (void ***)&ef->pcpu_stop, &count); 62850c202c5SJeff Roberson /* Error just means there is no pcpu set to relocate. */ 6292f22b3ffSMatthew D Fleming if (error != 0) 63050c202c5SJeff Roberson return (0); 63150c202c5SJeff Roberson count *= sizeof(void *); 63250c202c5SJeff Roberson /* 6332f22b3ffSMatthew D Fleming * Allocate space in the primary pcpu area. Copy in our 6342f22b3ffSMatthew D Fleming * initialization from the data section and then initialize 6352f22b3ffSMatthew D Fleming * all per-cpu storage from that. 63650c202c5SJeff Roberson */ 63750c202c5SJeff Roberson ef->pcpu_base = (Elf_Addr)(uintptr_t)dpcpu_alloc(count); 6382f22b3ffSMatthew D Fleming if (ef->pcpu_base == 0) 63950c202c5SJeff Roberson return (ENOSPC); 64050c202c5SJeff Roberson memcpy((void *)ef->pcpu_base, (void *)ef->pcpu_start, count); 64150c202c5SJeff Roberson dpcpu_copy((void *)ef->pcpu_base, count); 64247813f5dSMikolaj Golub elf_set_add(&set_pcpu_list, ef->pcpu_start, ef->pcpu_stop, 64347813f5dSMikolaj Golub ef->pcpu_base); 64450c202c5SJeff Roberson 64550c202c5SJeff Roberson return (0); 64650c202c5SJeff Roberson } 64750c202c5SJeff Roberson 648eddfbb76SRobert Watson #ifdef VIMAGE 649eddfbb76SRobert Watson static int 650eddfbb76SRobert Watson parse_vnet(elf_file_t ef) 651eddfbb76SRobert Watson { 652eddfbb76SRobert Watson int count; 653eddfbb76SRobert Watson int error; 654eddfbb76SRobert Watson 655eddfbb76SRobert Watson ef->vnet_start = 0; 656eddfbb76SRobert Watson ef->vnet_stop = 0; 657eddfbb76SRobert Watson error = link_elf_lookup_set(&ef->lf, "vnet", (void ***)&ef->vnet_start, 658eddfbb76SRobert Watson (void ***)&ef->vnet_stop, &count); 659eddfbb76SRobert Watson /* Error just means there is no vnet data set to relocate. */ 6602f22b3ffSMatthew D Fleming if (error != 0) 661eddfbb76SRobert Watson return (0); 662eddfbb76SRobert Watson count *= sizeof(void *); 663eddfbb76SRobert Watson /* 6642f22b3ffSMatthew D Fleming * Allocate space in the primary vnet area. Copy in our 6652f22b3ffSMatthew D Fleming * initialization from the data section and then initialize 6662f22b3ffSMatthew D Fleming * all per-vnet storage from that. 667eddfbb76SRobert Watson */ 668eddfbb76SRobert Watson ef->vnet_base = (Elf_Addr)(uintptr_t)vnet_data_alloc(count); 6692f22b3ffSMatthew D Fleming if (ef->vnet_base == 0) 670eddfbb76SRobert Watson return (ENOSPC); 671eddfbb76SRobert Watson memcpy((void *)ef->vnet_base, (void *)ef->vnet_start, count); 672eddfbb76SRobert Watson vnet_data_copy((void *)ef->vnet_base, count); 67347813f5dSMikolaj Golub elf_set_add(&set_vnet_list, ef->vnet_start, ef->vnet_stop, 67447813f5dSMikolaj Golub ef->vnet_base); 675eddfbb76SRobert Watson 676eddfbb76SRobert Watson return (0); 677eddfbb76SRobert Watson } 678eddfbb76SRobert Watson #endif 679eddfbb76SRobert Watson 68050c202c5SJeff Roberson static int 68154823af2SPeter Wemm link_elf_link_preload(linker_class_t cls, 682326e27d8SDoug Rabson const char* filename, linker_file_t *result) 683de78ca7eSPeter Wemm { 6840067051fSMarcel Moolenaar Elf_Addr *ctors_addrp; 6850067051fSMarcel Moolenaar Elf_Size *ctors_sizep; 686de78ca7eSPeter Wemm caddr_t modptr, baseptr, sizeptr, dynptr; 687de78ca7eSPeter Wemm char *type; 688de78ca7eSPeter Wemm elf_file_t ef; 689de78ca7eSPeter Wemm linker_file_t lf; 690de78ca7eSPeter Wemm int error; 691de78ca7eSPeter Wemm vm_offset_t dp; 692de78ca7eSPeter Wemm 69354823af2SPeter Wemm /* Look to see if we have the file preloaded */ 694de78ca7eSPeter Wemm modptr = preload_search_by_name(filename); 695de78ca7eSPeter Wemm if (modptr == NULL) 6962f22b3ffSMatthew D Fleming return (ENOENT); 697de78ca7eSPeter Wemm 698de78ca7eSPeter Wemm type = (char *)preload_search_info(modptr, MODINFO_TYPE); 699de78ca7eSPeter Wemm baseptr = preload_search_info(modptr, MODINFO_ADDR); 700de78ca7eSPeter Wemm sizeptr = preload_search_info(modptr, MODINFO_SIZE); 7012f22b3ffSMatthew D Fleming dynptr = preload_search_info(modptr, 7022f22b3ffSMatthew D Fleming MODINFO_METADATA | MODINFOMD_DYNAMIC); 70367db8b23SPeter Wemm if (type == NULL || 70467db8b23SPeter Wemm (strcmp(type, "elf" __XSTRING(__ELF_WORD_SIZE) " module") != 0 && 70567db8b23SPeter Wemm strcmp(type, "elf module") != 0)) 706de78ca7eSPeter Wemm return (EFTYPE); 707de78ca7eSPeter Wemm if (baseptr == NULL || sizeptr == NULL || dynptr == NULL) 708de78ca7eSPeter Wemm return (EINVAL); 709de78ca7eSPeter Wemm 710326e27d8SDoug Rabson lf = linker_make_file(filename, &link_elf_class); 7112f22b3ffSMatthew D Fleming if (lf == NULL) 7122f22b3ffSMatthew D Fleming return (ENOMEM); 713326e27d8SDoug Rabson 714326e27d8SDoug Rabson ef = (elf_file_t) lf; 715326e27d8SDoug Rabson ef->preloaded = 1; 716ca65d5c7SPeter Wemm ef->modptr = modptr; 717de78ca7eSPeter Wemm ef->address = *(caddr_t *)baseptr; 718de78ca7eSPeter Wemm #ifdef SPARSE_MAPPING 719de78ca7eSPeter Wemm ef->object = 0; 720de78ca7eSPeter Wemm #endif 721de78ca7eSPeter Wemm dp = (vm_offset_t)ef->address + *(vm_offset_t *)dynptr; 722de78ca7eSPeter Wemm ef->dynamic = (Elf_Dyn *)dp; 723de78ca7eSPeter Wemm lf->address = ef->address; 724de78ca7eSPeter Wemm lf->size = *(size_t *)sizeptr; 725de78ca7eSPeter Wemm 7260067051fSMarcel Moolenaar ctors_addrp = (Elf_Addr *)preload_search_info(modptr, 7270067051fSMarcel Moolenaar MODINFO_METADATA | MODINFOMD_CTORS_ADDR); 7280067051fSMarcel Moolenaar ctors_sizep = (Elf_Size *)preload_search_info(modptr, 7290067051fSMarcel Moolenaar MODINFO_METADATA | MODINFOMD_CTORS_SIZE); 7300067051fSMarcel Moolenaar if (ctors_addrp != NULL && ctors_sizep != NULL) { 7310067051fSMarcel Moolenaar lf->ctors_addr = ef->address + *ctors_addrp; 7320067051fSMarcel Moolenaar lf->ctors_size = *ctors_sizep; 7330067051fSMarcel Moolenaar } 7340067051fSMarcel Moolenaar 735326e27d8SDoug Rabson error = parse_dynamic(ef); 73650c202c5SJeff Roberson if (error == 0) 73750c202c5SJeff Roberson error = parse_dpcpu(ef); 738eddfbb76SRobert Watson #ifdef VIMAGE 739eddfbb76SRobert Watson if (error == 0) 740eddfbb76SRobert Watson error = parse_vnet(ef); 741eddfbb76SRobert Watson #endif 7422f22b3ffSMatthew D Fleming if (error != 0) { 74365a311fcSPoul-Henning Kamp linker_file_unload(lf, LINKER_UNLOAD_FORCE); 7442f22b3ffSMatthew D Fleming return (error); 745de78ca7eSPeter Wemm } 7467251b4bfSJake Burkholder link_elf_reloc_local(lf); 747de78ca7eSPeter Wemm *result = lf; 748de78ca7eSPeter Wemm return (0); 749de78ca7eSPeter Wemm } 750de78ca7eSPeter Wemm 751de78ca7eSPeter Wemm static int 75254823af2SPeter Wemm link_elf_link_preload_finish(linker_file_t lf) 75354823af2SPeter Wemm { 75454823af2SPeter Wemm elf_file_t ef; 75554823af2SPeter Wemm int error; 75654823af2SPeter Wemm 75754823af2SPeter Wemm ef = (elf_file_t) lf; 75854823af2SPeter Wemm error = relocate_file(ef); 7592f22b3ffSMatthew D Fleming if (error != 0) 7602f22b3ffSMatthew D Fleming return (error); 76154823af2SPeter Wemm (void)link_elf_preload_parse_symbols(ef); 76254823af2SPeter Wemm 763c143d6c2SMarcel Moolenaar return (link_elf_link_common_finish(lf)); 76454823af2SPeter Wemm } 76554823af2SPeter Wemm 76654823af2SPeter Wemm static int 767c143d6c2SMarcel Moolenaar link_elf_load_file(linker_class_t cls, const char* filename, 768c143d6c2SMarcel Moolenaar linker_file_t* result) 769a4f67738SDoug Rabson { 770a4f67738SDoug Rabson struct nameidata nd; 771b40ce416SJulian Elischer struct thread* td = curthread; /* XXX */ 772caab6e90SPeter Wemm Elf_Ehdr *hdr; 773caab6e90SPeter Wemm caddr_t firstpage; 774fe3db7c7SDoug Rabson int nbytes, i; 775fe3db7c7SDoug Rabson Elf_Phdr *phdr; 776fe3db7c7SDoug Rabson Elf_Phdr *phlimit; 7771a330eb0SPeter Wemm Elf_Phdr *segs[MAXSEGS]; 778fe3db7c7SDoug Rabson int nsegs; 779fe3db7c7SDoug Rabson Elf_Phdr *phdyn; 780fe3db7c7SDoug Rabson caddr_t mapbase; 781fe3db7c7SDoug Rabson size_t mapsize; 782fe3db7c7SDoug Rabson Elf_Addr base_vaddr; 783fe3db7c7SDoug Rabson Elf_Addr base_vlimit; 784a4f67738SDoug Rabson int error = 0; 785526d0bd5SKonstantin Belousov ssize_t resid; 786526d0bd5SKonstantin Belousov int flags; 787a4f67738SDoug Rabson elf_file_t ef; 788a4f67738SDoug Rabson linker_file_t lf; 789ca65d5c7SPeter Wemm Elf_Shdr *shdr; 790ca65d5c7SPeter Wemm int symtabindex; 791ca65d5c7SPeter Wemm int symstrindex; 7920067051fSMarcel Moolenaar int shstrindex; 793ca65d5c7SPeter Wemm int symcnt; 794ca65d5c7SPeter Wemm int strcnt; 7950067051fSMarcel Moolenaar char *shstrs; 796ca65d5c7SPeter Wemm 797ca65d5c7SPeter Wemm shdr = NULL; 798ca65d5c7SPeter Wemm lf = NULL; 7990067051fSMarcel Moolenaar shstrs = NULL; 800a4f67738SDoug Rabson 8015050aa86SKonstantin Belousov NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, filename, td); 802e6796b67SKirk McKusick flags = FREAD; 8039e223287SKonstantin Belousov error = vn_open(&nd, &flags, 0, NULL); 8042f22b3ffSMatthew D Fleming if (error != 0) 8052f22b3ffSMatthew D Fleming return (error); 806762e6b85SEivind Eklund NDFREE(&nd, NDF_ONLY_PNBUF); 8071f49b573SRuslan Ermilov if (nd.ni_vp->v_type != VREG) { 8081f49b573SRuslan Ermilov error = ENOEXEC; 8091f49b573SRuslan Ermilov firstpage = NULL; 8101f49b573SRuslan Ermilov goto out; 8111f49b573SRuslan Ermilov } 812a3df768bSRobert Watson #ifdef MAC 81330d239bcSRobert Watson error = mac_kld_check_load(curthread->td_ucred, nd.ni_vp); 8142f22b3ffSMatthew D Fleming if (error != 0) { 815a3df768bSRobert Watson firstpage = NULL; 816a3df768bSRobert Watson goto out; 817a3df768bSRobert Watson } 818a3df768bSRobert Watson #endif 819a4f67738SDoug Rabson 820a4f67738SDoug Rabson /* 821fe3db7c7SDoug Rabson * Read the elf header from the file. 822a4f67738SDoug Rabson */ 823a163d034SWarner Losh firstpage = malloc(PAGE_SIZE, M_LINKER, M_WAITOK); 824caab6e90SPeter Wemm hdr = (Elf_Ehdr *)firstpage; 825caab6e90SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, firstpage, PAGE_SIZE, 0, 8269ca43589SRobert Watson UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 8279ca43589SRobert Watson &resid, td); 828caab6e90SPeter Wemm nbytes = PAGE_SIZE - resid; 8292f22b3ffSMatthew D Fleming if (error != 0) 830a4f67738SDoug Rabson goto out; 831a4f67738SDoug Rabson 832caab6e90SPeter Wemm if (!IS_ELF(*hdr)) { 833fe3db7c7SDoug Rabson error = ENOEXEC; 834a4f67738SDoug Rabson goto out; 835fe3db7c7SDoug Rabson } 836fe3db7c7SDoug Rabson 8372f22b3ffSMatthew D Fleming if (hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS || 8382f22b3ffSMatthew D Fleming hdr->e_ident[EI_DATA] != ELF_TARG_DATA) { 839552f9f63SEdwin Groothuis link_elf_error(filename, "Unsupported file layout"); 840fe3db7c7SDoug Rabson error = ENOEXEC; 841fe3db7c7SDoug Rabson goto out; 842fe3db7c7SDoug Rabson } 8432f22b3ffSMatthew D Fleming if (hdr->e_ident[EI_VERSION] != EV_CURRENT || 8442f22b3ffSMatthew D Fleming hdr->e_version != EV_CURRENT) { 845552f9f63SEdwin Groothuis link_elf_error(filename, "Unsupported file version"); 846fe3db7c7SDoug Rabson error = ENOEXEC; 847fe3db7c7SDoug Rabson goto out; 848fe3db7c7SDoug Rabson } 849caab6e90SPeter Wemm if (hdr->e_type != ET_EXEC && hdr->e_type != ET_DYN) { 850a1d7ce03SAttilio Rao error = ENOSYS; 851fe3db7c7SDoug Rabson goto out; 852fe3db7c7SDoug Rabson } 853caab6e90SPeter Wemm if (hdr->e_machine != ELF_TARG_MACH) { 854552f9f63SEdwin Groothuis link_elf_error(filename, "Unsupported machine"); 855fe3db7c7SDoug Rabson error = ENOEXEC; 856fe3db7c7SDoug Rabson goto out; 857fe3db7c7SDoug Rabson } 858a4f67738SDoug Rabson 859a4f67738SDoug Rabson /* 8602f22b3ffSMatthew D Fleming * We rely on the program header being in the first page. 8612f22b3ffSMatthew D Fleming * This is not strictly required by the ABI specification, but 8622f22b3ffSMatthew D Fleming * it seems to always true in practice. And, it simplifies 8632f22b3ffSMatthew D Fleming * things considerably. 864a4f67738SDoug Rabson */ 865caab6e90SPeter Wemm if (!((hdr->e_phentsize == sizeof(Elf_Phdr)) && 866caab6e90SPeter Wemm (hdr->e_phoff + hdr->e_phnum*sizeof(Elf_Phdr) <= PAGE_SIZE) && 867caab6e90SPeter Wemm (hdr->e_phoff + hdr->e_phnum*sizeof(Elf_Phdr) <= nbytes))) 868552f9f63SEdwin Groothuis link_elf_error(filename, "Unreadable program headers"); 869fe3db7c7SDoug Rabson 870fe3db7c7SDoug Rabson /* 871fe3db7c7SDoug Rabson * Scan the program header entries, and save key information. 872fe3db7c7SDoug Rabson * 873fe3db7c7SDoug Rabson * We rely on there being exactly two load segments, text and data, 874fe3db7c7SDoug Rabson * in that order. 875fe3db7c7SDoug Rabson */ 876caab6e90SPeter Wemm phdr = (Elf_Phdr *) (firstpage + hdr->e_phoff); 877caab6e90SPeter Wemm phlimit = phdr + hdr->e_phnum; 878fe3db7c7SDoug Rabson nsegs = 0; 879fe3db7c7SDoug Rabson phdyn = NULL; 880fe3db7c7SDoug Rabson while (phdr < phlimit) { 881fe3db7c7SDoug Rabson switch (phdr->p_type) { 882fe3db7c7SDoug Rabson case PT_LOAD: 8831a330eb0SPeter Wemm if (nsegs == MAXSEGS) { 884552f9f63SEdwin Groothuis link_elf_error(filename, "Too many sections"); 885fe3db7c7SDoug Rabson error = ENOEXEC; 886fe3db7c7SDoug Rabson goto out; 887fe3db7c7SDoug Rabson } 88887b1831fSPoul-Henning Kamp /* 88987b1831fSPoul-Henning Kamp * XXX: We just trust they come in right order ?? 89087b1831fSPoul-Henning Kamp */ 891fe3db7c7SDoug Rabson segs[nsegs] = phdr; 892fe3db7c7SDoug Rabson ++nsegs; 893fe3db7c7SDoug Rabson break; 894fe3db7c7SDoug Rabson 895fe3db7c7SDoug Rabson case PT_DYNAMIC: 896fe3db7c7SDoug Rabson phdyn = phdr; 897fe3db7c7SDoug Rabson break; 8989548091bSBoris Popov 8999548091bSBoris Popov case PT_INTERP: 900a1d7ce03SAttilio Rao error = ENOSYS; 9019548091bSBoris Popov goto out; 902fe3db7c7SDoug Rabson } 903fe3db7c7SDoug Rabson 904fe3db7c7SDoug Rabson ++phdr; 905fe3db7c7SDoug Rabson } 906fe3db7c7SDoug Rabson if (phdyn == NULL) { 907552f9f63SEdwin Groothuis link_elf_error(filename, "Object is not dynamically-linked"); 908fe3db7c7SDoug Rabson error = ENOEXEC; 909fe3db7c7SDoug Rabson goto out; 910fe3db7c7SDoug Rabson } 9111a330eb0SPeter Wemm if (nsegs == 0) { 912552f9f63SEdwin Groothuis link_elf_error(filename, "No sections"); 91387b1831fSPoul-Henning Kamp error = ENOEXEC; 91487b1831fSPoul-Henning Kamp goto out; 91587b1831fSPoul-Henning Kamp } 916fe3db7c7SDoug Rabson 917fe3db7c7SDoug Rabson /* 9182f22b3ffSMatthew D Fleming * Allocate the entire address space of the object, to stake 9192f22b3ffSMatthew D Fleming * out our contiguous region, and to establish the base 9202f22b3ffSMatthew D Fleming * address for relocation. 921fe3db7c7SDoug Rabson */ 922fe3db7c7SDoug Rabson base_vaddr = trunc_page(segs[0]->p_vaddr); 9231a330eb0SPeter Wemm base_vlimit = round_page(segs[nsegs - 1]->p_vaddr + 9241a330eb0SPeter Wemm segs[nsegs - 1]->p_memsz); 925fe3db7c7SDoug Rabson mapsize = base_vlimit - base_vaddr; 926fe3db7c7SDoug Rabson 927326e27d8SDoug Rabson lf = linker_make_file(filename, &link_elf_class); 9282f22b3ffSMatthew D Fleming if (lf == NULL) { 929326e27d8SDoug Rabson error = ENOMEM; 930326e27d8SDoug Rabson goto out; 931326e27d8SDoug Rabson } 932326e27d8SDoug Rabson 933326e27d8SDoug Rabson ef = (elf_file_t) lf; 934fe3db7c7SDoug Rabson #ifdef SPARSE_MAPPING 935fe3db7c7SDoug Rabson ef->object = vm_object_allocate(OBJT_DEFAULT, mapsize >> PAGE_SHIFT); 936fe3db7c7SDoug Rabson if (ef->object == NULL) { 937fe3db7c7SDoug Rabson error = ENOMEM; 938fe3db7c7SDoug Rabson goto out; 939fe3db7c7SDoug Rabson } 940fe3db7c7SDoug Rabson ef->address = (caddr_t) vm_map_min(kernel_map); 941fe3db7c7SDoug Rabson error = vm_map_find(kernel_map, ef->object, 0, 942edb572a3SJohn Baldwin (vm_offset_t *) &ef->address, mapsize, 0, VMFS_OPTIMAL_SPACE, 943fe3db7c7SDoug Rabson VM_PROT_ALL, VM_PROT_ALL, 0); 9442f22b3ffSMatthew D Fleming if (error != 0) { 945fe3db7c7SDoug Rabson vm_object_deallocate(ef->object); 946326e27d8SDoug Rabson ef->object = 0; 947fe3db7c7SDoug Rabson goto out; 948fe3db7c7SDoug Rabson } 949fe3db7c7SDoug Rabson #else 95078bcf87eSOlivier Houchard ef->address = malloc(mapsize, M_LINKER, M_EXEC | M_WAITOK); 951fe3db7c7SDoug Rabson #endif 952fe3db7c7SDoug Rabson mapbase = ef->address; 953a4f67738SDoug Rabson 954a4f67738SDoug Rabson /* 955a4f67738SDoug Rabson * Read the text and data sections and zero the bss. 956a4f67738SDoug Rabson */ 9571a330eb0SPeter Wemm for (i = 0; i < nsegs; i++) { 958fe3db7c7SDoug Rabson caddr_t segbase = mapbase + segs[i]->p_vaddr - base_vaddr; 959fe3db7c7SDoug Rabson error = vn_rdwr(UIO_READ, nd.ni_vp, 960fe3db7c7SDoug Rabson segbase, segs[i]->p_filesz, segs[i]->p_offset, 9619ca43589SRobert Watson UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 9629ca43589SRobert Watson &resid, td); 9632f22b3ffSMatthew D Fleming if (error != 0) 964a4f67738SDoug Rabson goto out; 965fe3db7c7SDoug Rabson bzero(segbase + segs[i]->p_filesz, 966fe3db7c7SDoug Rabson segs[i]->p_memsz - segs[i]->p_filesz); 96741673965SAlan Cox 96841673965SAlan Cox #ifdef SPARSE_MAPPING 96941673965SAlan Cox /* 97041673965SAlan Cox * Wire down the pages 97141673965SAlan Cox */ 9725d3043ceSAlan Cox error = vm_map_wire(kernel_map, 97341673965SAlan Cox (vm_offset_t) segbase, 97441673965SAlan Cox (vm_offset_t) segbase + segs[i]->p_memsz, 97541673965SAlan Cox VM_MAP_WIRE_SYSTEM|VM_MAP_WIRE_NOHOLES); 9765d3043ceSAlan Cox if (error != KERN_SUCCESS) { 9775d3043ceSAlan Cox error = ENOMEM; 9785d3043ceSAlan Cox goto out; 9795d3043ceSAlan Cox } 98041673965SAlan Cox #endif 981fe3db7c7SDoug Rabson } 982fe3db7c7SDoug Rabson 983f99502a4SBrian Feldman #ifdef GPROF 984f99502a4SBrian Feldman /* Update profiling information with the new text segment. */ 98570f37788SJohn Baldwin mtx_lock(&Giant); 986853a17adSEnji Cooper kmupetext((uintfptr_t)(mapbase + segs[0]->p_vaddr - base_vaddr + 987f99502a4SBrian Feldman segs[0]->p_memsz)); 98870f37788SJohn Baldwin mtx_unlock(&Giant); 989f99502a4SBrian Feldman #endif 990f99502a4SBrian Feldman 991326e27d8SDoug Rabson ef->dynamic = (Elf_Dyn *) (mapbase + phdyn->p_vaddr - base_vaddr); 992a4f67738SDoug Rabson 993a4f67738SDoug Rabson lf->address = ef->address; 994fe3db7c7SDoug Rabson lf->size = mapsize; 995a4f67738SDoug Rabson 996326e27d8SDoug Rabson error = parse_dynamic(ef); 9972f22b3ffSMatthew D Fleming if (error != 0) 998de78ca7eSPeter Wemm goto out; 99950c202c5SJeff Roberson error = parse_dpcpu(ef); 10002f22b3ffSMatthew D Fleming if (error != 0) 100150c202c5SJeff Roberson goto out; 1002eddfbb76SRobert Watson #ifdef VIMAGE 1003eddfbb76SRobert Watson error = parse_vnet(ef); 10042f22b3ffSMatthew D Fleming if (error != 0) 1005eddfbb76SRobert Watson goto out; 1006eddfbb76SRobert Watson #endif 10077251b4bfSJake Burkholder link_elf_reloc_local(lf); 10087251b4bfSJake Burkholder 10094f7afc20SKonstantin Belousov VOP_UNLOCK(nd.ni_vp, 0); 10107b9716baSIan Dowse error = linker_load_dependencies(lf); 10114f7afc20SKonstantin Belousov vn_lock(nd.ni_vp, LK_EXCLUSIVE | LK_RETRY); 10122f22b3ffSMatthew D Fleming if (error != 0) 1013de78ca7eSPeter Wemm goto out; 1014326e27d8SDoug Rabson error = relocate_file(ef); 10152f22b3ffSMatthew D Fleming if (error != 0) 1016ca65d5c7SPeter Wemm goto out; 1017ca65d5c7SPeter Wemm 10182f22b3ffSMatthew D Fleming /* 10192f22b3ffSMatthew D Fleming * Try and load the symbol table if it's present. (you can 10202f22b3ffSMatthew D Fleming * strip it!) 10212f22b3ffSMatthew D Fleming */ 1022caab6e90SPeter Wemm nbytes = hdr->e_shnum * hdr->e_shentsize; 1023caab6e90SPeter Wemm if (nbytes == 0 || hdr->e_shoff == 0) 1024ca65d5c7SPeter Wemm goto nosyms; 1025a163d034SWarner Losh shdr = malloc(nbytes, M_LINKER, M_WAITOK | M_ZERO); 1026ca65d5c7SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, 1027caab6e90SPeter Wemm (caddr_t)shdr, nbytes, hdr->e_shoff, 10289ca43589SRobert Watson UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 10299ca43589SRobert Watson &resid, td); 10302f22b3ffSMatthew D Fleming if (error != 0) 1031ca65d5c7SPeter Wemm goto out; 10320067051fSMarcel Moolenaar 10330067051fSMarcel Moolenaar /* Read section string table */ 10340067051fSMarcel Moolenaar shstrindex = hdr->e_shstrndx; 10350067051fSMarcel Moolenaar if (shstrindex != 0 && shdr[shstrindex].sh_type == SHT_STRTAB && 10360067051fSMarcel Moolenaar shdr[shstrindex].sh_size != 0) { 10370067051fSMarcel Moolenaar nbytes = shdr[shstrindex].sh_size; 10380067051fSMarcel Moolenaar shstrs = malloc(nbytes, M_LINKER, M_WAITOK | M_ZERO); 10390067051fSMarcel Moolenaar error = vn_rdwr(UIO_READ, nd.ni_vp, (caddr_t)shstrs, nbytes, 10400067051fSMarcel Moolenaar shdr[shstrindex].sh_offset, UIO_SYSSPACE, IO_NODELOCKED, 10410067051fSMarcel Moolenaar td->td_ucred, NOCRED, &resid, td); 10420067051fSMarcel Moolenaar if (error) 10430067051fSMarcel Moolenaar goto out; 10440067051fSMarcel Moolenaar } 10450067051fSMarcel Moolenaar 1046ca65d5c7SPeter Wemm symtabindex = -1; 1047ca65d5c7SPeter Wemm symstrindex = -1; 1048caab6e90SPeter Wemm for (i = 0; i < hdr->e_shnum; i++) { 1049ca65d5c7SPeter Wemm if (shdr[i].sh_type == SHT_SYMTAB) { 1050ca65d5c7SPeter Wemm symtabindex = i; 1051ca65d5c7SPeter Wemm symstrindex = shdr[i].sh_link; 10520067051fSMarcel Moolenaar } else if (shstrs != NULL && shdr[i].sh_name != 0 && 10530067051fSMarcel Moolenaar strcmp(shstrs + shdr[i].sh_name, ".ctors") == 0) { 10540067051fSMarcel Moolenaar /* Record relocated address and size of .ctors. */ 10550067051fSMarcel Moolenaar lf->ctors_addr = mapbase + shdr[i].sh_addr - base_vaddr; 10560067051fSMarcel Moolenaar lf->ctors_size = shdr[i].sh_size; 1057ca65d5c7SPeter Wemm } 1058ca65d5c7SPeter Wemm } 1059ca65d5c7SPeter Wemm if (symtabindex < 0 || symstrindex < 0) 1060ca65d5c7SPeter Wemm goto nosyms; 1061ca65d5c7SPeter Wemm 1062ca65d5c7SPeter Wemm symcnt = shdr[symtabindex].sh_size; 1063a163d034SWarner Losh ef->symbase = malloc(symcnt, M_LINKER, M_WAITOK); 1064ca65d5c7SPeter Wemm strcnt = shdr[symstrindex].sh_size; 1065a163d034SWarner Losh ef->strbase = malloc(strcnt, M_LINKER, M_WAITOK); 1066ca65d5c7SPeter Wemm 1067ca65d5c7SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, 1068ca65d5c7SPeter Wemm ef->symbase, symcnt, shdr[symtabindex].sh_offset, 10699ca43589SRobert Watson UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 10709ca43589SRobert Watson &resid, td); 10712f22b3ffSMatthew D Fleming if (error != 0) 1072ca65d5c7SPeter Wemm goto out; 1073ca65d5c7SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, 1074ca65d5c7SPeter Wemm ef->strbase, strcnt, shdr[symstrindex].sh_offset, 10759ca43589SRobert Watson UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 10769ca43589SRobert Watson &resid, td); 10772f22b3ffSMatthew D Fleming if (error != 0) 1078ca65d5c7SPeter Wemm goto out; 1079ca65d5c7SPeter Wemm 1080ca65d5c7SPeter Wemm ef->ddbsymcnt = symcnt / sizeof(Elf_Sym); 1081ca65d5c7SPeter Wemm ef->ddbsymtab = (const Elf_Sym *)ef->symbase; 1082ca65d5c7SPeter Wemm ef->ddbstrcnt = strcnt; 1083ca65d5c7SPeter Wemm ef->ddbstrtab = ef->strbase; 1084ca65d5c7SPeter Wemm 10858a710317SMarcel Moolenaar nosyms: 1086c143d6c2SMarcel Moolenaar error = link_elf_link_common_finish(lf); 10872f22b3ffSMatthew D Fleming if (error != 0) 1088c143d6c2SMarcel Moolenaar goto out; 1089326e27d8SDoug Rabson 1090a4f67738SDoug Rabson *result = lf; 1091a4f67738SDoug Rabson 1092a4f67738SDoug Rabson out: 1093f1d2d305SKonstantin Belousov VOP_UNLOCK(nd.ni_vp, 0); 1094f1d2d305SKonstantin Belousov vn_close(nd.ni_vp, FREAD, td->td_ucred, td); 10952f22b3ffSMatthew D Fleming if (error != 0 && lf != NULL) 109665a311fcSPoul-Henning Kamp linker_file_unload(lf, LINKER_UNLOAD_FORCE); 1097ca65d5c7SPeter Wemm free(shdr, M_LINKER); 1098caab6e90SPeter Wemm free(firstpage, M_LINKER); 10990067051fSMarcel Moolenaar free(shstrs, M_LINKER); 1100a4f67738SDoug Rabson 11012f22b3ffSMatthew D Fleming return (error); 1102a4f67738SDoug Rabson } 1103a4f67738SDoug Rabson 110450c202c5SJeff Roberson Elf_Addr 110550c202c5SJeff Roberson elf_relocaddr(linker_file_t lf, Elf_Addr x) 110650c202c5SJeff Roberson { 110750c202c5SJeff Roberson elf_file_t ef; 110850c202c5SJeff Roberson 110950c202c5SJeff Roberson ef = (elf_file_t)lf; 111050c202c5SJeff Roberson if (x >= ef->pcpu_start && x < ef->pcpu_stop) 111150c202c5SJeff Roberson return ((x - ef->pcpu_start) + ef->pcpu_base); 1112eddfbb76SRobert Watson #ifdef VIMAGE 1113eddfbb76SRobert Watson if (x >= ef->vnet_start && x < ef->vnet_stop) 1114eddfbb76SRobert Watson return ((x - ef->vnet_start) + ef->vnet_base); 1115eddfbb76SRobert Watson #endif 111650c202c5SJeff Roberson return (x); 111750c202c5SJeff Roberson } 111850c202c5SJeff Roberson 111950c202c5SJeff Roberson 1120a4f67738SDoug Rabson static void 1121de78ca7eSPeter Wemm link_elf_unload_file(linker_file_t file) 1122a4f67738SDoug Rabson { 1123326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) file; 1124a4f67738SDoug Rabson 11252f22b3ffSMatthew D Fleming if (ef->pcpu_base != 0) { 11262f22b3ffSMatthew D Fleming dpcpu_free((void *)ef->pcpu_base, 11272f22b3ffSMatthew D Fleming ef->pcpu_stop - ef->pcpu_start); 112847813f5dSMikolaj Golub elf_set_delete(&set_pcpu_list, ef->pcpu_start); 112950c202c5SJeff Roberson } 1130eddfbb76SRobert Watson #ifdef VIMAGE 11312f22b3ffSMatthew D Fleming if (ef->vnet_base != 0) { 11322f22b3ffSMatthew D Fleming vnet_data_free((void *)ef->vnet_base, 11332f22b3ffSMatthew D Fleming ef->vnet_stop - ef->vnet_start); 113447813f5dSMikolaj Golub elf_set_delete(&set_vnet_list, ef->vnet_start); 1135eddfbb76SRobert Watson } 1136eddfbb76SRobert Watson #endif 1137ecb01c64SMarcel Moolenaar #ifdef GDB 11382f22b3ffSMatthew D Fleming if (ef->gdb.l_ld != NULL) { 1139326e27d8SDoug Rabson GDB_STATE(RT_DELETE); 1140ed6c3888SPeter Wemm free((void *)(uintptr_t)ef->gdb.l_name, M_LINKER); 1141326e27d8SDoug Rabson link_elf_delete_gdb(&ef->gdb); 1142326e27d8SDoug Rabson GDB_STATE(RT_CONSISTENT); 1143326e27d8SDoug Rabson } 1144326e27d8SDoug Rabson #endif 1145326e27d8SDoug Rabson 11461aeb23cdSMarcel Moolenaar /* Notify MD code that a module is being unloaded. */ 11471aeb23cdSMarcel Moolenaar elf_cpu_unload_file(file); 11481aeb23cdSMarcel Moolenaar 1149326e27d8SDoug Rabson if (ef->preloaded) { 115054823af2SPeter Wemm link_elf_unload_preload(file); 1151326e27d8SDoug Rabson return; 1152326e27d8SDoug Rabson } 1153c143d6c2SMarcel Moolenaar 1154fe3db7c7SDoug Rabson #ifdef SPARSE_MAPPING 11552f22b3ffSMatthew D Fleming if (ef->object != NULL) { 1156fe3db7c7SDoug Rabson vm_map_remove(kernel_map, (vm_offset_t) ef->address, 1157fe3db7c7SDoug Rabson (vm_offset_t) ef->address 1158fe3db7c7SDoug Rabson + (ef->object->size << PAGE_SHIFT)); 1159fe3db7c7SDoug Rabson } 1160fe3db7c7SDoug Rabson #else 1161a4f67738SDoug Rabson free(ef->address, M_LINKER); 1162fe3db7c7SDoug Rabson #endif 1163ca65d5c7SPeter Wemm free(ef->symbase, M_LINKER); 1164ca65d5c7SPeter Wemm free(ef->strbase, M_LINKER); 1165a2024a3eSJohn Birrell free(ef->ctftab, M_LINKER); 1166a2024a3eSJohn Birrell free(ef->ctfoff, M_LINKER); 1167a2024a3eSJohn Birrell free(ef->typoff, M_LINKER); 1168a4f67738SDoug Rabson } 1169a4f67738SDoug Rabson 1170de78ca7eSPeter Wemm static void 117154823af2SPeter Wemm link_elf_unload_preload(linker_file_t file) 1172de78ca7eSPeter Wemm { 117373624a80SMark Johnston if (file->pathname != NULL) 117473624a80SMark Johnston preload_delete_name(file->pathname); 1175de78ca7eSPeter Wemm } 1176de78ca7eSPeter Wemm 1177fe3db7c7SDoug Rabson static const char * 1178757686b1SMarcel Moolenaar symbol_name(elf_file_t ef, Elf_Size r_info) 1179a4f67738SDoug Rabson { 1180fe3db7c7SDoug Rabson const Elf_Sym *ref; 1181a4f67738SDoug Rabson 1182aa855a59SPeter Wemm if (ELF_R_SYM(r_info)) { 1183aa855a59SPeter Wemm ref = ef->symtab + ELF_R_SYM(r_info); 11842f22b3ffSMatthew D Fleming return (ef->strtab + ref->st_name); 11852f22b3ffSMatthew D Fleming } 11862f22b3ffSMatthew D Fleming return (NULL); 1187a4f67738SDoug Rabson } 1188a4f67738SDoug Rabson 1189a4f67738SDoug Rabson static int 1190*36716fe2SMark Johnston symbol_type(elf_file_t ef, Elf_Size r_info) 1191a4f67738SDoug Rabson { 1192*36716fe2SMark Johnston const Elf_Sym *ref; 1193*36716fe2SMark Johnston 1194*36716fe2SMark Johnston if (ELF_R_SYM(r_info)) { 1195*36716fe2SMark Johnston ref = ef->symtab + ELF_R_SYM(r_info); 1196*36716fe2SMark Johnston return (ELF_ST_TYPE(ref->st_info)); 1197*36716fe2SMark Johnston } 1198*36716fe2SMark Johnston return (STT_NOTYPE); 1199*36716fe2SMark Johnston } 1200*36716fe2SMark Johnston 1201*36716fe2SMark Johnston static int 1202*36716fe2SMark Johnston relocate_file1(elf_file_t ef, elf_lookup_fn lookup, elf_reloc_fn reloc, 1203*36716fe2SMark Johnston bool ifuncs) 1204*36716fe2SMark Johnston { 1205fe3db7c7SDoug Rabson const Elf_Rel *rel; 1206fe3db7c7SDoug Rabson const Elf_Rela *rela; 1207aa855a59SPeter Wemm const char *symname; 1208a4f67738SDoug Rabson 1209*36716fe2SMark Johnston #define APPLY_RELOCS(iter, tbl, tblsize, type) do { \ 1210*36716fe2SMark Johnston for ((iter) = (tbl); (iter) != NULL && \ 1211*36716fe2SMark Johnston (iter) < (tbl) + (tblsize) / sizeof(*(iter)); (iter)++) { \ 1212*36716fe2SMark Johnston if ((symbol_type(ef, (iter)->r_info) == \ 1213*36716fe2SMark Johnston STT_GNU_IFUNC || \ 1214*36716fe2SMark Johnston elf_is_ifunc_reloc((iter)->r_info)) != ifuncs) \ 1215*36716fe2SMark Johnston continue; \ 1216*36716fe2SMark Johnston if (reloc(&ef->lf, (Elf_Addr)ef->address, \ 1217*36716fe2SMark Johnston (iter), (type), lookup)) { \ 1218*36716fe2SMark Johnston symname = symbol_name(ef, (iter)->r_info); \ 1219*36716fe2SMark Johnston printf("link_elf: symbol %s undefined\n", \ 1220*36716fe2SMark Johnston symname); \ 1221*36716fe2SMark Johnston return (ENOENT); \ 1222*36716fe2SMark Johnston } \ 1223*36716fe2SMark Johnston } \ 1224*36716fe2SMark Johnston } while (0) 1225a4f67738SDoug Rabson 1226*36716fe2SMark Johnston APPLY_RELOCS(rel, ef->rel, ef->relsize, ELF_RELOC_REL); 1227*36716fe2SMark Johnston APPLY_RELOCS(rela, ef->rela, ef->relasize, ELF_RELOC_RELA); 1228*36716fe2SMark Johnston APPLY_RELOCS(rel, ef->pltrel, ef->pltrelsize, ELF_RELOC_REL); 1229*36716fe2SMark Johnston APPLY_RELOCS(rela, ef->pltrela, ef->pltrelasize, ELF_RELOC_RELA); 1230a4f67738SDoug Rabson 1231*36716fe2SMark Johnston #undef APPLY_RELOCS 1232a4f67738SDoug Rabson 12332f22b3ffSMatthew D Fleming return (0); 1234a4f67738SDoug Rabson } 1235a4f67738SDoug Rabson 12367035cf14SKonstantin Belousov static int 12377035cf14SKonstantin Belousov relocate_file(elf_file_t ef) 12387035cf14SKonstantin Belousov { 1239*36716fe2SMark Johnston int error; 12407035cf14SKonstantin Belousov 1241*36716fe2SMark Johnston error = relocate_file1(ef, elf_lookup, elf_reloc, false); 1242*36716fe2SMark Johnston if (error == 0) 1243*36716fe2SMark Johnston error = relocate_file1(ef, elf_lookup, elf_reloc, true); 1244*36716fe2SMark Johnston return (error); 12457035cf14SKonstantin Belousov } 12467035cf14SKonstantin Belousov 1247fe3db7c7SDoug Rabson /* 1248fe3db7c7SDoug Rabson * Hash function for symbol table lookup. Don't even think about changing 1249fe3db7c7SDoug Rabson * this. It is specified by the System V ABI. 1250fe3db7c7SDoug Rabson */ 1251fe3db7c7SDoug Rabson static unsigned long 1252fe3db7c7SDoug Rabson elf_hash(const char *name) 1253a4f67738SDoug Rabson { 1254fe3db7c7SDoug Rabson const unsigned char *p = (const unsigned char *) name; 1255fe3db7c7SDoug Rabson unsigned long h = 0; 1256fe3db7c7SDoug Rabson unsigned long g; 1257a4f67738SDoug Rabson 1258fe3db7c7SDoug Rabson while (*p != '\0') { 1259fe3db7c7SDoug Rabson h = (h << 4) + *p++; 1260fe3db7c7SDoug Rabson if ((g = h & 0xf0000000) != 0) 1261fe3db7c7SDoug Rabson h ^= g >> 24; 1262fe3db7c7SDoug Rabson h &= ~g; 1263a4f67738SDoug Rabson } 12642f22b3ffSMatthew D Fleming return (h); 1265fe3db7c7SDoug Rabson } 1266a4f67738SDoug Rabson 126737c84183SPoul-Henning Kamp static int 1268d254af07SMatthew Dillon link_elf_lookup_symbol(linker_file_t lf, const char *name, c_linker_sym_t *sym) 1269a4f67738SDoug Rabson { 1270326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) lf; 1271fe3db7c7SDoug Rabson unsigned long symnum; 12722d636ab0SPeter Wemm const Elf_Sym* symp; 12732d636ab0SPeter Wemm const char *strp; 1274fe3db7c7SDoug Rabson unsigned long hash; 1275a4f67738SDoug Rabson int i; 1276a4f67738SDoug Rabson 1277f6494f2eSJohn Baldwin /* If we don't have a hash, bail. */ 1278f6494f2eSJohn Baldwin if (ef->buckets == NULL || ef->nbuckets == 0) { 1279f6494f2eSJohn Baldwin printf("link_elf_lookup_symbol: missing symbol hash table\n"); 12802f22b3ffSMatthew D Fleming return (ENOENT); 1281f6494f2eSJohn Baldwin } 1282f6494f2eSJohn Baldwin 12832d636ab0SPeter Wemm /* First, search hashed global symbols */ 1284fe3db7c7SDoug Rabson hash = elf_hash(name); 1285fe3db7c7SDoug Rabson symnum = ef->buckets[hash % ef->nbuckets]; 1286fe3db7c7SDoug Rabson 1287fe3db7c7SDoug Rabson while (symnum != STN_UNDEF) { 1288fe3db7c7SDoug Rabson if (symnum >= ef->nchains) { 12892f22b3ffSMatthew D Fleming printf("%s: corrupt symbol table\n", __func__); 12902f22b3ffSMatthew D Fleming return (ENOENT); 1291a4f67738SDoug Rabson } 1292fe3db7c7SDoug Rabson 1293fe3db7c7SDoug Rabson symp = ef->symtab + symnum; 1294fe3db7c7SDoug Rabson if (symp->st_name == 0) { 12952f22b3ffSMatthew D Fleming printf("%s: corrupt symbol table\n", __func__); 12962f22b3ffSMatthew D Fleming return (ENOENT); 1297fe3db7c7SDoug Rabson } 1298fe3db7c7SDoug Rabson 1299fe3db7c7SDoug Rabson strp = ef->strtab + symp->st_name; 1300fe3db7c7SDoug Rabson 1301fe3db7c7SDoug Rabson if (strcmp(name, strp) == 0) { 1302fe3db7c7SDoug Rabson if (symp->st_shndx != SHN_UNDEF || 1303fe3db7c7SDoug Rabson (symp->st_value != 0 && 13047035cf14SKonstantin Belousov (ELF_ST_TYPE(symp->st_info) == STT_FUNC || 13057035cf14SKonstantin Belousov ELF_ST_TYPE(symp->st_info) == STT_GNU_IFUNC))) { 1306d254af07SMatthew Dillon *sym = (c_linker_sym_t) symp; 13072f22b3ffSMatthew D Fleming return (0); 13082f22b3ffSMatthew D Fleming } 13092f22b3ffSMatthew D Fleming return (ENOENT); 1310fe3db7c7SDoug Rabson } 1311fe3db7c7SDoug Rabson 1312fe3db7c7SDoug Rabson symnum = ef->chains[symnum]; 1313a4f67738SDoug Rabson } 1314a4f67738SDoug Rabson 13152d636ab0SPeter Wemm /* If we have not found it, look at the full table (if loaded) */ 13162d636ab0SPeter Wemm if (ef->symtab == ef->ddbsymtab) 13172f22b3ffSMatthew D Fleming return (ENOENT); 13182d636ab0SPeter Wemm 13192d636ab0SPeter Wemm /* Exhaustive search */ 13202d636ab0SPeter Wemm for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) { 13212d636ab0SPeter Wemm strp = ef->ddbstrtab + symp->st_name; 13222d636ab0SPeter Wemm if (strcmp(name, strp) == 0) { 13232d636ab0SPeter Wemm if (symp->st_shndx != SHN_UNDEF || 13242d636ab0SPeter Wemm (symp->st_value != 0 && 13257035cf14SKonstantin Belousov (ELF_ST_TYPE(symp->st_info) == STT_FUNC || 13267035cf14SKonstantin Belousov ELF_ST_TYPE(symp->st_info) == STT_GNU_IFUNC))) { 1327d254af07SMatthew Dillon *sym = (c_linker_sym_t) symp; 13282f22b3ffSMatthew D Fleming return (0); 13292f22b3ffSMatthew D Fleming } 13302f22b3ffSMatthew D Fleming return (ENOENT); 13312d636ab0SPeter Wemm } 13322d636ab0SPeter Wemm } 13332d636ab0SPeter Wemm 13342f22b3ffSMatthew D Fleming return (ENOENT); 1335a4f67738SDoug Rabson } 1336a4f67738SDoug Rabson 1337de78ca7eSPeter Wemm static int 13382f22b3ffSMatthew D Fleming link_elf_symbol_values(linker_file_t lf, c_linker_sym_t sym, 13392f22b3ffSMatthew D Fleming linker_symval_t *symval) 1340a4f67738SDoug Rabson { 13417035cf14SKonstantin Belousov elf_file_t ef; 13427035cf14SKonstantin Belousov const Elf_Sym *es; 13437035cf14SKonstantin Belousov caddr_t val; 1344a4f67738SDoug Rabson 13457035cf14SKonstantin Belousov ef = (elf_file_t)lf; 13467035cf14SKonstantin Belousov es = (const Elf_Sym *)sym; 13475cf87418SMarcel Moolenaar if (es >= ef->symtab && es < (ef->symtab + ef->nchains)) { 1348a4f67738SDoug Rabson symval->name = ef->strtab + es->st_name; 13497035cf14SKonstantin Belousov val = (caddr_t)ef->address + es->st_value; 13507035cf14SKonstantin Belousov if (ELF_ST_TYPE(es->st_info) == STT_GNU_IFUNC) 13517035cf14SKonstantin Belousov val = ((caddr_t (*)(void))val)(); 13527035cf14SKonstantin Belousov symval->value = val; 1353a4f67738SDoug Rabson symval->size = es->st_size; 13542f22b3ffSMatthew D Fleming return (0); 1355a4f67738SDoug Rabson } 13562d636ab0SPeter Wemm if (ef->symtab == ef->ddbsymtab) 13572f22b3ffSMatthew D Fleming return (ENOENT); 13585cf87418SMarcel Moolenaar if (es >= ef->ddbsymtab && es < (ef->ddbsymtab + ef->ddbsymcnt)) { 13592d636ab0SPeter Wemm symval->name = ef->ddbstrtab + es->st_name; 13607035cf14SKonstantin Belousov val = (caddr_t)ef->address + es->st_value; 13617035cf14SKonstantin Belousov if (ELF_ST_TYPE(es->st_info) == STT_GNU_IFUNC) 13627035cf14SKonstantin Belousov val = ((caddr_t (*)(void))val)(); 13637035cf14SKonstantin Belousov symval->value = val; 13642d636ab0SPeter Wemm symval->size = es->st_size; 13652f22b3ffSMatthew D Fleming return (0); 13662d636ab0SPeter Wemm } 13672f22b3ffSMatthew D Fleming return (ENOENT); 13682d636ab0SPeter Wemm } 1369a4f67738SDoug Rabson 1370a4f67738SDoug Rabson static int 1371a4f67738SDoug Rabson link_elf_search_symbol(linker_file_t lf, caddr_t value, 1372d254af07SMatthew Dillon c_linker_sym_t *sym, long *diffp) 1373a4f67738SDoug Rabson { 1374326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) lf; 1375586453feSBruce Evans u_long off = (uintptr_t) (void *) value; 1376a4f67738SDoug Rabson u_long diff = off; 1377586453feSBruce Evans u_long st_value; 1378fe3db7c7SDoug Rabson const Elf_Sym* es; 1379b85f65afSPedro F. Giffuni const Elf_Sym* best = NULL; 1380a4f67738SDoug Rabson int i; 1381a4f67738SDoug Rabson 13822d636ab0SPeter Wemm for (i = 0, es = ef->ddbsymtab; i < ef->ddbsymcnt; i++, es++) { 1383a4f67738SDoug Rabson if (es->st_name == 0) 1384a4f67738SDoug Rabson continue; 1385586453feSBruce Evans st_value = es->st_value + (uintptr_t) (void *) ef->address; 1386b5abfb70SPeter Wemm if (off >= st_value) { 1387b5abfb70SPeter Wemm if (off - st_value < diff) { 1388b5abfb70SPeter Wemm diff = off - st_value; 1389a4f67738SDoug Rabson best = es; 1390a4f67738SDoug Rabson if (diff == 0) 1391a4f67738SDoug Rabson break; 1392b5abfb70SPeter Wemm } else if (off - st_value == diff) { 1393a4f67738SDoug Rabson best = es; 1394a4f67738SDoug Rabson } 1395a4f67738SDoug Rabson } 1396a4f67738SDoug Rabson } 1397b85f65afSPedro F. Giffuni if (best == NULL) 1398a4f67738SDoug Rabson *diffp = off; 1399a4f67738SDoug Rabson else 1400a4f67738SDoug Rabson *diffp = diff; 1401d254af07SMatthew Dillon *sym = (c_linker_sym_t) best; 1402a4f67738SDoug Rabson 14032f22b3ffSMatthew D Fleming return (0); 1404a4f67738SDoug Rabson } 1405f41325dbSPeter Wemm 1406f41325dbSPeter Wemm /* 1407f41325dbSPeter Wemm * Look up a linker set on an ELF system. 1408f41325dbSPeter Wemm */ 1409f41325dbSPeter Wemm static int 1410f41325dbSPeter Wemm link_elf_lookup_set(linker_file_t lf, const char *name, 1411f41325dbSPeter Wemm void ***startp, void ***stopp, int *countp) 1412f41325dbSPeter Wemm { 1413f41325dbSPeter Wemm c_linker_sym_t sym; 1414f41325dbSPeter Wemm linker_symval_t symval; 1415f41325dbSPeter Wemm char *setsym; 1416f41325dbSPeter Wemm void **start, **stop; 1417f41325dbSPeter Wemm int len, error = 0, count; 1418f41325dbSPeter Wemm 1419f41325dbSPeter Wemm len = strlen(name) + sizeof("__start_set_"); /* sizeof includes \0 */ 1420a163d034SWarner Losh setsym = malloc(len, M_LINKER, M_WAITOK); 1421f41325dbSPeter Wemm 1422f41325dbSPeter Wemm /* get address of first entry */ 1423f41325dbSPeter Wemm snprintf(setsym, len, "%s%s", "__start_set_", name); 1424f41325dbSPeter Wemm error = link_elf_lookup_symbol(lf, setsym, &sym); 14252f22b3ffSMatthew D Fleming if (error != 0) 1426f41325dbSPeter Wemm goto out; 1427f41325dbSPeter Wemm link_elf_symbol_values(lf, sym, &symval); 1428f41325dbSPeter Wemm if (symval.value == 0) { 1429f41325dbSPeter Wemm error = ESRCH; 1430f41325dbSPeter Wemm goto out; 1431f41325dbSPeter Wemm } 1432f41325dbSPeter Wemm start = (void **)symval.value; 1433f41325dbSPeter Wemm 1434f41325dbSPeter Wemm /* get address of last entry */ 1435f41325dbSPeter Wemm snprintf(setsym, len, "%s%s", "__stop_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 stop = (void **)symval.value; 1445f41325dbSPeter Wemm 1446f41325dbSPeter Wemm /* and the number of entries */ 1447f41325dbSPeter Wemm count = stop - start; 1448f41325dbSPeter Wemm 1449f41325dbSPeter Wemm /* and copy out */ 14502f22b3ffSMatthew D Fleming if (startp != NULL) 1451f41325dbSPeter Wemm *startp = start; 14522f22b3ffSMatthew D Fleming if (stopp != NULL) 1453f41325dbSPeter Wemm *stopp = stop; 14542f22b3ffSMatthew D Fleming if (countp != NULL) 1455f41325dbSPeter Wemm *countp = count; 1456f41325dbSPeter Wemm 1457f41325dbSPeter Wemm out: 1458f41325dbSPeter Wemm free(setsym, M_LINKER); 14592f22b3ffSMatthew D Fleming return (error); 1460f41325dbSPeter Wemm } 1461bb9fe9ddSBrian Feldman 1462bb9fe9ddSBrian Feldman static int 1463bb9fe9ddSBrian Feldman link_elf_each_function_name(linker_file_t file, 14642f22b3ffSMatthew D Fleming int (*callback)(const char *, void *), void *opaque) 14652f22b3ffSMatthew D Fleming { 1466bb9fe9ddSBrian Feldman elf_file_t ef = (elf_file_t)file; 1467bb9fe9ddSBrian Feldman const Elf_Sym *symp; 1468bb9fe9ddSBrian Feldman int i, error; 1469bb9fe9ddSBrian Feldman 1470bb9fe9ddSBrian Feldman /* Exhaustive search */ 1471bb9fe9ddSBrian Feldman for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) { 1472bb9fe9ddSBrian Feldman if (symp->st_value != 0 && 14737035cf14SKonstantin Belousov (ELF_ST_TYPE(symp->st_info) == STT_FUNC || 14747035cf14SKonstantin Belousov ELF_ST_TYPE(symp->st_info) == STT_GNU_IFUNC)) { 1475bb9fe9ddSBrian Feldman error = callback(ef->ddbstrtab + symp->st_name, opaque); 14762f22b3ffSMatthew D Fleming if (error != 0) 1477bb9fe9ddSBrian Feldman return (error); 1478bb9fe9ddSBrian Feldman } 1479bb9fe9ddSBrian Feldman } 1480bb9fe9ddSBrian Feldman return (0); 1481bb9fe9ddSBrian Feldman } 148284201059SMarcel Moolenaar 1483a2024a3eSJohn Birrell static int 1484a2024a3eSJohn Birrell link_elf_each_function_nameval(linker_file_t file, 1485a2024a3eSJohn Birrell linker_function_nameval_callback_t callback, void *opaque) 1486a2024a3eSJohn Birrell { 1487a2024a3eSJohn Birrell linker_symval_t symval; 1488a2024a3eSJohn Birrell elf_file_t ef = (elf_file_t)file; 1489a2024a3eSJohn Birrell const Elf_Sym* symp; 1490a2024a3eSJohn Birrell int i, error; 1491a2024a3eSJohn Birrell 1492a2024a3eSJohn Birrell /* Exhaustive search */ 1493a2024a3eSJohn Birrell for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) { 1494a2024a3eSJohn Birrell if (symp->st_value != 0 && 14957035cf14SKonstantin Belousov (ELF_ST_TYPE(symp->st_info) == STT_FUNC || 14967035cf14SKonstantin Belousov ELF_ST_TYPE(symp->st_info) == STT_GNU_IFUNC)) { 14972f22b3ffSMatthew D Fleming error = link_elf_symbol_values(file, 14982f22b3ffSMatthew D Fleming (c_linker_sym_t) symp, &symval); 14992f22b3ffSMatthew D Fleming if (error != 0) 1500a2024a3eSJohn Birrell return (error); 1501a2024a3eSJohn Birrell error = callback(file, i, &symval, opaque); 15022f22b3ffSMatthew D Fleming if (error != 0) 1503a2024a3eSJohn Birrell return (error); 1504a2024a3eSJohn Birrell } 1505a2024a3eSJohn Birrell } 1506a2024a3eSJohn Birrell return (0); 1507a2024a3eSJohn Birrell } 1508a2024a3eSJohn Birrell 1509169d513cSJake Burkholder const Elf_Sym * 1510757686b1SMarcel Moolenaar elf_get_sym(linker_file_t lf, Elf_Size symidx) 1511169d513cSJake Burkholder { 1512169d513cSJake Burkholder elf_file_t ef = (elf_file_t)lf; 1513169d513cSJake Burkholder 1514169d513cSJake Burkholder if (symidx >= ef->nchains) 1515169d513cSJake Burkholder return (NULL); 1516169d513cSJake Burkholder return (ef->symtab + symidx); 1517169d513cSJake Burkholder } 1518169d513cSJake Burkholder 151947f75012SMarcel Moolenaar const char * 1520757686b1SMarcel Moolenaar elf_get_symname(linker_file_t lf, Elf_Size symidx) 152147f75012SMarcel Moolenaar { 152247f75012SMarcel Moolenaar elf_file_t ef = (elf_file_t)lf; 152347f75012SMarcel Moolenaar const Elf_Sym *sym; 152447f75012SMarcel Moolenaar 152547f75012SMarcel Moolenaar if (symidx >= ef->nchains) 152647f75012SMarcel Moolenaar return (NULL); 152747f75012SMarcel Moolenaar sym = ef->symtab + symidx; 152847f75012SMarcel Moolenaar return (ef->strtab + sym->st_name); 152947f75012SMarcel Moolenaar } 153047f75012SMarcel Moolenaar 1531d297ad16SMarcel Moolenaar /* 1532d297ad16SMarcel Moolenaar * Symbol lookup function that can be used when the symbol index is known (ie 1533d297ad16SMarcel Moolenaar * in relocations). It uses the symbol index instead of doing a fully fledged 1534d297ad16SMarcel Moolenaar * hash table based lookup when such is valid. For example for local symbols. 1535d297ad16SMarcel Moolenaar * This is not only more efficient, it's also more correct. It's not always 1536d297ad16SMarcel Moolenaar * the case that the symbol can be found through the hash table. 1537d297ad16SMarcel Moolenaar */ 1538cff8c6f2SKonstantin Belousov static int 1539cff8c6f2SKonstantin Belousov elf_lookup(linker_file_t lf, Elf_Size symidx, int deps, Elf_Addr *res) 1540d297ad16SMarcel Moolenaar { 1541d297ad16SMarcel Moolenaar elf_file_t ef = (elf_file_t)lf; 1542d297ad16SMarcel Moolenaar const Elf_Sym *sym; 1543d297ad16SMarcel Moolenaar const char *symbol; 154447813f5dSMikolaj Golub Elf_Addr addr, start, base; 1545d297ad16SMarcel Moolenaar 1546d297ad16SMarcel Moolenaar /* Don't even try to lookup the symbol if the index is bogus. */ 1547cff8c6f2SKonstantin Belousov if (symidx >= ef->nchains) { 1548cff8c6f2SKonstantin Belousov *res = 0; 1549cff8c6f2SKonstantin Belousov return (EINVAL); 1550cff8c6f2SKonstantin Belousov } 1551d297ad16SMarcel Moolenaar 1552d297ad16SMarcel Moolenaar sym = ef->symtab + symidx; 1553d297ad16SMarcel Moolenaar 1554d297ad16SMarcel Moolenaar /* 1555d297ad16SMarcel Moolenaar * Don't do a full lookup when the symbol is local. It may even 1556d297ad16SMarcel Moolenaar * fail because it may not be found through the hash table. 1557d297ad16SMarcel Moolenaar */ 1558d297ad16SMarcel Moolenaar if (ELF_ST_BIND(sym->st_info) == STB_LOCAL) { 1559d297ad16SMarcel Moolenaar /* Force lookup failure when we have an insanity. */ 1560cff8c6f2SKonstantin Belousov if (sym->st_shndx == SHN_UNDEF || sym->st_value == 0) { 1561cff8c6f2SKonstantin Belousov *res = 0; 1562cff8c6f2SKonstantin Belousov return (EINVAL); 1563cff8c6f2SKonstantin Belousov } 1564cff8c6f2SKonstantin Belousov *res = ((Elf_Addr)ef->address + sym->st_value); 1565d297ad16SMarcel Moolenaar return (0); 1566d297ad16SMarcel Moolenaar } 1567d297ad16SMarcel Moolenaar 1568d297ad16SMarcel Moolenaar /* 1569d297ad16SMarcel Moolenaar * XXX we can avoid doing a hash table based lookup for global 1570d297ad16SMarcel Moolenaar * symbols as well. This however is not always valid, so we'll 1571d297ad16SMarcel Moolenaar * just do it the hard way for now. Performance tweaks can 1572d297ad16SMarcel Moolenaar * always be added. 1573d297ad16SMarcel Moolenaar */ 1574d297ad16SMarcel Moolenaar 1575d297ad16SMarcel Moolenaar symbol = ef->strtab + sym->st_name; 1576d297ad16SMarcel Moolenaar 1577d297ad16SMarcel Moolenaar /* Force a lookup failure if the symbol name is bogus. */ 1578cff8c6f2SKonstantin Belousov if (*symbol == 0) { 1579cff8c6f2SKonstantin Belousov *res = 0; 1580cff8c6f2SKonstantin Belousov return (EINVAL); 1581cff8c6f2SKonstantin Belousov } 1582d297ad16SMarcel Moolenaar 158347813f5dSMikolaj Golub addr = ((Elf_Addr)linker_file_lookup_symbol(lf, symbol, deps)); 1584e8e0fac5SMark Johnston if (addr == 0 && ELF_ST_BIND(sym->st_info) != STB_WEAK) { 1585e8e0fac5SMark Johnston *res = 0; 1586e8e0fac5SMark Johnston return (EINVAL); 1587e8e0fac5SMark Johnston } 158847813f5dSMikolaj Golub 158947813f5dSMikolaj Golub if (elf_set_find(&set_pcpu_list, addr, &start, &base)) 159047813f5dSMikolaj Golub addr = addr - start + base; 159147813f5dSMikolaj Golub #ifdef VIMAGE 159247813f5dSMikolaj Golub else if (elf_set_find(&set_vnet_list, addr, &start, &base)) 159347813f5dSMikolaj Golub addr = addr - start + base; 159447813f5dSMikolaj Golub #endif 1595cff8c6f2SKonstantin Belousov *res = addr; 1596cff8c6f2SKonstantin Belousov return (0); 1597d297ad16SMarcel Moolenaar } 15987251b4bfSJake Burkholder 15997251b4bfSJake Burkholder static void 16007251b4bfSJake Burkholder link_elf_reloc_local(linker_file_t lf) 16017251b4bfSJake Burkholder { 16027251b4bfSJake Burkholder const Elf_Rel *rellim; 16037251b4bfSJake Burkholder const Elf_Rel *rel; 16047251b4bfSJake Burkholder const Elf_Rela *relalim; 16057251b4bfSJake Burkholder const Elf_Rela *rela; 16067251b4bfSJake Burkholder elf_file_t ef = (elf_file_t)lf; 16077251b4bfSJake Burkholder 16087251b4bfSJake Burkholder /* Perform relocations without addend if there are any: */ 16097251b4bfSJake Burkholder if ((rel = ef->rel) != NULL) { 16107251b4bfSJake Burkholder rellim = (const Elf_Rel *)((const char *)ef->rel + ef->relsize); 16117251b4bfSJake Burkholder while (rel < rellim) { 16122f22b3ffSMatthew D Fleming elf_reloc_local(lf, (Elf_Addr)ef->address, rel, 16132f22b3ffSMatthew D Fleming ELF_RELOC_REL, elf_lookup); 16147251b4bfSJake Burkholder rel++; 16157251b4bfSJake Burkholder } 16167251b4bfSJake Burkholder } 16177251b4bfSJake Burkholder 16187251b4bfSJake Burkholder /* Perform relocations with addend if there are any: */ 16197251b4bfSJake Burkholder if ((rela = ef->rela) != NULL) { 16202f22b3ffSMatthew D Fleming relalim = (const Elf_Rela *) 16212f22b3ffSMatthew D Fleming ((const char *)ef->rela + ef->relasize); 16227251b4bfSJake Burkholder while (rela < relalim) { 16232f22b3ffSMatthew D Fleming elf_reloc_local(lf, (Elf_Addr)ef->address, rela, 16242f22b3ffSMatthew D Fleming ELF_RELOC_RELA, elf_lookup); 16257251b4bfSJake Burkholder rela++; 16267251b4bfSJake Burkholder } 16277251b4bfSJake Burkholder } 16287251b4bfSJake Burkholder } 162900a5db46SStacey Son 163000a5db46SStacey Son static long 163100a5db46SStacey Son link_elf_symtab_get(linker_file_t lf, const Elf_Sym **symtab) 163200a5db46SStacey Son { 163300a5db46SStacey Son elf_file_t ef = (elf_file_t)lf; 163400a5db46SStacey Son 163500a5db46SStacey Son *symtab = ef->ddbsymtab; 163600a5db46SStacey Son 163700a5db46SStacey Son if (*symtab == NULL) 163800a5db46SStacey Son return (0); 163900a5db46SStacey Son 164000a5db46SStacey Son return (ef->ddbsymcnt); 164100a5db46SStacey Son } 164200a5db46SStacey Son 164300a5db46SStacey Son static long 164400a5db46SStacey Son link_elf_strtab_get(linker_file_t lf, caddr_t *strtab) 164500a5db46SStacey Son { 164600a5db46SStacey Son elf_file_t ef = (elf_file_t)lf; 164700a5db46SStacey Son 164800a5db46SStacey Son *strtab = ef->ddbstrtab; 164900a5db46SStacey Son 165000a5db46SStacey Son if (*strtab == NULL) 165100a5db46SStacey Son return (0); 165200a5db46SStacey Son 165300a5db46SStacey Son return (ef->ddbstrcnt); 165400a5db46SStacey Son } 16557035cf14SKonstantin Belousov 16567035cf14SKonstantin Belousov #if defined(__i386__) || defined(__amd64__) 1657*36716fe2SMark Johnston /* 1658*36716fe2SMark Johnston * Use this lookup routine when performing relocations early during boot. 1659*36716fe2SMark Johnston * The generic lookup routine depends on kobj, which is not initialized 1660*36716fe2SMark Johnston * at that point. 1661*36716fe2SMark Johnston */ 1662*36716fe2SMark Johnston static int 1663*36716fe2SMark Johnston elf_lookup_ifunc(linker_file_t lf, Elf_Size symidx, int deps __unused, 1664*36716fe2SMark Johnston Elf_Addr *res) 1665*36716fe2SMark Johnston { 1666*36716fe2SMark Johnston elf_file_t ef; 1667*36716fe2SMark Johnston const Elf_Sym *symp; 1668*36716fe2SMark Johnston caddr_t val; 1669*36716fe2SMark Johnston 1670*36716fe2SMark Johnston ef = (elf_file_t)lf; 1671*36716fe2SMark Johnston symp = ef->symtab + symidx; 1672*36716fe2SMark Johnston if (ELF_ST_TYPE(symp->st_info) == STT_GNU_IFUNC) { 1673*36716fe2SMark Johnston val = (caddr_t)ef->address + symp->st_value; 1674*36716fe2SMark Johnston *res = ((Elf_Addr (*)(void))val)(); 1675*36716fe2SMark Johnston return (0); 1676*36716fe2SMark Johnston } 1677*36716fe2SMark Johnston return (ENOENT); 1678*36716fe2SMark Johnston } 1679*36716fe2SMark Johnston 16807035cf14SKonstantin Belousov void 16817035cf14SKonstantin Belousov link_elf_ireloc(caddr_t kmdp) 16827035cf14SKonstantin Belousov { 16837035cf14SKonstantin Belousov struct elf_file eff; 16847035cf14SKonstantin Belousov elf_file_t ef; 168555c9d75eSKonstantin Belousov volatile char *c; 168655c9d75eSKonstantin Belousov size_t i; 16877035cf14SKonstantin Belousov 16887035cf14SKonstantin Belousov ef = &eff; 168955c9d75eSKonstantin Belousov 169055c9d75eSKonstantin Belousov /* Do not use bzero/memset before ireloc is done. */ 169155c9d75eSKonstantin Belousov for (c = (char *)ef, i = 0; i < sizeof(*ef); i++) 169255c9d75eSKonstantin Belousov c[i] = 0; 169355c9d75eSKonstantin Belousov 16947035cf14SKonstantin Belousov ef->modptr = kmdp; 16957035cf14SKonstantin Belousov ef->dynamic = (Elf_Dyn *)&_DYNAMIC; 16967035cf14SKonstantin Belousov parse_dynamic(ef); 16977035cf14SKonstantin Belousov ef->address = 0; 16987035cf14SKonstantin Belousov link_elf_preload_parse_symbols(ef); 1699*36716fe2SMark Johnston relocate_file1(ef, elf_lookup_ifunc, elf_reloc, true); 17007035cf14SKonstantin Belousov } 17017035cf14SKonstantin Belousov #endif 1702