1a4f67738SDoug Rabson /*- 2326e27d8SDoug Rabson * Copyright (c) 1998-2000 Doug Rabson 3a4f67738SDoug Rabson * All rights reserved. 4a4f67738SDoug Rabson * 5a4f67738SDoug Rabson * Redistribution and use in source and binary forms, with or without 6a4f67738SDoug Rabson * modification, are permitted provided that the following conditions 7a4f67738SDoug Rabson * are met: 8a4f67738SDoug Rabson * 1. Redistributions of source code must retain the above copyright 9a4f67738SDoug Rabson * notice, this list of conditions and the following disclaimer. 10a4f67738SDoug Rabson * 2. Redistributions in binary form must reproduce the above copyright 11a4f67738SDoug Rabson * notice, this list of conditions and the following disclaimer in the 12a4f67738SDoug Rabson * documentation and/or other materials provided with the distribution. 13a4f67738SDoug Rabson * 14a4f67738SDoug Rabson * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15a4f67738SDoug Rabson * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16a4f67738SDoug Rabson * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17a4f67738SDoug Rabson * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18a4f67738SDoug Rabson * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19a4f67738SDoug Rabson * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20a4f67738SDoug Rabson * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21a4f67738SDoug Rabson * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22a4f67738SDoug Rabson * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23a4f67738SDoug Rabson * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24a4f67738SDoug Rabson * SUCH DAMAGE. 25a4f67738SDoug Rabson */ 26a4f67738SDoug Rabson 27677b542eSDavid E. O'Brien #include <sys/cdefs.h> 28677b542eSDavid E. O'Brien __FBSDID("$FreeBSD$"); 29677b542eSDavid E. O'Brien 30a2024a3eSJohn Birrell #include "opt_ddb.h" 31ecb01c64SMarcel Moolenaar #include "opt_gdb.h" 32a3df768bSRobert Watson #include "opt_mac.h" 33326e27d8SDoug Rabson 34a4f67738SDoug Rabson #include <sys/param.h> 35a4f67738SDoug Rabson #include <sys/systm.h> 365ad6c3b1SBruce Evans #ifdef GPROF 375ad6c3b1SBruce Evans #include <sys/gmon.h> 385ad6c3b1SBruce Evans #endif 39fb919e4dSMark Murray #include <sys/kernel.h> 40fb919e4dSMark Murray #include <sys/lock.h> 41a4f67738SDoug Rabson #include <sys/malloc.h> 42c0b824f9SDima Dorfman #include <sys/mutex.h> 4362d615d5SJohn Baldwin #include <sys/mount.h> 44a4f67738SDoug Rabson #include <sys/proc.h> 45a4f67738SDoug Rabson #include <sys/namei.h> 46a4f67738SDoug Rabson #include <sys/fcntl.h> 47a4f67738SDoug Rabson #include <sys/vnode.h> 48a4f67738SDoug Rabson #include <sys/linker.h> 49fb919e4dSMark Murray 50a4f67738SDoug Rabson #include <machine/elf.h> 51a4f67738SDoug Rabson 52aed55708SRobert Watson #include <security/mac/mac_framework.h> 53aed55708SRobert Watson 54fe3db7c7SDoug Rabson #include <vm/vm.h> 55fe3db7c7SDoug Rabson #include <vm/vm_param.h> 56d1f088daSPeter Wemm #ifdef SPARSE_MAPPING 57fe3db7c7SDoug Rabson #include <vm/vm_object.h> 58fe3db7c7SDoug Rabson #include <vm/vm_kern.h> 59fe3db7c7SDoug Rabson #include <vm/vm_extern.h> 60d1f088daSPeter Wemm #endif 61fe3db7c7SDoug Rabson #include <vm/pmap.h> 62fe3db7c7SDoug Rabson #include <vm/vm_map.h> 63fb919e4dSMark Murray 64f9980387SPeter Wemm #include <sys/link_elf.h> 65fe3db7c7SDoug Rabson 66a2024a3eSJohn Birrell #ifdef DDB_CTF 67a2024a3eSJohn Birrell #include <net/zlib.h> 68a2024a3eSJohn Birrell #endif 69a2024a3eSJohn Birrell 70326e27d8SDoug Rabson #include "linker_if.h" 71a4f67738SDoug Rabson 721a330eb0SPeter Wemm #define MAXSEGS 4 731a330eb0SPeter Wemm 744f2945f8SDavid E. O'Brien typedef struct elf_file { 754f2945f8SDavid E. O'Brien struct linker_file lf; /* Common fields */ 764f2945f8SDavid E. O'Brien int preloaded; /* Was file pre-loaded */ 774f2945f8SDavid E. O'Brien caddr_t address; /* Relocation address */ 784f2945f8SDavid E. O'Brien #ifdef SPARSE_MAPPING 794f2945f8SDavid E. O'Brien vm_object_t object; /* VM object to hold file pages */ 804f2945f8SDavid E. O'Brien #endif 814f2945f8SDavid E. O'Brien Elf_Dyn* dynamic; /* Symbol table etc. */ 824f2945f8SDavid E. O'Brien Elf_Hashelt nbuckets; /* DT_HASH info */ 834f2945f8SDavid E. O'Brien Elf_Hashelt nchains; 844f2945f8SDavid E. O'Brien const Elf_Hashelt* buckets; 854f2945f8SDavid E. O'Brien const Elf_Hashelt* chains; 864f2945f8SDavid E. O'Brien caddr_t hash; 874f2945f8SDavid E. O'Brien caddr_t strtab; /* DT_STRTAB */ 884f2945f8SDavid E. O'Brien int strsz; /* DT_STRSZ */ 894f2945f8SDavid E. O'Brien const Elf_Sym* symtab; /* DT_SYMTAB */ 904f2945f8SDavid E. O'Brien Elf_Addr* got; /* DT_PLTGOT */ 914f2945f8SDavid E. O'Brien const Elf_Rel* pltrel; /* DT_JMPREL */ 924f2945f8SDavid E. O'Brien int pltrelsize; /* DT_PLTRELSZ */ 934f2945f8SDavid E. O'Brien const Elf_Rela* pltrela; /* DT_JMPREL */ 944f2945f8SDavid E. O'Brien int pltrelasize; /* DT_PLTRELSZ */ 954f2945f8SDavid E. O'Brien const Elf_Rel* rel; /* DT_REL */ 964f2945f8SDavid E. O'Brien int relsize; /* DT_RELSZ */ 974f2945f8SDavid E. O'Brien const Elf_Rela* rela; /* DT_RELA */ 984f2945f8SDavid E. O'Brien int relasize; /* DT_RELASZ */ 994f2945f8SDavid E. O'Brien caddr_t modptr; 1004f2945f8SDavid E. O'Brien const Elf_Sym* ddbsymtab; /* The symbol table we are using */ 1014f2945f8SDavid E. O'Brien long ddbsymcnt; /* Number of symbols */ 1024f2945f8SDavid E. O'Brien caddr_t ddbstrtab; /* String table */ 1034f2945f8SDavid E. O'Brien long ddbstrcnt; /* number of bytes in string table */ 1044f2945f8SDavid E. O'Brien caddr_t symbase; /* malloc'ed symbold base */ 1054f2945f8SDavid E. O'Brien caddr_t strbase; /* malloc'ed string base */ 1064f2945f8SDavid E. O'Brien caddr_t ctftab; /* CTF table */ 1074f2945f8SDavid E. O'Brien long ctfcnt; /* number of bytes in CTF table */ 1084f2945f8SDavid E. O'Brien caddr_t ctfoff; /* CTF offset table */ 1094f2945f8SDavid E. O'Brien caddr_t typoff; /* Type offset table */ 1104f2945f8SDavid E. O'Brien long typlen; /* Number of type entries. */ 1114f2945f8SDavid E. O'Brien #ifdef GDB 1124f2945f8SDavid E. O'Brien struct link_map gdb; /* hooks for gdb */ 1134f2945f8SDavid E. O'Brien #endif 1144f2945f8SDavid E. O'Brien } *elf_file_t; 1154f2945f8SDavid E. O'Brien 116a2024a3eSJohn Birrell #include <kern/kern_ctf.c> 117a2024a3eSJohn Birrell 118c143d6c2SMarcel Moolenaar static int link_elf_link_common_finish(linker_file_t); 11954823af2SPeter Wemm static int link_elf_link_preload(linker_class_t cls, 120326e27d8SDoug Rabson const char*, linker_file_t*); 12154823af2SPeter Wemm static int link_elf_link_preload_finish(linker_file_t); 12254823af2SPeter Wemm static int link_elf_load_file(linker_class_t, const char*, linker_file_t*); 123326e27d8SDoug Rabson static int link_elf_lookup_symbol(linker_file_t, const char*, 124326e27d8SDoug Rabson c_linker_sym_t*); 125326e27d8SDoug Rabson static int link_elf_symbol_values(linker_file_t, c_linker_sym_t, linker_symval_t*); 126326e27d8SDoug Rabson static int link_elf_search_symbol(linker_file_t, caddr_t value, 127326e27d8SDoug Rabson c_linker_sym_t* sym, long* diffp); 128326e27d8SDoug Rabson 129326e27d8SDoug Rabson static void link_elf_unload_file(linker_file_t); 13054823af2SPeter Wemm static void link_elf_unload_preload(linker_file_t); 131f41325dbSPeter Wemm static int link_elf_lookup_set(linker_file_t, const char *, 132f41325dbSPeter Wemm void ***, void ***, int *); 133bb9fe9ddSBrian Feldman static int link_elf_each_function_name(linker_file_t, 134bb9fe9ddSBrian Feldman int (*)(const char *, void *), 135bb9fe9ddSBrian Feldman void *); 136a2024a3eSJohn Birrell static int link_elf_each_function_nameval(linker_file_t, 137a2024a3eSJohn Birrell linker_function_nameval_callback_t, 138a2024a3eSJohn Birrell void *); 1397251b4bfSJake Burkholder static void link_elf_reloc_local(linker_file_t); 14000a5db46SStacey Son static long link_elf_symtab_get(linker_file_t, const Elf_Sym **); 14100a5db46SStacey Son static long link_elf_strtab_get(linker_file_t, caddr_t *); 142757686b1SMarcel Moolenaar static Elf_Addr elf_lookup(linker_file_t lf, Elf_Size symidx, int deps); 143326e27d8SDoug Rabson 144326e27d8SDoug Rabson static kobj_method_t link_elf_methods[] = { 145326e27d8SDoug Rabson KOBJMETHOD(linker_lookup_symbol, link_elf_lookup_symbol), 146326e27d8SDoug Rabson KOBJMETHOD(linker_symbol_values, link_elf_symbol_values), 147326e27d8SDoug Rabson KOBJMETHOD(linker_search_symbol, link_elf_search_symbol), 148326e27d8SDoug Rabson KOBJMETHOD(linker_unload, link_elf_unload_file), 14954823af2SPeter Wemm KOBJMETHOD(linker_load_file, link_elf_load_file), 15054823af2SPeter Wemm KOBJMETHOD(linker_link_preload, link_elf_link_preload), 15154823af2SPeter Wemm KOBJMETHOD(linker_link_preload_finish, link_elf_link_preload_finish), 152f41325dbSPeter Wemm KOBJMETHOD(linker_lookup_set, link_elf_lookup_set), 153bb9fe9ddSBrian Feldman KOBJMETHOD(linker_each_function_name, link_elf_each_function_name), 154a2024a3eSJohn Birrell KOBJMETHOD(linker_each_function_nameval, link_elf_each_function_nameval), 155a2024a3eSJohn Birrell KOBJMETHOD(linker_ctf_get, link_elf_ctf_get), 15600a5db46SStacey Son KOBJMETHOD(linker_symtab_get, link_elf_symtab_get), 15700a5db46SStacey Son KOBJMETHOD(linker_strtab_get, link_elf_strtab_get), 158326e27d8SDoug Rabson { 0, 0 } 159326e27d8SDoug Rabson }; 160326e27d8SDoug Rabson 161326e27d8SDoug Rabson static struct linker_class link_elf_class = { 162326e27d8SDoug Rabson #if ELF_TARG_CLASS == ELFCLASS32 163326e27d8SDoug Rabson "elf32", 164326e27d8SDoug Rabson #else 165326e27d8SDoug Rabson "elf64", 166326e27d8SDoug Rabson #endif 167326e27d8SDoug Rabson link_elf_methods, sizeof(struct elf_file) 168326e27d8SDoug Rabson }; 169326e27d8SDoug Rabson 170326e27d8SDoug Rabson static int parse_dynamic(elf_file_t ef); 171326e27d8SDoug Rabson static int relocate_file(elf_file_t ef); 17254823af2SPeter Wemm static int link_elf_preload_parse_symbols(elf_file_t ef); 173326e27d8SDoug Rabson 174ecb01c64SMarcel Moolenaar #ifdef GDB 175ca29467eSJohn Baldwin static void r_debug_state(struct r_debug *dummy_one, 176ca29467eSJohn Baldwin struct link_map *dummy_two); 177326e27d8SDoug Rabson 178326e27d8SDoug Rabson /* 179326e27d8SDoug Rabson * A list of loaded modules for GDB to use for loading symbols. 180326e27d8SDoug Rabson */ 181326e27d8SDoug Rabson struct r_debug r_debug; 182326e27d8SDoug Rabson 183ca29467eSJohn Baldwin #define GDB_STATE(s) r_debug.r_state = s; r_debug_state(NULL, NULL); 184326e27d8SDoug Rabson 185326e27d8SDoug Rabson /* 186326e27d8SDoug Rabson * Function for the debugger to set a breakpoint on to gain control. 187326e27d8SDoug Rabson */ 18837c84183SPoul-Henning Kamp static void 189ca29467eSJohn Baldwin r_debug_state(struct r_debug *dummy_one __unused, 190ca29467eSJohn Baldwin struct link_map *dummy_two __unused) 191326e27d8SDoug Rabson { 192326e27d8SDoug Rabson } 193326e27d8SDoug Rabson 1941720979bSMarcel Moolenaar static void 1951720979bSMarcel Moolenaar link_elf_add_gdb(struct link_map *l) 1961720979bSMarcel Moolenaar { 1971720979bSMarcel Moolenaar struct link_map *prev; 1981720979bSMarcel Moolenaar 199c143d6c2SMarcel Moolenaar l->l_next = NULL; 200c143d6c2SMarcel Moolenaar 201c143d6c2SMarcel Moolenaar if (r_debug.r_map == NULL) { 202c143d6c2SMarcel Moolenaar /* Add first. */ 203c143d6c2SMarcel Moolenaar l->l_prev = NULL; 204c143d6c2SMarcel Moolenaar r_debug.r_map = l; 205c143d6c2SMarcel Moolenaar } else { 206c143d6c2SMarcel Moolenaar /* Append to list. */ 2071720979bSMarcel Moolenaar for (prev = r_debug.r_map; prev->l_next != NULL; prev = prev->l_next) 2081720979bSMarcel Moolenaar ; 2091720979bSMarcel Moolenaar l->l_prev = prev; 2101720979bSMarcel Moolenaar prev->l_next = l; 2111720979bSMarcel Moolenaar } 212c143d6c2SMarcel Moolenaar } 2131720979bSMarcel Moolenaar 2141720979bSMarcel Moolenaar static void 2151720979bSMarcel Moolenaar link_elf_delete_gdb(struct link_map *l) 2161720979bSMarcel Moolenaar { 2171720979bSMarcel Moolenaar if (l->l_prev == NULL) { 218c143d6c2SMarcel Moolenaar /* Remove first. */ 2191720979bSMarcel Moolenaar if ((r_debug.r_map = l->l_next) != NULL) 2201720979bSMarcel Moolenaar l->l_next->l_prev = NULL; 221c143d6c2SMarcel Moolenaar } else { 222c143d6c2SMarcel Moolenaar /* Remove any but first. */ 2231720979bSMarcel Moolenaar if ((l->l_prev->l_next = l->l_next) != NULL) 2241720979bSMarcel Moolenaar l->l_next->l_prev = l->l_prev; 2251720979bSMarcel Moolenaar } 226c143d6c2SMarcel Moolenaar } 227ecb01c64SMarcel Moolenaar #endif /* GDB */ 228a4f67738SDoug Rabson 22984201059SMarcel Moolenaar #ifdef __ia64__ 23084201059SMarcel Moolenaar Elf_Addr link_elf_get_gp(linker_file_t); 23184201059SMarcel Moolenaar #endif 23284201059SMarcel Moolenaar 2334f2945f8SDavid E. O'Brien /* 2344f2945f8SDavid E. O'Brien * The kernel symbol table starts here. 2354f2945f8SDavid E. O'Brien */ 2364f2945f8SDavid E. O'Brien extern struct _dynamic _DYNAMIC; 2374f2945f8SDavid E. O'Brien 238a4f67738SDoug Rabson static void 239552f9f63SEdwin Groothuis link_elf_error(const char *filename, const char *s) 2401720979bSMarcel Moolenaar { 241552f9f63SEdwin Groothuis if (filename == NULL) 2421720979bSMarcel Moolenaar printf("kldload: %s\n", s); 243552f9f63SEdwin Groothuis else 244552f9f63SEdwin Groothuis printf("kldload: %s: %s\n", filename, s); 2451720979bSMarcel Moolenaar } 2461720979bSMarcel Moolenaar 247c143d6c2SMarcel Moolenaar /* 248c143d6c2SMarcel Moolenaar * Actions performed after linking/loading both the preloaded kernel and any 249c143d6c2SMarcel Moolenaar * modules; whether preloaded or dynamicly loaded. 250c143d6c2SMarcel Moolenaar */ 251c143d6c2SMarcel Moolenaar static int 252c143d6c2SMarcel Moolenaar link_elf_link_common_finish(linker_file_t lf) 253c143d6c2SMarcel Moolenaar { 254ecb01c64SMarcel Moolenaar #ifdef GDB 255c143d6c2SMarcel Moolenaar elf_file_t ef = (elf_file_t)lf; 256c143d6c2SMarcel Moolenaar char *newfilename; 257c143d6c2SMarcel Moolenaar #endif 2581aeb23cdSMarcel Moolenaar int error; 2591aeb23cdSMarcel Moolenaar 2601aeb23cdSMarcel Moolenaar /* Notify MD code that a module is being loaded. */ 2611aeb23cdSMarcel Moolenaar error = elf_cpu_load_file(lf); 2621aeb23cdSMarcel Moolenaar if (error) 2631aeb23cdSMarcel Moolenaar return (error); 264c143d6c2SMarcel Moolenaar 265ecb01c64SMarcel Moolenaar #ifdef GDB 266c143d6c2SMarcel Moolenaar GDB_STATE(RT_ADD); 267c143d6c2SMarcel Moolenaar ef->gdb.l_addr = lf->address; 268a163d034SWarner Losh newfilename = malloc(strlen(lf->filename) + 1, M_LINKER, M_WAITOK); 269c143d6c2SMarcel Moolenaar strcpy(newfilename, lf->filename); 270c143d6c2SMarcel Moolenaar ef->gdb.l_name = newfilename; 271c143d6c2SMarcel Moolenaar ef->gdb.l_ld = ef->dynamic; 272c143d6c2SMarcel Moolenaar link_elf_add_gdb(&ef->gdb); 273c143d6c2SMarcel Moolenaar GDB_STATE(RT_CONSISTENT); 274c143d6c2SMarcel Moolenaar #endif 275c143d6c2SMarcel Moolenaar 276c143d6c2SMarcel Moolenaar return (0); 277c143d6c2SMarcel Moolenaar } 278c143d6c2SMarcel Moolenaar 2791720979bSMarcel Moolenaar static void 280a4f67738SDoug Rabson link_elf_init(void* arg) 281a4f67738SDoug Rabson { 282de78ca7eSPeter Wemm Elf_Dyn *dp; 283de78ca7eSPeter Wemm caddr_t modptr, baseptr, sizeptr; 284de78ca7eSPeter Wemm elf_file_t ef; 285de78ca7eSPeter Wemm char *modname; 286a4f67738SDoug Rabson 287326e27d8SDoug Rabson linker_add_class(&link_elf_class); 288a4f67738SDoug Rabson 289de78ca7eSPeter Wemm dp = (Elf_Dyn*) &_DYNAMIC; 290de78ca7eSPeter Wemm modname = NULL; 29167db8b23SPeter Wemm modptr = preload_search_by_type("elf" __XSTRING(__ELF_WORD_SIZE) " kernel"); 29267db8b23SPeter Wemm if (modptr == NULL) 293de78ca7eSPeter Wemm modptr = preload_search_by_type("elf kernel"); 294de78ca7eSPeter Wemm if (modptr) 295de78ca7eSPeter Wemm modname = (char *)preload_search_info(modptr, MODINFO_NAME); 296de78ca7eSPeter Wemm if (modname == NULL) 297de78ca7eSPeter Wemm modname = "kernel"; 298326e27d8SDoug Rabson linker_kernel_file = linker_make_file(modname, &link_elf_class); 299a4f67738SDoug Rabson if (linker_kernel_file == NULL) 300a4f67738SDoug Rabson panic("link_elf_init: Can't create linker structures for kernel"); 301326e27d8SDoug Rabson 302326e27d8SDoug Rabson ef = (elf_file_t) linker_kernel_file; 30354823af2SPeter Wemm ef->preloaded = 1; 304326e27d8SDoug Rabson ef->address = 0; 305326e27d8SDoug Rabson #ifdef SPARSE_MAPPING 306326e27d8SDoug Rabson ef->object = 0; 307326e27d8SDoug Rabson #endif 308326e27d8SDoug Rabson ef->dynamic = dp; 309326e27d8SDoug Rabson 31000dda5e8SPeter Wemm if (dp) 311326e27d8SDoug Rabson parse_dynamic(ef); 3124173e420SPeter Wemm linker_kernel_file->address = (caddr_t) KERNBASE; 313d009ccfaSBruce Evans linker_kernel_file->size = -(intptr_t)linker_kernel_file->address; 314de78ca7eSPeter Wemm 315de78ca7eSPeter Wemm if (modptr) { 3162d636ab0SPeter Wemm ef->modptr = modptr; 317de78ca7eSPeter Wemm baseptr = preload_search_info(modptr, MODINFO_ADDR); 318de78ca7eSPeter Wemm if (baseptr) 319de78ca7eSPeter Wemm linker_kernel_file->address = *(caddr_t *)baseptr; 320de78ca7eSPeter Wemm sizeptr = preload_search_info(modptr, MODINFO_SIZE); 321de78ca7eSPeter Wemm if (sizeptr) 322de78ca7eSPeter Wemm linker_kernel_file->size = *(size_t *)sizeptr; 323de78ca7eSPeter Wemm } 32454823af2SPeter Wemm (void)link_elf_preload_parse_symbols(ef); 325326e27d8SDoug Rabson 326ecb01c64SMarcel Moolenaar #ifdef GDB 327c143d6c2SMarcel Moolenaar r_debug.r_map = NULL; 328326e27d8SDoug Rabson r_debug.r_brk = r_debug_state; 329326e27d8SDoug Rabson r_debug.r_state = RT_CONSISTENT; 330326e27d8SDoug Rabson #endif 331c143d6c2SMarcel Moolenaar 332c143d6c2SMarcel Moolenaar (void)link_elf_link_common_finish(linker_kernel_file); 33359800afcSJohn Baldwin linker_kernel_file->flags |= LINKER_FILE_LINKED; 334a4f67738SDoug Rabson } 335a4f67738SDoug Rabson 3368120ddb4SJung-uk Kim SYSINIT(link_elf, SI_SUB_KLD, SI_ORDER_THIRD, link_elf_init, 0); 337a4f67738SDoug Rabson 338a4f67738SDoug Rabson static int 33954823af2SPeter Wemm link_elf_preload_parse_symbols(elf_file_t ef) 3402d636ab0SPeter Wemm { 3412d636ab0SPeter Wemm caddr_t pointer; 3422d636ab0SPeter Wemm caddr_t ssym, esym, base; 3432d636ab0SPeter Wemm caddr_t strtab; 3442d636ab0SPeter Wemm int strcnt; 3452d636ab0SPeter Wemm Elf_Sym* symtab; 3462d636ab0SPeter Wemm int symcnt; 3472d636ab0SPeter Wemm 348ca65d5c7SPeter Wemm if (ef->modptr == NULL) 349ca65d5c7SPeter Wemm return 0; 3502d636ab0SPeter Wemm pointer = preload_search_info(ef->modptr, MODINFO_METADATA|MODINFOMD_SSYM); 3512d636ab0SPeter Wemm if (pointer == NULL) 3522d636ab0SPeter Wemm return 0; 3532d636ab0SPeter Wemm ssym = *(caddr_t *)pointer; 3542d636ab0SPeter Wemm pointer = preload_search_info(ef->modptr, MODINFO_METADATA|MODINFOMD_ESYM); 3552d636ab0SPeter Wemm if (pointer == NULL) 3562d636ab0SPeter Wemm return 0; 3572d636ab0SPeter Wemm esym = *(caddr_t *)pointer; 3582d636ab0SPeter Wemm 3592d636ab0SPeter Wemm base = ssym; 3602d636ab0SPeter Wemm 3612d636ab0SPeter Wemm symcnt = *(long *)base; 3622d636ab0SPeter Wemm base += sizeof(long); 3632d636ab0SPeter Wemm symtab = (Elf_Sym *)base; 3642d636ab0SPeter Wemm base += roundup(symcnt, sizeof(long)); 3652d636ab0SPeter Wemm 3662d636ab0SPeter Wemm if (base > esym || base < ssym) { 3672d636ab0SPeter Wemm printf("Symbols are corrupt!\n"); 3682d636ab0SPeter Wemm return EINVAL; 3692d636ab0SPeter Wemm } 3702d636ab0SPeter Wemm 3712d636ab0SPeter Wemm strcnt = *(long *)base; 3722d636ab0SPeter Wemm base += sizeof(long); 3732d636ab0SPeter Wemm strtab = base; 3742d636ab0SPeter Wemm base += roundup(strcnt, sizeof(long)); 3752d636ab0SPeter Wemm 3762d636ab0SPeter Wemm if (base > esym || base < ssym) { 3772d636ab0SPeter Wemm printf("Symbols are corrupt!\n"); 3782d636ab0SPeter Wemm return EINVAL; 3792d636ab0SPeter Wemm } 3802d636ab0SPeter Wemm 3812d636ab0SPeter Wemm ef->ddbsymtab = symtab; 3822d636ab0SPeter Wemm ef->ddbsymcnt = symcnt / sizeof(Elf_Sym); 3832d636ab0SPeter Wemm ef->ddbstrtab = strtab; 3842d636ab0SPeter Wemm ef->ddbstrcnt = strcnt; 3852d636ab0SPeter Wemm 3862d636ab0SPeter Wemm return 0; 3872d636ab0SPeter Wemm } 3882d636ab0SPeter Wemm 3892d636ab0SPeter Wemm static int 390326e27d8SDoug Rabson parse_dynamic(elf_file_t ef) 391a4f67738SDoug Rabson { 392326e27d8SDoug Rabson Elf_Dyn *dp; 393fe3db7c7SDoug Rabson int plttype = DT_REL; 394a4f67738SDoug Rabson 395a4f67738SDoug Rabson for (dp = ef->dynamic; dp->d_tag != DT_NULL; dp++) { 396a4f67738SDoug Rabson switch (dp->d_tag) { 397a4f67738SDoug Rabson case DT_HASH: 398a4f67738SDoug Rabson { 399a4f67738SDoug Rabson /* From src/libexec/rtld-elf/rtld.c */ 4007e510298SJake Burkholder const Elf_Hashelt *hashtab = (const Elf_Hashelt *) 401a4f67738SDoug Rabson (ef->address + dp->d_un.d_ptr); 402a4f67738SDoug Rabson ef->nbuckets = hashtab[0]; 403a4f67738SDoug Rabson ef->nchains = hashtab[1]; 404a4f67738SDoug Rabson ef->buckets = hashtab + 2; 405a4f67738SDoug Rabson ef->chains = ef->buckets + ef->nbuckets; 406a4f67738SDoug Rabson break; 407a4f67738SDoug Rabson } 408a4f67738SDoug Rabson case DT_STRTAB: 409fe3db7c7SDoug Rabson ef->strtab = (caddr_t) (ef->address + dp->d_un.d_ptr); 410a4f67738SDoug Rabson break; 4112d636ab0SPeter Wemm case DT_STRSZ: 4122d636ab0SPeter Wemm ef->strsz = dp->d_un.d_val; 4132d636ab0SPeter Wemm break; 414a4f67738SDoug Rabson case DT_SYMTAB: 415fe3db7c7SDoug Rabson ef->symtab = (Elf_Sym*) (ef->address + dp->d_un.d_ptr); 416a4f67738SDoug Rabson break; 417a4f67738SDoug Rabson case DT_SYMENT: 418a4f67738SDoug Rabson if (dp->d_un.d_val != sizeof(Elf_Sym)) 419a4f67738SDoug Rabson return ENOEXEC; 420fe3db7c7SDoug Rabson break; 421fe3db7c7SDoug Rabson case DT_PLTGOT: 422fe3db7c7SDoug Rabson ef->got = (Elf_Addr *) (ef->address + dp->d_un.d_ptr); 423fe3db7c7SDoug Rabson break; 424fe3db7c7SDoug Rabson case DT_REL: 425fe3db7c7SDoug Rabson ef->rel = (const Elf_Rel *) (ef->address + dp->d_un.d_ptr); 426fe3db7c7SDoug Rabson break; 427fe3db7c7SDoug Rabson case DT_RELSZ: 428fe3db7c7SDoug Rabson ef->relsize = dp->d_un.d_val; 429fe3db7c7SDoug Rabson break; 430fe3db7c7SDoug Rabson case DT_RELENT: 431fe3db7c7SDoug Rabson if (dp->d_un.d_val != sizeof(Elf_Rel)) 432fe3db7c7SDoug Rabson return ENOEXEC; 433fe3db7c7SDoug Rabson break; 434fe3db7c7SDoug Rabson case DT_JMPREL: 435fe3db7c7SDoug Rabson ef->pltrel = (const Elf_Rel *) (ef->address + dp->d_un.d_ptr); 436fe3db7c7SDoug Rabson break; 437fe3db7c7SDoug Rabson case DT_PLTRELSZ: 438fe3db7c7SDoug Rabson ef->pltrelsize = dp->d_un.d_val; 439fe3db7c7SDoug Rabson break; 440fe3db7c7SDoug Rabson case DT_RELA: 441fe3db7c7SDoug Rabson ef->rela = (const Elf_Rela *) (ef->address + dp->d_un.d_ptr); 442fe3db7c7SDoug Rabson break; 443fe3db7c7SDoug Rabson case DT_RELASZ: 444fe3db7c7SDoug Rabson ef->relasize = dp->d_un.d_val; 445fe3db7c7SDoug Rabson break; 446fe3db7c7SDoug Rabson case DT_RELAENT: 447fe3db7c7SDoug Rabson if (dp->d_un.d_val != sizeof(Elf_Rela)) 448fe3db7c7SDoug Rabson return ENOEXEC; 449fe3db7c7SDoug Rabson break; 450fe3db7c7SDoug Rabson case DT_PLTREL: 451fe3db7c7SDoug Rabson plttype = dp->d_un.d_val; 452fe3db7c7SDoug Rabson if (plttype != DT_REL && plttype != DT_RELA) 453fe3db7c7SDoug Rabson return ENOEXEC; 454fe3db7c7SDoug Rabson break; 455ecb01c64SMarcel Moolenaar #ifdef GDB 456326e27d8SDoug Rabson case DT_DEBUG: 457326e27d8SDoug Rabson dp->d_un.d_ptr = (Elf_Addr) &r_debug; 458326e27d8SDoug Rabson break; 459326e27d8SDoug Rabson #endif 460a4f67738SDoug Rabson } 461a4f67738SDoug Rabson } 462fe3db7c7SDoug Rabson 463fe3db7c7SDoug Rabson if (plttype == DT_RELA) { 464fe3db7c7SDoug Rabson ef->pltrela = (const Elf_Rela *) ef->pltrel; 465fe3db7c7SDoug Rabson ef->pltrel = NULL; 466fe3db7c7SDoug Rabson ef->pltrelasize = ef->pltrelsize; 467fe3db7c7SDoug Rabson ef->pltrelsize = 0; 468fe3db7c7SDoug Rabson } 469fe3db7c7SDoug Rabson 4702d636ab0SPeter Wemm ef->ddbsymtab = ef->symtab; 4712d636ab0SPeter Wemm ef->ddbsymcnt = ef->nchains; 4722d636ab0SPeter Wemm ef->ddbstrtab = ef->strtab; 4732d636ab0SPeter Wemm ef->ddbstrcnt = ef->strsz; 4742d636ab0SPeter Wemm 475a4f67738SDoug Rabson return 0; 476a4f67738SDoug Rabson } 477a4f67738SDoug Rabson 478a4f67738SDoug Rabson static int 47954823af2SPeter Wemm link_elf_link_preload(linker_class_t cls, 480326e27d8SDoug Rabson const char* filename, linker_file_t *result) 481de78ca7eSPeter Wemm { 482de78ca7eSPeter Wemm caddr_t modptr, baseptr, sizeptr, dynptr; 483de78ca7eSPeter Wemm char *type; 484de78ca7eSPeter Wemm elf_file_t ef; 485de78ca7eSPeter Wemm linker_file_t lf; 486de78ca7eSPeter Wemm int error; 487de78ca7eSPeter Wemm vm_offset_t dp; 488de78ca7eSPeter Wemm 48954823af2SPeter Wemm /* Look to see if we have the file preloaded */ 490de78ca7eSPeter Wemm modptr = preload_search_by_name(filename); 491de78ca7eSPeter Wemm if (modptr == NULL) 49254823af2SPeter Wemm return ENOENT; 493de78ca7eSPeter Wemm 494de78ca7eSPeter Wemm type = (char *)preload_search_info(modptr, MODINFO_TYPE); 495de78ca7eSPeter Wemm baseptr = preload_search_info(modptr, MODINFO_ADDR); 496de78ca7eSPeter Wemm sizeptr = preload_search_info(modptr, MODINFO_SIZE); 497de78ca7eSPeter Wemm dynptr = preload_search_info(modptr, MODINFO_METADATA|MODINFOMD_DYNAMIC); 49867db8b23SPeter Wemm if (type == NULL || 49967db8b23SPeter Wemm (strcmp(type, "elf" __XSTRING(__ELF_WORD_SIZE) " module") != 0 && 50067db8b23SPeter Wemm strcmp(type, "elf module") != 0)) 501de78ca7eSPeter Wemm return (EFTYPE); 502de78ca7eSPeter Wemm if (baseptr == NULL || sizeptr == NULL || dynptr == NULL) 503de78ca7eSPeter Wemm return (EINVAL); 504de78ca7eSPeter Wemm 505326e27d8SDoug Rabson lf = linker_make_file(filename, &link_elf_class); 506326e27d8SDoug Rabson if (lf == NULL) { 507326e27d8SDoug Rabson return ENOMEM; 508326e27d8SDoug Rabson } 509326e27d8SDoug Rabson 510326e27d8SDoug Rabson ef = (elf_file_t) lf; 511326e27d8SDoug Rabson ef->preloaded = 1; 512ca65d5c7SPeter Wemm ef->modptr = modptr; 513de78ca7eSPeter Wemm ef->address = *(caddr_t *)baseptr; 514de78ca7eSPeter Wemm #ifdef SPARSE_MAPPING 515de78ca7eSPeter Wemm ef->object = 0; 516de78ca7eSPeter Wemm #endif 517de78ca7eSPeter Wemm dp = (vm_offset_t)ef->address + *(vm_offset_t *)dynptr; 518de78ca7eSPeter Wemm ef->dynamic = (Elf_Dyn *)dp; 519de78ca7eSPeter Wemm lf->address = ef->address; 520de78ca7eSPeter Wemm lf->size = *(size_t *)sizeptr; 521de78ca7eSPeter Wemm 522326e27d8SDoug Rabson error = parse_dynamic(ef); 523de78ca7eSPeter Wemm if (error) { 52465a311fcSPoul-Henning Kamp linker_file_unload(lf, LINKER_UNLOAD_FORCE); 525de78ca7eSPeter Wemm return error; 526de78ca7eSPeter Wemm } 5277251b4bfSJake Burkholder link_elf_reloc_local(lf); 528de78ca7eSPeter Wemm *result = lf; 529de78ca7eSPeter Wemm return (0); 530de78ca7eSPeter Wemm } 531de78ca7eSPeter Wemm 532de78ca7eSPeter Wemm static int 53354823af2SPeter Wemm link_elf_link_preload_finish(linker_file_t lf) 53454823af2SPeter Wemm { 53554823af2SPeter Wemm elf_file_t ef; 53654823af2SPeter Wemm int error; 53754823af2SPeter Wemm 53854823af2SPeter Wemm ef = (elf_file_t) lf; 53954823af2SPeter Wemm #if 0 /* this will be more trouble than it's worth for now */ 54054823af2SPeter Wemm for (dp = ef->dynamic; dp->d_tag != DT_NULL; dp++) { 54154823af2SPeter Wemm if (dp->d_tag != DT_NEEDED) 54254823af2SPeter Wemm continue; 54354823af2SPeter Wemm modname = ef->strtab + dp->d_un.d_val; 54454823af2SPeter Wemm error = linker_load_module(modname, lf); 54554823af2SPeter Wemm if (error) 54654823af2SPeter Wemm goto out; 54754823af2SPeter Wemm } 54854823af2SPeter Wemm #endif 54954823af2SPeter Wemm error = relocate_file(ef); 55054823af2SPeter Wemm if (error) 55154823af2SPeter Wemm return error; 55254823af2SPeter Wemm (void)link_elf_preload_parse_symbols(ef); 55354823af2SPeter Wemm 554c143d6c2SMarcel Moolenaar return (link_elf_link_common_finish(lf)); 55554823af2SPeter Wemm } 55654823af2SPeter Wemm 55754823af2SPeter Wemm static int 558c143d6c2SMarcel Moolenaar link_elf_load_file(linker_class_t cls, const char* filename, 559c143d6c2SMarcel Moolenaar linker_file_t* result) 560a4f67738SDoug Rabson { 561a4f67738SDoug Rabson struct nameidata nd; 562b40ce416SJulian Elischer struct thread* td = curthread; /* XXX */ 563caab6e90SPeter Wemm Elf_Ehdr *hdr; 564caab6e90SPeter Wemm caddr_t firstpage; 565fe3db7c7SDoug Rabson int nbytes, i; 566fe3db7c7SDoug Rabson Elf_Phdr *phdr; 567fe3db7c7SDoug Rabson Elf_Phdr *phlimit; 5681a330eb0SPeter Wemm Elf_Phdr *segs[MAXSEGS]; 569fe3db7c7SDoug Rabson int nsegs; 570fe3db7c7SDoug Rabson Elf_Phdr *phdyn; 571fe3db7c7SDoug Rabson Elf_Phdr *phphdr; 572fe3db7c7SDoug Rabson caddr_t mapbase; 573fe3db7c7SDoug Rabson size_t mapsize; 574fe3db7c7SDoug Rabson Elf_Off base_offset; 575fe3db7c7SDoug Rabson Elf_Addr base_vaddr; 576fe3db7c7SDoug Rabson Elf_Addr base_vlimit; 577a4f67738SDoug Rabson int error = 0; 578e6796b67SKirk McKusick int resid, flags; 579a4f67738SDoug Rabson elf_file_t ef; 580a4f67738SDoug Rabson linker_file_t lf; 581ca65d5c7SPeter Wemm Elf_Shdr *shdr; 582ca65d5c7SPeter Wemm int symtabindex; 583ca65d5c7SPeter Wemm int symstrindex; 584ca65d5c7SPeter Wemm int symcnt; 585ca65d5c7SPeter Wemm int strcnt; 58662d615d5SJohn Baldwin int vfslocked; 587ca65d5c7SPeter Wemm 588ca65d5c7SPeter Wemm shdr = NULL; 589ca65d5c7SPeter Wemm lf = NULL; 590a4f67738SDoug Rabson 59162d615d5SJohn Baldwin NDINIT(&nd, LOOKUP, FOLLOW | MPSAFE, UIO_SYSSPACE, filename, td); 592e6796b67SKirk McKusick flags = FREAD; 5939e223287SKonstantin Belousov error = vn_open(&nd, &flags, 0, NULL); 594a4f67738SDoug Rabson if (error) 595a4f67738SDoug Rabson return error; 59662d615d5SJohn Baldwin vfslocked = NDHASGIANT(&nd); 597762e6b85SEivind Eklund NDFREE(&nd, NDF_ONLY_PNBUF); 5981f49b573SRuslan Ermilov if (nd.ni_vp->v_type != VREG) { 5991f49b573SRuslan Ermilov error = ENOEXEC; 6001f49b573SRuslan Ermilov firstpage = NULL; 6011f49b573SRuslan Ermilov goto out; 6021f49b573SRuslan Ermilov } 603a3df768bSRobert Watson #ifdef MAC 60430d239bcSRobert Watson error = mac_kld_check_load(curthread->td_ucred, nd.ni_vp); 605a3df768bSRobert Watson if (error) { 606a3df768bSRobert Watson firstpage = NULL; 607a3df768bSRobert Watson goto out; 608a3df768bSRobert Watson } 609a3df768bSRobert Watson #endif 610a4f67738SDoug Rabson 611a4f67738SDoug Rabson /* 612fe3db7c7SDoug Rabson * Read the elf header from the file. 613a4f67738SDoug Rabson */ 614a163d034SWarner Losh firstpage = malloc(PAGE_SIZE, M_LINKER, M_WAITOK); 615caab6e90SPeter Wemm if (firstpage == NULL) { 616caab6e90SPeter Wemm error = ENOMEM; 617caab6e90SPeter Wemm goto out; 618caab6e90SPeter Wemm } 619caab6e90SPeter Wemm hdr = (Elf_Ehdr *)firstpage; 620caab6e90SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, firstpage, PAGE_SIZE, 0, 6219ca43589SRobert Watson UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 6229ca43589SRobert Watson &resid, td); 623caab6e90SPeter Wemm nbytes = PAGE_SIZE - resid; 624a4f67738SDoug Rabson if (error) 625a4f67738SDoug Rabson goto out; 626a4f67738SDoug Rabson 627caab6e90SPeter Wemm if (!IS_ELF(*hdr)) { 628fe3db7c7SDoug Rabson error = ENOEXEC; 629a4f67738SDoug Rabson goto out; 630fe3db7c7SDoug Rabson } 631fe3db7c7SDoug Rabson 632caab6e90SPeter Wemm if (hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS 633caab6e90SPeter Wemm || hdr->e_ident[EI_DATA] != ELF_TARG_DATA) { 634552f9f63SEdwin Groothuis link_elf_error(filename, "Unsupported file layout"); 635fe3db7c7SDoug Rabson error = ENOEXEC; 636fe3db7c7SDoug Rabson goto out; 637fe3db7c7SDoug Rabson } 638caab6e90SPeter Wemm if (hdr->e_ident[EI_VERSION] != EV_CURRENT 639caab6e90SPeter Wemm || hdr->e_version != EV_CURRENT) { 640552f9f63SEdwin Groothuis link_elf_error(filename, "Unsupported file version"); 641fe3db7c7SDoug Rabson error = ENOEXEC; 642fe3db7c7SDoug Rabson goto out; 643fe3db7c7SDoug Rabson } 644caab6e90SPeter Wemm if (hdr->e_type != ET_EXEC && hdr->e_type != ET_DYN) { 645a1d7ce03SAttilio Rao error = ENOSYS; 646fe3db7c7SDoug Rabson goto out; 647fe3db7c7SDoug Rabson } 648caab6e90SPeter Wemm if (hdr->e_machine != ELF_TARG_MACH) { 649552f9f63SEdwin Groothuis link_elf_error(filename, "Unsupported machine"); 650fe3db7c7SDoug Rabson error = ENOEXEC; 651fe3db7c7SDoug Rabson goto out; 652fe3db7c7SDoug Rabson } 653a4f67738SDoug Rabson 654a4f67738SDoug Rabson /* 655fe3db7c7SDoug Rabson * We rely on the program header being in the first page. This is 656fe3db7c7SDoug Rabson * not strictly required by the ABI specification, but it seems to 657fe3db7c7SDoug Rabson * always true in practice. And, it simplifies things considerably. 658a4f67738SDoug Rabson */ 659caab6e90SPeter Wemm if (!((hdr->e_phentsize == sizeof(Elf_Phdr)) && 660caab6e90SPeter Wemm (hdr->e_phoff + hdr->e_phnum*sizeof(Elf_Phdr) <= PAGE_SIZE) && 661caab6e90SPeter Wemm (hdr->e_phoff + hdr->e_phnum*sizeof(Elf_Phdr) <= nbytes))) 662552f9f63SEdwin Groothuis link_elf_error(filename, "Unreadable program headers"); 663fe3db7c7SDoug Rabson 664fe3db7c7SDoug Rabson /* 665fe3db7c7SDoug Rabson * Scan the program header entries, and save key information. 666fe3db7c7SDoug Rabson * 667fe3db7c7SDoug Rabson * We rely on there being exactly two load segments, text and data, 668fe3db7c7SDoug Rabson * in that order. 669fe3db7c7SDoug Rabson */ 670caab6e90SPeter Wemm phdr = (Elf_Phdr *) (firstpage + hdr->e_phoff); 671caab6e90SPeter Wemm phlimit = phdr + hdr->e_phnum; 672fe3db7c7SDoug Rabson nsegs = 0; 673fe3db7c7SDoug Rabson phdyn = NULL; 674fe3db7c7SDoug Rabson phphdr = NULL; 675fe3db7c7SDoug Rabson while (phdr < phlimit) { 676fe3db7c7SDoug Rabson switch (phdr->p_type) { 677fe3db7c7SDoug Rabson 678fe3db7c7SDoug Rabson case PT_LOAD: 6791a330eb0SPeter Wemm if (nsegs == MAXSEGS) { 680552f9f63SEdwin Groothuis link_elf_error(filename, "Too many sections"); 681fe3db7c7SDoug Rabson error = ENOEXEC; 682fe3db7c7SDoug Rabson goto out; 683fe3db7c7SDoug Rabson } 68487b1831fSPoul-Henning Kamp /* 68587b1831fSPoul-Henning Kamp * XXX: We just trust they come in right order ?? 68687b1831fSPoul-Henning Kamp */ 687fe3db7c7SDoug Rabson segs[nsegs] = phdr; 688fe3db7c7SDoug Rabson ++nsegs; 689fe3db7c7SDoug Rabson break; 690fe3db7c7SDoug Rabson 691fe3db7c7SDoug Rabson case PT_PHDR: 692fe3db7c7SDoug Rabson phphdr = phdr; 693fe3db7c7SDoug Rabson break; 694fe3db7c7SDoug Rabson 695fe3db7c7SDoug Rabson case PT_DYNAMIC: 696fe3db7c7SDoug Rabson phdyn = phdr; 697fe3db7c7SDoug Rabson break; 6989548091bSBoris Popov 6999548091bSBoris Popov case PT_INTERP: 700a1d7ce03SAttilio Rao error = ENOSYS; 7019548091bSBoris Popov goto out; 702fe3db7c7SDoug Rabson } 703fe3db7c7SDoug Rabson 704fe3db7c7SDoug Rabson ++phdr; 705fe3db7c7SDoug Rabson } 706fe3db7c7SDoug Rabson if (phdyn == NULL) { 707552f9f63SEdwin Groothuis link_elf_error(filename, "Object is not dynamically-linked"); 708fe3db7c7SDoug Rabson error = ENOEXEC; 709fe3db7c7SDoug Rabson goto out; 710fe3db7c7SDoug Rabson } 7111a330eb0SPeter Wemm if (nsegs == 0) { 712552f9f63SEdwin Groothuis link_elf_error(filename, "No sections"); 71387b1831fSPoul-Henning Kamp error = ENOEXEC; 71487b1831fSPoul-Henning Kamp goto out; 71587b1831fSPoul-Henning Kamp } 716fe3db7c7SDoug Rabson 717fe3db7c7SDoug Rabson /* 718fe3db7c7SDoug Rabson * Allocate the entire address space of the object, to stake out our 719fe3db7c7SDoug Rabson * contiguous region, and to establish the base address for relocation. 720fe3db7c7SDoug Rabson */ 721fe3db7c7SDoug Rabson base_offset = trunc_page(segs[0]->p_offset); 722fe3db7c7SDoug Rabson base_vaddr = trunc_page(segs[0]->p_vaddr); 7231a330eb0SPeter Wemm base_vlimit = round_page(segs[nsegs - 1]->p_vaddr + 7241a330eb0SPeter Wemm segs[nsegs - 1]->p_memsz); 725fe3db7c7SDoug Rabson mapsize = base_vlimit - base_vaddr; 726fe3db7c7SDoug Rabson 727326e27d8SDoug Rabson lf = linker_make_file(filename, &link_elf_class); 728326e27d8SDoug Rabson if (!lf) { 729326e27d8SDoug Rabson error = ENOMEM; 730326e27d8SDoug Rabson goto out; 731326e27d8SDoug Rabson } 732326e27d8SDoug Rabson 733326e27d8SDoug Rabson ef = (elf_file_t) lf; 734fe3db7c7SDoug Rabson #ifdef SPARSE_MAPPING 735fe3db7c7SDoug Rabson ef->object = vm_object_allocate(OBJT_DEFAULT, mapsize >> PAGE_SHIFT); 736fe3db7c7SDoug Rabson if (ef->object == NULL) { 737fe3db7c7SDoug Rabson error = ENOMEM; 738fe3db7c7SDoug Rabson goto out; 739fe3db7c7SDoug Rabson } 740fe3db7c7SDoug Rabson ef->address = (caddr_t) vm_map_min(kernel_map); 741fe3db7c7SDoug Rabson error = vm_map_find(kernel_map, ef->object, 0, 742fe3db7c7SDoug Rabson (vm_offset_t *) &ef->address, 743fe3db7c7SDoug Rabson mapsize, 1, 744fe3db7c7SDoug Rabson VM_PROT_ALL, VM_PROT_ALL, 0); 745fe3db7c7SDoug Rabson if (error) { 746fe3db7c7SDoug Rabson vm_object_deallocate(ef->object); 747326e27d8SDoug Rabson ef->object = 0; 748fe3db7c7SDoug Rabson goto out; 749fe3db7c7SDoug Rabson } 750fe3db7c7SDoug Rabson #else 751a163d034SWarner Losh ef->address = malloc(mapsize, M_LINKER, M_WAITOK); 752326e27d8SDoug Rabson if (!ef->address) { 753326e27d8SDoug Rabson error = ENOMEM; 754326e27d8SDoug Rabson goto out; 755326e27d8SDoug Rabson } 756fe3db7c7SDoug Rabson #endif 757fe3db7c7SDoug Rabson mapbase = ef->address; 758a4f67738SDoug Rabson 759a4f67738SDoug Rabson /* 760a4f67738SDoug Rabson * Read the text and data sections and zero the bss. 761a4f67738SDoug Rabson */ 7621a330eb0SPeter Wemm for (i = 0; i < nsegs; i++) { 763fe3db7c7SDoug Rabson caddr_t segbase = mapbase + segs[i]->p_vaddr - base_vaddr; 764fe3db7c7SDoug Rabson error = vn_rdwr(UIO_READ, nd.ni_vp, 765fe3db7c7SDoug Rabson segbase, segs[i]->p_filesz, segs[i]->p_offset, 7669ca43589SRobert Watson UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 7679ca43589SRobert Watson &resid, td); 768fe3db7c7SDoug Rabson if (error) { 769a4f67738SDoug Rabson goto out; 770a4f67738SDoug Rabson } 771fe3db7c7SDoug Rabson bzero(segbase + segs[i]->p_filesz, 772fe3db7c7SDoug Rabson segs[i]->p_memsz - segs[i]->p_filesz); 77341673965SAlan Cox 77441673965SAlan Cox #ifdef SPARSE_MAPPING 77541673965SAlan Cox /* 77641673965SAlan Cox * Wire down the pages 77741673965SAlan Cox */ 7785d3043ceSAlan Cox error = vm_map_wire(kernel_map, 77941673965SAlan Cox (vm_offset_t) segbase, 78041673965SAlan Cox (vm_offset_t) segbase + segs[i]->p_memsz, 78141673965SAlan Cox VM_MAP_WIRE_SYSTEM|VM_MAP_WIRE_NOHOLES); 7825d3043ceSAlan Cox if (error != KERN_SUCCESS) { 7835d3043ceSAlan Cox error = ENOMEM; 7845d3043ceSAlan Cox goto out; 7855d3043ceSAlan Cox } 78641673965SAlan Cox #endif 787fe3db7c7SDoug Rabson } 788fe3db7c7SDoug Rabson 789f99502a4SBrian Feldman #ifdef GPROF 790f99502a4SBrian Feldman /* Update profiling information with the new text segment. */ 79170f37788SJohn Baldwin mtx_lock(&Giant); 792f99502a4SBrian Feldman kmupetext((uintfptr_t)(mapbase + segs[0]->p_vaddr - base_vaddr + 793f99502a4SBrian Feldman segs[0]->p_memsz)); 79470f37788SJohn Baldwin mtx_unlock(&Giant); 795f99502a4SBrian Feldman #endif 796f99502a4SBrian Feldman 797326e27d8SDoug Rabson ef->dynamic = (Elf_Dyn *) (mapbase + phdyn->p_vaddr - base_vaddr); 798a4f67738SDoug Rabson 799a4f67738SDoug Rabson lf->address = ef->address; 800fe3db7c7SDoug Rabson lf->size = mapsize; 801a4f67738SDoug Rabson 802326e27d8SDoug Rabson error = parse_dynamic(ef); 803ca65d5c7SPeter Wemm if (error) 804de78ca7eSPeter Wemm goto out; 8057251b4bfSJake Burkholder link_elf_reloc_local(lf); 8067251b4bfSJake Burkholder 8074f7afc20SKonstantin Belousov VOP_UNLOCK(nd.ni_vp, 0); 8087b9716baSIan Dowse error = linker_load_dependencies(lf); 8094f7afc20SKonstantin Belousov vn_lock(nd.ni_vp, LK_EXCLUSIVE | LK_RETRY); 810ca65d5c7SPeter Wemm if (error) 811de78ca7eSPeter Wemm goto out; 81254823af2SPeter Wemm #if 0 /* this will be more trouble than it's worth for now */ 81354823af2SPeter Wemm for (dp = ef->dynamic; dp->d_tag != DT_NULL; dp++) { 81454823af2SPeter Wemm if (dp->d_tag != DT_NEEDED) 81554823af2SPeter Wemm continue; 81654823af2SPeter Wemm modname = ef->strtab + dp->d_un.d_val; 81754823af2SPeter Wemm error = linker_load_module(modname, lf); 81854823af2SPeter Wemm if (error) 81954823af2SPeter Wemm goto out; 82054823af2SPeter Wemm } 82154823af2SPeter Wemm #endif 822326e27d8SDoug Rabson error = relocate_file(ef); 823ca65d5c7SPeter Wemm if (error) 824ca65d5c7SPeter Wemm goto out; 825ca65d5c7SPeter Wemm 826ca65d5c7SPeter Wemm /* Try and load the symbol table if it's present. (you can strip it!) */ 827caab6e90SPeter Wemm nbytes = hdr->e_shnum * hdr->e_shentsize; 828caab6e90SPeter Wemm if (nbytes == 0 || hdr->e_shoff == 0) 829ca65d5c7SPeter Wemm goto nosyms; 830a163d034SWarner Losh shdr = malloc(nbytes, M_LINKER, M_WAITOK | M_ZERO); 831ca65d5c7SPeter Wemm if (shdr == NULL) { 832ca65d5c7SPeter Wemm error = ENOMEM; 833a4f67738SDoug Rabson goto out; 834a4f67738SDoug Rabson } 835ca65d5c7SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, 836caab6e90SPeter Wemm (caddr_t)shdr, nbytes, hdr->e_shoff, 8379ca43589SRobert Watson UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 8389ca43589SRobert Watson &resid, td); 839ca65d5c7SPeter Wemm if (error) 840ca65d5c7SPeter Wemm goto out; 841ca65d5c7SPeter Wemm symtabindex = -1; 842ca65d5c7SPeter Wemm symstrindex = -1; 843caab6e90SPeter Wemm for (i = 0; i < hdr->e_shnum; i++) { 844ca65d5c7SPeter Wemm if (shdr[i].sh_type == SHT_SYMTAB) { 845ca65d5c7SPeter Wemm symtabindex = i; 846ca65d5c7SPeter Wemm symstrindex = shdr[i].sh_link; 847ca65d5c7SPeter Wemm } 848ca65d5c7SPeter Wemm } 849ca65d5c7SPeter Wemm if (symtabindex < 0 || symstrindex < 0) 850ca65d5c7SPeter Wemm goto nosyms; 851ca65d5c7SPeter Wemm 852ca65d5c7SPeter Wemm symcnt = shdr[symtabindex].sh_size; 853a163d034SWarner Losh ef->symbase = malloc(symcnt, M_LINKER, M_WAITOK); 854ca65d5c7SPeter Wemm strcnt = shdr[symstrindex].sh_size; 855a163d034SWarner Losh ef->strbase = malloc(strcnt, M_LINKER, M_WAITOK); 856ca65d5c7SPeter Wemm 857ca65d5c7SPeter Wemm if (ef->symbase == NULL || ef->strbase == NULL) { 858ca65d5c7SPeter Wemm error = ENOMEM; 859ca65d5c7SPeter Wemm goto out; 860ca65d5c7SPeter Wemm } 861ca65d5c7SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, 862ca65d5c7SPeter Wemm ef->symbase, symcnt, shdr[symtabindex].sh_offset, 8639ca43589SRobert Watson UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 8649ca43589SRobert Watson &resid, td); 865ca65d5c7SPeter Wemm if (error) 866ca65d5c7SPeter Wemm goto out; 867ca65d5c7SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, 868ca65d5c7SPeter Wemm ef->strbase, strcnt, shdr[symstrindex].sh_offset, 8699ca43589SRobert Watson UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 8709ca43589SRobert Watson &resid, td); 871ca65d5c7SPeter Wemm if (error) 872ca65d5c7SPeter Wemm goto out; 873ca65d5c7SPeter Wemm 874ca65d5c7SPeter Wemm ef->ddbsymcnt = symcnt / sizeof(Elf_Sym); 875ca65d5c7SPeter Wemm ef->ddbsymtab = (const Elf_Sym *)ef->symbase; 876ca65d5c7SPeter Wemm ef->ddbstrcnt = strcnt; 877ca65d5c7SPeter Wemm ef->ddbstrtab = ef->strbase; 878ca65d5c7SPeter Wemm 879c143d6c2SMarcel Moolenaar error = link_elf_link_common_finish(lf); 880c143d6c2SMarcel Moolenaar if (error) 881c143d6c2SMarcel Moolenaar goto out; 882326e27d8SDoug Rabson 883ca65d5c7SPeter Wemm nosyms: 884a4f67738SDoug Rabson 885a4f67738SDoug Rabson *result = lf; 886a4f67738SDoug Rabson 887a4f67738SDoug Rabson out: 888ca65d5c7SPeter Wemm if (error && lf) 88965a311fcSPoul-Henning Kamp linker_file_unload(lf, LINKER_UNLOAD_FORCE); 890ca65d5c7SPeter Wemm if (shdr) 891ca65d5c7SPeter Wemm free(shdr, M_LINKER); 892caab6e90SPeter Wemm if (firstpage) 893caab6e90SPeter Wemm free(firstpage, M_LINKER); 89422db15c0SAttilio Rao VOP_UNLOCK(nd.ni_vp, 0); 895a854ed98SJohn Baldwin vn_close(nd.ni_vp, FREAD, td->td_ucred, td); 89662d615d5SJohn Baldwin VFS_UNLOCK_GIANT(vfslocked); 897a4f67738SDoug Rabson 898a4f67738SDoug Rabson return error; 899a4f67738SDoug Rabson } 900a4f67738SDoug Rabson 901a4f67738SDoug Rabson static void 902de78ca7eSPeter Wemm link_elf_unload_file(linker_file_t file) 903a4f67738SDoug Rabson { 904326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) file; 905a4f67738SDoug Rabson 906ecb01c64SMarcel Moolenaar #ifdef GDB 907326e27d8SDoug Rabson if (ef->gdb.l_ld) { 908326e27d8SDoug Rabson GDB_STATE(RT_DELETE); 909ed6c3888SPeter Wemm free((void *)(uintptr_t)ef->gdb.l_name, M_LINKER); 910326e27d8SDoug Rabson link_elf_delete_gdb(&ef->gdb); 911326e27d8SDoug Rabson GDB_STATE(RT_CONSISTENT); 912326e27d8SDoug Rabson } 913326e27d8SDoug Rabson #endif 914326e27d8SDoug Rabson 9151aeb23cdSMarcel Moolenaar /* Notify MD code that a module is being unloaded. */ 9161aeb23cdSMarcel Moolenaar elf_cpu_unload_file(file); 9171aeb23cdSMarcel Moolenaar 918326e27d8SDoug Rabson if (ef->preloaded) { 91954823af2SPeter Wemm link_elf_unload_preload(file); 920326e27d8SDoug Rabson return; 921326e27d8SDoug Rabson } 922c143d6c2SMarcel Moolenaar 923fe3db7c7SDoug Rabson #ifdef SPARSE_MAPPING 924fe3db7c7SDoug Rabson if (ef->object) { 925fe3db7c7SDoug Rabson vm_map_remove(kernel_map, (vm_offset_t) ef->address, 926fe3db7c7SDoug Rabson (vm_offset_t) ef->address 927fe3db7c7SDoug Rabson + (ef->object->size << PAGE_SHIFT)); 928fe3db7c7SDoug Rabson } 929fe3db7c7SDoug Rabson #else 930ca65d5c7SPeter Wemm if (ef->address) 931a4f67738SDoug Rabson free(ef->address, M_LINKER); 932fe3db7c7SDoug Rabson #endif 933ca65d5c7SPeter Wemm if (ef->symbase) 934ca65d5c7SPeter Wemm free(ef->symbase, M_LINKER); 935ca65d5c7SPeter Wemm if (ef->strbase) 936ca65d5c7SPeter Wemm free(ef->strbase, M_LINKER); 937a2024a3eSJohn Birrell if (ef->ctftab) 938a2024a3eSJohn Birrell free(ef->ctftab, M_LINKER); 939a2024a3eSJohn Birrell if (ef->ctfoff) 940a2024a3eSJohn Birrell free(ef->ctfoff, M_LINKER); 941a2024a3eSJohn Birrell if (ef->typoff) 942a2024a3eSJohn Birrell free(ef->typoff, M_LINKER); 943a4f67738SDoug Rabson } 944a4f67738SDoug Rabson 945de78ca7eSPeter Wemm static void 94654823af2SPeter Wemm link_elf_unload_preload(linker_file_t file) 947de78ca7eSPeter Wemm { 948de78ca7eSPeter Wemm if (file->filename) 949de78ca7eSPeter Wemm preload_delete_name(file->filename); 950de78ca7eSPeter Wemm } 951de78ca7eSPeter Wemm 952fe3db7c7SDoug Rabson static const char * 953757686b1SMarcel Moolenaar symbol_name(elf_file_t ef, Elf_Size r_info) 954a4f67738SDoug Rabson { 955fe3db7c7SDoug Rabson const Elf_Sym *ref; 956a4f67738SDoug Rabson 957aa855a59SPeter Wemm if (ELF_R_SYM(r_info)) { 958aa855a59SPeter Wemm ref = ef->symtab + ELF_R_SYM(r_info); 959434bf653SPeter Wemm return ef->strtab + ref->st_name; 960fe3db7c7SDoug Rabson } else 961fe3db7c7SDoug Rabson return NULL; 962a4f67738SDoug Rabson } 963a4f67738SDoug Rabson 964a4f67738SDoug Rabson static int 965326e27d8SDoug Rabson relocate_file(elf_file_t ef) 966a4f67738SDoug Rabson { 967fe3db7c7SDoug Rabson const Elf_Rel *rellim; 968fe3db7c7SDoug Rabson const Elf_Rel *rel; 969fe3db7c7SDoug Rabson const Elf_Rela *relalim; 970fe3db7c7SDoug Rabson const Elf_Rela *rela; 971aa855a59SPeter Wemm const char *symname; 972a4f67738SDoug Rabson 973fe3db7c7SDoug Rabson /* Perform relocations without addend if there are any: */ 974aa855a59SPeter Wemm rel = ef->rel; 975aa855a59SPeter Wemm if (rel) { 976cacd1f6aSBruce Evans rellim = (const Elf_Rel *)((const char *)ef->rel + ef->relsize); 977aa855a59SPeter Wemm while (rel < rellim) { 978e8855d4fSPeter Wemm if (elf_reloc(&ef->lf, (Elf_Addr)ef->address, rel, ELF_RELOC_REL, 979e8855d4fSPeter Wemm elf_lookup)) { 980aa855a59SPeter Wemm symname = symbol_name(ef, rel->r_info); 981ef83592dSPeter Wemm printf("link_elf: symbol %s undefined\n", symname); 982a4f67738SDoug Rabson return ENOENT; 983a13ddfb6SPeter Wemm } 984aa855a59SPeter Wemm rel++; 985aa855a59SPeter Wemm } 986a4f67738SDoug Rabson } 987a4f67738SDoug Rabson 988fe3db7c7SDoug Rabson /* Perform relocations with addend if there are any: */ 989aa855a59SPeter Wemm rela = ef->rela; 990aa855a59SPeter Wemm if (rela) { 991cacd1f6aSBruce Evans relalim = (const Elf_Rela *)((const char *)ef->rela + ef->relasize); 992aa855a59SPeter Wemm while (rela < relalim) { 993e8855d4fSPeter Wemm if (elf_reloc(&ef->lf, (Elf_Addr)ef->address, rela, ELF_RELOC_RELA, 994e8855d4fSPeter Wemm elf_lookup)) { 995aa855a59SPeter Wemm symname = symbol_name(ef, rela->r_info); 996ef83592dSPeter Wemm printf("link_elf: symbol %s undefined\n", symname); 997fe3db7c7SDoug Rabson return ENOENT; 998a13ddfb6SPeter Wemm } 999aa855a59SPeter Wemm rela++; 1000aa855a59SPeter Wemm } 1001a4f67738SDoug Rabson } 1002a4f67738SDoug Rabson 1003fe3db7c7SDoug Rabson /* Perform PLT relocations without addend if there are any: */ 1004aa855a59SPeter Wemm rel = ef->pltrel; 1005aa855a59SPeter Wemm if (rel) { 1006cacd1f6aSBruce Evans rellim = (const Elf_Rel *)((const char *)ef->pltrel + ef->pltrelsize); 1007aa855a59SPeter Wemm while (rel < rellim) { 1008e8855d4fSPeter Wemm if (elf_reloc(&ef->lf, (Elf_Addr)ef->address, rel, ELF_RELOC_REL, 1009e8855d4fSPeter Wemm elf_lookup)) { 1010aa855a59SPeter Wemm symname = symbol_name(ef, rel->r_info); 1011ef83592dSPeter Wemm printf("link_elf: symbol %s undefined\n", symname); 1012fe3db7c7SDoug Rabson return ENOENT; 1013a13ddfb6SPeter Wemm } 1014aa855a59SPeter Wemm rel++; 1015aa855a59SPeter Wemm } 1016a4f67738SDoug Rabson } 1017a4f67738SDoug Rabson 1018fe3db7c7SDoug Rabson /* Perform relocations with addend if there are any: */ 1019aa855a59SPeter Wemm rela = ef->pltrela; 1020aa855a59SPeter Wemm if (rela) { 1021cacd1f6aSBruce Evans relalim = (const Elf_Rela *)((const char *)ef->pltrela + ef->pltrelasize); 1022aa855a59SPeter Wemm while (rela < relalim) { 1023e8855d4fSPeter Wemm if (elf_reloc(&ef->lf, (Elf_Addr)ef->address, rela, ELF_RELOC_RELA, 1024e8855d4fSPeter Wemm elf_lookup)) { 1025aa855a59SPeter Wemm symname = symbol_name(ef, rela->r_info); 1026ef83592dSPeter Wemm printf("link_elf: symbol %s undefined\n", symname); 1027fe3db7c7SDoug Rabson return ENOENT; 1028a13ddfb6SPeter Wemm } 1029aa855a59SPeter Wemm rela++; 1030aa855a59SPeter Wemm } 1031a4f67738SDoug Rabson } 1032a4f67738SDoug Rabson 1033a4f67738SDoug Rabson return 0; 1034a4f67738SDoug Rabson } 1035a4f67738SDoug Rabson 1036fe3db7c7SDoug Rabson /* 1037fe3db7c7SDoug Rabson * Hash function for symbol table lookup. Don't even think about changing 1038fe3db7c7SDoug Rabson * this. It is specified by the System V ABI. 1039fe3db7c7SDoug Rabson */ 1040fe3db7c7SDoug Rabson static unsigned long 1041fe3db7c7SDoug Rabson elf_hash(const char *name) 1042a4f67738SDoug Rabson { 1043fe3db7c7SDoug Rabson const unsigned char *p = (const unsigned char *) name; 1044fe3db7c7SDoug Rabson unsigned long h = 0; 1045fe3db7c7SDoug Rabson unsigned long g; 1046a4f67738SDoug Rabson 1047fe3db7c7SDoug Rabson while (*p != '\0') { 1048fe3db7c7SDoug Rabson h = (h << 4) + *p++; 1049fe3db7c7SDoug Rabson if ((g = h & 0xf0000000) != 0) 1050fe3db7c7SDoug Rabson h ^= g >> 24; 1051fe3db7c7SDoug Rabson h &= ~g; 1052a4f67738SDoug Rabson } 1053fe3db7c7SDoug Rabson return h; 1054fe3db7c7SDoug Rabson } 1055a4f67738SDoug Rabson 105637c84183SPoul-Henning Kamp static int 1057d254af07SMatthew Dillon link_elf_lookup_symbol(linker_file_t lf, const char* name, c_linker_sym_t* sym) 1058a4f67738SDoug Rabson { 1059326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) lf; 1060fe3db7c7SDoug Rabson unsigned long symnum; 10612d636ab0SPeter Wemm const Elf_Sym* symp; 10622d636ab0SPeter Wemm const char *strp; 1063fe3db7c7SDoug Rabson unsigned long hash; 1064a4f67738SDoug Rabson int i; 1065a4f67738SDoug Rabson 1066f6494f2eSJohn Baldwin /* If we don't have a hash, bail. */ 1067f6494f2eSJohn Baldwin if (ef->buckets == NULL || ef->nbuckets == 0) { 1068f6494f2eSJohn Baldwin printf("link_elf_lookup_symbol: missing symbol hash table\n"); 1069f6494f2eSJohn Baldwin return ENOENT; 1070f6494f2eSJohn Baldwin } 1071f6494f2eSJohn Baldwin 10722d636ab0SPeter Wemm /* First, search hashed global symbols */ 1073fe3db7c7SDoug Rabson hash = elf_hash(name); 1074fe3db7c7SDoug Rabson symnum = ef->buckets[hash % ef->nbuckets]; 1075fe3db7c7SDoug Rabson 1076fe3db7c7SDoug Rabson while (symnum != STN_UNDEF) { 1077fe3db7c7SDoug Rabson if (symnum >= ef->nchains) { 1078fe3db7c7SDoug Rabson printf("link_elf_lookup_symbol: corrupt symbol table\n"); 1079fe3db7c7SDoug Rabson return ENOENT; 1080a4f67738SDoug Rabson } 1081fe3db7c7SDoug Rabson 1082fe3db7c7SDoug Rabson symp = ef->symtab + symnum; 1083fe3db7c7SDoug Rabson if (symp->st_name == 0) { 1084fe3db7c7SDoug Rabson printf("link_elf_lookup_symbol: corrupt symbol table\n"); 1085fe3db7c7SDoug Rabson return ENOENT; 1086fe3db7c7SDoug Rabson } 1087fe3db7c7SDoug Rabson 1088fe3db7c7SDoug Rabson strp = ef->strtab + symp->st_name; 1089fe3db7c7SDoug Rabson 1090fe3db7c7SDoug Rabson if (strcmp(name, strp) == 0) { 1091fe3db7c7SDoug Rabson if (symp->st_shndx != SHN_UNDEF || 1092fe3db7c7SDoug Rabson (symp->st_value != 0 && 1093fe3db7c7SDoug Rabson ELF_ST_TYPE(symp->st_info) == STT_FUNC)) { 1094d254af07SMatthew Dillon *sym = (c_linker_sym_t) symp; 1095fe3db7c7SDoug Rabson return 0; 1096fe3db7c7SDoug Rabson } else 1097fe3db7c7SDoug Rabson return ENOENT; 1098fe3db7c7SDoug Rabson } 1099fe3db7c7SDoug Rabson 1100fe3db7c7SDoug Rabson symnum = ef->chains[symnum]; 1101a4f67738SDoug Rabson } 1102a4f67738SDoug Rabson 11032d636ab0SPeter Wemm /* If we have not found it, look at the full table (if loaded) */ 11042d636ab0SPeter Wemm if (ef->symtab == ef->ddbsymtab) 11052d636ab0SPeter Wemm return ENOENT; 11062d636ab0SPeter Wemm 11072d636ab0SPeter Wemm /* Exhaustive search */ 11082d636ab0SPeter Wemm for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) { 11092d636ab0SPeter Wemm strp = ef->ddbstrtab + symp->st_name; 11102d636ab0SPeter Wemm if (strcmp(name, strp) == 0) { 11112d636ab0SPeter Wemm if (symp->st_shndx != SHN_UNDEF || 11122d636ab0SPeter Wemm (symp->st_value != 0 && 11132d636ab0SPeter Wemm ELF_ST_TYPE(symp->st_info) == STT_FUNC)) { 1114d254af07SMatthew Dillon *sym = (c_linker_sym_t) symp; 11152d636ab0SPeter Wemm return 0; 11162d636ab0SPeter Wemm } else 11172d636ab0SPeter Wemm return ENOENT; 11182d636ab0SPeter Wemm } 11192d636ab0SPeter Wemm } 11202d636ab0SPeter Wemm 1121a4f67738SDoug Rabson return ENOENT; 1122a4f67738SDoug Rabson } 1123a4f67738SDoug Rabson 1124de78ca7eSPeter Wemm static int 1125fe08c21aSMatthew Dillon link_elf_symbol_values(linker_file_t lf, c_linker_sym_t sym, linker_symval_t* symval) 1126a4f67738SDoug Rabson { 1127326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) lf; 11288aef1712SMatthew Dillon const Elf_Sym* es = (const Elf_Sym*) sym; 1129a4f67738SDoug Rabson 11305cf87418SMarcel Moolenaar if (es >= ef->symtab && es < (ef->symtab + ef->nchains)) { 1131a4f67738SDoug Rabson symval->name = ef->strtab + es->st_name; 1132fe3db7c7SDoug Rabson symval->value = (caddr_t) ef->address + es->st_value; 1133a4f67738SDoug Rabson symval->size = es->st_size; 1134de78ca7eSPeter Wemm return 0; 1135a4f67738SDoug Rabson } 11362d636ab0SPeter Wemm if (ef->symtab == ef->ddbsymtab) 11372d636ab0SPeter Wemm return ENOENT; 11385cf87418SMarcel Moolenaar if (es >= ef->ddbsymtab && es < (ef->ddbsymtab + ef->ddbsymcnt)) { 11392d636ab0SPeter Wemm symval->name = ef->ddbstrtab + es->st_name; 11402d636ab0SPeter Wemm symval->value = (caddr_t) ef->address + es->st_value; 11412d636ab0SPeter Wemm symval->size = es->st_size; 11422d636ab0SPeter Wemm return 0; 11432d636ab0SPeter Wemm } 11442d636ab0SPeter Wemm return ENOENT; 11452d636ab0SPeter Wemm } 1146a4f67738SDoug Rabson 1147a4f67738SDoug Rabson static int 1148a4f67738SDoug Rabson link_elf_search_symbol(linker_file_t lf, caddr_t value, 1149d254af07SMatthew Dillon c_linker_sym_t* sym, long* diffp) 1150a4f67738SDoug Rabson { 1151326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) lf; 1152586453feSBruce Evans u_long off = (uintptr_t) (void *) value; 1153a4f67738SDoug Rabson u_long diff = off; 1154586453feSBruce Evans u_long st_value; 1155fe3db7c7SDoug Rabson const Elf_Sym* es; 1156fe3db7c7SDoug Rabson const Elf_Sym* best = 0; 1157a4f67738SDoug Rabson int i; 1158a4f67738SDoug Rabson 11592d636ab0SPeter Wemm for (i = 0, es = ef->ddbsymtab; i < ef->ddbsymcnt; i++, es++) { 1160a4f67738SDoug Rabson if (es->st_name == 0) 1161a4f67738SDoug Rabson continue; 1162586453feSBruce Evans st_value = es->st_value + (uintptr_t) (void *) ef->address; 1163b5abfb70SPeter Wemm if (off >= st_value) { 1164b5abfb70SPeter Wemm if (off - st_value < diff) { 1165b5abfb70SPeter Wemm diff = off - st_value; 1166a4f67738SDoug Rabson best = es; 1167a4f67738SDoug Rabson if (diff == 0) 1168a4f67738SDoug Rabson break; 1169b5abfb70SPeter Wemm } else if (off - st_value == diff) { 1170a4f67738SDoug Rabson best = es; 1171a4f67738SDoug Rabson } 1172a4f67738SDoug Rabson } 1173a4f67738SDoug Rabson } 1174a4f67738SDoug Rabson if (best == 0) 1175a4f67738SDoug Rabson *diffp = off; 1176a4f67738SDoug Rabson else 1177a4f67738SDoug Rabson *diffp = diff; 1178d254af07SMatthew Dillon *sym = (c_linker_sym_t) best; 1179a4f67738SDoug Rabson 1180a4f67738SDoug Rabson return 0; 1181a4f67738SDoug Rabson } 1182f41325dbSPeter Wemm 1183f41325dbSPeter Wemm /* 1184f41325dbSPeter Wemm * Look up a linker set on an ELF system. 1185f41325dbSPeter Wemm */ 1186f41325dbSPeter Wemm static int 1187f41325dbSPeter Wemm link_elf_lookup_set(linker_file_t lf, const char *name, 1188f41325dbSPeter Wemm void ***startp, void ***stopp, int *countp) 1189f41325dbSPeter Wemm { 1190f41325dbSPeter Wemm c_linker_sym_t sym; 1191f41325dbSPeter Wemm linker_symval_t symval; 1192f41325dbSPeter Wemm char *setsym; 1193f41325dbSPeter Wemm void **start, **stop; 1194f41325dbSPeter Wemm int len, error = 0, count; 1195f41325dbSPeter Wemm 1196f41325dbSPeter Wemm len = strlen(name) + sizeof("__start_set_"); /* sizeof includes \0 */ 1197a163d034SWarner Losh setsym = malloc(len, M_LINKER, M_WAITOK); 1198f41325dbSPeter Wemm if (setsym == NULL) 1199f41325dbSPeter Wemm return ENOMEM; 1200f41325dbSPeter Wemm 1201f41325dbSPeter Wemm /* get address of first entry */ 1202f41325dbSPeter Wemm snprintf(setsym, len, "%s%s", "__start_set_", name); 1203f41325dbSPeter Wemm error = link_elf_lookup_symbol(lf, setsym, &sym); 1204f41325dbSPeter Wemm if (error) 1205f41325dbSPeter Wemm goto out; 1206f41325dbSPeter Wemm link_elf_symbol_values(lf, sym, &symval); 1207f41325dbSPeter Wemm if (symval.value == 0) { 1208f41325dbSPeter Wemm error = ESRCH; 1209f41325dbSPeter Wemm goto out; 1210f41325dbSPeter Wemm } 1211f41325dbSPeter Wemm start = (void **)symval.value; 1212f41325dbSPeter Wemm 1213f41325dbSPeter Wemm /* get address of last entry */ 1214f41325dbSPeter Wemm snprintf(setsym, len, "%s%s", "__stop_set_", name); 1215f41325dbSPeter Wemm error = link_elf_lookup_symbol(lf, setsym, &sym); 1216f41325dbSPeter Wemm if (error) 1217f41325dbSPeter Wemm goto out; 1218f41325dbSPeter Wemm link_elf_symbol_values(lf, sym, &symval); 1219f41325dbSPeter Wemm if (symval.value == 0) { 1220f41325dbSPeter Wemm error = ESRCH; 1221f41325dbSPeter Wemm goto out; 1222f41325dbSPeter Wemm } 1223f41325dbSPeter Wemm stop = (void **)symval.value; 1224f41325dbSPeter Wemm 1225f41325dbSPeter Wemm /* and the number of entries */ 1226f41325dbSPeter Wemm count = stop - start; 1227f41325dbSPeter Wemm 1228f41325dbSPeter Wemm /* and copy out */ 1229f41325dbSPeter Wemm if (startp) 1230f41325dbSPeter Wemm *startp = start; 1231f41325dbSPeter Wemm if (stopp) 1232f41325dbSPeter Wemm *stopp = stop; 1233f41325dbSPeter Wemm if (countp) 1234f41325dbSPeter Wemm *countp = count; 1235f41325dbSPeter Wemm 1236f41325dbSPeter Wemm out: 1237f41325dbSPeter Wemm free(setsym, M_LINKER); 1238f41325dbSPeter Wemm return error; 1239f41325dbSPeter Wemm } 1240bb9fe9ddSBrian Feldman 1241bb9fe9ddSBrian Feldman static int 1242bb9fe9ddSBrian Feldman link_elf_each_function_name(linker_file_t file, 1243bb9fe9ddSBrian Feldman int (*callback)(const char *, void *), void *opaque) { 1244bb9fe9ddSBrian Feldman elf_file_t ef = (elf_file_t)file; 1245bb9fe9ddSBrian Feldman const Elf_Sym* symp; 1246bb9fe9ddSBrian Feldman int i, error; 1247bb9fe9ddSBrian Feldman 1248bb9fe9ddSBrian Feldman /* Exhaustive search */ 1249bb9fe9ddSBrian Feldman for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) { 1250bb9fe9ddSBrian Feldman if (symp->st_value != 0 && 1251bb9fe9ddSBrian Feldman ELF_ST_TYPE(symp->st_info) == STT_FUNC) { 1252bb9fe9ddSBrian Feldman error = callback(ef->ddbstrtab + symp->st_name, opaque); 1253bb9fe9ddSBrian Feldman if (error) 1254bb9fe9ddSBrian Feldman return (error); 1255bb9fe9ddSBrian Feldman } 1256bb9fe9ddSBrian Feldman } 1257bb9fe9ddSBrian Feldman return (0); 1258bb9fe9ddSBrian Feldman } 125984201059SMarcel Moolenaar 1260a2024a3eSJohn Birrell static int 1261a2024a3eSJohn Birrell link_elf_each_function_nameval(linker_file_t file, 1262a2024a3eSJohn Birrell linker_function_nameval_callback_t callback, void *opaque) 1263a2024a3eSJohn Birrell { 1264a2024a3eSJohn Birrell linker_symval_t symval; 1265a2024a3eSJohn Birrell elf_file_t ef = (elf_file_t)file; 1266a2024a3eSJohn Birrell const Elf_Sym* symp; 1267a2024a3eSJohn Birrell int i, error; 1268a2024a3eSJohn Birrell 1269a2024a3eSJohn Birrell /* Exhaustive search */ 1270a2024a3eSJohn Birrell for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) { 1271a2024a3eSJohn Birrell if (symp->st_value != 0 && 1272a2024a3eSJohn Birrell ELF_ST_TYPE(symp->st_info) == STT_FUNC) { 1273a2024a3eSJohn Birrell error = link_elf_symbol_values(file, (c_linker_sym_t) symp, &symval); 1274a2024a3eSJohn Birrell if (error) 1275a2024a3eSJohn Birrell return (error); 1276a2024a3eSJohn Birrell error = callback(file, i, &symval, opaque); 1277a2024a3eSJohn Birrell if (error) 1278a2024a3eSJohn Birrell return (error); 1279a2024a3eSJohn Birrell } 1280a2024a3eSJohn Birrell } 1281a2024a3eSJohn Birrell return (0); 1282a2024a3eSJohn Birrell } 1283a2024a3eSJohn Birrell 128484201059SMarcel Moolenaar #ifdef __ia64__ 128584201059SMarcel Moolenaar /* 128684201059SMarcel Moolenaar * Each KLD has its own GP. The GP value for each load module is given by 128784201059SMarcel Moolenaar * DT_PLTGOT on ia64. We need GP to construct function descriptors, but 128884201059SMarcel Moolenaar * don't have direct access to the ELF file structure. The link_elf_get_gp() 128984201059SMarcel Moolenaar * function returns the GP given a pointer to a generic linker file struct. 129084201059SMarcel Moolenaar */ 129184201059SMarcel Moolenaar Elf_Addr 129284201059SMarcel Moolenaar link_elf_get_gp(linker_file_t lf) 129384201059SMarcel Moolenaar { 129484201059SMarcel Moolenaar elf_file_t ef = (elf_file_t)lf; 129584201059SMarcel Moolenaar return (Elf_Addr)ef->got; 129684201059SMarcel Moolenaar } 129784201059SMarcel Moolenaar #endif 1298d297ad16SMarcel Moolenaar 1299169d513cSJake Burkholder const Elf_Sym * 1300757686b1SMarcel Moolenaar elf_get_sym(linker_file_t lf, Elf_Size symidx) 1301169d513cSJake Burkholder { 1302169d513cSJake Burkholder elf_file_t ef = (elf_file_t)lf; 1303169d513cSJake Burkholder 1304169d513cSJake Burkholder if (symidx >= ef->nchains) 1305169d513cSJake Burkholder return (NULL); 1306169d513cSJake Burkholder return (ef->symtab + symidx); 1307169d513cSJake Burkholder } 1308169d513cSJake Burkholder 130947f75012SMarcel Moolenaar const char * 1310757686b1SMarcel Moolenaar elf_get_symname(linker_file_t lf, Elf_Size symidx) 131147f75012SMarcel Moolenaar { 131247f75012SMarcel Moolenaar elf_file_t ef = (elf_file_t)lf; 131347f75012SMarcel Moolenaar const Elf_Sym *sym; 131447f75012SMarcel Moolenaar 131547f75012SMarcel Moolenaar if (symidx >= ef->nchains) 131647f75012SMarcel Moolenaar return (NULL); 131747f75012SMarcel Moolenaar sym = ef->symtab + symidx; 131847f75012SMarcel Moolenaar return (ef->strtab + sym->st_name); 131947f75012SMarcel Moolenaar } 132047f75012SMarcel Moolenaar 1321d297ad16SMarcel Moolenaar /* 1322d297ad16SMarcel Moolenaar * Symbol lookup function that can be used when the symbol index is known (ie 1323d297ad16SMarcel Moolenaar * in relocations). It uses the symbol index instead of doing a fully fledged 1324d297ad16SMarcel Moolenaar * hash table based lookup when such is valid. For example for local symbols. 1325d297ad16SMarcel Moolenaar * This is not only more efficient, it's also more correct. It's not always 1326d297ad16SMarcel Moolenaar * the case that the symbol can be found through the hash table. 1327d297ad16SMarcel Moolenaar */ 1328e8855d4fSPeter Wemm static Elf_Addr 1329757686b1SMarcel Moolenaar elf_lookup(linker_file_t lf, Elf_Size symidx, int deps) 1330d297ad16SMarcel Moolenaar { 1331d297ad16SMarcel Moolenaar elf_file_t ef = (elf_file_t)lf; 1332d297ad16SMarcel Moolenaar const Elf_Sym *sym; 1333d297ad16SMarcel Moolenaar const char *symbol; 1334d297ad16SMarcel Moolenaar 1335d297ad16SMarcel Moolenaar /* Don't even try to lookup the symbol if the index is bogus. */ 1336d297ad16SMarcel Moolenaar if (symidx >= ef->nchains) 1337d297ad16SMarcel Moolenaar return (0); 1338d297ad16SMarcel Moolenaar 1339d297ad16SMarcel Moolenaar sym = ef->symtab + symidx; 1340d297ad16SMarcel Moolenaar 1341d297ad16SMarcel Moolenaar /* 1342d297ad16SMarcel Moolenaar * Don't do a full lookup when the symbol is local. It may even 1343d297ad16SMarcel Moolenaar * fail because it may not be found through the hash table. 1344d297ad16SMarcel Moolenaar */ 1345d297ad16SMarcel Moolenaar if (ELF_ST_BIND(sym->st_info) == STB_LOCAL) { 1346d297ad16SMarcel Moolenaar /* Force lookup failure when we have an insanity. */ 1347d297ad16SMarcel Moolenaar if (sym->st_shndx == SHN_UNDEF || sym->st_value == 0) 1348d297ad16SMarcel Moolenaar return (0); 1349d297ad16SMarcel Moolenaar return ((Elf_Addr)ef->address + sym->st_value); 1350d297ad16SMarcel Moolenaar } 1351d297ad16SMarcel Moolenaar 1352d297ad16SMarcel Moolenaar /* 1353d297ad16SMarcel Moolenaar * XXX we can avoid doing a hash table based lookup for global 1354d297ad16SMarcel Moolenaar * symbols as well. This however is not always valid, so we'll 1355d297ad16SMarcel Moolenaar * just do it the hard way for now. Performance tweaks can 1356d297ad16SMarcel Moolenaar * always be added. 1357d297ad16SMarcel Moolenaar */ 1358d297ad16SMarcel Moolenaar 1359d297ad16SMarcel Moolenaar symbol = ef->strtab + sym->st_name; 1360d297ad16SMarcel Moolenaar 1361d297ad16SMarcel Moolenaar /* Force a lookup failure if the symbol name is bogus. */ 1362d297ad16SMarcel Moolenaar if (*symbol == 0) 1363d297ad16SMarcel Moolenaar return (0); 1364d297ad16SMarcel Moolenaar 1365d297ad16SMarcel Moolenaar return ((Elf_Addr)linker_file_lookup_symbol(lf, symbol, deps)); 1366d297ad16SMarcel Moolenaar } 13677251b4bfSJake Burkholder 13687251b4bfSJake Burkholder static void 13697251b4bfSJake Burkholder link_elf_reloc_local(linker_file_t lf) 13707251b4bfSJake Burkholder { 13717251b4bfSJake Burkholder const Elf_Rel *rellim; 13727251b4bfSJake Burkholder const Elf_Rel *rel; 13737251b4bfSJake Burkholder const Elf_Rela *relalim; 13747251b4bfSJake Burkholder const Elf_Rela *rela; 13757251b4bfSJake Burkholder elf_file_t ef = (elf_file_t)lf; 13767251b4bfSJake Burkholder 13777251b4bfSJake Burkholder /* Perform relocations without addend if there are any: */ 13787251b4bfSJake Burkholder if ((rel = ef->rel) != NULL) { 13797251b4bfSJake Burkholder rellim = (const Elf_Rel *)((const char *)ef->rel + ef->relsize); 13807251b4bfSJake Burkholder while (rel < rellim) { 1381e8855d4fSPeter Wemm elf_reloc_local(lf, (Elf_Addr)ef->address, rel, ELF_RELOC_REL, 1382e8855d4fSPeter Wemm elf_lookup); 13837251b4bfSJake Burkholder rel++; 13847251b4bfSJake Burkholder } 13857251b4bfSJake Burkholder } 13867251b4bfSJake Burkholder 13877251b4bfSJake Burkholder /* Perform relocations with addend if there are any: */ 13887251b4bfSJake Burkholder if ((rela = ef->rela) != NULL) { 13897251b4bfSJake Burkholder relalim = (const Elf_Rela *)((const char *)ef->rela + ef->relasize); 13907251b4bfSJake Burkholder while (rela < relalim) { 1391e8855d4fSPeter Wemm elf_reloc_local(lf, (Elf_Addr)ef->address, rela, ELF_RELOC_RELA, 1392e8855d4fSPeter Wemm elf_lookup); 13937251b4bfSJake Burkholder rela++; 13947251b4bfSJake Burkholder } 13957251b4bfSJake Burkholder } 13967251b4bfSJake Burkholder } 139700a5db46SStacey Son 139800a5db46SStacey Son static long 139900a5db46SStacey Son link_elf_symtab_get(linker_file_t lf, const Elf_Sym **symtab) 140000a5db46SStacey Son { 140100a5db46SStacey Son elf_file_t ef = (elf_file_t)lf; 140200a5db46SStacey Son 140300a5db46SStacey Son *symtab = ef->ddbsymtab; 140400a5db46SStacey Son 140500a5db46SStacey Son if (*symtab == NULL) 140600a5db46SStacey Son return (0); 140700a5db46SStacey Son 140800a5db46SStacey Son return (ef->ddbsymcnt); 140900a5db46SStacey Son } 141000a5db46SStacey Son 141100a5db46SStacey Son static long 141200a5db46SStacey Son link_elf_strtab_get(linker_file_t lf, caddr_t *strtab) 141300a5db46SStacey Son { 141400a5db46SStacey Son elf_file_t ef = (elf_file_t)lf; 141500a5db46SStacey Son 141600a5db46SStacey Son *strtab = ef->ddbstrtab; 141700a5db46SStacey Son 141800a5db46SStacey Son if (*strtab == NULL) 141900a5db46SStacey Son return (0); 142000a5db46SStacey Son 142100a5db46SStacey Son return (ef->ddbstrcnt); 142200a5db46SStacey Son } 1423