1a4f67738SDoug Rabson /*-
24d846d26SWarner Losh * SPDX-License-Identifier: BSD-2-Clause
38a36da99SPedro F. Giffuni *
4326e27d8SDoug Rabson * Copyright (c) 1998-2000 Doug Rabson
5e9eabf59SPeter Wemm * Copyright (c) 2004 Peter Wemm
6a4f67738SDoug Rabson * All rights reserved.
7a4f67738SDoug Rabson *
8a4f67738SDoug Rabson * Redistribution and use in source and binary forms, with or without
9a4f67738SDoug Rabson * modification, are permitted provided that the following conditions
10a4f67738SDoug Rabson * are met:
11a4f67738SDoug Rabson * 1. Redistributions of source code must retain the above copyright
12a4f67738SDoug Rabson * notice, this list of conditions and the following disclaimer.
13a4f67738SDoug Rabson * 2. Redistributions in binary form must reproduce the above copyright
14a4f67738SDoug Rabson * notice, this list of conditions and the following disclaimer in the
15a4f67738SDoug Rabson * documentation and/or other materials provided with the distribution.
16a4f67738SDoug Rabson *
17a4f67738SDoug Rabson * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18a4f67738SDoug Rabson * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19a4f67738SDoug Rabson * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20a4f67738SDoug Rabson * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21a4f67738SDoug Rabson * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22a4f67738SDoug Rabson * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23a4f67738SDoug Rabson * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24a4f67738SDoug Rabson * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25a4f67738SDoug Rabson * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26a4f67738SDoug Rabson * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27a4f67738SDoug Rabson * SUCH DAMAGE.
28a4f67738SDoug Rabson */
29a4f67738SDoug Rabson
30326e27d8SDoug Rabson #include "opt_ddb.h"
31326e27d8SDoug Rabson
32a4f67738SDoug Rabson #include <sys/param.h>
33a4f67738SDoug Rabson #include <sys/systm.h>
34fbf2a778SKonstantin Belousov #include <sys/fcntl.h>
35fb919e4dSMark Murray #include <sys/kernel.h>
36fb919e4dSMark Murray #include <sys/lock.h>
37a4f67738SDoug Rabson #include <sys/malloc.h>
38fbf2a778SKonstantin Belousov #include <sys/linker.h>
39c0b824f9SDima Dorfman #include <sys/mutex.h>
4062d615d5SJohn Baldwin #include <sys/mount.h>
41a4f67738SDoug Rabson #include <sys/namei.h>
42fbf2a778SKonstantin Belousov #include <sys/proc.h>
43fbf2a778SKonstantin Belousov #include <sys/rwlock.h>
44ecd8245eSKonstantin Belousov #include <sys/sysctl.h>
45a4f67738SDoug Rabson #include <sys/vnode.h>
46fb919e4dSMark Murray
47a4f67738SDoug Rabson #include <machine/elf.h>
48a4f67738SDoug Rabson
49eddfbb76SRobert Watson #include <net/vnet.h>
50eddfbb76SRobert Watson
51aed55708SRobert Watson #include <security/mac/mac_framework.h>
52aed55708SRobert Watson
53fe3db7c7SDoug Rabson #include <vm/vm.h>
54fe3db7c7SDoug Rabson #include <vm/vm_param.h>
55fe3db7c7SDoug Rabson #include <vm/pmap.h>
56fbf2a778SKonstantin Belousov #include <vm/vm_extern.h>
57fbf2a778SKonstantin Belousov #include <vm/vm_kern.h>
58fe3db7c7SDoug Rabson #include <vm/vm_map.h>
59fbf2a778SKonstantin Belousov #include <vm/vm_object.h>
60fbf2a778SKonstantin Belousov #include <vm/vm_page.h>
61fbf2a778SKonstantin Belousov #include <vm/vm_pager.h>
62fb919e4dSMark Murray
63f9980387SPeter Wemm #include <sys/link_elf.h>
64fe3db7c7SDoug Rabson
65a2024a3eSJohn Birrell #ifdef DDB_CTF
6622bbc4b2SXin LI #include <contrib/zlib/zlib.h>
67a2024a3eSJohn Birrell #endif
68a2024a3eSJohn Birrell
69326e27d8SDoug Rabson #include "linker_if.h"
70a4f67738SDoug Rabson
71e9eabf59SPeter Wemm typedef struct {
72e9eabf59SPeter Wemm void *addr;
7320947801SPeter Wemm Elf_Off size;
741d9eae9fSMark Johnston int flags; /* Section flags. */
751d9eae9fSMark Johnston int sec; /* Original section number. */
76e9eabf59SPeter Wemm char *name;
77e9eabf59SPeter Wemm } Elf_progent;
78e9eabf59SPeter Wemm
79e9eabf59SPeter Wemm typedef struct {
80e9eabf59SPeter Wemm Elf_Rel *rel;
8120947801SPeter Wemm int nrel;
82e9eabf59SPeter Wemm int sec;
83e9eabf59SPeter Wemm } Elf_relent;
84e9eabf59SPeter Wemm
85e9eabf59SPeter Wemm typedef struct {
86e9eabf59SPeter Wemm Elf_Rela *rela;
8720947801SPeter Wemm int nrela;
88e9eabf59SPeter Wemm int sec;
89e9eabf59SPeter Wemm } Elf_relaent;
90e9eabf59SPeter Wemm
91a4f67738SDoug Rabson typedef struct elf_file {
92326e27d8SDoug Rabson struct linker_file lf; /* Common fields */
9320947801SPeter Wemm
9470b7ffeeSIan Dowse int preloaded;
95fe3db7c7SDoug Rabson caddr_t address; /* Relocation address */
96fe3db7c7SDoug Rabson vm_object_t object; /* VM object to hold file pages */
97e9eabf59SPeter Wemm Elf_Shdr *e_shdr;
98e9eabf59SPeter Wemm
99e9eabf59SPeter Wemm Elf_progent *progtab;
100d821d364SPedro F. Giffuni u_int nprogtab;
101e9eabf59SPeter Wemm
102e9eabf59SPeter Wemm Elf_relaent *relatab;
103d821d364SPedro F. Giffuni u_int nrelatab;
104e9eabf59SPeter Wemm
105e9eabf59SPeter Wemm Elf_relent *reltab;
106b474c780SDavid E. O'Brien int nreltab;
107e9eabf59SPeter Wemm
108e9eabf59SPeter Wemm Elf_Sym *ddbsymtab; /* The symbol table we are using */
1092d636ab0SPeter Wemm long ddbsymcnt; /* Number of symbols */
1102d636ab0SPeter Wemm caddr_t ddbstrtab; /* String table */
1112d636ab0SPeter Wemm long ddbstrcnt; /* number of bytes in string table */
112e9eabf59SPeter Wemm
113e9eabf59SPeter Wemm caddr_t shstrtab; /* Section name string table */
114e9eabf59SPeter Wemm long shstrcnt; /* number of bytes in string table */
115e9eabf59SPeter Wemm
116a2024a3eSJohn Birrell caddr_t ctftab; /* CTF table */
117a2024a3eSJohn Birrell long ctfcnt; /* number of bytes in CTF table */
118a2024a3eSJohn Birrell caddr_t ctfoff; /* CTF offset table */
119a2024a3eSJohn Birrell caddr_t typoff; /* Type offset table */
120a2024a3eSJohn Birrell long typlen; /* Number of type entries. */
121a2024a3eSJohn Birrell
122a4f67738SDoug Rabson } *elf_file_t;
123a4f67738SDoug Rabson
124a2024a3eSJohn Birrell #include <kern/kern_ctf.c>
125a2024a3eSJohn Birrell
12654823af2SPeter Wemm static int link_elf_link_preload(linker_class_t cls,
127326e27d8SDoug Rabson const char *, linker_file_t *);
12854823af2SPeter Wemm static int link_elf_link_preload_finish(linker_file_t);
12954823af2SPeter Wemm static int link_elf_load_file(linker_class_t, const char *, linker_file_t *);
130326e27d8SDoug Rabson static int link_elf_lookup_symbol(linker_file_t, const char *,
131326e27d8SDoug Rabson c_linker_sym_t *);
13295c20fafSKonstantin Belousov static int link_elf_lookup_debug_symbol(linker_file_t, const char *,
13395c20fafSKonstantin Belousov c_linker_sym_t *);
134c21bc6f3SBojan Novković static int link_elf_lookup_debug_symbol_ctf(linker_file_t lf,
135c21bc6f3SBojan Novković const char *name, c_linker_sym_t *sym, linker_ctf_t *lc);
136e9eabf59SPeter Wemm static int link_elf_symbol_values(linker_file_t, c_linker_sym_t,
137e9eabf59SPeter Wemm linker_symval_t *);
13895c20fafSKonstantin Belousov static int link_elf_debug_symbol_values(linker_file_t, c_linker_sym_t,
13995c20fafSKonstantin Belousov linker_symval_t *);
140326e27d8SDoug Rabson static int link_elf_search_symbol(linker_file_t, caddr_t value,
141326e27d8SDoug Rabson c_linker_sym_t *sym, long *diffp);
142326e27d8SDoug Rabson
143326e27d8SDoug Rabson static void link_elf_unload_file(linker_file_t);
144f41325dbSPeter Wemm static int link_elf_lookup_set(linker_file_t, const char *,
145f41325dbSPeter Wemm void ***, void ***, int *);
146bb9fe9ddSBrian Feldman static int link_elf_each_function_name(linker_file_t,
147e9eabf59SPeter Wemm int (*)(const char *, void *), void *);
148a2024a3eSJohn Birrell static int link_elf_each_function_nameval(linker_file_t,
149a2024a3eSJohn Birrell linker_function_nameval_callback_t,
150a2024a3eSJohn Birrell void *);
151289ead7cSKonstantin Belousov static int link_elf_reloc_local(linker_file_t, bool);
152e76f11f4SAndriy Gapon static long link_elf_symtab_get(linker_file_t, const Elf_Sym **);
15300a5db46SStacey Son static long link_elf_strtab_get(linker_file_t, caddr_t *);
154110113bcSZhenlei Huang #ifdef VIMAGE
155110113bcSZhenlei Huang static void link_elf_propagate_vnets(linker_file_t);
156110113bcSZhenlei Huang #endif
157326e27d8SDoug Rabson
158cff8c6f2SKonstantin Belousov static int elf_obj_lookup(linker_file_t lf, Elf_Size symidx, int deps,
159cff8c6f2SKonstantin Belousov Elf_Addr *);
160e9eabf59SPeter Wemm
161326e27d8SDoug Rabson static kobj_method_t link_elf_methods[] = {
162326e27d8SDoug Rabson KOBJMETHOD(linker_lookup_symbol, link_elf_lookup_symbol),
16395c20fafSKonstantin Belousov KOBJMETHOD(linker_lookup_debug_symbol, link_elf_lookup_debug_symbol),
164c21bc6f3SBojan Novković KOBJMETHOD(linker_lookup_debug_symbol_ctf, link_elf_lookup_debug_symbol_ctf),
165326e27d8SDoug Rabson KOBJMETHOD(linker_symbol_values, link_elf_symbol_values),
16695c20fafSKonstantin Belousov KOBJMETHOD(linker_debug_symbol_values, link_elf_debug_symbol_values),
167326e27d8SDoug Rabson KOBJMETHOD(linker_search_symbol, link_elf_search_symbol),
168326e27d8SDoug Rabson KOBJMETHOD(linker_unload, link_elf_unload_file),
16954823af2SPeter Wemm KOBJMETHOD(linker_load_file, link_elf_load_file),
17054823af2SPeter Wemm KOBJMETHOD(linker_link_preload, link_elf_link_preload),
17154823af2SPeter Wemm KOBJMETHOD(linker_link_preload_finish, link_elf_link_preload_finish),
172f41325dbSPeter Wemm KOBJMETHOD(linker_lookup_set, link_elf_lookup_set),
173bb9fe9ddSBrian Feldman KOBJMETHOD(linker_each_function_name, link_elf_each_function_name),
174a2024a3eSJohn Birrell KOBJMETHOD(linker_each_function_nameval, link_elf_each_function_nameval),
175a2024a3eSJohn Birrell KOBJMETHOD(linker_ctf_get, link_elf_ctf_get),
176c21bc6f3SBojan Novković KOBJMETHOD(linker_ctf_lookup_typename, link_elf_ctf_lookup_typename),
17700a5db46SStacey Son KOBJMETHOD(linker_symtab_get, link_elf_symtab_get),
17800a5db46SStacey Son KOBJMETHOD(linker_strtab_get, link_elf_strtab_get),
179110113bcSZhenlei Huang #ifdef VIMAGE
180110113bcSZhenlei Huang KOBJMETHOD(linker_propagate_vnets, link_elf_propagate_vnets),
181110113bcSZhenlei Huang #endif
1826d775f0bSMark Johnston KOBJMETHOD_END
183326e27d8SDoug Rabson };
184326e27d8SDoug Rabson
185326e27d8SDoug Rabson static struct linker_class link_elf_class = {
186326e27d8SDoug Rabson #if ELF_TARG_CLASS == ELFCLASS32
187e9eabf59SPeter Wemm "elf32_obj",
188326e27d8SDoug Rabson #else
189e9eabf59SPeter Wemm "elf64_obj",
190326e27d8SDoug Rabson #endif
191326e27d8SDoug Rabson link_elf_methods, sizeof(struct elf_file)
192326e27d8SDoug Rabson };
193326e27d8SDoug Rabson
194ecd8245eSKonstantin Belousov static bool link_elf_obj_leak_locals = true;
195ecd8245eSKonstantin Belousov SYSCTL_BOOL(_debug, OID_AUTO, link_elf_obj_leak_locals,
196ecd8245eSKonstantin Belousov CTLFLAG_RWTUN, &link_elf_obj_leak_locals, 0,
197ecd8245eSKonstantin Belousov "Allow local symbols to participate in global module symbol resolution");
198ecd8245eSKonstantin Belousov
199326e27d8SDoug Rabson static int relocate_file(elf_file_t ef);
2002832cd54SKonstantin Belousov static void elf_obj_cleanup_globals_cache(elf_file_t);
201a4f67738SDoug Rabson
202a4f67738SDoug Rabson static void
link_elf_error(const char * filename,const char * s)203552f9f63SEdwin Groothuis link_elf_error(const char *filename, const char *s)
2041720979bSMarcel Moolenaar {
205552f9f63SEdwin Groothuis if (filename == NULL)
2061720979bSMarcel Moolenaar printf("kldload: %s\n", s);
207552f9f63SEdwin Groothuis else
208552f9f63SEdwin Groothuis printf("kldload: %s: %s\n", filename, s);
2091720979bSMarcel Moolenaar }
2101720979bSMarcel Moolenaar
2111720979bSMarcel Moolenaar static void
link_elf_init(void * arg)212a4f67738SDoug Rabson link_elf_init(void *arg)
213a4f67738SDoug Rabson {
214a4f67738SDoug Rabson
215326e27d8SDoug Rabson linker_add_class(&link_elf_class);
216a4f67738SDoug Rabson }
217891cf3edSEd Maste SYSINIT(link_elf_obj, SI_SUB_KLD, SI_ORDER_SECOND, link_elf_init, NULL);
218a4f67738SDoug Rabson
2191d9eae9fSMark Johnston static void
link_elf_protect_range(elf_file_t ef,vm_offset_t start,vm_offset_t end,vm_prot_t prot)2201d9eae9fSMark Johnston link_elf_protect_range(elf_file_t ef, vm_offset_t start, vm_offset_t end,
2211d9eae9fSMark Johnston vm_prot_t prot)
2221d9eae9fSMark Johnston {
2231d9eae9fSMark Johnston int error __unused;
2241d9eae9fSMark Johnston
2251d9eae9fSMark Johnston KASSERT(start <= end && start >= (vm_offset_t)ef->address &&
2261d9eae9fSMark Johnston end <= round_page((vm_offset_t)ef->address + ef->lf.size),
2271d9eae9fSMark Johnston ("link_elf_protect_range: invalid range %#jx-%#jx",
2281d9eae9fSMark Johnston (uintmax_t)start, (uintmax_t)end));
2291d9eae9fSMark Johnston
2301d9eae9fSMark Johnston if (start == end)
2311d9eae9fSMark Johnston return;
232f822c9e2SMark Johnston if (ef->preloaded) {
233f822c9e2SMark Johnston #ifdef __amd64__
234f822c9e2SMark Johnston error = pmap_change_prot(start, end - start, prot);
235f822c9e2SMark Johnston KASSERT(error == 0,
236f822c9e2SMark Johnston ("link_elf_protect_range: pmap_change_prot() returned %d",
237f822c9e2SMark Johnston error));
238f822c9e2SMark Johnston #endif
239f822c9e2SMark Johnston return;
240f822c9e2SMark Johnston }
2410659df6fSKonstantin Belousov error = vm_map_protect(kernel_map, start, end, prot, 0,
2420659df6fSKonstantin Belousov VM_MAP_PROTECT_SET_PROT);
2431d9eae9fSMark Johnston KASSERT(error == KERN_SUCCESS,
2441d9eae9fSMark Johnston ("link_elf_protect_range: vm_map_protect() returned %d", error));
2451d9eae9fSMark Johnston }
2461d9eae9fSMark Johnston
2471d9eae9fSMark Johnston /*
2481d9eae9fSMark Johnston * Restrict permissions on linker file memory based on section flags.
2491d9eae9fSMark Johnston * Sections need not be page-aligned, so overlap within a page is possible.
2501d9eae9fSMark Johnston */
2511d9eae9fSMark Johnston static void
link_elf_protect(elf_file_t ef)2521d9eae9fSMark Johnston link_elf_protect(elf_file_t ef)
2531d9eae9fSMark Johnston {
2541d9eae9fSMark Johnston vm_offset_t end, segend, segstart, start;
2551d9eae9fSMark Johnston vm_prot_t gapprot, prot, segprot;
2561d9eae9fSMark Johnston int i;
2571d9eae9fSMark Johnston
2581d9eae9fSMark Johnston /*
2591d9eae9fSMark Johnston * If the file was preloaded, the last page may contain other preloaded
2601d9eae9fSMark Johnston * data which may need to be writeable. ELF files are always
2611d9eae9fSMark Johnston * page-aligned, but other preloaded data, such as entropy or CPU
2621d9eae9fSMark Johnston * microcode may be loaded with a smaller alignment.
2631d9eae9fSMark Johnston */
2641d9eae9fSMark Johnston gapprot = ef->preloaded ? VM_PROT_RW : VM_PROT_READ;
2651d9eae9fSMark Johnston
2661d9eae9fSMark Johnston start = end = (vm_offset_t)ef->address;
2671d9eae9fSMark Johnston prot = VM_PROT_READ;
2681d9eae9fSMark Johnston for (i = 0; i < ef->nprogtab; i++) {
2691d9eae9fSMark Johnston /*
2701d9eae9fSMark Johnston * VNET and DPCPU sections have their memory allocated by their
2711d9eae9fSMark Johnston * respective subsystems.
2721d9eae9fSMark Johnston */
2731d9eae9fSMark Johnston if (ef->progtab[i].name != NULL && (
2741d9eae9fSMark Johnston #ifdef VIMAGE
2751d9eae9fSMark Johnston strcmp(ef->progtab[i].name, VNET_SETNAME) == 0 ||
2761d9eae9fSMark Johnston #endif
2771d9eae9fSMark Johnston strcmp(ef->progtab[i].name, DPCPU_SETNAME) == 0))
2781d9eae9fSMark Johnston continue;
2791d9eae9fSMark Johnston
2801d9eae9fSMark Johnston segstart = trunc_page((vm_offset_t)ef->progtab[i].addr);
2811d9eae9fSMark Johnston segend = round_page((vm_offset_t)ef->progtab[i].addr +
2821d9eae9fSMark Johnston ef->progtab[i].size);
2831d9eae9fSMark Johnston segprot = VM_PROT_READ;
2841d9eae9fSMark Johnston if ((ef->progtab[i].flags & SHF_WRITE) != 0)
2851d9eae9fSMark Johnston segprot |= VM_PROT_WRITE;
2861d9eae9fSMark Johnston if ((ef->progtab[i].flags & SHF_EXECINSTR) != 0)
2871d9eae9fSMark Johnston segprot |= VM_PROT_EXECUTE;
2881d9eae9fSMark Johnston
2891d9eae9fSMark Johnston if (end <= segstart) {
2901d9eae9fSMark Johnston /*
2911d9eae9fSMark Johnston * Case 1: there is no overlap between the previous
2921d9eae9fSMark Johnston * segment and this one. Apply protections to the
2931d9eae9fSMark Johnston * previous segment, and protect the gap between the
2941d9eae9fSMark Johnston * previous and current segments, if any.
2951d9eae9fSMark Johnston */
2961d9eae9fSMark Johnston link_elf_protect_range(ef, start, end, prot);
2971d9eae9fSMark Johnston link_elf_protect_range(ef, end, segstart, gapprot);
2981d9eae9fSMark Johnston
2991d9eae9fSMark Johnston start = segstart;
3001d9eae9fSMark Johnston end = segend;
3011d9eae9fSMark Johnston prot = segprot;
3021d9eae9fSMark Johnston } else if (start < segstart && end == segend) {
3031d9eae9fSMark Johnston /*
3041d9eae9fSMark Johnston * Case 2: the current segment is a subrange of the
3051d9eae9fSMark Johnston * previous segment. Apply protections to the
3061d9eae9fSMark Johnston * non-overlapping portion of the previous segment.
3071d9eae9fSMark Johnston */
3081d9eae9fSMark Johnston link_elf_protect_range(ef, start, segstart, prot);
3091d9eae9fSMark Johnston
3101d9eae9fSMark Johnston start = segstart;
3111d9eae9fSMark Johnston prot |= segprot;
3121d9eae9fSMark Johnston } else if (end < segend) {
3131d9eae9fSMark Johnston /*
3141d9eae9fSMark Johnston * Case 3: there is partial overlap between the previous
3151d9eae9fSMark Johnston * and current segments. Apply protections to the
3161d9eae9fSMark Johnston * non-overlapping portion of the previous segment, and
3171d9eae9fSMark Johnston * then the overlap, which must use the union of the two
3181d9eae9fSMark Johnston * segments' protections.
3191d9eae9fSMark Johnston */
3201d9eae9fSMark Johnston link_elf_protect_range(ef, start, segstart, prot);
3211d9eae9fSMark Johnston link_elf_protect_range(ef, segstart, end,
3221d9eae9fSMark Johnston prot | segprot);
3231d9eae9fSMark Johnston start = end;
3241d9eae9fSMark Johnston end = segend;
3251d9eae9fSMark Johnston prot = segprot;
3261d9eae9fSMark Johnston } else {
3271d9eae9fSMark Johnston /*
3281d9eae9fSMark Johnston * Case 4: the two segments reside in the same page.
3291d9eae9fSMark Johnston */
3301d9eae9fSMark Johnston prot |= segprot;
3311d9eae9fSMark Johnston }
3321d9eae9fSMark Johnston }
3331d9eae9fSMark Johnston
3341d9eae9fSMark Johnston /*
3351d9eae9fSMark Johnston * Fix up the last unprotected segment and trailing data.
3361d9eae9fSMark Johnston */
3371d9eae9fSMark Johnston link_elf_protect_range(ef, start, end, prot);
3381d9eae9fSMark Johnston link_elf_protect_range(ef, end,
3391d9eae9fSMark Johnston round_page((vm_offset_t)ef->address + ef->lf.size), gapprot);
3401d9eae9fSMark Johnston }
3411d9eae9fSMark Johnston
342a4f67738SDoug Rabson static int
link_elf_link_preload(linker_class_t cls,const char * filename,linker_file_t * result)343e9eabf59SPeter Wemm link_elf_link_preload(linker_class_t cls, const char *filename,
344e9eabf59SPeter Wemm linker_file_t *result)
3452d636ab0SPeter Wemm {
34670b7ffeeSIan Dowse Elf_Ehdr *hdr;
34770b7ffeeSIan Dowse Elf_Shdr *shdr;
34870b7ffeeSIan Dowse Elf_Sym *es;
34970b7ffeeSIan Dowse void *modptr, *baseptr, *sizeptr;
35070b7ffeeSIan Dowse char *type;
35170b7ffeeSIan Dowse elf_file_t ef;
35270b7ffeeSIan Dowse linker_file_t lf;
35370b7ffeeSIan Dowse Elf_Addr off;
35470b7ffeeSIan Dowse int error, i, j, pb, ra, rl, shstrindex, symstrindex, symtabindex;
35570b7ffeeSIan Dowse
35670b7ffeeSIan Dowse /* Look to see if we have the file preloaded */
35770b7ffeeSIan Dowse modptr = preload_search_by_name(filename);
35870b7ffeeSIan Dowse if (modptr == NULL)
35970b7ffeeSIan Dowse return ENOENT;
36070b7ffeeSIan Dowse
36170b7ffeeSIan Dowse type = (char *)preload_search_info(modptr, MODINFO_TYPE);
36270b7ffeeSIan Dowse baseptr = preload_search_info(modptr, MODINFO_ADDR);
36370b7ffeeSIan Dowse sizeptr = preload_search_info(modptr, MODINFO_SIZE);
36470b7ffeeSIan Dowse hdr = (Elf_Ehdr *)preload_search_info(modptr, MODINFO_METADATA |
36570b7ffeeSIan Dowse MODINFOMD_ELFHDR);
36670b7ffeeSIan Dowse shdr = (Elf_Shdr *)preload_search_info(modptr, MODINFO_METADATA |
36770b7ffeeSIan Dowse MODINFOMD_SHDR);
36870b7ffeeSIan Dowse if (type == NULL || (strcmp(type, "elf" __XSTRING(__ELF_WORD_SIZE)
36970b7ffeeSIan Dowse " obj module") != 0 &&
37070b7ffeeSIan Dowse strcmp(type, "elf obj module") != 0)) {
371de78ca7eSPeter Wemm return (EFTYPE);
372de78ca7eSPeter Wemm }
37370b7ffeeSIan Dowse if (baseptr == NULL || sizeptr == NULL || hdr == NULL ||
37470b7ffeeSIan Dowse shdr == NULL)
37570b7ffeeSIan Dowse return (EINVAL);
37670b7ffeeSIan Dowse
37770b7ffeeSIan Dowse lf = linker_make_file(filename, &link_elf_class);
37870b7ffeeSIan Dowse if (lf == NULL)
37970b7ffeeSIan Dowse return (ENOMEM);
38070b7ffeeSIan Dowse
38170b7ffeeSIan Dowse ef = (elf_file_t)lf;
38270b7ffeeSIan Dowse ef->preloaded = 1;
38370b7ffeeSIan Dowse ef->address = *(caddr_t *)baseptr;
38470b7ffeeSIan Dowse lf->address = *(caddr_t *)baseptr;
38570b7ffeeSIan Dowse lf->size = *(size_t *)sizeptr;
38670b7ffeeSIan Dowse
38770b7ffeeSIan Dowse if (hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS ||
38870b7ffeeSIan Dowse hdr->e_ident[EI_DATA] != ELF_TARG_DATA ||
38970b7ffeeSIan Dowse hdr->e_ident[EI_VERSION] != EV_CURRENT ||
39070b7ffeeSIan Dowse hdr->e_version != EV_CURRENT ||
39170b7ffeeSIan Dowse hdr->e_type != ET_REL ||
39270b7ffeeSIan Dowse hdr->e_machine != ELF_TARG_MACH) {
39370b7ffeeSIan Dowse error = EFTYPE;
39470b7ffeeSIan Dowse goto out;
39570b7ffeeSIan Dowse }
39670b7ffeeSIan Dowse ef->e_shdr = shdr;
39770b7ffeeSIan Dowse
39870b7ffeeSIan Dowse /* Scan the section header for information and table sizing. */
39970b7ffeeSIan Dowse symtabindex = -1;
40070b7ffeeSIan Dowse symstrindex = -1;
40170b7ffeeSIan Dowse for (i = 0; i < hdr->e_shnum; i++) {
40270b7ffeeSIan Dowse switch (shdr[i].sh_type) {
40370b7ffeeSIan Dowse case SHT_PROGBITS:
40470b7ffeeSIan Dowse case SHT_NOBITS:
40513f28d96SKonstantin Belousov #ifdef __amd64__
406b715d9afSKonstantin Belousov case SHT_X86_64_UNWIND:
40713f28d96SKonstantin Belousov #endif
4085e6989baSMark Johnston case SHT_INIT_ARRAY:
4095e6989baSMark Johnston case SHT_FINI_ARRAY:
41058c4aee0SJohn Baldwin /* Ignore sections not loaded by the loader. */
41158c4aee0SJohn Baldwin if (shdr[i].sh_addr == 0)
41258c4aee0SJohn Baldwin break;
41370b7ffeeSIan Dowse ef->nprogtab++;
41470b7ffeeSIan Dowse break;
41570b7ffeeSIan Dowse case SHT_SYMTAB:
41670b7ffeeSIan Dowse symtabindex = i;
41770b7ffeeSIan Dowse symstrindex = shdr[i].sh_link;
41870b7ffeeSIan Dowse break;
41970b7ffeeSIan Dowse case SHT_REL:
42015746ef4SJohn Baldwin /*
42115746ef4SJohn Baldwin * Ignore relocation tables for sections not
42215746ef4SJohn Baldwin * loaded by the loader.
42315746ef4SJohn Baldwin */
42415746ef4SJohn Baldwin if (shdr[shdr[i].sh_info].sh_addr == 0)
42515746ef4SJohn Baldwin break;
426b474c780SDavid E. O'Brien ef->nreltab++;
42770b7ffeeSIan Dowse break;
42870b7ffeeSIan Dowse case SHT_RELA:
42915746ef4SJohn Baldwin if (shdr[shdr[i].sh_info].sh_addr == 0)
43015746ef4SJohn Baldwin break;
431b474c780SDavid E. O'Brien ef->nrelatab++;
43270b7ffeeSIan Dowse break;
43370b7ffeeSIan Dowse }
43470b7ffeeSIan Dowse }
43570b7ffeeSIan Dowse
43670b7ffeeSIan Dowse shstrindex = hdr->e_shstrndx;
43770b7ffeeSIan Dowse if (ef->nprogtab == 0 || symstrindex < 0 ||
43870b7ffeeSIan Dowse symstrindex >= hdr->e_shnum ||
43970b7ffeeSIan Dowse shdr[symstrindex].sh_type != SHT_STRTAB || shstrindex == 0 ||
44070b7ffeeSIan Dowse shstrindex >= hdr->e_shnum ||
44170b7ffeeSIan Dowse shdr[shstrindex].sh_type != SHT_STRTAB) {
44270b7ffeeSIan Dowse printf("%s: bad/missing section headers\n", filename);
44370b7ffeeSIan Dowse error = ENOEXEC;
44470b7ffeeSIan Dowse goto out;
44570b7ffeeSIan Dowse }
44670b7ffeeSIan Dowse
44770b7ffeeSIan Dowse /* Allocate space for tracking the load chunks */
44870b7ffeeSIan Dowse if (ef->nprogtab != 0)
44970b7ffeeSIan Dowse ef->progtab = malloc(ef->nprogtab * sizeof(*ef->progtab),
45070b7ffeeSIan Dowse M_LINKER, M_WAITOK | M_ZERO);
451b474c780SDavid E. O'Brien if (ef->nreltab != 0)
452b474c780SDavid E. O'Brien ef->reltab = malloc(ef->nreltab * sizeof(*ef->reltab),
453b474c780SDavid E. O'Brien M_LINKER, M_WAITOK | M_ZERO);
454b474c780SDavid E. O'Brien if (ef->nrelatab != 0)
455b474c780SDavid E. O'Brien ef->relatab = malloc(ef->nrelatab * sizeof(*ef->relatab),
456b474c780SDavid E. O'Brien M_LINKER, M_WAITOK | M_ZERO);
45770b7ffeeSIan Dowse if ((ef->nprogtab != 0 && ef->progtab == NULL) ||
458b474c780SDavid E. O'Brien (ef->nreltab != 0 && ef->reltab == NULL) ||
459b474c780SDavid E. O'Brien (ef->nrelatab != 0 && ef->relatab == NULL)) {
46070b7ffeeSIan Dowse error = ENOMEM;
46170b7ffeeSIan Dowse goto out;
46270b7ffeeSIan Dowse }
46370b7ffeeSIan Dowse
46470b7ffeeSIan Dowse /* XXX, relocate the sh_addr fields saved by the loader. */
46570b7ffeeSIan Dowse off = 0;
46670b7ffeeSIan Dowse for (i = 0; i < hdr->e_shnum; i++) {
46770b7ffeeSIan Dowse if (shdr[i].sh_addr != 0 && (off == 0 || shdr[i].sh_addr < off))
46870b7ffeeSIan Dowse off = shdr[i].sh_addr;
46970b7ffeeSIan Dowse }
47070b7ffeeSIan Dowse for (i = 0; i < hdr->e_shnum; i++) {
47170b7ffeeSIan Dowse if (shdr[i].sh_addr != 0)
47270b7ffeeSIan Dowse shdr[i].sh_addr = shdr[i].sh_addr - off +
47370b7ffeeSIan Dowse (Elf_Addr)ef->address;
47470b7ffeeSIan Dowse }
47570b7ffeeSIan Dowse
47670b7ffeeSIan Dowse ef->ddbsymcnt = shdr[symtabindex].sh_size / sizeof(Elf_Sym);
47770b7ffeeSIan Dowse ef->ddbsymtab = (Elf_Sym *)shdr[symtabindex].sh_addr;
47870b7ffeeSIan Dowse ef->ddbstrcnt = shdr[symstrindex].sh_size;
47970b7ffeeSIan Dowse ef->ddbstrtab = (char *)shdr[symstrindex].sh_addr;
48070b7ffeeSIan Dowse ef->shstrcnt = shdr[shstrindex].sh_size;
48170b7ffeeSIan Dowse ef->shstrtab = (char *)shdr[shstrindex].sh_addr;
48270b7ffeeSIan Dowse
48370b7ffeeSIan Dowse /* Now fill out progtab and the relocation tables. */
48470b7ffeeSIan Dowse pb = 0;
48570b7ffeeSIan Dowse rl = 0;
48670b7ffeeSIan Dowse ra = 0;
48770b7ffeeSIan Dowse for (i = 0; i < hdr->e_shnum; i++) {
48870b7ffeeSIan Dowse switch (shdr[i].sh_type) {
48970b7ffeeSIan Dowse case SHT_PROGBITS:
49070b7ffeeSIan Dowse case SHT_NOBITS:
49113f28d96SKonstantin Belousov #ifdef __amd64__
492b715d9afSKonstantin Belousov case SHT_X86_64_UNWIND:
49313f28d96SKonstantin Belousov #endif
4944aa157ddSMark Johnston case SHT_INIT_ARRAY:
4955e6989baSMark Johnston case SHT_FINI_ARRAY:
49658c4aee0SJohn Baldwin if (shdr[i].sh_addr == 0)
49758c4aee0SJohn Baldwin break;
49870b7ffeeSIan Dowse ef->progtab[pb].addr = (void *)shdr[i].sh_addr;
49970b7ffeeSIan Dowse if (shdr[i].sh_type == SHT_PROGBITS)
50070b7ffeeSIan Dowse ef->progtab[pb].name = "<<PROGBITS>>";
50113f28d96SKonstantin Belousov #ifdef __amd64__
502b715d9afSKonstantin Belousov else if (shdr[i].sh_type == SHT_X86_64_UNWIND)
50313f28d96SKonstantin Belousov ef->progtab[pb].name = "<<UNWIND>>";
50413f28d96SKonstantin Belousov #endif
5055e6989baSMark Johnston else if (shdr[i].sh_type == SHT_INIT_ARRAY)
5065e6989baSMark Johnston ef->progtab[pb].name = "<<INIT_ARRAY>>";
5075e6989baSMark Johnston else if (shdr[i].sh_type == SHT_FINI_ARRAY)
5085e6989baSMark Johnston ef->progtab[pb].name = "<<FINI_ARRAY>>";
50970b7ffeeSIan Dowse else
51070b7ffeeSIan Dowse ef->progtab[pb].name = "<<NOBITS>>";
51170b7ffeeSIan Dowse ef->progtab[pb].size = shdr[i].sh_size;
5121d9eae9fSMark Johnston ef->progtab[pb].flags = shdr[i].sh_flags;
51370b7ffeeSIan Dowse ef->progtab[pb].sec = i;
51470b7ffeeSIan Dowse if (ef->shstrtab && shdr[i].sh_name != 0)
51570b7ffeeSIan Dowse ef->progtab[pb].name =
51670b7ffeeSIan Dowse ef->shstrtab + shdr[i].sh_name;
51750c202c5SJeff Roberson if (ef->progtab[pb].name != NULL &&
5185f67450dSDimitry Andric !strcmp(ef->progtab[pb].name, DPCPU_SETNAME)) {
51950c202c5SJeff Roberson void *dpcpu;
52050c202c5SJeff Roberson
52150c202c5SJeff Roberson dpcpu = dpcpu_alloc(shdr[i].sh_size);
52250c202c5SJeff Roberson if (dpcpu == NULL) {
5230f823b64SBjoern A. Zeeb printf("%s: pcpu module space is out "
5249afc5684SBjoern A. Zeeb "of space; cannot allocate %#jx "
5259afc5684SBjoern A. Zeeb "for %s\n", __func__,
5269afc5684SBjoern A. Zeeb (uintmax_t)shdr[i].sh_size,
5270f823b64SBjoern A. Zeeb filename);
52850c202c5SJeff Roberson error = ENOSPC;
52950c202c5SJeff Roberson goto out;
53050c202c5SJeff Roberson }
53150c202c5SJeff Roberson memcpy(dpcpu, ef->progtab[pb].addr,
53250c202c5SJeff Roberson ef->progtab[pb].size);
53350c202c5SJeff Roberson dpcpu_copy(dpcpu, shdr[i].sh_size);
53450c202c5SJeff Roberson ef->progtab[pb].addr = dpcpu;
535eddfbb76SRobert Watson #ifdef VIMAGE
536eddfbb76SRobert Watson } else if (ef->progtab[pb].name != NULL &&
53717ef1febSRobert Watson !strcmp(ef->progtab[pb].name, VNET_SETNAME)) {
538eddfbb76SRobert Watson void *vnet_data;
539eddfbb76SRobert Watson
540eddfbb76SRobert Watson vnet_data = vnet_data_alloc(shdr[i].sh_size);
541eddfbb76SRobert Watson if (vnet_data == NULL) {
5420f823b64SBjoern A. Zeeb printf("%s: vnet module space is out "
5439afc5684SBjoern A. Zeeb "of space; cannot allocate %#jx "
5449afc5684SBjoern A. Zeeb "for %s\n", __func__,
5459afc5684SBjoern A. Zeeb (uintmax_t)shdr[i].sh_size,
5460f823b64SBjoern A. Zeeb filename);
547eddfbb76SRobert Watson error = ENOSPC;
548eddfbb76SRobert Watson goto out;
549eddfbb76SRobert Watson }
550eddfbb76SRobert Watson memcpy(vnet_data, ef->progtab[pb].addr,
551eddfbb76SRobert Watson ef->progtab[pb].size);
552eddfbb76SRobert Watson ef->progtab[pb].addr = vnet_data;
553cf7974fdSZhenlei Huang vnet_save_init(ef->progtab[pb].addr,
554cf7974fdSZhenlei Huang ef->progtab[pb].size);
555eddfbb76SRobert Watson #endif
5565e6989baSMark Johnston } else if ((ef->progtab[pb].name != NULL &&
5575e6989baSMark Johnston strcmp(ef->progtab[pb].name, ".ctors") == 0) ||
5585e6989baSMark Johnston shdr[i].sh_type == SHT_INIT_ARRAY) {
5595e6989baSMark Johnston if (lf->ctors_addr != 0) {
5605e6989baSMark Johnston printf(
5615e6989baSMark Johnston "%s: multiple ctor sections in %s\n",
5625e6989baSMark Johnston __func__, filename);
5635e6989baSMark Johnston } else {
5640067051fSMarcel Moolenaar lf->ctors_addr = ef->progtab[pb].addr;
5650067051fSMarcel Moolenaar lf->ctors_size = shdr[i].sh_size;
56650c202c5SJeff Roberson }
5679e575fadSMark Johnston } else if ((ef->progtab[pb].name != NULL &&
5689e575fadSMark Johnston strcmp(ef->progtab[pb].name, ".dtors") == 0) ||
5699e575fadSMark Johnston shdr[i].sh_type == SHT_FINI_ARRAY) {
5709e575fadSMark Johnston if (lf->dtors_addr != 0) {
5719e575fadSMark Johnston printf(
5729e575fadSMark Johnston "%s: multiple dtor sections in %s\n",
5739e575fadSMark Johnston __func__, filename);
5749e575fadSMark Johnston } else {
5759e575fadSMark Johnston lf->dtors_addr = ef->progtab[pb].addr;
5769e575fadSMark Johnston lf->dtors_size = shdr[i].sh_size;
5779e575fadSMark Johnston }
5785e6989baSMark Johnston }
57970b7ffeeSIan Dowse
58070b7ffeeSIan Dowse /* Update all symbol values with the offset. */
58170b7ffeeSIan Dowse for (j = 0; j < ef->ddbsymcnt; j++) {
58270b7ffeeSIan Dowse es = &ef->ddbsymtab[j];
58370b7ffeeSIan Dowse if (es->st_shndx != i)
58470b7ffeeSIan Dowse continue;
58570b7ffeeSIan Dowse es->st_value += (Elf_Addr)ef->progtab[pb].addr;
58670b7ffeeSIan Dowse }
58770b7ffeeSIan Dowse pb++;
58870b7ffeeSIan Dowse break;
58970b7ffeeSIan Dowse case SHT_REL:
59015746ef4SJohn Baldwin if (shdr[shdr[i].sh_info].sh_addr == 0)
59115746ef4SJohn Baldwin break;
59270b7ffeeSIan Dowse ef->reltab[rl].rel = (Elf_Rel *)shdr[i].sh_addr;
59370b7ffeeSIan Dowse ef->reltab[rl].nrel = shdr[i].sh_size / sizeof(Elf_Rel);
59470b7ffeeSIan Dowse ef->reltab[rl].sec = shdr[i].sh_info;
59570b7ffeeSIan Dowse rl++;
59670b7ffeeSIan Dowse break;
59770b7ffeeSIan Dowse case SHT_RELA:
59815746ef4SJohn Baldwin if (shdr[shdr[i].sh_info].sh_addr == 0)
59915746ef4SJohn Baldwin break;
60070b7ffeeSIan Dowse ef->relatab[ra].rela = (Elf_Rela *)shdr[i].sh_addr;
60170b7ffeeSIan Dowse ef->relatab[ra].nrela =
60270b7ffeeSIan Dowse shdr[i].sh_size / sizeof(Elf_Rela);
60370b7ffeeSIan Dowse ef->relatab[ra].sec = shdr[i].sh_info;
60470b7ffeeSIan Dowse ra++;
60570b7ffeeSIan Dowse break;
60670b7ffeeSIan Dowse }
60770b7ffeeSIan Dowse }
6083cfce8e4SKonstantin Belousov if (pb != ef->nprogtab) {
6093cfce8e4SKonstantin Belousov printf("%s: lost progbits\n", filename);
6103cfce8e4SKonstantin Belousov error = ENOEXEC;
6113cfce8e4SKonstantin Belousov goto out;
6123cfce8e4SKonstantin Belousov }
6133cfce8e4SKonstantin Belousov if (rl != ef->nreltab) {
6143cfce8e4SKonstantin Belousov printf("%s: lost reltab\n", filename);
6153cfce8e4SKonstantin Belousov error = ENOEXEC;
6163cfce8e4SKonstantin Belousov goto out;
6173cfce8e4SKonstantin Belousov }
6183cfce8e4SKonstantin Belousov if (ra != ef->nrelatab) {
6193cfce8e4SKonstantin Belousov printf("%s: lost relatab\n", filename);
6203cfce8e4SKonstantin Belousov error = ENOEXEC;
6213cfce8e4SKonstantin Belousov goto out;
6223cfce8e4SKonstantin Belousov }
62370b7ffeeSIan Dowse
624f822c9e2SMark Johnston /*
625f822c9e2SMark Johnston * The file needs to be writeable and executable while applying
626f822c9e2SMark Johnston * relocations. Mapping protections are applied once relocation
627f822c9e2SMark Johnston * processing is complete.
628f822c9e2SMark Johnston */
629f822c9e2SMark Johnston link_elf_protect_range(ef, (vm_offset_t)ef->address,
630f822c9e2SMark Johnston round_page((vm_offset_t)ef->address + ef->lf.size), VM_PROT_ALL);
631f822c9e2SMark Johnston
63270b7ffeeSIan Dowse /* Local intra-module relocations */
633289ead7cSKonstantin Belousov error = link_elf_reloc_local(lf, false);
6343cfce8e4SKonstantin Belousov if (error != 0)
6353cfce8e4SKonstantin Belousov goto out;
63670b7ffeeSIan Dowse *result = lf;
63770b7ffeeSIan Dowse return (0);
63870b7ffeeSIan Dowse
63970b7ffeeSIan Dowse out:
64070b7ffeeSIan Dowse /* preload not done this way */
64170b7ffeeSIan Dowse linker_file_unload(lf, LINKER_UNLOAD_FORCE);
64270b7ffeeSIan Dowse return (error);
64370b7ffeeSIan Dowse }
644de78ca7eSPeter Wemm
6450067051fSMarcel Moolenaar static void
link_elf_invoke_cbs(caddr_t addr,size_t size)6469e575fadSMark Johnston link_elf_invoke_cbs(caddr_t addr, size_t size)
6470067051fSMarcel Moolenaar {
6480067051fSMarcel Moolenaar void (**ctor)(void);
6490067051fSMarcel Moolenaar size_t i, cnt;
6500067051fSMarcel Moolenaar
6510067051fSMarcel Moolenaar if (addr == NULL || size == 0)
6520067051fSMarcel Moolenaar return;
6530067051fSMarcel Moolenaar cnt = size / sizeof(*ctor);
6540067051fSMarcel Moolenaar ctor = (void *)addr;
6550067051fSMarcel Moolenaar for (i = 0; i < cnt; i++) {
6560067051fSMarcel Moolenaar if (ctor[i] != NULL)
6570067051fSMarcel Moolenaar (*ctor[i])();
6580067051fSMarcel Moolenaar }
6590067051fSMarcel Moolenaar }
6600067051fSMarcel Moolenaar
6617ef5c19bSMark Johnston static void
link_elf_invoke_ctors(linker_file_t lf)6627ef5c19bSMark Johnston link_elf_invoke_ctors(linker_file_t lf)
6637ef5c19bSMark Johnston {
6647ef5c19bSMark Johnston KASSERT(lf->ctors_invoked == LF_NONE,
6657ef5c19bSMark Johnston ("%s: file %s ctor state %d",
6667ef5c19bSMark Johnston __func__, lf->filename, lf->ctors_invoked));
6677ef5c19bSMark Johnston
6687ef5c19bSMark Johnston link_elf_invoke_cbs(lf->ctors_addr, lf->ctors_size);
6697ef5c19bSMark Johnston lf->ctors_invoked = LF_CTORS;
6707ef5c19bSMark Johnston }
6717ef5c19bSMark Johnston
6727ef5c19bSMark Johnston static void
link_elf_invoke_dtors(linker_file_t lf)6737ef5c19bSMark Johnston link_elf_invoke_dtors(linker_file_t lf)
6747ef5c19bSMark Johnston {
6757ef5c19bSMark Johnston KASSERT(lf->ctors_invoked != LF_DTORS,
6767ef5c19bSMark Johnston ("%s: file %s ctor state %d",
6777ef5c19bSMark Johnston __func__, lf->filename, lf->ctors_invoked));
6787ef5c19bSMark Johnston
6797ef5c19bSMark Johnston if (lf->ctors_invoked == LF_CTORS) {
6807ef5c19bSMark Johnston link_elf_invoke_cbs(lf->dtors_addr, lf->dtors_size);
6817ef5c19bSMark Johnston lf->ctors_invoked = LF_DTORS;
6827ef5c19bSMark Johnston }
6837ef5c19bSMark Johnston }
6847ef5c19bSMark Johnston
685de78ca7eSPeter Wemm static int
link_elf_link_preload_finish(linker_file_t lf)68654823af2SPeter Wemm link_elf_link_preload_finish(linker_file_t lf)
68754823af2SPeter Wemm {
68870b7ffeeSIan Dowse elf_file_t ef;
68970b7ffeeSIan Dowse int error;
69070b7ffeeSIan Dowse
69170b7ffeeSIan Dowse ef = (elf_file_t)lf;
69270b7ffeeSIan Dowse error = relocate_file(ef);
69370b7ffeeSIan Dowse if (error)
694289ead7cSKonstantin Belousov return (error);
69570b7ffeeSIan Dowse
69670b7ffeeSIan Dowse /* Notify MD code that a module is being loaded. */
69770b7ffeeSIan Dowse error = elf_cpu_load_file(lf);
69870b7ffeeSIan Dowse if (error)
69970b7ffeeSIan Dowse return (error);
70070b7ffeeSIan Dowse
7018f941950SKonstantin Belousov #if defined(__i386__) || defined(__amd64__)
702289ead7cSKonstantin Belousov /* Now ifuncs. */
703289ead7cSKonstantin Belousov error = link_elf_reloc_local(lf, true);
704289ead7cSKonstantin Belousov if (error != 0)
705289ead7cSKonstantin Belousov return (error);
7068f941950SKonstantin Belousov #endif
707289ead7cSKonstantin Belousov
708f822c9e2SMark Johnston /* Apply protections now that relocation processing is complete. */
709f822c9e2SMark Johnston link_elf_protect(ef);
710f822c9e2SMark Johnston
7117ef5c19bSMark Johnston link_elf_invoke_ctors(lf);
71270b7ffeeSIan Dowse return (0);
71354823af2SPeter Wemm }
71454823af2SPeter Wemm
71554823af2SPeter Wemm static int
link_elf_load_file(linker_class_t cls,const char * filename,linker_file_t * result)716c143d6c2SMarcel Moolenaar link_elf_load_file(linker_class_t cls, const char *filename,
717c143d6c2SMarcel Moolenaar linker_file_t *result)
718a4f67738SDoug Rabson {
719a344babfSGleb Smirnoff struct nameidata *nd;
720b40ce416SJulian Elischer struct thread *td = curthread; /* XXX */
721caab6e90SPeter Wemm Elf_Ehdr *hdr;
722e9eabf59SPeter Wemm Elf_Shdr *shdr;
723a8774e39SPeter Wemm Elf_Sym *es;
724a8774e39SPeter Wemm int nbytes, i, j;
72520947801SPeter Wemm vm_offset_t mapbase;
726fe3db7c7SDoug Rabson size_t mapsize;
727a4f67738SDoug Rabson int error = 0;
728526d0bd5SKonstantin Belousov ssize_t resid;
729526d0bd5SKonstantin Belousov int flags;
730a4f67738SDoug Rabson elf_file_t ef;
731a4f67738SDoug Rabson linker_file_t lf;
732ca65d5c7SPeter Wemm int symtabindex;
733ca65d5c7SPeter Wemm int symstrindex;
734e9eabf59SPeter Wemm int shstrindex;
735e9eabf59SPeter Wemm int nsym;
73620947801SPeter Wemm int pb, rl, ra;
737e9eabf59SPeter Wemm int alignmask;
738ca65d5c7SPeter Wemm
739ca65d5c7SPeter Wemm shdr = NULL;
740ca65d5c7SPeter Wemm lf = NULL;
741e9eabf59SPeter Wemm mapsize = 0;
742e9eabf59SPeter Wemm hdr = NULL;
743a4f67738SDoug Rabson
744a344babfSGleb Smirnoff nd = malloc(sizeof(struct nameidata), M_TEMP, M_WAITOK);
7457e1d3eefSMateusz Guzik NDINIT(nd, LOOKUP, FOLLOW, UIO_SYSSPACE, filename);
746e6796b67SKirk McKusick flags = FREAD;
747a344babfSGleb Smirnoff error = vn_open(nd, &flags, 0, NULL);
748a344babfSGleb Smirnoff if (error) {
749a344babfSGleb Smirnoff free(nd, M_TEMP);
750a4f67738SDoug Rabson return error;
751a344babfSGleb Smirnoff }
752bb92cd7bSMateusz Guzik NDFREE_PNBUF(nd);
753a344babfSGleb Smirnoff if (nd->ni_vp->v_type != VREG) {
7541f49b573SRuslan Ermilov error = ENOEXEC;
7551f49b573SRuslan Ermilov goto out;
7561f49b573SRuslan Ermilov }
757a3df768bSRobert Watson #ifdef MAC
758a344babfSGleb Smirnoff error = mac_kld_check_load(td->td_ucred, nd->ni_vp);
759a3df768bSRobert Watson if (error) {
760a3df768bSRobert Watson goto out;
761a3df768bSRobert Watson }
762a3df768bSRobert Watson #endif
763a4f67738SDoug Rabson
764e9eabf59SPeter Wemm /* Read the elf header from the file. */
765e9eabf59SPeter Wemm hdr = malloc(sizeof(*hdr), M_LINKER, M_WAITOK);
766a344babfSGleb Smirnoff error = vn_rdwr(UIO_READ, nd->ni_vp, (void *)hdr, sizeof(*hdr), 0,
7679ca43589SRobert Watson UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED,
7689ca43589SRobert Watson &resid, td);
769a4f67738SDoug Rabson if (error)
770a4f67738SDoug Rabson goto out;
771e9eabf59SPeter Wemm if (resid != 0){
772e9eabf59SPeter Wemm error = ENOEXEC;
773e9eabf59SPeter Wemm goto out;
774e9eabf59SPeter Wemm }
775a4f67738SDoug Rabson
776caab6e90SPeter Wemm if (!IS_ELF(*hdr)) {
777fe3db7c7SDoug Rabson error = ENOEXEC;
778a4f67738SDoug Rabson goto out;
779fe3db7c7SDoug Rabson }
780fe3db7c7SDoug Rabson
781caab6e90SPeter Wemm if (hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS
782caab6e90SPeter Wemm || hdr->e_ident[EI_DATA] != ELF_TARG_DATA) {
783552f9f63SEdwin Groothuis link_elf_error(filename, "Unsupported file layout");
784fe3db7c7SDoug Rabson error = ENOEXEC;
785fe3db7c7SDoug Rabson goto out;
786fe3db7c7SDoug Rabson }
787caab6e90SPeter Wemm if (hdr->e_ident[EI_VERSION] != EV_CURRENT
788caab6e90SPeter Wemm || hdr->e_version != EV_CURRENT) {
789552f9f63SEdwin Groothuis link_elf_error(filename, "Unsupported file version");
790fe3db7c7SDoug Rabson error = ENOEXEC;
791fe3db7c7SDoug Rabson goto out;
792fe3db7c7SDoug Rabson }
793e9eabf59SPeter Wemm if (hdr->e_type != ET_REL) {
794a1d7ce03SAttilio Rao error = ENOSYS;
795fe3db7c7SDoug Rabson goto out;
796fe3db7c7SDoug Rabson }
797caab6e90SPeter Wemm if (hdr->e_machine != ELF_TARG_MACH) {
798552f9f63SEdwin Groothuis link_elf_error(filename, "Unsupported machine");
799fe3db7c7SDoug Rabson error = ENOEXEC;
800fe3db7c7SDoug Rabson goto out;
801fe3db7c7SDoug Rabson }
802a4f67738SDoug Rabson
803326e27d8SDoug Rabson lf = linker_make_file(filename, &link_elf_class);
804326e27d8SDoug Rabson if (!lf) {
805326e27d8SDoug Rabson error = ENOMEM;
806326e27d8SDoug Rabson goto out;
807326e27d8SDoug Rabson }
808326e27d8SDoug Rabson ef = (elf_file_t) lf;
809e9eabf59SPeter Wemm ef->nprogtab = 0;
810e9eabf59SPeter Wemm ef->e_shdr = 0;
811b474c780SDavid E. O'Brien ef->nreltab = 0;
812b474c780SDavid E. O'Brien ef->nrelatab = 0;
813e9eabf59SPeter Wemm
814e9eabf59SPeter Wemm /* Allocate and read in the section header */
815e9eabf59SPeter Wemm nbytes = hdr->e_shnum * hdr->e_shentsize;
816e9eabf59SPeter Wemm if (nbytes == 0 || hdr->e_shoff == 0 ||
817e9eabf59SPeter Wemm hdr->e_shentsize != sizeof(Elf_Shdr)) {
818e9eabf59SPeter Wemm error = ENOEXEC;
819e9eabf59SPeter Wemm goto out;
820e9eabf59SPeter Wemm }
82120947801SPeter Wemm shdr = malloc(nbytes, M_LINKER, M_WAITOK);
822e9eabf59SPeter Wemm ef->e_shdr = shdr;
823a344babfSGleb Smirnoff error = vn_rdwr(UIO_READ, nd->ni_vp, (caddr_t)shdr, nbytes,
824a344babfSGleb Smirnoff hdr->e_shoff, UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred,
825a344babfSGleb Smirnoff NOCRED, &resid, td);
826e9eabf59SPeter Wemm if (error)
827e9eabf59SPeter Wemm goto out;
828e9eabf59SPeter Wemm if (resid) {
829e9eabf59SPeter Wemm error = ENOEXEC;
830e9eabf59SPeter Wemm goto out;
831e9eabf59SPeter Wemm }
832e9eabf59SPeter Wemm
833e9eabf59SPeter Wemm /* Scan the section header for information and table sizing. */
834e9eabf59SPeter Wemm nsym = 0;
835e9eabf59SPeter Wemm symtabindex = -1;
836e9eabf59SPeter Wemm symstrindex = -1;
837e9eabf59SPeter Wemm for (i = 0; i < hdr->e_shnum; i++) {
838676799a0SAndriy Gapon if (shdr[i].sh_size == 0)
839676799a0SAndriy Gapon continue;
840e9eabf59SPeter Wemm switch (shdr[i].sh_type) {
841e9eabf59SPeter Wemm case SHT_PROGBITS:
842e9eabf59SPeter Wemm case SHT_NOBITS:
84313f28d96SKonstantin Belousov #ifdef __amd64__
844b715d9afSKonstantin Belousov case SHT_X86_64_UNWIND:
84513f28d96SKonstantin Belousov #endif
8465e6989baSMark Johnston case SHT_INIT_ARRAY:
8475e6989baSMark Johnston case SHT_FINI_ARRAY:
84858c4aee0SJohn Baldwin if ((shdr[i].sh_flags & SHF_ALLOC) == 0)
84958c4aee0SJohn Baldwin break;
85020947801SPeter Wemm ef->nprogtab++;
851e9eabf59SPeter Wemm break;
852e9eabf59SPeter Wemm case SHT_SYMTAB:
853e9eabf59SPeter Wemm nsym++;
854e9eabf59SPeter Wemm symtabindex = i;
855e9eabf59SPeter Wemm symstrindex = shdr[i].sh_link;
856e9eabf59SPeter Wemm break;
857e9eabf59SPeter Wemm case SHT_REL:
85815746ef4SJohn Baldwin /*
85915746ef4SJohn Baldwin * Ignore relocation tables for unallocated
86015746ef4SJohn Baldwin * sections.
86115746ef4SJohn Baldwin */
86215746ef4SJohn Baldwin if ((shdr[shdr[i].sh_info].sh_flags & SHF_ALLOC) == 0)
86315746ef4SJohn Baldwin break;
864b474c780SDavid E. O'Brien ef->nreltab++;
865e9eabf59SPeter Wemm break;
866e9eabf59SPeter Wemm case SHT_RELA:
86715746ef4SJohn Baldwin if ((shdr[shdr[i].sh_info].sh_flags & SHF_ALLOC) == 0)
86815746ef4SJohn Baldwin break;
869b474c780SDavid E. O'Brien ef->nrelatab++;
870e9eabf59SPeter Wemm break;
871e9eabf59SPeter Wemm case SHT_STRTAB:
872e9eabf59SPeter Wemm break;
873e9eabf59SPeter Wemm }
874e9eabf59SPeter Wemm }
87520947801SPeter Wemm if (ef->nprogtab == 0) {
876552f9f63SEdwin Groothuis link_elf_error(filename, "file has no contents");
877e9eabf59SPeter Wemm error = ENOEXEC;
878e9eabf59SPeter Wemm goto out;
879e9eabf59SPeter Wemm }
880e9eabf59SPeter Wemm if (nsym != 1) {
881e9eabf59SPeter Wemm /* Only allow one symbol table for now */
882f912a970SEd Maste link_elf_error(filename,
883f912a970SEd Maste "file must have exactly one symbol table");
884e9eabf59SPeter Wemm error = ENOEXEC;
885e9eabf59SPeter Wemm goto out;
886e9eabf59SPeter Wemm }
887e9eabf59SPeter Wemm if (symstrindex < 0 || symstrindex > hdr->e_shnum ||
888e9eabf59SPeter Wemm shdr[symstrindex].sh_type != SHT_STRTAB) {
889552f9f63SEdwin Groothuis link_elf_error(filename, "file has invalid symbol strings");
890e9eabf59SPeter Wemm error = ENOEXEC;
891e9eabf59SPeter Wemm goto out;
892e9eabf59SPeter Wemm }
893e9eabf59SPeter Wemm
894e9eabf59SPeter Wemm /* Allocate space for tracking the load chunks */
895e9eabf59SPeter Wemm if (ef->nprogtab != 0)
89620947801SPeter Wemm ef->progtab = malloc(ef->nprogtab * sizeof(*ef->progtab),
89720947801SPeter Wemm M_LINKER, M_WAITOK | M_ZERO);
898b474c780SDavid E. O'Brien if (ef->nreltab != 0)
899b474c780SDavid E. O'Brien ef->reltab = malloc(ef->nreltab * sizeof(*ef->reltab),
900b474c780SDavid E. O'Brien M_LINKER, M_WAITOK | M_ZERO);
901b474c780SDavid E. O'Brien if (ef->nrelatab != 0)
902b474c780SDavid E. O'Brien ef->relatab = malloc(ef->nrelatab * sizeof(*ef->relatab),
903b474c780SDavid E. O'Brien M_LINKER, M_WAITOK | M_ZERO);
904e9eabf59SPeter Wemm
9053cfce8e4SKonstantin Belousov if (symtabindex == -1) {
9063cfce8e4SKonstantin Belousov link_elf_error(filename, "lost symbol table index");
9073cfce8e4SKonstantin Belousov error = ENOEXEC;
9083cfce8e4SKonstantin Belousov goto out;
9093cfce8e4SKonstantin Belousov }
91020947801SPeter Wemm /* Allocate space for and load the symbol table */
911e9eabf59SPeter Wemm ef->ddbsymcnt = shdr[symtabindex].sh_size / sizeof(Elf_Sym);
912e9eabf59SPeter Wemm ef->ddbsymtab = malloc(shdr[symtabindex].sh_size, M_LINKER, M_WAITOK);
913a344babfSGleb Smirnoff error = vn_rdwr(UIO_READ, nd->ni_vp, (void *)ef->ddbsymtab,
91420947801SPeter Wemm shdr[symtabindex].sh_size, shdr[symtabindex].sh_offset,
91520947801SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED,
91620947801SPeter Wemm &resid, td);
91720947801SPeter Wemm if (error)
91820947801SPeter Wemm goto out;
91920947801SPeter Wemm if (resid != 0){
92020947801SPeter Wemm error = EINVAL;
92120947801SPeter Wemm goto out;
92220947801SPeter Wemm }
923e9eabf59SPeter Wemm
92420947801SPeter Wemm /* Allocate space for and load the symbol strings */
925e9eabf59SPeter Wemm ef->ddbstrcnt = shdr[symstrindex].sh_size;
926e9eabf59SPeter Wemm ef->ddbstrtab = malloc(shdr[symstrindex].sh_size, M_LINKER, M_WAITOK);
927a344babfSGleb Smirnoff error = vn_rdwr(UIO_READ, nd->ni_vp, ef->ddbstrtab,
92820947801SPeter Wemm shdr[symstrindex].sh_size, shdr[symstrindex].sh_offset,
92920947801SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED,
93020947801SPeter Wemm &resid, td);
93120947801SPeter Wemm if (error)
93220947801SPeter Wemm goto out;
93320947801SPeter Wemm if (resid != 0){
93420947801SPeter Wemm error = EINVAL;
93520947801SPeter Wemm goto out;
93620947801SPeter Wemm }
937e9eabf59SPeter Wemm
938e9eabf59SPeter Wemm /* Do we have a string table for the section names? */
939e9eabf59SPeter Wemm shstrindex = -1;
94020947801SPeter Wemm if (hdr->e_shstrndx != 0 &&
94120947801SPeter Wemm shdr[hdr->e_shstrndx].sh_type == SHT_STRTAB) {
942e9eabf59SPeter Wemm shstrindex = hdr->e_shstrndx;
943e9eabf59SPeter Wemm ef->shstrcnt = shdr[shstrindex].sh_size;
94420947801SPeter Wemm ef->shstrtab = malloc(shdr[shstrindex].sh_size, M_LINKER,
94520947801SPeter Wemm M_WAITOK);
946a344babfSGleb Smirnoff error = vn_rdwr(UIO_READ, nd->ni_vp, ef->shstrtab,
94720947801SPeter Wemm shdr[shstrindex].sh_size, shdr[shstrindex].sh_offset,
948e9eabf59SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED,
949e9eabf59SPeter Wemm &resid, td);
950e9eabf59SPeter Wemm if (error)
951e9eabf59SPeter Wemm goto out;
95220947801SPeter Wemm if (resid != 0){
95320947801SPeter Wemm error = EINVAL;
95420947801SPeter Wemm goto out;
95520947801SPeter Wemm }
956e9eabf59SPeter Wemm }
957e9eabf59SPeter Wemm
95820947801SPeter Wemm /* Size up code/data(progbits) and bss(nobits). */
959e9eabf59SPeter Wemm alignmask = 0;
960e9eabf59SPeter Wemm for (i = 0; i < hdr->e_shnum; i++) {
961676799a0SAndriy Gapon if (shdr[i].sh_size == 0)
962676799a0SAndriy Gapon continue;
963e9eabf59SPeter Wemm switch (shdr[i].sh_type) {
964e9eabf59SPeter Wemm case SHT_PROGBITS:
965e9eabf59SPeter Wemm case SHT_NOBITS:
96613f28d96SKonstantin Belousov #ifdef __amd64__
967b715d9afSKonstantin Belousov case SHT_X86_64_UNWIND:
96813f28d96SKonstantin Belousov #endif
9695e6989baSMark Johnston case SHT_INIT_ARRAY:
9705e6989baSMark Johnston case SHT_FINI_ARRAY:
97158c4aee0SJohn Baldwin if ((shdr[i].sh_flags & SHF_ALLOC) == 0)
97258c4aee0SJohn Baldwin break;
973e9eabf59SPeter Wemm alignmask = shdr[i].sh_addralign - 1;
974e9eabf59SPeter Wemm mapsize += alignmask;
975e9eabf59SPeter Wemm mapsize &= ~alignmask;
976e9eabf59SPeter Wemm mapsize += shdr[i].sh_size;
977e9eabf59SPeter Wemm break;
978e9eabf59SPeter Wemm }
979e9eabf59SPeter Wemm }
980e9eabf59SPeter Wemm
981e9eabf59SPeter Wemm /*
982e9eabf59SPeter Wemm * We know how much space we need for the text/data/bss/etc.
983e9eabf59SPeter Wemm * This stuff needs to be in a single chunk so that profiling etc
984e9eabf59SPeter Wemm * can get the bounds and gdb can associate offsets with modules
985e9eabf59SPeter Wemm */
986fbf2a778SKonstantin Belousov ef->object = vm_pager_allocate(OBJT_PHYS, NULL, round_page(mapsize),
987fbf2a778SKonstantin Belousov VM_PROT_ALL, 0, thread0.td_ucred);
988fe3db7c7SDoug Rabson if (ef->object == NULL) {
989fe3db7c7SDoug Rabson error = ENOMEM;
990fe3db7c7SDoug Rabson goto out;
991fe3db7c7SDoug Rabson }
992d80126a6SMark Johnston #if VM_NRESERVLEVEL > 0
993d80126a6SMark Johnston vm_object_color(ef->object, 0);
994d80126a6SMark Johnston #endif
995ac68d1c9SAlan Cox
996ac68d1c9SAlan Cox /*
997ac68d1c9SAlan Cox * In order to satisfy amd64's architectural requirements on the
998ac68d1c9SAlan Cox * location of code and data in the kernel's address space, request a
999ac68d1c9SAlan Cox * mapping that is above the kernel.
10001d9eae9fSMark Johnston *
10011d9eae9fSMark Johnston * Protections will be restricted once relocations are applied.
1002ac68d1c9SAlan Cox */
10034104e835SOleksandr Tymoshenko #ifdef __amd64__
1004ac68d1c9SAlan Cox mapbase = KERNBASE;
10054104e835SOleksandr Tymoshenko #else
10064104e835SOleksandr Tymoshenko mapbase = VM_MIN_KERNEL_ADDRESS;
10074104e835SOleksandr Tymoshenko #endif
100820947801SPeter Wemm error = vm_map_find(kernel_map, ef->object, 0, &mapbase,
1009edb572a3SJohn Baldwin round_page(mapsize), 0, VMFS_OPTIMAL_SPACE, VM_PROT_ALL,
1010edb572a3SJohn Baldwin VM_PROT_ALL, 0);
1011092bacb2SMark Johnston if (error != KERN_SUCCESS) {
1012fe3db7c7SDoug Rabson vm_object_deallocate(ef->object);
1013092bacb2SMark Johnston ef->object = NULL;
1014092bacb2SMark Johnston error = ENOMEM;
1015fe3db7c7SDoug Rabson goto out;
1016fe3db7c7SDoug Rabson }
101720947801SPeter Wemm
1018e9eabf59SPeter Wemm /* Wire the pages */
10197f1ef325SAlan Cox error = vm_map_wire(kernel_map, mapbase,
102020947801SPeter Wemm mapbase + round_page(mapsize),
1021e9eabf59SPeter Wemm VM_MAP_WIRE_SYSTEM|VM_MAP_WIRE_NOHOLES);
10227f1ef325SAlan Cox if (error != KERN_SUCCESS) {
10237f1ef325SAlan Cox error = ENOMEM;
10247f1ef325SAlan Cox goto out;
10257f1ef325SAlan Cox }
1026a4f67738SDoug Rabson
102720947801SPeter Wemm /* Inform the kld system about the situation */
102820947801SPeter Wemm lf->address = ef->address = (caddr_t)mapbase;
102920947801SPeter Wemm lf->size = mapsize;
1030e9eabf59SPeter Wemm
1031e9eabf59SPeter Wemm /*
103220947801SPeter Wemm * Now load code/data(progbits), zero bss(nobits), allocate space for
103320947801SPeter Wemm * and load relocs
1034e9eabf59SPeter Wemm */
103520947801SPeter Wemm pb = 0;
103620947801SPeter Wemm rl = 0;
103720947801SPeter Wemm ra = 0;
103820947801SPeter Wemm alignmask = 0;
103920947801SPeter Wemm for (i = 0; i < hdr->e_shnum; i++) {
1040676799a0SAndriy Gapon if (shdr[i].sh_size == 0)
1041676799a0SAndriy Gapon continue;
104220947801SPeter Wemm switch (shdr[i].sh_type) {
104320947801SPeter Wemm case SHT_PROGBITS:
104420947801SPeter Wemm case SHT_NOBITS:
104513f28d96SKonstantin Belousov #ifdef __amd64__
1046b715d9afSKonstantin Belousov case SHT_X86_64_UNWIND:
104713f28d96SKonstantin Belousov #endif
10485e6989baSMark Johnston case SHT_INIT_ARRAY:
10495e6989baSMark Johnston case SHT_FINI_ARRAY:
105058c4aee0SJohn Baldwin if ((shdr[i].sh_flags & SHF_ALLOC) == 0)
105158c4aee0SJohn Baldwin break;
105220947801SPeter Wemm alignmask = shdr[i].sh_addralign - 1;
105320947801SPeter Wemm mapbase += alignmask;
105420947801SPeter Wemm mapbase &= ~alignmask;
10550067051fSMarcel Moolenaar if (ef->shstrtab != NULL && shdr[i].sh_name != 0) {
105650c202c5SJeff Roberson ef->progtab[pb].name =
105750c202c5SJeff Roberson ef->shstrtab + shdr[i].sh_name;
10585e6989baSMark Johnston if (!strcmp(ef->progtab[pb].name, ".ctors") ||
10595e6989baSMark Johnston shdr[i].sh_type == SHT_INIT_ARRAY) {
10605e6989baSMark Johnston if (lf->ctors_addr != 0) {
10615e6989baSMark Johnston printf(
10625e6989baSMark Johnston "%s: multiple ctor sections in %s\n",
10635e6989baSMark Johnston __func__, filename);
10645e6989baSMark Johnston } else {
10655e6989baSMark Johnston lf->ctors_addr =
10665e6989baSMark Johnston (caddr_t)mapbase;
10675e6989baSMark Johnston lf->ctors_size =
10685e6989baSMark Johnston shdr[i].sh_size;
10695e6989baSMark Johnston }
10709e575fadSMark Johnston } else if (!strcmp(ef->progtab[pb].name,
10719e575fadSMark Johnston ".dtors") ||
10729e575fadSMark Johnston shdr[i].sh_type == SHT_FINI_ARRAY) {
10739e575fadSMark Johnston if (lf->dtors_addr != 0) {
10749e575fadSMark Johnston printf(
10759e575fadSMark Johnston "%s: multiple dtor sections in %s\n",
10769e575fadSMark Johnston __func__, filename);
10779e575fadSMark Johnston } else {
10789e575fadSMark Johnston lf->dtors_addr =
10799e575fadSMark Johnston (caddr_t)mapbase;
10809e575fadSMark Johnston lf->dtors_size =
10819e575fadSMark Johnston shdr[i].sh_size;
10829e575fadSMark Johnston }
10830067051fSMarcel Moolenaar }
10840067051fSMarcel Moolenaar } else if (shdr[i].sh_type == SHT_PROGBITS)
108520947801SPeter Wemm ef->progtab[pb].name = "<<PROGBITS>>";
108613f28d96SKonstantin Belousov #ifdef __amd64__
1087b715d9afSKonstantin Belousov else if (shdr[i].sh_type == SHT_X86_64_UNWIND)
108813f28d96SKonstantin Belousov ef->progtab[pb].name = "<<UNWIND>>";
108913f28d96SKonstantin Belousov #endif
109050c202c5SJeff Roberson else
109150c202c5SJeff Roberson ef->progtab[pb].name = "<<NOBITS>>";
109250c202c5SJeff Roberson if (ef->progtab[pb].name != NULL &&
10930f823b64SBjoern A. Zeeb !strcmp(ef->progtab[pb].name, DPCPU_SETNAME)) {
109450c202c5SJeff Roberson ef->progtab[pb].addr =
109550c202c5SJeff Roberson dpcpu_alloc(shdr[i].sh_size);
10960f823b64SBjoern A. Zeeb if (ef->progtab[pb].addr == NULL) {
10970f823b64SBjoern A. Zeeb printf("%s: pcpu module space is out "
10989afc5684SBjoern A. Zeeb "of space; cannot allocate %#jx "
10999afc5684SBjoern A. Zeeb "for %s\n", __func__,
11009afc5684SBjoern A. Zeeb (uintmax_t)shdr[i].sh_size,
11010f823b64SBjoern A. Zeeb filename);
11020f823b64SBjoern A. Zeeb }
11030f823b64SBjoern A. Zeeb }
1104eddfbb76SRobert Watson #ifdef VIMAGE
1105eddfbb76SRobert Watson else if (ef->progtab[pb].name != NULL &&
11060f823b64SBjoern A. Zeeb !strcmp(ef->progtab[pb].name, VNET_SETNAME)) {
1107eddfbb76SRobert Watson ef->progtab[pb].addr =
1108eddfbb76SRobert Watson vnet_data_alloc(shdr[i].sh_size);
11090f823b64SBjoern A. Zeeb if (ef->progtab[pb].addr == NULL) {
11100f823b64SBjoern A. Zeeb printf("%s: vnet module space is out "
11119afc5684SBjoern A. Zeeb "of space; cannot allocate %#jx "
11129afc5684SBjoern A. Zeeb "for %s\n", __func__,
11139afc5684SBjoern A. Zeeb (uintmax_t)shdr[i].sh_size,
11140f823b64SBjoern A. Zeeb filename);
11150f823b64SBjoern A. Zeeb }
11160f823b64SBjoern A. Zeeb }
1117eddfbb76SRobert Watson #endif
111850c202c5SJeff Roberson else
111950c202c5SJeff Roberson ef->progtab[pb].addr =
112050c202c5SJeff Roberson (void *)(uintptr_t)mapbase;
112150c202c5SJeff Roberson if (ef->progtab[pb].addr == NULL) {
112250c202c5SJeff Roberson error = ENOSPC;
112350c202c5SJeff Roberson goto out;
112450c202c5SJeff Roberson }
112550c202c5SJeff Roberson ef->progtab[pb].size = shdr[i].sh_size;
11261d9eae9fSMark Johnston ef->progtab[pb].flags = shdr[i].sh_flags;
112750c202c5SJeff Roberson ef->progtab[pb].sec = i;
112813f28d96SKonstantin Belousov if (shdr[i].sh_type == SHT_PROGBITS
112913f28d96SKonstantin Belousov #ifdef __amd64__
1130b715d9afSKonstantin Belousov || shdr[i].sh_type == SHT_X86_64_UNWIND
113113f28d96SKonstantin Belousov #endif
113213f28d96SKonstantin Belousov ) {
1133a344babfSGleb Smirnoff error = vn_rdwr(UIO_READ, nd->ni_vp,
113420947801SPeter Wemm ef->progtab[pb].addr,
113520947801SPeter Wemm shdr[i].sh_size, shdr[i].sh_offset,
113620947801SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred,
113720947801SPeter Wemm NOCRED, &resid, td);
113820947801SPeter Wemm if (error)
113920947801SPeter Wemm goto out;
114020947801SPeter Wemm if (resid != 0){
114120947801SPeter Wemm error = EINVAL;
114220947801SPeter Wemm goto out;
114320947801SPeter Wemm }
1144205821a7SZhenlei Huang /* Initialize the per-cpu area. */
1145eddfbb76SRobert Watson if (ef->progtab[pb].addr != (void *)mapbase &&
11465f67450dSDimitry Andric !strcmp(ef->progtab[pb].name, DPCPU_SETNAME))
114750c202c5SJeff Roberson dpcpu_copy(ef->progtab[pb].addr,
114850c202c5SJeff Roberson shdr[i].sh_size);
114950c202c5SJeff Roberson } else
115020947801SPeter Wemm bzero(ef->progtab[pb].addr, shdr[i].sh_size);
1151a8774e39SPeter Wemm
1152cf7974fdSZhenlei Huang #ifdef VIMAGE
1153cf7974fdSZhenlei Huang if (ef->progtab[pb].addr != (void *)mapbase &&
1154cf7974fdSZhenlei Huang strcmp(ef->progtab[pb].name, VNET_SETNAME) == 0)
1155cf7974fdSZhenlei Huang vnet_save_init(ef->progtab[pb].addr,
1156cf7974fdSZhenlei Huang ef->progtab[pb].size);
1157cf7974fdSZhenlei Huang #endif
1158a8774e39SPeter Wemm /* Update all symbol values with the offset. */
1159a8774e39SPeter Wemm for (j = 0; j < ef->ddbsymcnt; j++) {
1160a8774e39SPeter Wemm es = &ef->ddbsymtab[j];
1161a8774e39SPeter Wemm if (es->st_shndx != i)
1162a8774e39SPeter Wemm continue;
1163a8774e39SPeter Wemm es->st_value += (Elf_Addr)ef->progtab[pb].addr;
1164a8774e39SPeter Wemm }
116520947801SPeter Wemm mapbase += shdr[i].sh_size;
116620947801SPeter Wemm pb++;
116720947801SPeter Wemm break;
116820947801SPeter Wemm case SHT_REL:
116915746ef4SJohn Baldwin if ((shdr[shdr[i].sh_info].sh_flags & SHF_ALLOC) == 0)
117015746ef4SJohn Baldwin break;
117120947801SPeter Wemm ef->reltab[rl].rel = malloc(shdr[i].sh_size, M_LINKER,
117220947801SPeter Wemm M_WAITOK);
117320947801SPeter Wemm ef->reltab[rl].nrel = shdr[i].sh_size / sizeof(Elf_Rel);
117420947801SPeter Wemm ef->reltab[rl].sec = shdr[i].sh_info;
1175a344babfSGleb Smirnoff error = vn_rdwr(UIO_READ, nd->ni_vp,
117620947801SPeter Wemm (void *)ef->reltab[rl].rel,
117720947801SPeter Wemm shdr[i].sh_size, shdr[i].sh_offset,
1178e9eabf59SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED,
1179e9eabf59SPeter Wemm &resid, td);
1180e9eabf59SPeter Wemm if (error)
1181e9eabf59SPeter Wemm goto out;
118220947801SPeter Wemm if (resid != 0){
118320947801SPeter Wemm error = EINVAL;
118420947801SPeter Wemm goto out;
1185e9eabf59SPeter Wemm }
118620947801SPeter Wemm rl++;
118720947801SPeter Wemm break;
118820947801SPeter Wemm case SHT_RELA:
118915746ef4SJohn Baldwin if ((shdr[shdr[i].sh_info].sh_flags & SHF_ALLOC) == 0)
119015746ef4SJohn Baldwin break;
119120947801SPeter Wemm ef->relatab[ra].rela = malloc(shdr[i].sh_size, M_LINKER,
119220947801SPeter Wemm M_WAITOK);
119320947801SPeter Wemm ef->relatab[ra].nrela =
119420947801SPeter Wemm shdr[i].sh_size / sizeof(Elf_Rela);
119520947801SPeter Wemm ef->relatab[ra].sec = shdr[i].sh_info;
1196a344babfSGleb Smirnoff error = vn_rdwr(UIO_READ, nd->ni_vp,
119720947801SPeter Wemm (void *)ef->relatab[ra].rela,
119820947801SPeter Wemm shdr[i].sh_size, shdr[i].sh_offset,
1199e9eabf59SPeter Wemm UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED,
1200e9eabf59SPeter Wemm &resid, td);
1201e9eabf59SPeter Wemm if (error)
1202e9eabf59SPeter Wemm goto out;
120320947801SPeter Wemm if (resid != 0){
120420947801SPeter Wemm error = EINVAL;
120520947801SPeter Wemm goto out;
1206e9eabf59SPeter Wemm }
120720947801SPeter Wemm ra++;
120820947801SPeter Wemm break;
120920947801SPeter Wemm }
121020947801SPeter Wemm }
12113cfce8e4SKonstantin Belousov if (pb != ef->nprogtab) {
12123cfce8e4SKonstantin Belousov link_elf_error(filename, "lost progbits");
12133cfce8e4SKonstantin Belousov error = ENOEXEC;
12143cfce8e4SKonstantin Belousov goto out;
12153cfce8e4SKonstantin Belousov }
12163cfce8e4SKonstantin Belousov if (rl != ef->nreltab) {
12173cfce8e4SKonstantin Belousov link_elf_error(filename, "lost reltab");
12183cfce8e4SKonstantin Belousov error = ENOEXEC;
12193cfce8e4SKonstantin Belousov goto out;
12203cfce8e4SKonstantin Belousov }
12213cfce8e4SKonstantin Belousov if (ra != ef->nrelatab) {
12223cfce8e4SKonstantin Belousov link_elf_error(filename, "lost relatab");
12233cfce8e4SKonstantin Belousov error = ENOEXEC;
12243cfce8e4SKonstantin Belousov goto out;
12253cfce8e4SKonstantin Belousov }
12263cfce8e4SKonstantin Belousov if (mapbase != (vm_offset_t)ef->address + mapsize) {
12273cfce8e4SKonstantin Belousov printf(
12283cfce8e4SKonstantin Belousov "%s: mapbase 0x%lx != address %p + mapsize 0x%lx (0x%lx)\n",
12293cfce8e4SKonstantin Belousov filename != NULL ? filename : "<none>",
12306f3c6327SNeel Natu (u_long)mapbase, ef->address, (u_long)mapsize,
12316f3c6327SNeel Natu (u_long)(vm_offset_t)ef->address + mapsize);
12323cfce8e4SKonstantin Belousov error = ENOMEM;
12333cfce8e4SKonstantin Belousov goto out;
12343cfce8e4SKonstantin Belousov }
1235e9eabf59SPeter Wemm
1236e9eabf59SPeter Wemm /* Local intra-module relocations */
1237289ead7cSKonstantin Belousov error = link_elf_reloc_local(lf, false);
12383cfce8e4SKonstantin Belousov if (error != 0)
12393cfce8e4SKonstantin Belousov goto out;
12407251b4bfSJake Burkholder
1241e9eabf59SPeter Wemm /* Pull in dependencies */
1242b249ce48SMateusz Guzik VOP_UNLOCK(nd->ni_vp);
12437b9716baSIan Dowse error = linker_load_dependencies(lf);
1244a344babfSGleb Smirnoff vn_lock(nd->ni_vp, LK_EXCLUSIVE | LK_RETRY);
1245ca65d5c7SPeter Wemm if (error)
1246de78ca7eSPeter Wemm goto out;
1247e9eabf59SPeter Wemm
1248e9eabf59SPeter Wemm /* External relocations */
1249326e27d8SDoug Rabson error = relocate_file(ef);
1250ca65d5c7SPeter Wemm if (error)
1251ca65d5c7SPeter Wemm goto out;
1252ca65d5c7SPeter Wemm
1253e9eabf59SPeter Wemm /* Notify MD code that a module is being loaded. */
1254e9eabf59SPeter Wemm error = elf_cpu_load_file(lf);
1255ca65d5c7SPeter Wemm if (error)
1256ca65d5c7SPeter Wemm goto out;
1257a4f67738SDoug Rabson
12588f941950SKonstantin Belousov #if defined(__i386__) || defined(__amd64__)
1259289ead7cSKonstantin Belousov /* Now ifuncs. */
1260289ead7cSKonstantin Belousov error = link_elf_reloc_local(lf, true);
1261289ead7cSKonstantin Belousov if (error != 0)
1262289ead7cSKonstantin Belousov goto out;
12638f941950SKonstantin Belousov #endif
1264289ead7cSKonstantin Belousov
12651d9eae9fSMark Johnston link_elf_protect(ef);
12667ef5c19bSMark Johnston link_elf_invoke_ctors(lf);
1267a4f67738SDoug Rabson *result = lf;
1268a4f67738SDoug Rabson
1269a4f67738SDoug Rabson out:
1270b249ce48SMateusz Guzik VOP_UNLOCK(nd->ni_vp);
1271a344babfSGleb Smirnoff vn_close(nd->ni_vp, FREAD, td->td_ucred, td);
1272a344babfSGleb Smirnoff free(nd, M_TEMP);
1273ca65d5c7SPeter Wemm if (error && lf)
127465a311fcSPoul-Henning Kamp linker_file_unload(lf, LINKER_UNLOAD_FORCE);
1275e9eabf59SPeter Wemm free(hdr, M_LINKER);
1276a4f67738SDoug Rabson
1277a4f67738SDoug Rabson return error;
1278a4f67738SDoug Rabson }
1279a4f67738SDoug Rabson
1280a4f67738SDoug Rabson static void
link_elf_unload_file(linker_file_t file)1281de78ca7eSPeter Wemm link_elf_unload_file(linker_file_t file)
1282a4f67738SDoug Rabson {
1283326e27d8SDoug Rabson elf_file_t ef = (elf_file_t) file;
1284d821d364SPedro F. Giffuni u_int i;
1285a4f67738SDoug Rabson
12867ef5c19bSMark Johnston link_elf_invoke_dtors(file);
12879e575fadSMark Johnston
12881aeb23cdSMarcel Moolenaar /* Notify MD code that a module is being unloaded. */
12891aeb23cdSMarcel Moolenaar elf_cpu_unload_file(file);
12901aeb23cdSMarcel Moolenaar
129150c202c5SJeff Roberson if (ef->progtab) {
129250c202c5SJeff Roberson for (i = 0; i < ef->nprogtab; i++) {
129350c202c5SJeff Roberson if (ef->progtab[i].size == 0)
129450c202c5SJeff Roberson continue;
129550c202c5SJeff Roberson if (ef->progtab[i].name == NULL)
129650c202c5SJeff Roberson continue;
12975f67450dSDimitry Andric if (!strcmp(ef->progtab[i].name, DPCPU_SETNAME))
129850c202c5SJeff Roberson dpcpu_free(ef->progtab[i].addr,
129950c202c5SJeff Roberson ef->progtab[i].size);
1300eddfbb76SRobert Watson #ifdef VIMAGE
130117ef1febSRobert Watson else if (!strcmp(ef->progtab[i].name, VNET_SETNAME))
1302eddfbb76SRobert Watson vnet_data_free(ef->progtab[i].addr,
1303eddfbb76SRobert Watson ef->progtab[i].size);
1304eddfbb76SRobert Watson #endif
130550c202c5SJeff Roberson }
130650c202c5SJeff Roberson }
130770b7ffeeSIan Dowse if (ef->preloaded) {
130870b7ffeeSIan Dowse free(ef->reltab, M_LINKER);
130970b7ffeeSIan Dowse free(ef->relatab, M_LINKER);
131070b7ffeeSIan Dowse free(ef->progtab, M_LINKER);
1311a2024a3eSJohn Birrell free(ef->ctftab, M_LINKER);
1312a2024a3eSJohn Birrell free(ef->ctfoff, M_LINKER);
1313a2024a3eSJohn Birrell free(ef->typoff, M_LINKER);
131473624a80SMark Johnston if (file->pathname != NULL)
131573624a80SMark Johnston preload_delete_name(file->pathname);
131670b7ffeeSIan Dowse return;
131770b7ffeeSIan Dowse }
131870b7ffeeSIan Dowse
1319b474c780SDavid E. O'Brien for (i = 0; i < ef->nreltab; i++)
132020947801SPeter Wemm free(ef->reltab[i].rel, M_LINKER);
1321b474c780SDavid E. O'Brien for (i = 0; i < ef->nrelatab; i++)
132220947801SPeter Wemm free(ef->relatab[i].rela, M_LINKER);
132320947801SPeter Wemm free(ef->reltab, M_LINKER);
132420947801SPeter Wemm free(ef->relatab, M_LINKER);
132520947801SPeter Wemm free(ef->progtab, M_LINKER);
132620947801SPeter Wemm
1327092bacb2SMark Johnston if (ef->object != NULL)
1328fe3db7c7SDoug Rabson vm_map_remove(kernel_map, (vm_offset_t)ef->address,
1329092bacb2SMark Johnston (vm_offset_t)ef->address + ptoa(ef->object->size));
1330e9eabf59SPeter Wemm free(ef->e_shdr, M_LINKER);
1331e9eabf59SPeter Wemm free(ef->ddbsymtab, M_LINKER);
1332e9eabf59SPeter Wemm free(ef->ddbstrtab, M_LINKER);
133320947801SPeter Wemm free(ef->shstrtab, M_LINKER);
1334a2024a3eSJohn Birrell free(ef->ctftab, M_LINKER);
1335a2024a3eSJohn Birrell free(ef->ctfoff, M_LINKER);
1336a2024a3eSJohn Birrell free(ef->typoff, M_LINKER);
1337de78ca7eSPeter Wemm }
1338de78ca7eSPeter Wemm
1339fe3db7c7SDoug Rabson static const char *
symbol_name(elf_file_t ef,Elf_Size r_info)1340757686b1SMarcel Moolenaar symbol_name(elf_file_t ef, Elf_Size r_info)
1341a4f67738SDoug Rabson {
1342fe3db7c7SDoug Rabson const Elf_Sym *ref;
1343a4f67738SDoug Rabson
1344aa855a59SPeter Wemm if (ELF_R_SYM(r_info)) {
1345e9eabf59SPeter Wemm ref = ef->ddbsymtab + ELF_R_SYM(r_info);
1346e9eabf59SPeter Wemm return ef->ddbstrtab + ref->st_name;
1347fe3db7c7SDoug Rabson } else
1348fe3db7c7SDoug Rabson return NULL;
1349a4f67738SDoug Rabson }
1350a4f67738SDoug Rabson
1351e9eabf59SPeter Wemm static Elf_Addr
findbase(elf_file_t ef,int sec)1352e9eabf59SPeter Wemm findbase(elf_file_t ef, int sec)
1353e9eabf59SPeter Wemm {
1354e9eabf59SPeter Wemm int i;
1355e9eabf59SPeter Wemm Elf_Addr base = 0;
1356e9eabf59SPeter Wemm
1357e9eabf59SPeter Wemm for (i = 0; i < ef->nprogtab; i++) {
1358a8774e39SPeter Wemm if (sec == ef->progtab[i].sec) {
1359e9eabf59SPeter Wemm base = (Elf_Addr)ef->progtab[i].addr;
1360a8774e39SPeter Wemm break;
1361e9eabf59SPeter Wemm }
1362a8774e39SPeter Wemm }
1363e9eabf59SPeter Wemm return base;
1364e9eabf59SPeter Wemm }
1365e9eabf59SPeter Wemm
1366a4f67738SDoug Rabson static int
relocate_file1(elf_file_t ef,bool ifuncs)1367b11e6fd7SMark Johnston relocate_file1(elf_file_t ef, bool ifuncs)
1368a4f67738SDoug Rabson {
1369fe3db7c7SDoug Rabson const Elf_Rel *rellim;
1370fe3db7c7SDoug Rabson const Elf_Rel *rel;
1371fe3db7c7SDoug Rabson const Elf_Rela *relalim;
1372fe3db7c7SDoug Rabson const Elf_Rela *rela;
1373aa855a59SPeter Wemm const char *symname;
1374e9eabf59SPeter Wemm const Elf_Sym *sym;
1375e9eabf59SPeter Wemm int i;
1376757686b1SMarcel Moolenaar Elf_Size symidx;
1377e9eabf59SPeter Wemm Elf_Addr base;
1378e9eabf59SPeter Wemm
1379fe3db7c7SDoug Rabson /* Perform relocations without addend if there are any: */
1380b474c780SDavid E. O'Brien for (i = 0; i < ef->nreltab; i++) {
1381e9eabf59SPeter Wemm rel = ef->reltab[i].rel;
13823cfce8e4SKonstantin Belousov if (rel == NULL) {
13833cfce8e4SKonstantin Belousov link_elf_error(ef->lf.filename, "lost a reltab!");
13843cfce8e4SKonstantin Belousov return (ENOEXEC);
13853cfce8e4SKonstantin Belousov }
138620947801SPeter Wemm rellim = rel + ef->reltab[i].nrel;
1387e9eabf59SPeter Wemm base = findbase(ef, ef->reltab[i].sec);
13883cfce8e4SKonstantin Belousov if (base == 0) {
13893cfce8e4SKonstantin Belousov link_elf_error(ef->lf.filename, "lost base for reltab");
13903cfce8e4SKonstantin Belousov return (ENOEXEC);
13913cfce8e4SKonstantin Belousov }
139220947801SPeter Wemm for ( ; rel < rellim; rel++) {
1393e9eabf59SPeter Wemm symidx = ELF_R_SYM(rel->r_info);
139420947801SPeter Wemm if (symidx >= ef->ddbsymcnt)
139520947801SPeter Wemm continue;
1396e9eabf59SPeter Wemm sym = ef->ddbsymtab + symidx;
139720947801SPeter Wemm /* Local relocs are already done */
139820947801SPeter Wemm if (ELF_ST_BIND(sym->st_info) == STB_LOCAL)
139920947801SPeter Wemm continue;
1400b11e6fd7SMark Johnston if ((ELF_ST_TYPE(sym->st_info) == STT_GNU_IFUNC ||
1401b11e6fd7SMark Johnston elf_is_ifunc_reloc(rel->r_info)) != ifuncs)
1402b11e6fd7SMark Johnston continue;
140320947801SPeter Wemm if (elf_reloc(&ef->lf, base, rel, ELF_RELOC_REL,
140420947801SPeter Wemm elf_obj_lookup)) {
1405aa855a59SPeter Wemm symname = symbol_name(ef, rel->r_info);
140620947801SPeter Wemm printf("link_elf_obj: symbol %s undefined\n",
140720947801SPeter Wemm symname);
14083cfce8e4SKonstantin Belousov return (ENOENT);
1409a13ddfb6SPeter Wemm }
1410aa855a59SPeter Wemm }
1411a4f67738SDoug Rabson }
1412a4f67738SDoug Rabson
1413fe3db7c7SDoug Rabson /* Perform relocations with addend if there are any: */
1414b474c780SDavid E. O'Brien for (i = 0; i < ef->nrelatab; i++) {
1415e9eabf59SPeter Wemm rela = ef->relatab[i].rela;
14163cfce8e4SKonstantin Belousov if (rela == NULL) {
14173cfce8e4SKonstantin Belousov link_elf_error(ef->lf.filename, "lost a relatab!");
14183cfce8e4SKonstantin Belousov return (ENOEXEC);
14193cfce8e4SKonstantin Belousov }
142020947801SPeter Wemm relalim = rela + ef->relatab[i].nrela;
1421e9eabf59SPeter Wemm base = findbase(ef, ef->relatab[i].sec);
14223cfce8e4SKonstantin Belousov if (base == 0) {
14233cfce8e4SKonstantin Belousov link_elf_error(ef->lf.filename,
14243cfce8e4SKonstantin Belousov "lost base for relatab");
14253cfce8e4SKonstantin Belousov return (ENOEXEC);
14263cfce8e4SKonstantin Belousov }
142720947801SPeter Wemm for ( ; rela < relalim; rela++) {
1428e9eabf59SPeter Wemm symidx = ELF_R_SYM(rela->r_info);
142920947801SPeter Wemm if (symidx >= ef->ddbsymcnt)
143020947801SPeter Wemm continue;
1431e9eabf59SPeter Wemm sym = ef->ddbsymtab + symidx;
143220947801SPeter Wemm /* Local relocs are already done */
143320947801SPeter Wemm if (ELF_ST_BIND(sym->st_info) == STB_LOCAL)
143420947801SPeter Wemm continue;
1435b11e6fd7SMark Johnston if ((ELF_ST_TYPE(sym->st_info) == STT_GNU_IFUNC ||
1436b11e6fd7SMark Johnston elf_is_ifunc_reloc(rela->r_info)) != ifuncs)
1437b11e6fd7SMark Johnston continue;
143820947801SPeter Wemm if (elf_reloc(&ef->lf, base, rela, ELF_RELOC_RELA,
143920947801SPeter Wemm elf_obj_lookup)) {
1440aa855a59SPeter Wemm symname = symbol_name(ef, rela->r_info);
144120947801SPeter Wemm printf("link_elf_obj: symbol %s undefined\n",
144220947801SPeter Wemm symname);
14433cfce8e4SKonstantin Belousov return (ENOENT);
1444a13ddfb6SPeter Wemm }
1445e9eabf59SPeter Wemm }
1446e9eabf59SPeter Wemm }
1447a4f67738SDoug Rabson
14482832cd54SKonstantin Belousov /*
1449e3043798SPedro F. Giffuni * Only clean SHN_FBSD_CACHED for successful return. If we
14502832cd54SKonstantin Belousov * modified symbol table for the object but found an
14512832cd54SKonstantin Belousov * unresolved symbol, there is no reason to roll back.
14522832cd54SKonstantin Belousov */
14532832cd54SKonstantin Belousov elf_obj_cleanup_globals_cache(ef);
14542832cd54SKonstantin Belousov
14553cfce8e4SKonstantin Belousov return (0);
1456a4f67738SDoug Rabson }
1457a4f67738SDoug Rabson
145837c84183SPoul-Henning Kamp static int
relocate_file(elf_file_t ef)1459b11e6fd7SMark Johnston relocate_file(elf_file_t ef)
1460b11e6fd7SMark Johnston {
1461b11e6fd7SMark Johnston int error;
1462b11e6fd7SMark Johnston
1463b11e6fd7SMark Johnston error = relocate_file1(ef, false);
1464b11e6fd7SMark Johnston if (error == 0)
1465b11e6fd7SMark Johnston error = relocate_file1(ef, true);
1466b11e6fd7SMark Johnston return (error);
1467b11e6fd7SMark Johnston }
1468b11e6fd7SMark Johnston
1469b11e6fd7SMark Johnston static int
link_elf_lookup_symbol1(linker_file_t lf,const char * name,c_linker_sym_t * sym,bool see_local)147095c20fafSKonstantin Belousov link_elf_lookup_symbol1(linker_file_t lf, const char *name, c_linker_sym_t *sym,
147195c20fafSKonstantin Belousov bool see_local)
1472a4f67738SDoug Rabson {
1473326e27d8SDoug Rabson elf_file_t ef = (elf_file_t)lf;
14742d636ab0SPeter Wemm const Elf_Sym *symp;
14752d636ab0SPeter Wemm const char *strp;
1476a4f67738SDoug Rabson int i;
1477a4f67738SDoug Rabson
14782d636ab0SPeter Wemm for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) {
14792d636ab0SPeter Wemm strp = ef->ddbstrtab + symp->st_name;
1480a8774e39SPeter Wemm if (symp->st_shndx != SHN_UNDEF && strcmp(name, strp) == 0) {
148195c20fafSKonstantin Belousov if (see_local ||
148295c20fafSKonstantin Belousov ELF_ST_BIND(symp->st_info) == STB_GLOBAL) {
1483d254af07SMatthew Dillon *sym = (c_linker_sym_t) symp;
148495c20fafSKonstantin Belousov return (0);
148595c20fafSKonstantin Belousov }
148695c20fafSKonstantin Belousov return (ENOENT);
14872d636ab0SPeter Wemm }
14882d636ab0SPeter Wemm }
1489a7e4eb14SKonstantin Belousov return (ENOENT);
1490a4f67738SDoug Rabson }
1491a4f67738SDoug Rabson
1492de78ca7eSPeter Wemm static int
link_elf_lookup_symbol(linker_file_t lf,const char * name,c_linker_sym_t * sym)149395c20fafSKonstantin Belousov link_elf_lookup_symbol(linker_file_t lf, const char *name, c_linker_sym_t *sym)
149495c20fafSKonstantin Belousov {
1495ecd8245eSKonstantin Belousov return (link_elf_lookup_symbol1(lf, name, sym,
1496ecd8245eSKonstantin Belousov link_elf_obj_leak_locals));
149795c20fafSKonstantin Belousov }
149895c20fafSKonstantin Belousov
149995c20fafSKonstantin Belousov static int
link_elf_lookup_debug_symbol(linker_file_t lf,const char * name,c_linker_sym_t * sym)150095c20fafSKonstantin Belousov link_elf_lookup_debug_symbol(linker_file_t lf, const char *name,
150195c20fafSKonstantin Belousov c_linker_sym_t *sym)
150295c20fafSKonstantin Belousov {
150395c20fafSKonstantin Belousov return (link_elf_lookup_symbol1(lf, name, sym, true));
150495c20fafSKonstantin Belousov }
150595c20fafSKonstantin Belousov
150695c20fafSKonstantin Belousov static int
link_elf_lookup_debug_symbol_ctf(linker_file_t lf,const char * name,c_linker_sym_t * sym,linker_ctf_t * lc)1507c21bc6f3SBojan Novković link_elf_lookup_debug_symbol_ctf(linker_file_t lf, const char *name,
1508c21bc6f3SBojan Novković c_linker_sym_t *sym, linker_ctf_t *lc)
1509c21bc6f3SBojan Novković {
1510c21bc6f3SBojan Novković if (link_elf_lookup_debug_symbol(lf, name, sym))
1511c21bc6f3SBojan Novković return (ENOENT);
1512c21bc6f3SBojan Novković
1513c21bc6f3SBojan Novković return (link_elf_ctf_get_ddb(lf, lc));
1514c21bc6f3SBojan Novković }
1515c21bc6f3SBojan Novković
1516c21bc6f3SBojan Novković static int
link_elf_symbol_values1(linker_file_t lf,c_linker_sym_t sym,linker_symval_t * symval,bool see_local)151795c20fafSKonstantin Belousov link_elf_symbol_values1(linker_file_t lf, c_linker_sym_t sym,
151895c20fafSKonstantin Belousov linker_symval_t *symval, bool see_local)
1519a4f67738SDoug Rabson {
15207035cf14SKonstantin Belousov elf_file_t ef;
15217035cf14SKonstantin Belousov const Elf_Sym *es;
15227035cf14SKonstantin Belousov caddr_t val;
1523a4f67738SDoug Rabson
15247035cf14SKonstantin Belousov ef = (elf_file_t) lf;
15257035cf14SKonstantin Belousov es = (const Elf_Sym*) sym;
15267035cf14SKonstantin Belousov val = (caddr_t)es->st_value;
15275cf87418SMarcel Moolenaar if (es >= ef->ddbsymtab && es < (ef->ddbsymtab + ef->ddbsymcnt)) {
152895c20fafSKonstantin Belousov if (!see_local && ELF_ST_BIND(es->st_info) == STB_LOCAL)
152995c20fafSKonstantin Belousov return (ENOENT);
15302d636ab0SPeter Wemm symval->name = ef->ddbstrtab + es->st_name;
15317035cf14SKonstantin Belousov val = (caddr_t)es->st_value;
15327035cf14SKonstantin Belousov if (ELF_ST_TYPE(es->st_info) == STT_GNU_IFUNC)
15337035cf14SKonstantin Belousov val = ((caddr_t (*)(void))val)();
15347035cf14SKonstantin Belousov symval->value = val;
15352d636ab0SPeter Wemm symval->size = es->st_size;
1536a7e4eb14SKonstantin Belousov return (0);
15372d636ab0SPeter Wemm }
1538a7e4eb14SKonstantin Belousov return (ENOENT);
15392d636ab0SPeter Wemm }
1540a4f67738SDoug Rabson
1541a4f67738SDoug Rabson static int
link_elf_symbol_values(linker_file_t lf,c_linker_sym_t sym,linker_symval_t * symval)154295c20fafSKonstantin Belousov link_elf_symbol_values(linker_file_t lf, c_linker_sym_t sym,
154395c20fafSKonstantin Belousov linker_symval_t *symval)
154495c20fafSKonstantin Belousov {
1545ecd8245eSKonstantin Belousov return (link_elf_symbol_values1(lf, sym, symval,
1546ecd8245eSKonstantin Belousov link_elf_obj_leak_locals));
154795c20fafSKonstantin Belousov }
154895c20fafSKonstantin Belousov
154995c20fafSKonstantin Belousov static int
link_elf_debug_symbol_values(linker_file_t lf,c_linker_sym_t sym,linker_symval_t * symval)155095c20fafSKonstantin Belousov link_elf_debug_symbol_values(linker_file_t lf, c_linker_sym_t sym,
155195c20fafSKonstantin Belousov linker_symval_t *symval)
155295c20fafSKonstantin Belousov {
155395c20fafSKonstantin Belousov return (link_elf_symbol_values1(lf, sym, symval, true));
155495c20fafSKonstantin Belousov }
155595c20fafSKonstantin Belousov
155695c20fafSKonstantin Belousov static int
link_elf_search_symbol(linker_file_t lf,caddr_t value,c_linker_sym_t * sym,long * diffp)1557a4f67738SDoug Rabson link_elf_search_symbol(linker_file_t lf, caddr_t value,
1558d254af07SMatthew Dillon c_linker_sym_t *sym, long *diffp)
1559a4f67738SDoug Rabson {
1560326e27d8SDoug Rabson elf_file_t ef = (elf_file_t)lf;
1561586453feSBruce Evans u_long off = (uintptr_t)(void *)value;
1562a4f67738SDoug Rabson u_long diff = off;
1563586453feSBruce Evans u_long st_value;
1564fe3db7c7SDoug Rabson const Elf_Sym *es;
1565b85f65afSPedro F. Giffuni const Elf_Sym *best = NULL;
1566a4f67738SDoug Rabson int i;
1567a4f67738SDoug Rabson
15682d636ab0SPeter Wemm for (i = 0, es = ef->ddbsymtab; i < ef->ddbsymcnt; i++, es++) {
1569a4f67738SDoug Rabson if (es->st_name == 0)
1570a4f67738SDoug Rabson continue;
1571a8774e39SPeter Wemm st_value = es->st_value;
1572b5abfb70SPeter Wemm if (off >= st_value) {
1573b5abfb70SPeter Wemm if (off - st_value < diff) {
1574b5abfb70SPeter Wemm diff = off - st_value;
1575a4f67738SDoug Rabson best = es;
1576a4f67738SDoug Rabson if (diff == 0)
1577a4f67738SDoug Rabson break;
1578b5abfb70SPeter Wemm } else if (off - st_value == diff) {
1579a4f67738SDoug Rabson best = es;
1580a4f67738SDoug Rabson }
1581a4f67738SDoug Rabson }
1582a4f67738SDoug Rabson }
1583b85f65afSPedro F. Giffuni if (best == NULL)
1584a4f67738SDoug Rabson *diffp = off;
1585a4f67738SDoug Rabson else
1586a4f67738SDoug Rabson *diffp = diff;
1587d254af07SMatthew Dillon *sym = (c_linker_sym_t) best;
1588a4f67738SDoug Rabson
1589a7e4eb14SKonstantin Belousov return (0);
1590a4f67738SDoug Rabson }
1591f41325dbSPeter Wemm
1592f41325dbSPeter Wemm /*
1593f41325dbSPeter Wemm * Look up a linker set on an ELF system.
1594f41325dbSPeter Wemm */
1595f41325dbSPeter Wemm static int
link_elf_lookup_set(linker_file_t lf,const char * name,void *** startp,void *** stopp,int * countp)1596f41325dbSPeter Wemm link_elf_lookup_set(linker_file_t lf, const char *name,
1597f41325dbSPeter Wemm void ***startp, void ***stopp, int *countp)
1598f41325dbSPeter Wemm {
1599e9eabf59SPeter Wemm elf_file_t ef = (elf_file_t)lf;
1600f41325dbSPeter Wemm void **start, **stop;
1601e9eabf59SPeter Wemm int i, count;
1602f41325dbSPeter Wemm
1603e9eabf59SPeter Wemm /* Relative to section number */
1604e9eabf59SPeter Wemm for (i = 0; i < ef->nprogtab; i++) {
1605e9eabf59SPeter Wemm if ((strncmp(ef->progtab[i].name, "set_", 4) == 0) &&
1606e9eabf59SPeter Wemm strcmp(ef->progtab[i].name + 4, name) == 0) {
1607e9eabf59SPeter Wemm start = (void **)ef->progtab[i].addr;
160820947801SPeter Wemm stop = (void **)((char *)ef->progtab[i].addr +
160920947801SPeter Wemm ef->progtab[i].size);
1610f41325dbSPeter Wemm count = stop - start;
1611f41325dbSPeter Wemm if (startp)
1612f41325dbSPeter Wemm *startp = start;
1613f41325dbSPeter Wemm if (stopp)
1614f41325dbSPeter Wemm *stopp = stop;
1615f41325dbSPeter Wemm if (countp)
1616f41325dbSPeter Wemm *countp = count;
1617e9eabf59SPeter Wemm return (0);
1618e9eabf59SPeter Wemm }
1619e9eabf59SPeter Wemm }
1620e9eabf59SPeter Wemm return (ESRCH);
1621f41325dbSPeter Wemm }
1622bb9fe9ddSBrian Feldman
1623bb9fe9ddSBrian Feldman static int
link_elf_each_function_name(linker_file_t file,int (* callback)(const char *,void *),void * opaque)1624bb9fe9ddSBrian Feldman link_elf_each_function_name(linker_file_t file,
1625e9eabf59SPeter Wemm int (*callback)(const char *, void *), void *opaque)
1626e9eabf59SPeter Wemm {
1627bb9fe9ddSBrian Feldman elf_file_t ef = (elf_file_t)file;
1628bb9fe9ddSBrian Feldman const Elf_Sym *symp;
1629bb9fe9ddSBrian Feldman int i, error;
1630bb9fe9ddSBrian Feldman
1631bb9fe9ddSBrian Feldman /* Exhaustive search */
1632bb9fe9ddSBrian Feldman for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) {
1633bb9fe9ddSBrian Feldman if (symp->st_value != 0 &&
16347035cf14SKonstantin Belousov (ELF_ST_TYPE(symp->st_info) == STT_FUNC ||
16357035cf14SKonstantin Belousov ELF_ST_TYPE(symp->st_info) == STT_GNU_IFUNC)) {
1636bb9fe9ddSBrian Feldman error = callback(ef->ddbstrtab + symp->st_name, opaque);
1637bb9fe9ddSBrian Feldman if (error)
1638bb9fe9ddSBrian Feldman return (error);
1639bb9fe9ddSBrian Feldman }
1640bb9fe9ddSBrian Feldman }
1641bb9fe9ddSBrian Feldman return (0);
1642bb9fe9ddSBrian Feldman }
164384201059SMarcel Moolenaar
1644a2024a3eSJohn Birrell static int
link_elf_each_function_nameval(linker_file_t file,linker_function_nameval_callback_t callback,void * opaque)1645a2024a3eSJohn Birrell link_elf_each_function_nameval(linker_file_t file,
1646a2024a3eSJohn Birrell linker_function_nameval_callback_t callback, void *opaque)
1647a2024a3eSJohn Birrell {
1648a2024a3eSJohn Birrell linker_symval_t symval;
1649a2024a3eSJohn Birrell elf_file_t ef = (elf_file_t)file;
1650a2024a3eSJohn Birrell const Elf_Sym *symp;
1651a2024a3eSJohn Birrell int i, error;
1652a2024a3eSJohn Birrell
1653a2024a3eSJohn Birrell /* Exhaustive search */
1654a2024a3eSJohn Birrell for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) {
1655a2024a3eSJohn Birrell if (symp->st_value != 0 &&
16567035cf14SKonstantin Belousov (ELF_ST_TYPE(symp->st_info) == STT_FUNC ||
16577035cf14SKonstantin Belousov ELF_ST_TYPE(symp->st_info) == STT_GNU_IFUNC)) {
165895c20fafSKonstantin Belousov error = link_elf_debug_symbol_values(file,
16597035cf14SKonstantin Belousov (c_linker_sym_t)symp, &symval);
166095c20fafSKonstantin Belousov if (error == 0)
1661a2024a3eSJohn Birrell error = callback(file, i, &symval, opaque);
166295c20fafSKonstantin Belousov if (error != 0)
1663a2024a3eSJohn Birrell return (error);
1664a2024a3eSJohn Birrell }
1665a2024a3eSJohn Birrell }
1666a2024a3eSJohn Birrell return (0);
1667a2024a3eSJohn Birrell }
1668a2024a3eSJohn Birrell
16692832cd54SKonstantin Belousov static void
elf_obj_cleanup_globals_cache(elf_file_t ef)16702832cd54SKonstantin Belousov elf_obj_cleanup_globals_cache(elf_file_t ef)
16712832cd54SKonstantin Belousov {
16722832cd54SKonstantin Belousov Elf_Sym *sym;
16732832cd54SKonstantin Belousov Elf_Size i;
16742832cd54SKonstantin Belousov
16752832cd54SKonstantin Belousov for (i = 0; i < ef->ddbsymcnt; i++) {
16762832cd54SKonstantin Belousov sym = ef->ddbsymtab + i;
16772832cd54SKonstantin Belousov if (sym->st_shndx == SHN_FBSD_CACHED) {
16782832cd54SKonstantin Belousov sym->st_shndx = SHN_UNDEF;
16792832cd54SKonstantin Belousov sym->st_value = 0;
16802832cd54SKonstantin Belousov }
16812832cd54SKonstantin Belousov }
16822832cd54SKonstantin Belousov }
16832832cd54SKonstantin Belousov
1684d297ad16SMarcel Moolenaar /*
1685d297ad16SMarcel Moolenaar * Symbol lookup function that can be used when the symbol index is known (ie
1686d297ad16SMarcel Moolenaar * in relocations). It uses the symbol index instead of doing a fully fledged
1687d297ad16SMarcel Moolenaar * hash table based lookup when such is valid. For example for local symbols.
1688d297ad16SMarcel Moolenaar * This is not only more efficient, it's also more correct. It's not always
1689d297ad16SMarcel Moolenaar * the case that the symbol can be found through the hash table.
1690d297ad16SMarcel Moolenaar */
1691cff8c6f2SKonstantin Belousov static int
elf_obj_lookup(linker_file_t lf,Elf_Size symidx,int deps,Elf_Addr * res)1692cff8c6f2SKonstantin Belousov elf_obj_lookup(linker_file_t lf, Elf_Size symidx, int deps, Elf_Addr *res)
1693d297ad16SMarcel Moolenaar {
1694d297ad16SMarcel Moolenaar elf_file_t ef = (elf_file_t)lf;
16952832cd54SKonstantin Belousov Elf_Sym *sym;
1696d297ad16SMarcel Moolenaar const char *symbol;
1697cff8c6f2SKonstantin Belousov Elf_Addr res1;
1698d297ad16SMarcel Moolenaar
1699d297ad16SMarcel Moolenaar /* Don't even try to lookup the symbol if the index is bogus. */
1700cff8c6f2SKonstantin Belousov if (symidx >= ef->ddbsymcnt) {
1701cff8c6f2SKonstantin Belousov *res = 0;
1702cff8c6f2SKonstantin Belousov return (EINVAL);
1703cff8c6f2SKonstantin Belousov }
1704d297ad16SMarcel Moolenaar
1705e9eabf59SPeter Wemm sym = ef->ddbsymtab + symidx;
1706d297ad16SMarcel Moolenaar
17074cec6f5dSPeter Wemm /* Quick answer if there is a definition included. */
1708cff8c6f2SKonstantin Belousov if (sym->st_shndx != SHN_UNDEF) {
1709289ead7cSKonstantin Belousov res1 = (Elf_Addr)sym->st_value;
1710289ead7cSKonstantin Belousov if (ELF_ST_TYPE(sym->st_info) == STT_GNU_IFUNC)
1711289ead7cSKonstantin Belousov res1 = ((Elf_Addr (*)(void))res1)();
1712289ead7cSKonstantin Belousov *res = res1;
1713cff8c6f2SKonstantin Belousov return (0);
1714cff8c6f2SKonstantin Belousov }
17154cec6f5dSPeter Wemm
17164cec6f5dSPeter Wemm /* If we get here, then it is undefined and needs a lookup. */
17174cec6f5dSPeter Wemm switch (ELF_ST_BIND(sym->st_info)) {
17184cec6f5dSPeter Wemm case STB_LOCAL:
17194cec6f5dSPeter Wemm /* Local, but undefined? huh? */
1720cff8c6f2SKonstantin Belousov *res = 0;
1721cff8c6f2SKonstantin Belousov return (EINVAL);
1722d297ad16SMarcel Moolenaar
1723e9eabf59SPeter Wemm case STB_GLOBAL:
1724cff8c6f2SKonstantin Belousov case STB_WEAK:
1725e9eabf59SPeter Wemm /* Relative to Data or Function name */
1726e9eabf59SPeter Wemm symbol = ef->ddbstrtab + sym->st_name;
1727d297ad16SMarcel Moolenaar
1728d297ad16SMarcel Moolenaar /* Force a lookup failure if the symbol name is bogus. */
1729cff8c6f2SKonstantin Belousov if (*symbol == 0) {
1730cff8c6f2SKonstantin Belousov *res = 0;
1731cff8c6f2SKonstantin Belousov return (EINVAL);
1732cff8c6f2SKonstantin Belousov }
1733cff8c6f2SKonstantin Belousov res1 = (Elf_Addr)linker_file_lookup_symbol(lf, symbol, deps);
17342832cd54SKonstantin Belousov
17352832cd54SKonstantin Belousov /*
17362832cd54SKonstantin Belousov * Cache global lookups during module relocation. The failure
17372832cd54SKonstantin Belousov * case is particularly expensive for callers, who must scan
17382832cd54SKonstantin Belousov * through the entire globals table doing strcmp(). Cache to
17392832cd54SKonstantin Belousov * avoid doing such work repeatedly.
17402832cd54SKonstantin Belousov *
17412832cd54SKonstantin Belousov * After relocation is complete, undefined globals will be
17422832cd54SKonstantin Belousov * restored to SHN_UNDEF in elf_obj_cleanup_globals_cache(),
17432832cd54SKonstantin Belousov * above.
17442832cd54SKonstantin Belousov */
1745cff8c6f2SKonstantin Belousov if (res1 != 0) {
17462832cd54SKonstantin Belousov sym->st_shndx = SHN_FBSD_CACHED;
1747cff8c6f2SKonstantin Belousov sym->st_value = res1;
1748cff8c6f2SKonstantin Belousov *res = res1;
1749e9eabf59SPeter Wemm return (0);
1750cff8c6f2SKonstantin Belousov } else if (ELF_ST_BIND(sym->st_info) == STB_WEAK) {
1751cff8c6f2SKonstantin Belousov sym->st_value = 0;
1752cff8c6f2SKonstantin Belousov *res = 0;
1753cff8c6f2SKonstantin Belousov return (0);
1754cff8c6f2SKonstantin Belousov }
1755cff8c6f2SKonstantin Belousov return (EINVAL);
1756e9eabf59SPeter Wemm
1757e9eabf59SPeter Wemm default:
1758cff8c6f2SKonstantin Belousov return (EINVAL);
1759d297ad16SMarcel Moolenaar }
1760e9eabf59SPeter Wemm }
1761e9eabf59SPeter Wemm
17627251b4bfSJake Burkholder static void
link_elf_fix_link_set(elf_file_t ef)17637226306eSKonstantin Belousov link_elf_fix_link_set(elf_file_t ef)
17647226306eSKonstantin Belousov {
17657226306eSKonstantin Belousov static const char startn[] = "__start_";
17667226306eSKonstantin Belousov static const char stopn[] = "__stop_";
17677226306eSKonstantin Belousov Elf_Sym *sym;
17687226306eSKonstantin Belousov const char *sym_name, *linkset_name;
17697226306eSKonstantin Belousov Elf_Addr startp, stopp;
17707226306eSKonstantin Belousov Elf_Size symidx;
17717226306eSKonstantin Belousov int start, i;
17727226306eSKonstantin Belousov
17737226306eSKonstantin Belousov startp = stopp = 0;
17747226306eSKonstantin Belousov for (symidx = 1 /* zero entry is special */;
17757226306eSKonstantin Belousov symidx < ef->ddbsymcnt; symidx++) {
17767226306eSKonstantin Belousov sym = ef->ddbsymtab + symidx;
17777226306eSKonstantin Belousov if (sym->st_shndx != SHN_UNDEF)
17787226306eSKonstantin Belousov continue;
17797226306eSKonstantin Belousov
17807226306eSKonstantin Belousov sym_name = ef->ddbstrtab + sym->st_name;
17817226306eSKonstantin Belousov if (strncmp(sym_name, startn, sizeof(startn) - 1) == 0) {
17827226306eSKonstantin Belousov start = 1;
17837226306eSKonstantin Belousov linkset_name = sym_name + sizeof(startn) - 1;
17847226306eSKonstantin Belousov }
17857226306eSKonstantin Belousov else if (strncmp(sym_name, stopn, sizeof(stopn) - 1) == 0) {
17867226306eSKonstantin Belousov start = 0;
17877226306eSKonstantin Belousov linkset_name = sym_name + sizeof(stopn) - 1;
17887226306eSKonstantin Belousov }
17897226306eSKonstantin Belousov else
17907226306eSKonstantin Belousov continue;
17917226306eSKonstantin Belousov
17927226306eSKonstantin Belousov for (i = 0; i < ef->nprogtab; i++) {
17937226306eSKonstantin Belousov if (strcmp(ef->progtab[i].name, linkset_name) == 0) {
17947226306eSKonstantin Belousov startp = (Elf_Addr)ef->progtab[i].addr;
17957226306eSKonstantin Belousov stopp = (Elf_Addr)(startp + ef->progtab[i].size);
17967226306eSKonstantin Belousov break;
17977226306eSKonstantin Belousov }
17987226306eSKonstantin Belousov }
17997226306eSKonstantin Belousov if (i == ef->nprogtab)
18007226306eSKonstantin Belousov continue;
18017226306eSKonstantin Belousov
18027226306eSKonstantin Belousov sym->st_value = start ? startp : stopp;
18037226306eSKonstantin Belousov sym->st_shndx = i;
18047226306eSKonstantin Belousov }
18057226306eSKonstantin Belousov }
18067226306eSKonstantin Belousov
18073cfce8e4SKonstantin Belousov static int
link_elf_reloc_local(linker_file_t lf,bool ifuncs)1808289ead7cSKonstantin Belousov link_elf_reloc_local(linker_file_t lf, bool ifuncs)
18097251b4bfSJake Burkholder {
1810e9eabf59SPeter Wemm elf_file_t ef = (elf_file_t)lf;
18117251b4bfSJake Burkholder const Elf_Rel *rellim;
18127251b4bfSJake Burkholder const Elf_Rel *rel;
18137251b4bfSJake Burkholder const Elf_Rela *relalim;
18147251b4bfSJake Burkholder const Elf_Rela *rela;
1815e9eabf59SPeter Wemm const Elf_Sym *sym;
1816e9eabf59SPeter Wemm Elf_Addr base;
1817e9eabf59SPeter Wemm int i;
1818757686b1SMarcel Moolenaar Elf_Size symidx;
1819e9eabf59SPeter Wemm
18207226306eSKonstantin Belousov link_elf_fix_link_set(ef);
18217226306eSKonstantin Belousov
18227251b4bfSJake Burkholder /* Perform relocations without addend if there are any: */
1823b474c780SDavid E. O'Brien for (i = 0; i < ef->nreltab; i++) {
1824e9eabf59SPeter Wemm rel = ef->reltab[i].rel;
18253cfce8e4SKonstantin Belousov if (rel == NULL) {
18263cfce8e4SKonstantin Belousov link_elf_error(ef->lf.filename, "lost a reltab");
18273cfce8e4SKonstantin Belousov return (ENOEXEC);
18283cfce8e4SKonstantin Belousov }
182920947801SPeter Wemm rellim = rel + ef->reltab[i].nrel;
1830e9eabf59SPeter Wemm base = findbase(ef, ef->reltab[i].sec);
18313cfce8e4SKonstantin Belousov if (base == 0) {
18323cfce8e4SKonstantin Belousov link_elf_error(ef->lf.filename, "lost base for reltab");
18333cfce8e4SKonstantin Belousov return (ENOEXEC);
18343cfce8e4SKonstantin Belousov }
183520947801SPeter Wemm for ( ; rel < rellim; rel++) {
1836e9eabf59SPeter Wemm symidx = ELF_R_SYM(rel->r_info);
183720947801SPeter Wemm if (symidx >= ef->ddbsymcnt)
183820947801SPeter Wemm continue;
1839e9eabf59SPeter Wemm sym = ef->ddbsymtab + symidx;
184020947801SPeter Wemm /* Only do local relocs */
184120947801SPeter Wemm if (ELF_ST_BIND(sym->st_info) != STB_LOCAL)
184220947801SPeter Wemm continue;
184336716fe2SMark Johnston if ((ELF_ST_TYPE(sym->st_info) == STT_GNU_IFUNC ||
184444c705cfSMitchell Horne elf_is_ifunc_reloc(rel->r_info)) != ifuncs)
184544c705cfSMitchell Horne continue;
184644c705cfSMitchell Horne if (elf_reloc_local(lf, base, rel, ELF_RELOC_REL,
184744c705cfSMitchell Horne elf_obj_lookup) != 0)
184844c705cfSMitchell Horne return (ENOEXEC);
18497251b4bfSJake Burkholder }
1850e9eabf59SPeter Wemm }
18517251b4bfSJake Burkholder
18527251b4bfSJake Burkholder /* Perform relocations with addend if there are any: */
1853b474c780SDavid E. O'Brien for (i = 0; i < ef->nrelatab; i++) {
1854e9eabf59SPeter Wemm rela = ef->relatab[i].rela;
18553cfce8e4SKonstantin Belousov if (rela == NULL) {
18563cfce8e4SKonstantin Belousov link_elf_error(ef->lf.filename, "lost a relatab!");
18573cfce8e4SKonstantin Belousov return (ENOEXEC);
18583cfce8e4SKonstantin Belousov }
185920947801SPeter Wemm relalim = rela + ef->relatab[i].nrela;
1860e9eabf59SPeter Wemm base = findbase(ef, ef->relatab[i].sec);
18613cfce8e4SKonstantin Belousov if (base == 0) {
18623cfce8e4SKonstantin Belousov link_elf_error(ef->lf.filename, "lost base for reltab");
18633cfce8e4SKonstantin Belousov return (ENOEXEC);
18643cfce8e4SKonstantin Belousov }
186520947801SPeter Wemm for ( ; rela < relalim; rela++) {
1866e9eabf59SPeter Wemm symidx = ELF_R_SYM(rela->r_info);
186720947801SPeter Wemm if (symidx >= ef->ddbsymcnt)
186820947801SPeter Wemm continue;
1869e9eabf59SPeter Wemm sym = ef->ddbsymtab + symidx;
187020947801SPeter Wemm /* Only do local relocs */
187120947801SPeter Wemm if (ELF_ST_BIND(sym->st_info) != STB_LOCAL)
187220947801SPeter Wemm continue;
187336716fe2SMark Johnston if ((ELF_ST_TYPE(sym->st_info) == STT_GNU_IFUNC ||
187444c705cfSMitchell Horne elf_is_ifunc_reloc(rela->r_info)) != ifuncs)
187544c705cfSMitchell Horne continue;
187644c705cfSMitchell Horne if (elf_reloc_local(lf, base, rela, ELF_RELOC_RELA,
187744c705cfSMitchell Horne elf_obj_lookup) != 0)
187844c705cfSMitchell Horne return (ENOEXEC);
18797251b4bfSJake Burkholder }
18807251b4bfSJake Burkholder }
18813cfce8e4SKonstantin Belousov return (0);
1882e9eabf59SPeter Wemm }
188300a5db46SStacey Son
188400a5db46SStacey Son static long
link_elf_symtab_get(linker_file_t lf,const Elf_Sym ** symtab)1885e76f11f4SAndriy Gapon link_elf_symtab_get(linker_file_t lf, const Elf_Sym **symtab)
188600a5db46SStacey Son {
188700a5db46SStacey Son elf_file_t ef = (elf_file_t)lf;
188800a5db46SStacey Son
188900a5db46SStacey Son *symtab = ef->ddbsymtab;
189000a5db46SStacey Son if (*symtab == NULL)
189100a5db46SStacey Son return (0);
189200a5db46SStacey Son return (ef->ddbsymcnt);
189300a5db46SStacey Son }
189400a5db46SStacey Son
189500a5db46SStacey Son static long
link_elf_strtab_get(linker_file_t lf,caddr_t * strtab)189600a5db46SStacey Son link_elf_strtab_get(linker_file_t lf, caddr_t *strtab)
189700a5db46SStacey Son {
189800a5db46SStacey Son elf_file_t ef = (elf_file_t)lf;
189900a5db46SStacey Son
190000a5db46SStacey Son *strtab = ef->ddbstrtab;
190100a5db46SStacey Son if (*strtab == NULL)
190200a5db46SStacey Son return (0);
190300a5db46SStacey Son return (ef->ddbstrcnt);
190400a5db46SStacey Son }
1905110113bcSZhenlei Huang
1906110113bcSZhenlei Huang #ifdef VIMAGE
1907110113bcSZhenlei Huang static void
link_elf_propagate_vnets(linker_file_t lf)1908110113bcSZhenlei Huang link_elf_propagate_vnets(linker_file_t lf)
1909110113bcSZhenlei Huang {
1910110113bcSZhenlei Huang elf_file_t ef = (elf_file_t) lf;
1911110113bcSZhenlei Huang
1912110113bcSZhenlei Huang if (ef->progtab) {
1913110113bcSZhenlei Huang for (int i = 0; i < ef->nprogtab; i++) {
1914110113bcSZhenlei Huang if (ef->progtab[i].size == 0)
1915110113bcSZhenlei Huang continue;
1916110113bcSZhenlei Huang if (ef->progtab[i].name == NULL)
1917110113bcSZhenlei Huang continue;
1918110113bcSZhenlei Huang if (strcmp(ef->progtab[i].name, VNET_SETNAME) == 0) {
1919110113bcSZhenlei Huang vnet_data_copy(ef->progtab[i].addr,
1920110113bcSZhenlei Huang ef->progtab[i].size);
1921110113bcSZhenlei Huang break;
1922110113bcSZhenlei Huang }
1923110113bcSZhenlei Huang }
1924110113bcSZhenlei Huang }
1925110113bcSZhenlei Huang }
1926110113bcSZhenlei Huang #endif
1927