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 * 26c3aac50fSPeter Wemm * $FreeBSD$ 27a4f67738SDoug Rabson */ 28a4f67738SDoug Rabson 29326e27d8SDoug Rabson #include "opt_ddb.h" 30a3df768bSRobert Watson #include "opt_mac.h" 31326e27d8SDoug Rabson 32a4f67738SDoug Rabson #include <sys/param.h> 33a4f67738SDoug Rabson #include <sys/systm.h> 34fb919e4dSMark Murray #include <sys/kernel.h> 35fb919e4dSMark Murray #include <sys/lock.h> 36a3df768bSRobert Watson #include <sys/mac.h> 37a4f67738SDoug Rabson #include <sys/malloc.h> 38c0b824f9SDima Dorfman #include <sys/mutex.h> 39a4f67738SDoug Rabson #include <sys/proc.h> 40a4f67738SDoug Rabson #include <sys/namei.h> 41a4f67738SDoug Rabson #include <sys/fcntl.h> 42a4f67738SDoug Rabson #include <sys/vnode.h> 43a4f67738SDoug Rabson #include <sys/linker.h> 44fb919e4dSMark Murray 45a4f67738SDoug Rabson #include <machine/elf.h> 4608d68ddaSBrian Feldman #ifdef GPROF 4708d68ddaSBrian Feldman #include <machine/profile.h> 4808d68ddaSBrian Feldman #endif 49a4f67738SDoug Rabson 50fe3db7c7SDoug Rabson #include <vm/vm.h> 51fe3db7c7SDoug Rabson #include <vm/vm_param.h> 52d1f088daSPeter Wemm #ifdef SPARSE_MAPPING 53fe3db7c7SDoug Rabson #include <vm/vm_object.h> 54fe3db7c7SDoug Rabson #include <vm/vm_kern.h> 55fe3db7c7SDoug Rabson #include <vm/vm_extern.h> 56d1f088daSPeter Wemm #endif 57fe3db7c7SDoug Rabson #include <vm/pmap.h> 58fe3db7c7SDoug Rabson #include <vm/vm_map.h> 59fb919e4dSMark Murray 60f9980387SPeter Wemm #include <sys/link_elf.h> 61fe3db7c7SDoug Rabson 62326e27d8SDoug Rabson #include "linker_if.h" 63a4f67738SDoug Rabson 64a4f67738SDoug Rabson typedef struct elf_file { 65326e27d8SDoug Rabson struct linker_file lf; /* Common fields */ 66326e27d8SDoug Rabson int preloaded; /* Was file pre-loaded */ 67fe3db7c7SDoug Rabson caddr_t address; /* Relocation address */ 68fe3db7c7SDoug Rabson #ifdef SPARSE_MAPPING 69fe3db7c7SDoug Rabson vm_object_t object; /* VM object to hold file pages */ 70fe3db7c7SDoug Rabson #endif 71326e27d8SDoug Rabson Elf_Dyn* dynamic; /* Symbol table etc. */ 727e510298SJake Burkholder Elf_Hashelt nbuckets; /* DT_HASH info */ 737e510298SJake Burkholder Elf_Hashelt nchains; 747e510298SJake Burkholder const Elf_Hashelt* buckets; 757e510298SJake Burkholder const Elf_Hashelt* chains; 76a4f67738SDoug Rabson caddr_t hash; 77a4f67738SDoug Rabson caddr_t strtab; /* DT_STRTAB */ 782d636ab0SPeter Wemm int strsz; /* DT_STRSZ */ 79fe3db7c7SDoug Rabson const Elf_Sym* symtab; /* DT_SYMTAB */ 80fe3db7c7SDoug Rabson Elf_Addr* got; /* DT_PLTGOT */ 81fe3db7c7SDoug Rabson const Elf_Rel* pltrel; /* DT_JMPREL */ 82fe3db7c7SDoug Rabson int pltrelsize; /* DT_PLTRELSZ */ 83fe3db7c7SDoug Rabson const Elf_Rela* pltrela; /* DT_JMPREL */ 84fe3db7c7SDoug Rabson int pltrelasize; /* DT_PLTRELSZ */ 85fe3db7c7SDoug Rabson const Elf_Rel* rel; /* DT_REL */ 86fe3db7c7SDoug Rabson int relsize; /* DT_RELSZ */ 87fe3db7c7SDoug Rabson const Elf_Rela* rela; /* DT_RELA */ 88fe3db7c7SDoug Rabson int relasize; /* DT_RELASZ */ 892d636ab0SPeter Wemm caddr_t modptr; 902d636ab0SPeter Wemm const Elf_Sym* ddbsymtab; /* The symbol table we are using */ 912d636ab0SPeter Wemm long ddbsymcnt; /* Number of symbols */ 922d636ab0SPeter Wemm caddr_t ddbstrtab; /* String table */ 932d636ab0SPeter Wemm long ddbstrcnt; /* number of bytes in string table */ 94ca65d5c7SPeter Wemm caddr_t symbase; /* malloc'ed symbold base */ 95ca65d5c7SPeter Wemm caddr_t strbase; /* malloc'ed string base */ 96326e27d8SDoug Rabson #ifdef DDB 97326e27d8SDoug Rabson struct link_map gdb; /* hooks for gdb */ 98326e27d8SDoug Rabson #endif 99a4f67738SDoug Rabson } *elf_file_t; 100a4f67738SDoug Rabson 101c143d6c2SMarcel Moolenaar static int link_elf_link_common_finish(linker_file_t); 10254823af2SPeter Wemm static int link_elf_link_preload(linker_class_t cls, 103326e27d8SDoug Rabson const char*, linker_file_t*); 10454823af2SPeter Wemm static int link_elf_link_preload_finish(linker_file_t); 10554823af2SPeter Wemm static int link_elf_load_file(linker_class_t, const char*, linker_file_t*); 106326e27d8SDoug Rabson static int link_elf_lookup_symbol(linker_file_t, const char*, 107326e27d8SDoug Rabson c_linker_sym_t*); 108326e27d8SDoug Rabson static int link_elf_symbol_values(linker_file_t, c_linker_sym_t, linker_symval_t*); 109326e27d8SDoug Rabson static int link_elf_search_symbol(linker_file_t, caddr_t value, 110326e27d8SDoug Rabson c_linker_sym_t* sym, long* diffp); 111326e27d8SDoug Rabson 112326e27d8SDoug Rabson static void link_elf_unload_file(linker_file_t); 11354823af2SPeter Wemm static void link_elf_unload_preload(linker_file_t); 114f41325dbSPeter Wemm static int link_elf_lookup_set(linker_file_t, const char *, 115f41325dbSPeter Wemm void ***, void ***, int *); 116bb9fe9ddSBrian Feldman static int link_elf_each_function_name(linker_file_t, 117bb9fe9ddSBrian Feldman int (*)(const char *, void *), 118bb9fe9ddSBrian Feldman void *); 1197251b4bfSJake Burkholder static void link_elf_reloc_local(linker_file_t); 120326e27d8SDoug Rabson 121326e27d8SDoug Rabson static kobj_method_t link_elf_methods[] = { 122326e27d8SDoug Rabson KOBJMETHOD(linker_lookup_symbol, link_elf_lookup_symbol), 123326e27d8SDoug Rabson KOBJMETHOD(linker_symbol_values, link_elf_symbol_values), 124326e27d8SDoug Rabson KOBJMETHOD(linker_search_symbol, link_elf_search_symbol), 125326e27d8SDoug Rabson KOBJMETHOD(linker_unload, link_elf_unload_file), 12654823af2SPeter Wemm KOBJMETHOD(linker_load_file, link_elf_load_file), 12754823af2SPeter Wemm KOBJMETHOD(linker_link_preload, link_elf_link_preload), 12854823af2SPeter Wemm KOBJMETHOD(linker_link_preload_finish, link_elf_link_preload_finish), 129f41325dbSPeter Wemm KOBJMETHOD(linker_lookup_set, link_elf_lookup_set), 130bb9fe9ddSBrian Feldman KOBJMETHOD(linker_each_function_name, link_elf_each_function_name), 131326e27d8SDoug Rabson { 0, 0 } 132326e27d8SDoug Rabson }; 133326e27d8SDoug Rabson 134326e27d8SDoug Rabson static struct linker_class link_elf_class = { 135326e27d8SDoug Rabson #if ELF_TARG_CLASS == ELFCLASS32 136326e27d8SDoug Rabson "elf32", 137326e27d8SDoug Rabson #else 138326e27d8SDoug Rabson "elf64", 139326e27d8SDoug Rabson #endif 140326e27d8SDoug Rabson link_elf_methods, sizeof(struct elf_file) 141326e27d8SDoug Rabson }; 142326e27d8SDoug Rabson 143326e27d8SDoug Rabson static int parse_dynamic(elf_file_t ef); 144326e27d8SDoug Rabson static int relocate_file(elf_file_t ef); 14554823af2SPeter Wemm static int link_elf_preload_parse_symbols(elf_file_t ef); 146326e27d8SDoug Rabson 147326e27d8SDoug Rabson #ifdef DDB 148ca29467eSJohn Baldwin static void r_debug_state(struct r_debug *dummy_one, 149ca29467eSJohn Baldwin struct link_map *dummy_two); 150326e27d8SDoug Rabson 151326e27d8SDoug Rabson /* 152326e27d8SDoug Rabson * A list of loaded modules for GDB to use for loading symbols. 153326e27d8SDoug Rabson */ 154326e27d8SDoug Rabson struct r_debug r_debug; 155326e27d8SDoug Rabson 156ca29467eSJohn Baldwin #define GDB_STATE(s) r_debug.r_state = s; r_debug_state(NULL, NULL); 157326e27d8SDoug Rabson 158326e27d8SDoug Rabson /* 159326e27d8SDoug Rabson * Function for the debugger to set a breakpoint on to gain control. 160326e27d8SDoug Rabson */ 16137c84183SPoul-Henning Kamp static void 162ca29467eSJohn Baldwin r_debug_state(struct r_debug *dummy_one __unused, 163ca29467eSJohn Baldwin struct link_map *dummy_two __unused) 164326e27d8SDoug Rabson { 165326e27d8SDoug Rabson } 166326e27d8SDoug Rabson 1671720979bSMarcel Moolenaar static void 1681720979bSMarcel Moolenaar link_elf_add_gdb(struct link_map *l) 1691720979bSMarcel Moolenaar { 1701720979bSMarcel Moolenaar struct link_map *prev; 1711720979bSMarcel Moolenaar 172c143d6c2SMarcel Moolenaar l->l_next = NULL; 173c143d6c2SMarcel Moolenaar 174c143d6c2SMarcel Moolenaar if (r_debug.r_map == NULL) { 175c143d6c2SMarcel Moolenaar /* Add first. */ 176c143d6c2SMarcel Moolenaar l->l_prev = NULL; 177c143d6c2SMarcel Moolenaar r_debug.r_map = l; 178c143d6c2SMarcel Moolenaar } else { 179c143d6c2SMarcel Moolenaar /* Append to list. */ 1801720979bSMarcel Moolenaar for (prev = r_debug.r_map; prev->l_next != NULL; prev = prev->l_next) 1811720979bSMarcel Moolenaar ; 1821720979bSMarcel Moolenaar l->l_prev = prev; 1831720979bSMarcel Moolenaar prev->l_next = l; 1841720979bSMarcel Moolenaar } 185c143d6c2SMarcel Moolenaar } 1861720979bSMarcel Moolenaar 1871720979bSMarcel Moolenaar static void 1881720979bSMarcel Moolenaar link_elf_delete_gdb(struct link_map *l) 1891720979bSMarcel Moolenaar { 1901720979bSMarcel Moolenaar if (l->l_prev == NULL) { 191c143d6c2SMarcel Moolenaar /* Remove first. */ 1921720979bSMarcel Moolenaar if ((r_debug.r_map = l->l_next) != NULL) 1931720979bSMarcel Moolenaar l->l_next->l_prev = NULL; 194c143d6c2SMarcel Moolenaar } else { 195c143d6c2SMarcel Moolenaar /* Remove any but first. */ 1961720979bSMarcel Moolenaar if ((l->l_prev->l_next = l->l_next) != NULL) 1971720979bSMarcel Moolenaar l->l_next->l_prev = l->l_prev; 1981720979bSMarcel Moolenaar } 199c143d6c2SMarcel Moolenaar } 2001720979bSMarcel Moolenaar #endif /* DDB */ 201a4f67738SDoug Rabson 20284201059SMarcel Moolenaar #ifdef __ia64__ 20384201059SMarcel Moolenaar Elf_Addr link_elf_get_gp(linker_file_t); 20484201059SMarcel Moolenaar #endif 20584201059SMarcel Moolenaar 206a4f67738SDoug Rabson /* 207a4f67738SDoug Rabson * The kernel symbol table starts here. 208a4f67738SDoug Rabson */ 209a4f67738SDoug Rabson extern struct _dynamic _DYNAMIC; 210a4f67738SDoug Rabson 211a4f67738SDoug Rabson static void 2121720979bSMarcel Moolenaar link_elf_error(const char *s) 2131720979bSMarcel Moolenaar { 2141720979bSMarcel Moolenaar printf("kldload: %s\n", s); 2151720979bSMarcel Moolenaar } 2161720979bSMarcel Moolenaar 217c143d6c2SMarcel Moolenaar /* 218c143d6c2SMarcel Moolenaar * Actions performed after linking/loading both the preloaded kernel and any 219c143d6c2SMarcel Moolenaar * modules; whether preloaded or dynamicly loaded. 220c143d6c2SMarcel Moolenaar */ 221c143d6c2SMarcel Moolenaar static int 222c143d6c2SMarcel Moolenaar link_elf_link_common_finish(linker_file_t lf) 223c143d6c2SMarcel Moolenaar { 224c143d6c2SMarcel Moolenaar #ifdef DDB 225c143d6c2SMarcel Moolenaar elf_file_t ef = (elf_file_t)lf; 226c143d6c2SMarcel Moolenaar char *newfilename; 227c143d6c2SMarcel Moolenaar #endif 2281aeb23cdSMarcel Moolenaar int error; 2291aeb23cdSMarcel Moolenaar 2301aeb23cdSMarcel Moolenaar /* Notify MD code that a module is being loaded. */ 2311aeb23cdSMarcel Moolenaar error = elf_cpu_load_file(lf); 2321aeb23cdSMarcel Moolenaar if (error) 2331aeb23cdSMarcel Moolenaar return (error); 234c143d6c2SMarcel Moolenaar 235c143d6c2SMarcel Moolenaar #ifdef DDB 236c143d6c2SMarcel Moolenaar GDB_STATE(RT_ADD); 237c143d6c2SMarcel Moolenaar ef->gdb.l_addr = lf->address; 238c143d6c2SMarcel Moolenaar newfilename = malloc(strlen(lf->filename) + 1, M_LINKER, M_WAITOK); 239c143d6c2SMarcel Moolenaar strcpy(newfilename, lf->filename); 240c143d6c2SMarcel Moolenaar ef->gdb.l_name = newfilename; 241c143d6c2SMarcel Moolenaar ef->gdb.l_ld = ef->dynamic; 242c143d6c2SMarcel Moolenaar link_elf_add_gdb(&ef->gdb); 243c143d6c2SMarcel Moolenaar GDB_STATE(RT_CONSISTENT); 244c143d6c2SMarcel Moolenaar #endif 245c143d6c2SMarcel Moolenaar 246c143d6c2SMarcel Moolenaar return (0); 247c143d6c2SMarcel Moolenaar } 248c143d6c2SMarcel Moolenaar 2491720979bSMarcel Moolenaar static void 250a4f67738SDoug Rabson link_elf_init(void* arg) 251a4f67738SDoug Rabson { 252de78ca7eSPeter Wemm Elf_Dyn *dp; 253de78ca7eSPeter Wemm caddr_t modptr, baseptr, sizeptr; 254de78ca7eSPeter Wemm elf_file_t ef; 255de78ca7eSPeter Wemm char *modname; 256a4f67738SDoug Rabson 257326e27d8SDoug Rabson linker_add_class(&link_elf_class); 258a4f67738SDoug Rabson 259de78ca7eSPeter Wemm dp = (Elf_Dyn*) &_DYNAMIC; 260de78ca7eSPeter Wemm modname = NULL; 261de78ca7eSPeter Wemm modptr = preload_search_by_type("elf kernel"); 262de78ca7eSPeter Wemm if (modptr) 263de78ca7eSPeter Wemm modname = (char *)preload_search_info(modptr, MODINFO_NAME); 264de78ca7eSPeter Wemm if (modname == NULL) 265de78ca7eSPeter Wemm modname = "kernel"; 266326e27d8SDoug Rabson linker_kernel_file = linker_make_file(modname, &link_elf_class); 267a4f67738SDoug Rabson if (linker_kernel_file == NULL) 268a4f67738SDoug Rabson panic("link_elf_init: Can't create linker structures for kernel"); 269326e27d8SDoug Rabson 270326e27d8SDoug Rabson ef = (elf_file_t) linker_kernel_file; 27154823af2SPeter Wemm ef->preloaded = 1; 272326e27d8SDoug Rabson ef->address = 0; 273326e27d8SDoug Rabson #ifdef SPARSE_MAPPING 274326e27d8SDoug Rabson ef->object = 0; 275326e27d8SDoug Rabson #endif 276326e27d8SDoug Rabson ef->dynamic = dp; 277326e27d8SDoug Rabson 27800dda5e8SPeter Wemm if (dp) 279326e27d8SDoug Rabson parse_dynamic(ef); 2804173e420SPeter Wemm linker_kernel_file->address = (caddr_t) KERNBASE; 281d009ccfaSBruce Evans linker_kernel_file->size = -(intptr_t)linker_kernel_file->address; 282de78ca7eSPeter Wemm 283de78ca7eSPeter Wemm if (modptr) { 2842d636ab0SPeter Wemm ef->modptr = modptr; 285de78ca7eSPeter Wemm baseptr = preload_search_info(modptr, MODINFO_ADDR); 286de78ca7eSPeter Wemm if (baseptr) 287de78ca7eSPeter Wemm linker_kernel_file->address = *(caddr_t *)baseptr; 288de78ca7eSPeter Wemm sizeptr = preload_search_info(modptr, MODINFO_SIZE); 289de78ca7eSPeter Wemm if (sizeptr) 290de78ca7eSPeter Wemm linker_kernel_file->size = *(size_t *)sizeptr; 291de78ca7eSPeter Wemm } 29254823af2SPeter Wemm (void)link_elf_preload_parse_symbols(ef); 293326e27d8SDoug Rabson 294326e27d8SDoug Rabson #ifdef DDB 295c143d6c2SMarcel Moolenaar r_debug.r_map = NULL; 296326e27d8SDoug Rabson r_debug.r_brk = r_debug_state; 297326e27d8SDoug Rabson r_debug.r_state = RT_CONSISTENT; 298326e27d8SDoug Rabson #endif 299c143d6c2SMarcel Moolenaar 300c143d6c2SMarcel Moolenaar (void)link_elf_link_common_finish(linker_kernel_file); 301a4f67738SDoug Rabson } 302a4f67738SDoug Rabson 303de78ca7eSPeter Wemm SYSINIT(link_elf, SI_SUB_KLD, SI_ORDER_SECOND, link_elf_init, 0); 304a4f67738SDoug Rabson 305a4f67738SDoug Rabson static int 30654823af2SPeter Wemm link_elf_preload_parse_symbols(elf_file_t ef) 3072d636ab0SPeter Wemm { 3082d636ab0SPeter Wemm caddr_t pointer; 3092d636ab0SPeter Wemm caddr_t ssym, esym, base; 3102d636ab0SPeter Wemm caddr_t strtab; 3112d636ab0SPeter Wemm int strcnt; 3122d636ab0SPeter Wemm Elf_Sym* symtab; 3132d636ab0SPeter Wemm int symcnt; 3142d636ab0SPeter Wemm 315ca65d5c7SPeter Wemm if (ef->modptr == NULL) 316ca65d5c7SPeter Wemm return 0; 3172d636ab0SPeter Wemm pointer = preload_search_info(ef->modptr, MODINFO_METADATA|MODINFOMD_SSYM); 3182d636ab0SPeter Wemm if (pointer == NULL) 3192d636ab0SPeter Wemm return 0; 3202d636ab0SPeter Wemm ssym = *(caddr_t *)pointer; 3212d636ab0SPeter Wemm pointer = preload_search_info(ef->modptr, MODINFO_METADATA|MODINFOMD_ESYM); 3222d636ab0SPeter Wemm if (pointer == NULL) 3232d636ab0SPeter Wemm return 0; 3242d636ab0SPeter Wemm esym = *(caddr_t *)pointer; 3252d636ab0SPeter Wemm 3262d636ab0SPeter Wemm base = ssym; 3272d636ab0SPeter Wemm 3282d636ab0SPeter Wemm symcnt = *(long *)base; 3292d636ab0SPeter Wemm base += sizeof(long); 3302d636ab0SPeter Wemm symtab = (Elf_Sym *)base; 3312d636ab0SPeter Wemm base += roundup(symcnt, sizeof(long)); 3322d636ab0SPeter Wemm 3332d636ab0SPeter Wemm if (base > esym || base < ssym) { 3342d636ab0SPeter Wemm printf("Symbols are corrupt!\n"); 3352d636ab0SPeter Wemm return EINVAL; 3362d636ab0SPeter Wemm } 3372d636ab0SPeter Wemm 3382d636ab0SPeter Wemm strcnt = *(long *)base; 3392d636ab0SPeter Wemm base += sizeof(long); 3402d636ab0SPeter Wemm strtab = base; 3412d636ab0SPeter Wemm base += roundup(strcnt, sizeof(long)); 3422d636ab0SPeter Wemm 3432d636ab0SPeter Wemm if (base > esym || base < ssym) { 3442d636ab0SPeter Wemm printf("Symbols are corrupt!\n"); 3452d636ab0SPeter Wemm return EINVAL; 3462d636ab0SPeter Wemm } 3472d636ab0SPeter Wemm 3482d636ab0SPeter Wemm ef->ddbsymtab = symtab; 3492d636ab0SPeter Wemm ef->ddbsymcnt = symcnt / sizeof(Elf_Sym); 3502d636ab0SPeter Wemm ef->ddbstrtab = strtab; 3512d636ab0SPeter Wemm ef->ddbstrcnt = strcnt; 3522d636ab0SPeter Wemm 3532d636ab0SPeter Wemm return 0; 3542d636ab0SPeter Wemm } 3552d636ab0SPeter Wemm 3562d636ab0SPeter Wemm static int 357326e27d8SDoug Rabson parse_dynamic(elf_file_t ef) 358a4f67738SDoug Rabson { 359326e27d8SDoug Rabson Elf_Dyn *dp; 360fe3db7c7SDoug Rabson int plttype = DT_REL; 361a4f67738SDoug Rabson 362a4f67738SDoug Rabson for (dp = ef->dynamic; dp->d_tag != DT_NULL; dp++) { 363a4f67738SDoug Rabson switch (dp->d_tag) { 364a4f67738SDoug Rabson case DT_HASH: 365a4f67738SDoug Rabson { 366a4f67738SDoug Rabson /* From src/libexec/rtld-elf/rtld.c */ 3677e510298SJake Burkholder const Elf_Hashelt *hashtab = (const Elf_Hashelt *) 368a4f67738SDoug Rabson (ef->address + dp->d_un.d_ptr); 369a4f67738SDoug Rabson ef->nbuckets = hashtab[0]; 370a4f67738SDoug Rabson ef->nchains = hashtab[1]; 371a4f67738SDoug Rabson ef->buckets = hashtab + 2; 372a4f67738SDoug Rabson ef->chains = ef->buckets + ef->nbuckets; 373a4f67738SDoug Rabson break; 374a4f67738SDoug Rabson } 375a4f67738SDoug Rabson case DT_STRTAB: 376fe3db7c7SDoug Rabson ef->strtab = (caddr_t) (ef->address + dp->d_un.d_ptr); 377a4f67738SDoug Rabson break; 3782d636ab0SPeter Wemm case DT_STRSZ: 3792d636ab0SPeter Wemm ef->strsz = dp->d_un.d_val; 3802d636ab0SPeter Wemm break; 381a4f67738SDoug Rabson case DT_SYMTAB: 382fe3db7c7SDoug Rabson ef->symtab = (Elf_Sym*) (ef->address + dp->d_un.d_ptr); 383a4f67738SDoug Rabson break; 384a4f67738SDoug Rabson case DT_SYMENT: 385a4f67738SDoug Rabson if (dp->d_un.d_val != sizeof(Elf_Sym)) 386a4f67738SDoug Rabson return ENOEXEC; 387fe3db7c7SDoug Rabson break; 388fe3db7c7SDoug Rabson case DT_PLTGOT: 389fe3db7c7SDoug Rabson ef->got = (Elf_Addr *) (ef->address + dp->d_un.d_ptr); 390fe3db7c7SDoug Rabson break; 391fe3db7c7SDoug Rabson case DT_REL: 392fe3db7c7SDoug Rabson ef->rel = (const Elf_Rel *) (ef->address + dp->d_un.d_ptr); 393fe3db7c7SDoug Rabson break; 394fe3db7c7SDoug Rabson case DT_RELSZ: 395fe3db7c7SDoug Rabson ef->relsize = dp->d_un.d_val; 396fe3db7c7SDoug Rabson break; 397fe3db7c7SDoug Rabson case DT_RELENT: 398fe3db7c7SDoug Rabson if (dp->d_un.d_val != sizeof(Elf_Rel)) 399fe3db7c7SDoug Rabson return ENOEXEC; 400fe3db7c7SDoug Rabson break; 401fe3db7c7SDoug Rabson case DT_JMPREL: 402fe3db7c7SDoug Rabson ef->pltrel = (const Elf_Rel *) (ef->address + dp->d_un.d_ptr); 403fe3db7c7SDoug Rabson break; 404fe3db7c7SDoug Rabson case DT_PLTRELSZ: 405fe3db7c7SDoug Rabson ef->pltrelsize = dp->d_un.d_val; 406fe3db7c7SDoug Rabson break; 407fe3db7c7SDoug Rabson case DT_RELA: 408fe3db7c7SDoug Rabson ef->rela = (const Elf_Rela *) (ef->address + dp->d_un.d_ptr); 409fe3db7c7SDoug Rabson break; 410fe3db7c7SDoug Rabson case DT_RELASZ: 411fe3db7c7SDoug Rabson ef->relasize = dp->d_un.d_val; 412fe3db7c7SDoug Rabson break; 413fe3db7c7SDoug Rabson case DT_RELAENT: 414fe3db7c7SDoug Rabson if (dp->d_un.d_val != sizeof(Elf_Rela)) 415fe3db7c7SDoug Rabson return ENOEXEC; 416fe3db7c7SDoug Rabson break; 417fe3db7c7SDoug Rabson case DT_PLTREL: 418fe3db7c7SDoug Rabson plttype = dp->d_un.d_val; 419fe3db7c7SDoug Rabson if (plttype != DT_REL && plttype != DT_RELA) 420fe3db7c7SDoug Rabson return ENOEXEC; 421fe3db7c7SDoug Rabson break; 422326e27d8SDoug Rabson #ifdef DDB 423326e27d8SDoug Rabson case DT_DEBUG: 424326e27d8SDoug Rabson dp->d_un.d_ptr = (Elf_Addr) &r_debug; 425326e27d8SDoug Rabson break; 426326e27d8SDoug Rabson #endif 427a4f67738SDoug Rabson } 428a4f67738SDoug Rabson } 429fe3db7c7SDoug Rabson 430fe3db7c7SDoug Rabson if (plttype == DT_RELA) { 431fe3db7c7SDoug Rabson ef->pltrela = (const Elf_Rela *) ef->pltrel; 432fe3db7c7SDoug Rabson ef->pltrel = NULL; 433fe3db7c7SDoug Rabson ef->pltrelasize = ef->pltrelsize; 434fe3db7c7SDoug Rabson ef->pltrelsize = 0; 435fe3db7c7SDoug Rabson } 436fe3db7c7SDoug Rabson 4372d636ab0SPeter Wemm ef->ddbsymtab = ef->symtab; 4382d636ab0SPeter Wemm ef->ddbsymcnt = ef->nchains; 4392d636ab0SPeter Wemm ef->ddbstrtab = ef->strtab; 4402d636ab0SPeter Wemm ef->ddbstrcnt = ef->strsz; 4412d636ab0SPeter Wemm 442a4f67738SDoug Rabson return 0; 443a4f67738SDoug Rabson } 444a4f67738SDoug Rabson 445a4f67738SDoug Rabson static int 44654823af2SPeter Wemm link_elf_link_preload(linker_class_t cls, 447326e27d8SDoug Rabson const char* filename, linker_file_t *result) 448de78ca7eSPeter Wemm { 449de78ca7eSPeter Wemm caddr_t modptr, baseptr, sizeptr, dynptr; 450de78ca7eSPeter Wemm char *type; 451de78ca7eSPeter Wemm elf_file_t ef; 452de78ca7eSPeter Wemm linker_file_t lf; 453de78ca7eSPeter Wemm int error; 454de78ca7eSPeter Wemm vm_offset_t dp; 455de78ca7eSPeter Wemm 45654823af2SPeter Wemm /* Look to see if we have the file preloaded */ 457de78ca7eSPeter Wemm modptr = preload_search_by_name(filename); 458de78ca7eSPeter Wemm if (modptr == NULL) 45954823af2SPeter Wemm return ENOENT; 460de78ca7eSPeter Wemm 461de78ca7eSPeter Wemm type = (char *)preload_search_info(modptr, MODINFO_TYPE); 462de78ca7eSPeter Wemm baseptr = preload_search_info(modptr, MODINFO_ADDR); 463de78ca7eSPeter Wemm sizeptr = preload_search_info(modptr, MODINFO_SIZE); 464de78ca7eSPeter Wemm dynptr = preload_search_info(modptr, MODINFO_METADATA|MODINFOMD_DYNAMIC); 465de78ca7eSPeter Wemm if (type == NULL || strcmp(type, "elf module") != 0) 466de78ca7eSPeter Wemm return (EFTYPE); 467de78ca7eSPeter Wemm if (baseptr == NULL || sizeptr == NULL || dynptr == NULL) 468de78ca7eSPeter Wemm return (EINVAL); 469de78ca7eSPeter Wemm 470326e27d8SDoug Rabson lf = linker_make_file(filename, &link_elf_class); 471326e27d8SDoug Rabson if (lf == NULL) { 472326e27d8SDoug Rabson return ENOMEM; 473326e27d8SDoug Rabson } 474326e27d8SDoug Rabson 475326e27d8SDoug Rabson ef = (elf_file_t) lf; 476326e27d8SDoug Rabson ef->preloaded = 1; 477ca65d5c7SPeter Wemm ef->modptr = modptr; 478de78ca7eSPeter Wemm ef->address = *(caddr_t *)baseptr; 479de78ca7eSPeter Wemm #ifdef SPARSE_MAPPING 480de78ca7eSPeter Wemm ef->object = 0; 481de78ca7eSPeter Wemm #endif 482de78ca7eSPeter Wemm dp = (vm_offset_t)ef->address + *(vm_offset_t *)dynptr; 483de78ca7eSPeter Wemm ef->dynamic = (Elf_Dyn *)dp; 484de78ca7eSPeter Wemm lf->address = ef->address; 485de78ca7eSPeter Wemm lf->size = *(size_t *)sizeptr; 486de78ca7eSPeter Wemm 487326e27d8SDoug Rabson error = parse_dynamic(ef); 488de78ca7eSPeter Wemm if (error) { 489de78ca7eSPeter Wemm linker_file_unload(lf); 490de78ca7eSPeter Wemm return error; 491de78ca7eSPeter Wemm } 4927251b4bfSJake Burkholder link_elf_reloc_local(lf); 493de78ca7eSPeter Wemm *result = lf; 494de78ca7eSPeter Wemm return (0); 495de78ca7eSPeter Wemm } 496de78ca7eSPeter Wemm 497de78ca7eSPeter Wemm static int 49854823af2SPeter Wemm link_elf_link_preload_finish(linker_file_t lf) 49954823af2SPeter Wemm { 50054823af2SPeter Wemm elf_file_t ef; 50154823af2SPeter Wemm int error; 50254823af2SPeter Wemm 50354823af2SPeter Wemm ef = (elf_file_t) lf; 50454823af2SPeter Wemm #if 0 /* this will be more trouble than it's worth for now */ 50554823af2SPeter Wemm for (dp = ef->dynamic; dp->d_tag != DT_NULL; dp++) { 50654823af2SPeter Wemm if (dp->d_tag != DT_NEEDED) 50754823af2SPeter Wemm continue; 50854823af2SPeter Wemm modname = ef->strtab + dp->d_un.d_val; 50954823af2SPeter Wemm error = linker_load_module(modname, lf); 51054823af2SPeter Wemm if (error) 51154823af2SPeter Wemm goto out; 51254823af2SPeter Wemm } 51354823af2SPeter Wemm #endif 51454823af2SPeter Wemm error = relocate_file(ef); 51554823af2SPeter Wemm if (error) 51654823af2SPeter Wemm return error; 51754823af2SPeter Wemm (void)link_elf_preload_parse_symbols(ef); 51854823af2SPeter Wemm 519c143d6c2SMarcel Moolenaar return (link_elf_link_common_finish(lf)); 52054823af2SPeter Wemm } 52154823af2SPeter Wemm 52254823af2SPeter Wemm static int 523c143d6c2SMarcel Moolenaar link_elf_load_file(linker_class_t cls, const char* filename, 524c143d6c2SMarcel Moolenaar linker_file_t* result) 525a4f67738SDoug Rabson { 526a4f67738SDoug Rabson struct nameidata nd; 527b40ce416SJulian Elischer struct thread* td = curthread; /* XXX */ 528caab6e90SPeter Wemm Elf_Ehdr *hdr; 529caab6e90SPeter Wemm caddr_t firstpage; 530fe3db7c7SDoug Rabson int nbytes, i; 531fe3db7c7SDoug Rabson Elf_Phdr *phdr; 532fe3db7c7SDoug Rabson Elf_Phdr *phlimit; 533fe3db7c7SDoug Rabson Elf_Phdr *segs[2]; 534fe3db7c7SDoug Rabson int nsegs; 535fe3db7c7SDoug Rabson Elf_Phdr *phdyn; 536fe3db7c7SDoug Rabson Elf_Phdr *phphdr; 537fe3db7c7SDoug Rabson caddr_t mapbase; 538fe3db7c7SDoug Rabson size_t mapsize; 539fe3db7c7SDoug Rabson Elf_Off base_offset; 540fe3db7c7SDoug Rabson Elf_Addr base_vaddr; 541fe3db7c7SDoug Rabson Elf_Addr base_vlimit; 542a4f67738SDoug Rabson int error = 0; 543e6796b67SKirk McKusick int resid, flags; 544a4f67738SDoug Rabson elf_file_t ef; 545a4f67738SDoug Rabson linker_file_t lf; 546ca65d5c7SPeter Wemm Elf_Shdr *shdr; 547ca65d5c7SPeter Wemm int symtabindex; 548ca65d5c7SPeter Wemm int symstrindex; 549ca65d5c7SPeter Wemm int symcnt; 550ca65d5c7SPeter Wemm int strcnt; 551ca65d5c7SPeter Wemm 5520cddd8f0SMatthew Dillon GIANT_REQUIRED; 5530cddd8f0SMatthew Dillon 554ca65d5c7SPeter Wemm shdr = NULL; 555ca65d5c7SPeter Wemm lf = NULL; 556a4f67738SDoug Rabson 557b40ce416SJulian Elischer NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, filename, td); 558e6796b67SKirk McKusick flags = FREAD; 559e6796b67SKirk McKusick error = vn_open(&nd, &flags, 0); 560a4f67738SDoug Rabson if (error) 561a4f67738SDoug Rabson return error; 562762e6b85SEivind Eklund NDFREE(&nd, NDF_ONLY_PNBUF); 563a3df768bSRobert Watson #ifdef MAC 564a3df768bSRobert Watson error = mac_check_kld_load(curthread->td_ucred, nd.ni_vp); 565a3df768bSRobert Watson if (error) { 566a3df768bSRobert Watson firstpage = NULL; 567a3df768bSRobert Watson goto out; 568a3df768bSRobert Watson } 569a3df768bSRobert Watson #endif 570a4f67738SDoug Rabson 571a4f67738SDoug Rabson /* 572fe3db7c7SDoug Rabson * Read the elf header from the file. 573a4f67738SDoug Rabson */ 574caab6e90SPeter Wemm firstpage = malloc(PAGE_SIZE, M_LINKER, M_WAITOK); 575caab6e90SPeter Wemm if (firstpage == NULL) { 576caab6e90SPeter Wemm error = ENOMEM; 577caab6e90SPeter Wemm goto out; 578caab6e90SPeter Wemm } 579caab6e90SPeter Wemm hdr = (Elf_Ehdr *)firstpage; 580caab6e90SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, firstpage, PAGE_SIZE, 0, 5819ca43589SRobert Watson UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 5829ca43589SRobert Watson &resid, td); 583caab6e90SPeter Wemm nbytes = PAGE_SIZE - resid; 584a4f67738SDoug Rabson if (error) 585a4f67738SDoug Rabson goto out; 586a4f67738SDoug Rabson 587caab6e90SPeter Wemm if (!IS_ELF(*hdr)) { 588fe3db7c7SDoug Rabson error = ENOEXEC; 589a4f67738SDoug Rabson goto out; 590fe3db7c7SDoug Rabson } 591fe3db7c7SDoug Rabson 592caab6e90SPeter Wemm if (hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS 593caab6e90SPeter Wemm || hdr->e_ident[EI_DATA] != ELF_TARG_DATA) { 594fe3db7c7SDoug Rabson link_elf_error("Unsupported file layout"); 595fe3db7c7SDoug Rabson error = ENOEXEC; 596fe3db7c7SDoug Rabson goto out; 597fe3db7c7SDoug Rabson } 598caab6e90SPeter Wemm if (hdr->e_ident[EI_VERSION] != EV_CURRENT 599caab6e90SPeter Wemm || hdr->e_version != EV_CURRENT) { 600fe3db7c7SDoug Rabson link_elf_error("Unsupported file version"); 601fe3db7c7SDoug Rabson error = ENOEXEC; 602fe3db7c7SDoug Rabson goto out; 603fe3db7c7SDoug Rabson } 604caab6e90SPeter Wemm if (hdr->e_type != ET_EXEC && hdr->e_type != ET_DYN) { 605fe3db7c7SDoug Rabson link_elf_error("Unsupported file type"); 606fe3db7c7SDoug Rabson error = ENOEXEC; 607fe3db7c7SDoug Rabson goto out; 608fe3db7c7SDoug Rabson } 609caab6e90SPeter Wemm if (hdr->e_machine != ELF_TARG_MACH) { 610fe3db7c7SDoug Rabson link_elf_error("Unsupported machine"); 611fe3db7c7SDoug Rabson error = ENOEXEC; 612fe3db7c7SDoug Rabson goto out; 613fe3db7c7SDoug Rabson } 614a4f67738SDoug Rabson 615a4f67738SDoug Rabson /* 616fe3db7c7SDoug Rabson * We rely on the program header being in the first page. This is 617fe3db7c7SDoug Rabson * not strictly required by the ABI specification, but it seems to 618fe3db7c7SDoug Rabson * always true in practice. And, it simplifies things considerably. 619a4f67738SDoug Rabson */ 620caab6e90SPeter Wemm if (!((hdr->e_phentsize == sizeof(Elf_Phdr)) && 621caab6e90SPeter Wemm (hdr->e_phoff + hdr->e_phnum*sizeof(Elf_Phdr) <= PAGE_SIZE) && 622caab6e90SPeter Wemm (hdr->e_phoff + hdr->e_phnum*sizeof(Elf_Phdr) <= nbytes))) 623fe3db7c7SDoug Rabson link_elf_error("Unreadable program headers"); 624fe3db7c7SDoug Rabson 625fe3db7c7SDoug Rabson /* 626fe3db7c7SDoug Rabson * Scan the program header entries, and save key information. 627fe3db7c7SDoug Rabson * 628fe3db7c7SDoug Rabson * We rely on there being exactly two load segments, text and data, 629fe3db7c7SDoug Rabson * in that order. 630fe3db7c7SDoug Rabson */ 631caab6e90SPeter Wemm phdr = (Elf_Phdr *) (firstpage + hdr->e_phoff); 632caab6e90SPeter Wemm phlimit = phdr + hdr->e_phnum; 633fe3db7c7SDoug Rabson nsegs = 0; 634fe3db7c7SDoug Rabson phdyn = NULL; 635fe3db7c7SDoug Rabson phphdr = NULL; 636fe3db7c7SDoug Rabson while (phdr < phlimit) { 637fe3db7c7SDoug Rabson switch (phdr->p_type) { 638fe3db7c7SDoug Rabson 639fe3db7c7SDoug Rabson case PT_LOAD: 640fe3db7c7SDoug Rabson if (nsegs == 2) { 641fe3db7c7SDoug Rabson link_elf_error("Too many sections"); 642fe3db7c7SDoug Rabson error = ENOEXEC; 643fe3db7c7SDoug Rabson goto out; 644fe3db7c7SDoug Rabson } 645fe3db7c7SDoug Rabson segs[nsegs] = phdr; 646fe3db7c7SDoug Rabson ++nsegs; 647fe3db7c7SDoug Rabson break; 648fe3db7c7SDoug Rabson 649fe3db7c7SDoug Rabson case PT_PHDR: 650fe3db7c7SDoug Rabson phphdr = phdr; 651fe3db7c7SDoug Rabson break; 652fe3db7c7SDoug Rabson 653fe3db7c7SDoug Rabson case PT_DYNAMIC: 654fe3db7c7SDoug Rabson phdyn = phdr; 655fe3db7c7SDoug Rabson break; 6569548091bSBoris Popov 6579548091bSBoris Popov case PT_INTERP: 6589548091bSBoris Popov link_elf_error("Unsupported file type"); 6599548091bSBoris Popov error = ENOEXEC; 6609548091bSBoris Popov goto out; 661fe3db7c7SDoug Rabson } 662fe3db7c7SDoug Rabson 663fe3db7c7SDoug Rabson ++phdr; 664fe3db7c7SDoug Rabson } 665fe3db7c7SDoug Rabson if (phdyn == NULL) { 666fe3db7c7SDoug Rabson link_elf_error("Object is not dynamically-linked"); 667fe3db7c7SDoug Rabson error = ENOEXEC; 668fe3db7c7SDoug Rabson goto out; 669fe3db7c7SDoug Rabson } 670fe3db7c7SDoug Rabson 671fe3db7c7SDoug Rabson /* 672fe3db7c7SDoug Rabson * Allocate the entire address space of the object, to stake out our 673fe3db7c7SDoug Rabson * contiguous region, and to establish the base address for relocation. 674fe3db7c7SDoug Rabson */ 675fe3db7c7SDoug Rabson base_offset = trunc_page(segs[0]->p_offset); 676fe3db7c7SDoug Rabson base_vaddr = trunc_page(segs[0]->p_vaddr); 677fe3db7c7SDoug Rabson base_vlimit = round_page(segs[1]->p_vaddr + segs[1]->p_memsz); 678fe3db7c7SDoug Rabson mapsize = base_vlimit - base_vaddr; 679fe3db7c7SDoug Rabson 680326e27d8SDoug Rabson lf = linker_make_file(filename, &link_elf_class); 681326e27d8SDoug Rabson if (!lf) { 682326e27d8SDoug Rabson error = ENOMEM; 683326e27d8SDoug Rabson goto out; 684326e27d8SDoug Rabson } 685326e27d8SDoug Rabson 686326e27d8SDoug Rabson ef = (elf_file_t) lf; 687fe3db7c7SDoug Rabson #ifdef SPARSE_MAPPING 688fe3db7c7SDoug Rabson ef->object = vm_object_allocate(OBJT_DEFAULT, mapsize >> PAGE_SHIFT); 689fe3db7c7SDoug Rabson if (ef->object == NULL) { 690fe3db7c7SDoug Rabson error = ENOMEM; 691fe3db7c7SDoug Rabson goto out; 692fe3db7c7SDoug Rabson } 693fe3db7c7SDoug Rabson vm_object_reference(ef->object); 694fe3db7c7SDoug Rabson ef->address = (caddr_t) vm_map_min(kernel_map); 695fe3db7c7SDoug Rabson error = vm_map_find(kernel_map, ef->object, 0, 696fe3db7c7SDoug Rabson (vm_offset_t *) &ef->address, 697fe3db7c7SDoug Rabson mapsize, 1, 698fe3db7c7SDoug Rabson VM_PROT_ALL, VM_PROT_ALL, 0); 699fe3db7c7SDoug Rabson if (error) { 700fe3db7c7SDoug Rabson vm_object_deallocate(ef->object); 701326e27d8SDoug Rabson ef->object = 0; 702fe3db7c7SDoug Rabson goto out; 703fe3db7c7SDoug Rabson } 704fe3db7c7SDoug Rabson #else 705fe3db7c7SDoug Rabson ef->address = malloc(mapsize, M_LINKER, M_WAITOK); 706326e27d8SDoug Rabson if (!ef->address) { 707326e27d8SDoug Rabson error = ENOMEM; 708326e27d8SDoug Rabson goto out; 709326e27d8SDoug Rabson } 710fe3db7c7SDoug Rabson #endif 711fe3db7c7SDoug Rabson mapbase = ef->address; 712a4f67738SDoug Rabson 713a4f67738SDoug Rabson /* 714a4f67738SDoug Rabson * Read the text and data sections and zero the bss. 715a4f67738SDoug Rabson */ 716fe3db7c7SDoug Rabson for (i = 0; i < 2; i++) { 717fe3db7c7SDoug Rabson caddr_t segbase = mapbase + segs[i]->p_vaddr - base_vaddr; 718fe3db7c7SDoug Rabson error = vn_rdwr(UIO_READ, nd.ni_vp, 719fe3db7c7SDoug Rabson segbase, segs[i]->p_filesz, segs[i]->p_offset, 7209ca43589SRobert Watson UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 7219ca43589SRobert Watson &resid, td); 722fe3db7c7SDoug Rabson if (error) { 723a4f67738SDoug Rabson goto out; 724a4f67738SDoug Rabson } 725fe3db7c7SDoug Rabson bzero(segbase + segs[i]->p_filesz, 726fe3db7c7SDoug Rabson segs[i]->p_memsz - segs[i]->p_filesz); 727fe3db7c7SDoug Rabson 728fe3db7c7SDoug Rabson #ifdef SPARSE_MAPPING 729fe3db7c7SDoug Rabson /* 730fe3db7c7SDoug Rabson * Wire down the pages 731fe3db7c7SDoug Rabson */ 732b17c50dbSJake Burkholder vm_map_wire(kernel_map, 733fe3db7c7SDoug Rabson (vm_offset_t) segbase, 734fe3db7c7SDoug Rabson (vm_offset_t) segbase + segs[i]->p_memsz, 735fe3db7c7SDoug Rabson FALSE); 736fe3db7c7SDoug Rabson #endif 737fe3db7c7SDoug Rabson } 738fe3db7c7SDoug Rabson 739f99502a4SBrian Feldman #ifdef GPROF 740f99502a4SBrian Feldman /* Update profiling information with the new text segment. */ 741f99502a4SBrian Feldman kmupetext((uintfptr_t)(mapbase + segs[0]->p_vaddr - base_vaddr + 742f99502a4SBrian Feldman segs[0]->p_memsz)); 743f99502a4SBrian Feldman #endif 744f99502a4SBrian Feldman 745326e27d8SDoug Rabson ef->dynamic = (Elf_Dyn *) (mapbase + phdyn->p_vaddr - base_vaddr); 746a4f67738SDoug Rabson 747a4f67738SDoug Rabson lf->address = ef->address; 748fe3db7c7SDoug Rabson lf->size = mapsize; 749a4f67738SDoug Rabson 750326e27d8SDoug Rabson error = parse_dynamic(ef); 751ca65d5c7SPeter Wemm if (error) 752de78ca7eSPeter Wemm goto out; 7537251b4bfSJake Burkholder link_elf_reloc_local(lf); 7547251b4bfSJake Burkholder 7557b9716baSIan Dowse error = linker_load_dependencies(lf); 756ca65d5c7SPeter Wemm if (error) 757de78ca7eSPeter Wemm goto out; 75854823af2SPeter Wemm #if 0 /* this will be more trouble than it's worth for now */ 75954823af2SPeter Wemm for (dp = ef->dynamic; dp->d_tag != DT_NULL; dp++) { 76054823af2SPeter Wemm if (dp->d_tag != DT_NEEDED) 76154823af2SPeter Wemm continue; 76254823af2SPeter Wemm modname = ef->strtab + dp->d_un.d_val; 76354823af2SPeter Wemm error = linker_load_module(modname, lf); 76454823af2SPeter Wemm if (error) 76554823af2SPeter Wemm goto out; 76654823af2SPeter Wemm } 76754823af2SPeter Wemm #endif 768326e27d8SDoug Rabson error = relocate_file(ef); 769ca65d5c7SPeter Wemm if (error) 770ca65d5c7SPeter Wemm goto out; 771ca65d5c7SPeter Wemm 772ca65d5c7SPeter Wemm /* Try and load the symbol table if it's present. (you can strip it!) */ 773caab6e90SPeter Wemm nbytes = hdr->e_shnum * hdr->e_shentsize; 774caab6e90SPeter Wemm if (nbytes == 0 || hdr->e_shoff == 0) 775ca65d5c7SPeter Wemm goto nosyms; 7767cc0979fSDavid Malone shdr = malloc(nbytes, M_LINKER, M_WAITOK | M_ZERO); 777ca65d5c7SPeter Wemm if (shdr == NULL) { 778ca65d5c7SPeter Wemm error = ENOMEM; 779a4f67738SDoug Rabson goto out; 780a4f67738SDoug Rabson } 781ca65d5c7SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, 782caab6e90SPeter Wemm (caddr_t)shdr, nbytes, hdr->e_shoff, 7839ca43589SRobert Watson UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 7849ca43589SRobert Watson &resid, td); 785ca65d5c7SPeter Wemm if (error) 786ca65d5c7SPeter Wemm goto out; 787ca65d5c7SPeter Wemm symtabindex = -1; 788ca65d5c7SPeter Wemm symstrindex = -1; 789caab6e90SPeter Wemm for (i = 0; i < hdr->e_shnum; i++) { 790ca65d5c7SPeter Wemm if (shdr[i].sh_type == SHT_SYMTAB) { 791ca65d5c7SPeter Wemm symtabindex = i; 792ca65d5c7SPeter Wemm symstrindex = shdr[i].sh_link; 793ca65d5c7SPeter Wemm } 794ca65d5c7SPeter Wemm } 795ca65d5c7SPeter Wemm if (symtabindex < 0 || symstrindex < 0) 796ca65d5c7SPeter Wemm goto nosyms; 797ca65d5c7SPeter Wemm 798ca65d5c7SPeter Wemm symcnt = shdr[symtabindex].sh_size; 799ca65d5c7SPeter Wemm ef->symbase = malloc(symcnt, M_LINKER, M_WAITOK); 800ca65d5c7SPeter Wemm strcnt = shdr[symstrindex].sh_size; 801ca65d5c7SPeter Wemm ef->strbase = malloc(strcnt, M_LINKER, M_WAITOK); 802ca65d5c7SPeter Wemm 803ca65d5c7SPeter Wemm if (ef->symbase == NULL || ef->strbase == NULL) { 804ca65d5c7SPeter Wemm error = ENOMEM; 805ca65d5c7SPeter Wemm goto out; 806ca65d5c7SPeter Wemm } 807ca65d5c7SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, 808ca65d5c7SPeter Wemm ef->symbase, symcnt, shdr[symtabindex].sh_offset, 8099ca43589SRobert Watson UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 8109ca43589SRobert Watson &resid, td); 811ca65d5c7SPeter Wemm if (error) 812ca65d5c7SPeter Wemm goto out; 813ca65d5c7SPeter Wemm error = vn_rdwr(UIO_READ, nd.ni_vp, 814ca65d5c7SPeter Wemm ef->strbase, strcnt, shdr[symstrindex].sh_offset, 8159ca43589SRobert Watson UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, 8169ca43589SRobert Watson &resid, td); 817ca65d5c7SPeter Wemm if (error) 818ca65d5c7SPeter Wemm goto out; 819ca65d5c7SPeter Wemm 820ca65d5c7SPeter Wemm ef->ddbsymcnt = symcnt / sizeof(Elf_Sym); 821ca65d5c7SPeter Wemm ef->ddbsymtab = (const Elf_Sym *)ef->symbase; 822ca65d5c7SPeter Wemm ef->ddbstrcnt = strcnt; 823ca65d5c7SPeter Wemm ef->ddbstrtab = ef->strbase; 824ca65d5c7SPeter Wemm 825c143d6c2SMarcel Moolenaar error = link_elf_link_common_finish(lf); 826c143d6c2SMarcel Moolenaar if (error) 827c143d6c2SMarcel Moolenaar goto out; 828326e27d8SDoug Rabson 829ca65d5c7SPeter Wemm nosyms: 830a4f67738SDoug Rabson 831a4f67738SDoug Rabson *result = lf; 832a4f67738SDoug Rabson 833a4f67738SDoug Rabson out: 834ca65d5c7SPeter Wemm if (error && lf) 835ca65d5c7SPeter Wemm linker_file_unload(lf); 836ca65d5c7SPeter Wemm if (shdr) 837ca65d5c7SPeter Wemm free(shdr, M_LINKER); 838caab6e90SPeter Wemm if (firstpage) 839caab6e90SPeter Wemm free(firstpage, M_LINKER); 840b40ce416SJulian Elischer VOP_UNLOCK(nd.ni_vp, 0, td); 841a854ed98SJohn Baldwin vn_close(nd.ni_vp, FREAD, td->td_ucred, td); 842a4f67738SDoug Rabson 843a4f67738SDoug Rabson return error; 844a4f67738SDoug Rabson } 845a4f67738SDoug Rabson 846a4f67738SDoug Rabson static void 847de78ca7eSPeter Wemm link_elf_unload_file(linker_file_t file) 848a4f67738SDoug Rabson { 849326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) file; 850a4f67738SDoug Rabson 851326e27d8SDoug Rabson #ifdef DDB 852326e27d8SDoug Rabson if (ef->gdb.l_ld) { 853326e27d8SDoug Rabson GDB_STATE(RT_DELETE); 854ed6c3888SPeter Wemm free((void *)(uintptr_t)ef->gdb.l_name, M_LINKER); 855326e27d8SDoug Rabson link_elf_delete_gdb(&ef->gdb); 856326e27d8SDoug Rabson GDB_STATE(RT_CONSISTENT); 857326e27d8SDoug Rabson } 858326e27d8SDoug Rabson #endif 859326e27d8SDoug Rabson 8601aeb23cdSMarcel Moolenaar /* Notify MD code that a module is being unloaded. */ 8611aeb23cdSMarcel Moolenaar elf_cpu_unload_file(file); 8621aeb23cdSMarcel Moolenaar 863326e27d8SDoug Rabson if (ef->preloaded) { 86454823af2SPeter Wemm link_elf_unload_preload(file); 865326e27d8SDoug Rabson return; 866326e27d8SDoug Rabson } 867c143d6c2SMarcel Moolenaar 868fe3db7c7SDoug Rabson #ifdef SPARSE_MAPPING 869fe3db7c7SDoug Rabson if (ef->object) { 870fe3db7c7SDoug Rabson vm_map_remove(kernel_map, (vm_offset_t) ef->address, 871fe3db7c7SDoug Rabson (vm_offset_t) ef->address 872fe3db7c7SDoug Rabson + (ef->object->size << PAGE_SHIFT)); 873fe3db7c7SDoug Rabson vm_object_deallocate(ef->object); 874fe3db7c7SDoug Rabson } 875fe3db7c7SDoug Rabson #else 876ca65d5c7SPeter Wemm if (ef->address) 877a4f67738SDoug Rabson free(ef->address, M_LINKER); 878fe3db7c7SDoug Rabson #endif 879ca65d5c7SPeter Wemm if (ef->symbase) 880ca65d5c7SPeter Wemm free(ef->symbase, M_LINKER); 881ca65d5c7SPeter Wemm if (ef->strbase) 882ca65d5c7SPeter Wemm free(ef->strbase, M_LINKER); 883a4f67738SDoug Rabson } 884a4f67738SDoug Rabson 885de78ca7eSPeter Wemm static void 88654823af2SPeter Wemm link_elf_unload_preload(linker_file_t file) 887de78ca7eSPeter Wemm { 888de78ca7eSPeter Wemm if (file->filename) 889de78ca7eSPeter Wemm preload_delete_name(file->filename); 890de78ca7eSPeter Wemm } 891de78ca7eSPeter Wemm 892fe3db7c7SDoug Rabson static const char * 893aa855a59SPeter Wemm symbol_name(elf_file_t ef, Elf_Word r_info) 894a4f67738SDoug Rabson { 895fe3db7c7SDoug Rabson const Elf_Sym *ref; 896a4f67738SDoug Rabson 897aa855a59SPeter Wemm if (ELF_R_SYM(r_info)) { 898aa855a59SPeter Wemm ref = ef->symtab + ELF_R_SYM(r_info); 899434bf653SPeter Wemm return ef->strtab + ref->st_name; 900fe3db7c7SDoug Rabson } else 901fe3db7c7SDoug Rabson return NULL; 902a4f67738SDoug Rabson } 903a4f67738SDoug Rabson 904a4f67738SDoug Rabson static int 905326e27d8SDoug Rabson relocate_file(elf_file_t ef) 906a4f67738SDoug Rabson { 907fe3db7c7SDoug Rabson const Elf_Rel *rellim; 908fe3db7c7SDoug Rabson const Elf_Rel *rel; 909fe3db7c7SDoug Rabson const Elf_Rela *relalim; 910fe3db7c7SDoug Rabson const Elf_Rela *rela; 911aa855a59SPeter Wemm const char *symname; 912a4f67738SDoug Rabson 913fe3db7c7SDoug Rabson /* Perform relocations without addend if there are any: */ 914aa855a59SPeter Wemm rel = ef->rel; 915aa855a59SPeter Wemm if (rel) { 916cacd1f6aSBruce Evans rellim = (const Elf_Rel *)((const char *)ef->rel + ef->relsize); 917aa855a59SPeter Wemm while (rel < rellim) { 918d297ad16SMarcel Moolenaar if (elf_reloc(&ef->lf, rel, ELF_RELOC_REL)) { 919aa855a59SPeter Wemm symname = symbol_name(ef, rel->r_info); 920ef83592dSPeter Wemm printf("link_elf: symbol %s undefined\n", symname); 921a4f67738SDoug Rabson return ENOENT; 922a13ddfb6SPeter Wemm } 923aa855a59SPeter Wemm rel++; 924aa855a59SPeter Wemm } 925a4f67738SDoug Rabson } 926a4f67738SDoug Rabson 927fe3db7c7SDoug Rabson /* Perform relocations with addend if there are any: */ 928aa855a59SPeter Wemm rela = ef->rela; 929aa855a59SPeter Wemm if (rela) { 930cacd1f6aSBruce Evans relalim = (const Elf_Rela *)((const char *)ef->rela + ef->relasize); 931aa855a59SPeter Wemm while (rela < relalim) { 932d297ad16SMarcel Moolenaar if (elf_reloc(&ef->lf, rela, ELF_RELOC_RELA)) { 933aa855a59SPeter Wemm symname = symbol_name(ef, rela->r_info); 934ef83592dSPeter Wemm printf("link_elf: symbol %s undefined\n", symname); 935fe3db7c7SDoug Rabson return ENOENT; 936a13ddfb6SPeter Wemm } 937aa855a59SPeter Wemm rela++; 938aa855a59SPeter Wemm } 939a4f67738SDoug Rabson } 940a4f67738SDoug Rabson 941fe3db7c7SDoug Rabson /* Perform PLT relocations without addend if there are any: */ 942aa855a59SPeter Wemm rel = ef->pltrel; 943aa855a59SPeter Wemm if (rel) { 944cacd1f6aSBruce Evans rellim = (const Elf_Rel *)((const char *)ef->pltrel + ef->pltrelsize); 945aa855a59SPeter Wemm while (rel < rellim) { 946d297ad16SMarcel Moolenaar if (elf_reloc(&ef->lf, rel, ELF_RELOC_REL)) { 947aa855a59SPeter Wemm symname = symbol_name(ef, rel->r_info); 948ef83592dSPeter Wemm printf("link_elf: symbol %s undefined\n", symname); 949fe3db7c7SDoug Rabson return ENOENT; 950a13ddfb6SPeter Wemm } 951aa855a59SPeter Wemm rel++; 952aa855a59SPeter Wemm } 953a4f67738SDoug Rabson } 954a4f67738SDoug Rabson 955fe3db7c7SDoug Rabson /* Perform relocations with addend if there are any: */ 956aa855a59SPeter Wemm rela = ef->pltrela; 957aa855a59SPeter Wemm if (rela) { 958cacd1f6aSBruce Evans relalim = (const Elf_Rela *)((const char *)ef->pltrela + ef->pltrelasize); 959aa855a59SPeter Wemm while (rela < relalim) { 960d297ad16SMarcel Moolenaar if (elf_reloc(&ef->lf, rela, ELF_RELOC_RELA)) { 961aa855a59SPeter Wemm symname = symbol_name(ef, rela->r_info); 962ef83592dSPeter Wemm printf("link_elf: symbol %s undefined\n", symname); 963fe3db7c7SDoug Rabson return ENOENT; 964a13ddfb6SPeter Wemm } 965aa855a59SPeter Wemm rela++; 966aa855a59SPeter Wemm } 967a4f67738SDoug Rabson } 968a4f67738SDoug Rabson 969a4f67738SDoug Rabson return 0; 970a4f67738SDoug Rabson } 971a4f67738SDoug Rabson 972fe3db7c7SDoug Rabson /* 973fe3db7c7SDoug Rabson * Hash function for symbol table lookup. Don't even think about changing 974fe3db7c7SDoug Rabson * this. It is specified by the System V ABI. 975fe3db7c7SDoug Rabson */ 976fe3db7c7SDoug Rabson static unsigned long 977fe3db7c7SDoug Rabson elf_hash(const char *name) 978a4f67738SDoug Rabson { 979fe3db7c7SDoug Rabson const unsigned char *p = (const unsigned char *) name; 980fe3db7c7SDoug Rabson unsigned long h = 0; 981fe3db7c7SDoug Rabson unsigned long g; 982a4f67738SDoug Rabson 983fe3db7c7SDoug Rabson while (*p != '\0') { 984fe3db7c7SDoug Rabson h = (h << 4) + *p++; 985fe3db7c7SDoug Rabson if ((g = h & 0xf0000000) != 0) 986fe3db7c7SDoug Rabson h ^= g >> 24; 987fe3db7c7SDoug Rabson h &= ~g; 988a4f67738SDoug Rabson } 989fe3db7c7SDoug Rabson return h; 990fe3db7c7SDoug Rabson } 991a4f67738SDoug Rabson 99237c84183SPoul-Henning Kamp static int 993d254af07SMatthew Dillon link_elf_lookup_symbol(linker_file_t lf, const char* name, c_linker_sym_t* sym) 994a4f67738SDoug Rabson { 995326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) lf; 996fe3db7c7SDoug Rabson unsigned long symnum; 9972d636ab0SPeter Wemm const Elf_Sym* symp; 9982d636ab0SPeter Wemm const char *strp; 999fe3db7c7SDoug Rabson unsigned long hash; 1000a4f67738SDoug Rabson int i; 1001a4f67738SDoug Rabson 10022d636ab0SPeter Wemm /* First, search hashed global symbols */ 1003fe3db7c7SDoug Rabson hash = elf_hash(name); 1004fe3db7c7SDoug Rabson symnum = ef->buckets[hash % ef->nbuckets]; 1005fe3db7c7SDoug Rabson 1006fe3db7c7SDoug Rabson while (symnum != STN_UNDEF) { 1007fe3db7c7SDoug Rabson if (symnum >= ef->nchains) { 1008fe3db7c7SDoug Rabson printf("link_elf_lookup_symbol: corrupt symbol table\n"); 1009fe3db7c7SDoug Rabson return ENOENT; 1010a4f67738SDoug Rabson } 1011fe3db7c7SDoug Rabson 1012fe3db7c7SDoug Rabson symp = ef->symtab + symnum; 1013fe3db7c7SDoug Rabson if (symp->st_name == 0) { 1014fe3db7c7SDoug Rabson printf("link_elf_lookup_symbol: corrupt symbol table\n"); 1015fe3db7c7SDoug Rabson return ENOENT; 1016fe3db7c7SDoug Rabson } 1017fe3db7c7SDoug Rabson 1018fe3db7c7SDoug Rabson strp = ef->strtab + symp->st_name; 1019fe3db7c7SDoug Rabson 1020fe3db7c7SDoug Rabson if (strcmp(name, strp) == 0) { 1021fe3db7c7SDoug Rabson if (symp->st_shndx != SHN_UNDEF || 1022fe3db7c7SDoug Rabson (symp->st_value != 0 && 1023fe3db7c7SDoug Rabson ELF_ST_TYPE(symp->st_info) == STT_FUNC)) { 1024d254af07SMatthew Dillon *sym = (c_linker_sym_t) symp; 1025fe3db7c7SDoug Rabson return 0; 1026fe3db7c7SDoug Rabson } else 1027fe3db7c7SDoug Rabson return ENOENT; 1028fe3db7c7SDoug Rabson } 1029fe3db7c7SDoug Rabson 1030fe3db7c7SDoug Rabson symnum = ef->chains[symnum]; 1031a4f67738SDoug Rabson } 1032a4f67738SDoug Rabson 10332d636ab0SPeter Wemm /* If we have not found it, look at the full table (if loaded) */ 10342d636ab0SPeter Wemm if (ef->symtab == ef->ddbsymtab) 10352d636ab0SPeter Wemm return ENOENT; 10362d636ab0SPeter Wemm 10372d636ab0SPeter Wemm /* Exhaustive search */ 10382d636ab0SPeter Wemm for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) { 10392d636ab0SPeter Wemm strp = ef->ddbstrtab + symp->st_name; 10402d636ab0SPeter Wemm if (strcmp(name, strp) == 0) { 10412d636ab0SPeter Wemm if (symp->st_shndx != SHN_UNDEF || 10422d636ab0SPeter Wemm (symp->st_value != 0 && 10432d636ab0SPeter Wemm ELF_ST_TYPE(symp->st_info) == STT_FUNC)) { 1044d254af07SMatthew Dillon *sym = (c_linker_sym_t) symp; 10452d636ab0SPeter Wemm return 0; 10462d636ab0SPeter Wemm } else 10472d636ab0SPeter Wemm return ENOENT; 10482d636ab0SPeter Wemm } 10492d636ab0SPeter Wemm } 10502d636ab0SPeter Wemm 1051a4f67738SDoug Rabson return ENOENT; 1052a4f67738SDoug Rabson } 1053a4f67738SDoug Rabson 1054de78ca7eSPeter Wemm static int 1055fe08c21aSMatthew Dillon link_elf_symbol_values(linker_file_t lf, c_linker_sym_t sym, linker_symval_t* symval) 1056a4f67738SDoug Rabson { 1057326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) lf; 10588aef1712SMatthew Dillon const Elf_Sym* es = (const Elf_Sym*) sym; 1059a4f67738SDoug Rabson 10605cf87418SMarcel Moolenaar if (es >= ef->symtab && es < (ef->symtab + ef->nchains)) { 1061a4f67738SDoug Rabson symval->name = ef->strtab + es->st_name; 1062fe3db7c7SDoug Rabson symval->value = (caddr_t) ef->address + es->st_value; 1063a4f67738SDoug Rabson symval->size = es->st_size; 1064de78ca7eSPeter Wemm return 0; 1065a4f67738SDoug Rabson } 10662d636ab0SPeter Wemm if (ef->symtab == ef->ddbsymtab) 10672d636ab0SPeter Wemm return ENOENT; 10685cf87418SMarcel Moolenaar if (es >= ef->ddbsymtab && es < (ef->ddbsymtab + ef->ddbsymcnt)) { 10692d636ab0SPeter Wemm symval->name = ef->ddbstrtab + es->st_name; 10702d636ab0SPeter Wemm symval->value = (caddr_t) ef->address + es->st_value; 10712d636ab0SPeter Wemm symval->size = es->st_size; 10722d636ab0SPeter Wemm return 0; 10732d636ab0SPeter Wemm } 10742d636ab0SPeter Wemm return ENOENT; 10752d636ab0SPeter Wemm } 1076a4f67738SDoug Rabson 1077a4f67738SDoug Rabson static int 1078a4f67738SDoug Rabson link_elf_search_symbol(linker_file_t lf, caddr_t value, 1079d254af07SMatthew Dillon c_linker_sym_t* sym, long* diffp) 1080a4f67738SDoug Rabson { 1081326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) lf; 1082586453feSBruce Evans u_long off = (uintptr_t) (void *) value; 1083a4f67738SDoug Rabson u_long diff = off; 1084586453feSBruce Evans u_long st_value; 1085fe3db7c7SDoug Rabson const Elf_Sym* es; 1086fe3db7c7SDoug Rabson const Elf_Sym* best = 0; 1087a4f67738SDoug Rabson int i; 1088a4f67738SDoug Rabson 10892d636ab0SPeter Wemm for (i = 0, es = ef->ddbsymtab; i < ef->ddbsymcnt; i++, es++) { 1090a4f67738SDoug Rabson if (es->st_name == 0) 1091a4f67738SDoug Rabson continue; 1092586453feSBruce Evans st_value = es->st_value + (uintptr_t) (void *) ef->address; 1093b5abfb70SPeter Wemm if (off >= st_value) { 1094b5abfb70SPeter Wemm if (off - st_value < diff) { 1095b5abfb70SPeter Wemm diff = off - st_value; 1096a4f67738SDoug Rabson best = es; 1097a4f67738SDoug Rabson if (diff == 0) 1098a4f67738SDoug Rabson break; 1099b5abfb70SPeter Wemm } else if (off - st_value == diff) { 1100a4f67738SDoug Rabson best = es; 1101a4f67738SDoug Rabson } 1102a4f67738SDoug Rabson } 1103a4f67738SDoug Rabson } 1104a4f67738SDoug Rabson if (best == 0) 1105a4f67738SDoug Rabson *diffp = off; 1106a4f67738SDoug Rabson else 1107a4f67738SDoug Rabson *diffp = diff; 1108d254af07SMatthew Dillon *sym = (c_linker_sym_t) best; 1109a4f67738SDoug Rabson 1110a4f67738SDoug Rabson return 0; 1111a4f67738SDoug Rabson } 1112f41325dbSPeter Wemm 1113f41325dbSPeter Wemm /* 1114f41325dbSPeter Wemm * Look up a linker set on an ELF system. 1115f41325dbSPeter Wemm */ 1116f41325dbSPeter Wemm static int 1117f41325dbSPeter Wemm link_elf_lookup_set(linker_file_t lf, const char *name, 1118f41325dbSPeter Wemm void ***startp, void ***stopp, int *countp) 1119f41325dbSPeter Wemm { 1120f41325dbSPeter Wemm c_linker_sym_t sym; 1121f41325dbSPeter Wemm linker_symval_t symval; 1122f41325dbSPeter Wemm char *setsym; 1123f41325dbSPeter Wemm void **start, **stop; 1124f41325dbSPeter Wemm int len, error = 0, count; 1125f41325dbSPeter Wemm 1126f41325dbSPeter Wemm len = strlen(name) + sizeof("__start_set_"); /* sizeof includes \0 */ 1127f41325dbSPeter Wemm setsym = malloc(len, M_LINKER, M_WAITOK); 1128f41325dbSPeter Wemm if (setsym == NULL) 1129f41325dbSPeter Wemm return ENOMEM; 1130f41325dbSPeter Wemm 1131f41325dbSPeter Wemm /* get address of first entry */ 1132f41325dbSPeter Wemm snprintf(setsym, len, "%s%s", "__start_set_", name); 1133f41325dbSPeter Wemm error = link_elf_lookup_symbol(lf, setsym, &sym); 1134f41325dbSPeter Wemm if (error) 1135f41325dbSPeter Wemm goto out; 1136f41325dbSPeter Wemm link_elf_symbol_values(lf, sym, &symval); 1137f41325dbSPeter Wemm if (symval.value == 0) { 1138f41325dbSPeter Wemm error = ESRCH; 1139f41325dbSPeter Wemm goto out; 1140f41325dbSPeter Wemm } 1141f41325dbSPeter Wemm start = (void **)symval.value; 1142f41325dbSPeter Wemm 1143f41325dbSPeter Wemm /* get address of last entry */ 1144f41325dbSPeter Wemm snprintf(setsym, len, "%s%s", "__stop_set_", name); 1145f41325dbSPeter Wemm error = link_elf_lookup_symbol(lf, setsym, &sym); 1146f41325dbSPeter Wemm if (error) 1147f41325dbSPeter Wemm goto out; 1148f41325dbSPeter Wemm link_elf_symbol_values(lf, sym, &symval); 1149f41325dbSPeter Wemm if (symval.value == 0) { 1150f41325dbSPeter Wemm error = ESRCH; 1151f41325dbSPeter Wemm goto out; 1152f41325dbSPeter Wemm } 1153f41325dbSPeter Wemm stop = (void **)symval.value; 1154f41325dbSPeter Wemm 1155f41325dbSPeter Wemm /* and the number of entries */ 1156f41325dbSPeter Wemm count = stop - start; 1157f41325dbSPeter Wemm 1158f41325dbSPeter Wemm /* and copy out */ 1159f41325dbSPeter Wemm if (startp) 1160f41325dbSPeter Wemm *startp = start; 1161f41325dbSPeter Wemm if (stopp) 1162f41325dbSPeter Wemm *stopp = stop; 1163f41325dbSPeter Wemm if (countp) 1164f41325dbSPeter Wemm *countp = count; 1165f41325dbSPeter Wemm 1166f41325dbSPeter Wemm out: 1167f41325dbSPeter Wemm free(setsym, M_LINKER); 1168f41325dbSPeter Wemm return error; 1169f41325dbSPeter Wemm } 1170bb9fe9ddSBrian Feldman 1171bb9fe9ddSBrian Feldman static int 1172bb9fe9ddSBrian Feldman link_elf_each_function_name(linker_file_t file, 1173bb9fe9ddSBrian Feldman int (*callback)(const char *, void *), void *opaque) { 1174bb9fe9ddSBrian Feldman elf_file_t ef = (elf_file_t)file; 1175bb9fe9ddSBrian Feldman const Elf_Sym* symp; 1176bb9fe9ddSBrian Feldman int i, error; 1177bb9fe9ddSBrian Feldman 1178bb9fe9ddSBrian Feldman /* Exhaustive search */ 1179bb9fe9ddSBrian Feldman for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) { 1180bb9fe9ddSBrian Feldman if (symp->st_value != 0 && 1181bb9fe9ddSBrian Feldman ELF_ST_TYPE(symp->st_info) == STT_FUNC) { 1182bb9fe9ddSBrian Feldman error = callback(ef->ddbstrtab + symp->st_name, opaque); 1183bb9fe9ddSBrian Feldman if (error) 1184bb9fe9ddSBrian Feldman return (error); 1185bb9fe9ddSBrian Feldman } 1186bb9fe9ddSBrian Feldman } 1187bb9fe9ddSBrian Feldman return (0); 1188bb9fe9ddSBrian Feldman } 118984201059SMarcel Moolenaar 119084201059SMarcel Moolenaar #ifdef __ia64__ 119184201059SMarcel Moolenaar /* 119284201059SMarcel Moolenaar * Each KLD has its own GP. The GP value for each load module is given by 119384201059SMarcel Moolenaar * DT_PLTGOT on ia64. We need GP to construct function descriptors, but 119484201059SMarcel Moolenaar * don't have direct access to the ELF file structure. The link_elf_get_gp() 119584201059SMarcel Moolenaar * function returns the GP given a pointer to a generic linker file struct. 119684201059SMarcel Moolenaar */ 119784201059SMarcel Moolenaar Elf_Addr 119884201059SMarcel Moolenaar link_elf_get_gp(linker_file_t lf) 119984201059SMarcel Moolenaar { 120084201059SMarcel Moolenaar elf_file_t ef = (elf_file_t)lf; 120184201059SMarcel Moolenaar return (Elf_Addr)ef->got; 120284201059SMarcel Moolenaar } 120384201059SMarcel Moolenaar #endif 1204d297ad16SMarcel Moolenaar 1205169d513cSJake Burkholder const Elf_Sym * 1206169d513cSJake Burkholder elf_get_sym(linker_file_t lf, Elf_Word symidx) 1207169d513cSJake Burkholder { 1208169d513cSJake Burkholder elf_file_t ef = (elf_file_t)lf; 1209169d513cSJake Burkholder 1210169d513cSJake Burkholder if (symidx >= ef->nchains) 1211169d513cSJake Burkholder return (NULL); 1212169d513cSJake Burkholder return (ef->symtab + symidx); 1213169d513cSJake Burkholder } 1214169d513cSJake Burkholder 121547f75012SMarcel Moolenaar const char * 121647f75012SMarcel Moolenaar elf_get_symname(linker_file_t lf, Elf_Word symidx) 121747f75012SMarcel Moolenaar { 121847f75012SMarcel Moolenaar elf_file_t ef = (elf_file_t)lf; 121947f75012SMarcel Moolenaar const Elf_Sym *sym; 122047f75012SMarcel Moolenaar 122147f75012SMarcel Moolenaar if (symidx >= ef->nchains) 122247f75012SMarcel Moolenaar return (NULL); 122347f75012SMarcel Moolenaar sym = ef->symtab + symidx; 122447f75012SMarcel Moolenaar return (ef->strtab + sym->st_name); 122547f75012SMarcel Moolenaar } 122647f75012SMarcel Moolenaar 1227d297ad16SMarcel Moolenaar /* 1228d297ad16SMarcel Moolenaar * Symbol lookup function that can be used when the symbol index is known (ie 1229d297ad16SMarcel Moolenaar * in relocations). It uses the symbol index instead of doing a fully fledged 1230d297ad16SMarcel Moolenaar * hash table based lookup when such is valid. For example for local symbols. 1231d297ad16SMarcel Moolenaar * This is not only more efficient, it's also more correct. It's not always 1232d297ad16SMarcel Moolenaar * the case that the symbol can be found through the hash table. 1233d297ad16SMarcel Moolenaar */ 1234d297ad16SMarcel Moolenaar Elf_Addr 1235d297ad16SMarcel Moolenaar elf_lookup(linker_file_t lf, Elf_Word symidx, int deps) 1236d297ad16SMarcel Moolenaar { 1237d297ad16SMarcel Moolenaar elf_file_t ef = (elf_file_t)lf; 1238d297ad16SMarcel Moolenaar const Elf_Sym *sym; 1239d297ad16SMarcel Moolenaar const char *symbol; 1240d297ad16SMarcel Moolenaar 1241d297ad16SMarcel Moolenaar /* Don't even try to lookup the symbol if the index is bogus. */ 1242d297ad16SMarcel Moolenaar if (symidx >= ef->nchains) 1243d297ad16SMarcel Moolenaar return (0); 1244d297ad16SMarcel Moolenaar 1245d297ad16SMarcel Moolenaar sym = ef->symtab + symidx; 1246d297ad16SMarcel Moolenaar 1247d297ad16SMarcel Moolenaar /* 1248d297ad16SMarcel Moolenaar * Don't do a full lookup when the symbol is local. It may even 1249d297ad16SMarcel Moolenaar * fail because it may not be found through the hash table. 1250d297ad16SMarcel Moolenaar */ 1251d297ad16SMarcel Moolenaar if (ELF_ST_BIND(sym->st_info) == STB_LOCAL) { 1252d297ad16SMarcel Moolenaar /* Force lookup failure when we have an insanity. */ 1253d297ad16SMarcel Moolenaar if (sym->st_shndx == SHN_UNDEF || sym->st_value == 0) 1254d297ad16SMarcel Moolenaar return (0); 1255d297ad16SMarcel Moolenaar return ((Elf_Addr)ef->address + sym->st_value); 1256d297ad16SMarcel Moolenaar } 1257d297ad16SMarcel Moolenaar 1258d297ad16SMarcel Moolenaar /* 1259d297ad16SMarcel Moolenaar * XXX we can avoid doing a hash table based lookup for global 1260d297ad16SMarcel Moolenaar * symbols as well. This however is not always valid, so we'll 1261d297ad16SMarcel Moolenaar * just do it the hard way for now. Performance tweaks can 1262d297ad16SMarcel Moolenaar * always be added. 1263d297ad16SMarcel Moolenaar */ 1264d297ad16SMarcel Moolenaar 1265d297ad16SMarcel Moolenaar symbol = ef->strtab + sym->st_name; 1266d297ad16SMarcel Moolenaar 1267d297ad16SMarcel Moolenaar /* Force a lookup failure if the symbol name is bogus. */ 1268d297ad16SMarcel Moolenaar if (*symbol == 0) 1269d297ad16SMarcel Moolenaar return (0); 1270d297ad16SMarcel Moolenaar 1271d297ad16SMarcel Moolenaar return ((Elf_Addr)linker_file_lookup_symbol(lf, symbol, deps)); 1272d297ad16SMarcel Moolenaar } 12737251b4bfSJake Burkholder 12747251b4bfSJake Burkholder static void 12757251b4bfSJake Burkholder link_elf_reloc_local(linker_file_t lf) 12767251b4bfSJake Burkholder { 12777251b4bfSJake Burkholder const Elf_Rel *rellim; 12787251b4bfSJake Burkholder const Elf_Rel *rel; 12797251b4bfSJake Burkholder const Elf_Rela *relalim; 12807251b4bfSJake Burkholder const Elf_Rela *rela; 12817251b4bfSJake Burkholder elf_file_t ef = (elf_file_t)lf; 12827251b4bfSJake Burkholder 12837251b4bfSJake Burkholder /* Perform relocations without addend if there are any: */ 12847251b4bfSJake Burkholder if ((rel = ef->rel) != NULL) { 12857251b4bfSJake Burkholder rellim = (const Elf_Rel *)((const char *)ef->rel + ef->relsize); 12867251b4bfSJake Burkholder while (rel < rellim) { 12877251b4bfSJake Burkholder elf_reloc_local(lf, rel, ELF_RELOC_REL); 12887251b4bfSJake Burkholder rel++; 12897251b4bfSJake Burkholder } 12907251b4bfSJake Burkholder } 12917251b4bfSJake Burkholder 12927251b4bfSJake Burkholder /* Perform relocations with addend if there are any: */ 12937251b4bfSJake Burkholder if ((rela = ef->rela) != NULL) { 12947251b4bfSJake Burkholder relalim = (const Elf_Rela *)((const char *)ef->rela + ef->relasize); 12957251b4bfSJake Burkholder while (rela < relalim) { 12967251b4bfSJake Burkholder elf_reloc_local(lf, rela, ELF_RELOC_RELA); 12977251b4bfSJake Burkholder rela++; 12987251b4bfSJake Burkholder } 12997251b4bfSJake Burkholder } 13007251b4bfSJake Burkholder } 1301