xref: /freebsd/sys/kern/link_elf_obj.c (revision 8a36da99deb0e19363ec04e4d3facd869c1028f5)
1a4f67738SDoug Rabson /*-
2*8a36da99SPedro F. Giffuni  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3*8a36da99SPedro 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 
30677b542eSDavid E. O'Brien #include <sys/cdefs.h>
31677b542eSDavid E. O'Brien __FBSDID("$FreeBSD$");
32677b542eSDavid E. O'Brien 
33326e27d8SDoug Rabson #include "opt_ddb.h"
34326e27d8SDoug Rabson 
35a4f67738SDoug Rabson #include <sys/param.h>
36a4f67738SDoug Rabson #include <sys/systm.h>
37fb919e4dSMark Murray #include <sys/kernel.h>
38fb919e4dSMark Murray #include <sys/lock.h>
39a4f67738SDoug Rabson #include <sys/malloc.h>
40c0b824f9SDima Dorfman #include <sys/mutex.h>
4162d615d5SJohn Baldwin #include <sys/mount.h>
42a4f67738SDoug Rabson #include <sys/proc.h>
43a4f67738SDoug Rabson #include <sys/namei.h>
44a4f67738SDoug Rabson #include <sys/fcntl.h>
45a4f67738SDoug Rabson #include <sys/vnode.h>
46a4f67738SDoug Rabson #include <sys/linker.h>
47fb919e4dSMark Murray 
48a4f67738SDoug Rabson #include <machine/elf.h>
49a4f67738SDoug Rabson 
50eddfbb76SRobert Watson #include <net/vnet.h>
51eddfbb76SRobert Watson 
52aed55708SRobert Watson #include <security/mac/mac_framework.h>
53aed55708SRobert Watson 
54fe3db7c7SDoug Rabson #include <vm/vm.h>
55fe3db7c7SDoug Rabson #include <vm/vm_param.h>
56fe3db7c7SDoug Rabson #include <vm/vm_object.h>
57fe3db7c7SDoug Rabson #include <vm/vm_kern.h>
58fe3db7c7SDoug Rabson #include <vm/vm_extern.h>
59fe3db7c7SDoug Rabson #include <vm/pmap.h>
60fe3db7c7SDoug Rabson #include <vm/vm_map.h>
61fb919e4dSMark Murray 
62f9980387SPeter Wemm #include <sys/link_elf.h>
63fe3db7c7SDoug Rabson 
64a2024a3eSJohn Birrell #ifdef DDB_CTF
65d9db5225SCraig Rodrigues #include <sys/zlib.h>
66a2024a3eSJohn Birrell #endif
67a2024a3eSJohn Birrell 
68326e27d8SDoug Rabson #include "linker_if.h"
69a4f67738SDoug Rabson 
70e9eabf59SPeter Wemm typedef struct {
71e9eabf59SPeter Wemm 	void		*addr;
7220947801SPeter Wemm 	Elf_Off		size;
73e9eabf59SPeter Wemm 	int		flags;
74e9eabf59SPeter Wemm 	int		sec;	/* Original section */
75e9eabf59SPeter Wemm 	char		*name;
76e9eabf59SPeter Wemm } Elf_progent;
77e9eabf59SPeter Wemm 
78e9eabf59SPeter Wemm typedef struct {
79e9eabf59SPeter Wemm 	Elf_Rel		*rel;
8020947801SPeter Wemm 	int		nrel;
81e9eabf59SPeter Wemm 	int		sec;
82e9eabf59SPeter Wemm } Elf_relent;
83e9eabf59SPeter Wemm 
84e9eabf59SPeter Wemm typedef struct {
85e9eabf59SPeter Wemm 	Elf_Rela	*rela;
8620947801SPeter Wemm 	int		nrela;
87e9eabf59SPeter Wemm 	int		sec;
88e9eabf59SPeter Wemm } Elf_relaent;
89e9eabf59SPeter Wemm 
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;
100e9eabf59SPeter Wemm 	int		nprogtab;
101e9eabf59SPeter Wemm 
102e9eabf59SPeter Wemm 	Elf_relaent	*relatab;
103b474c780SDavid E. O'Brien 	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 *);
132e9eabf59SPeter Wemm static int	link_elf_symbol_values(linker_file_t, c_linker_sym_t,
133e9eabf59SPeter Wemm 		    linker_symval_t *);
134326e27d8SDoug Rabson static int	link_elf_search_symbol(linker_file_t, caddr_t value,
135326e27d8SDoug Rabson 		    c_linker_sym_t *sym, long *diffp);
136326e27d8SDoug Rabson 
137326e27d8SDoug Rabson static void	link_elf_unload_file(linker_file_t);
138f41325dbSPeter Wemm static int	link_elf_lookup_set(linker_file_t, const char *,
139f41325dbSPeter Wemm 		    void ***, void ***, int *);
140bb9fe9ddSBrian Feldman static int	link_elf_each_function_name(linker_file_t,
141e9eabf59SPeter Wemm 		    int (*)(const char *, void *), void *);
142a2024a3eSJohn Birrell static int	link_elf_each_function_nameval(linker_file_t,
143a2024a3eSJohn Birrell 				linker_function_nameval_callback_t,
144a2024a3eSJohn Birrell 				void *);
1453cfce8e4SKonstantin Belousov static int	link_elf_reloc_local(linker_file_t);
146e76f11f4SAndriy Gapon static long	link_elf_symtab_get(linker_file_t, const Elf_Sym **);
14700a5db46SStacey Son static long	link_elf_strtab_get(linker_file_t, caddr_t *);
148326e27d8SDoug Rabson 
149cff8c6f2SKonstantin Belousov static int	elf_obj_lookup(linker_file_t lf, Elf_Size symidx, int deps,
150cff8c6f2SKonstantin Belousov 		    Elf_Addr *);
151e9eabf59SPeter Wemm 
152326e27d8SDoug Rabson static kobj_method_t link_elf_methods[] = {
153326e27d8SDoug Rabson 	KOBJMETHOD(linker_lookup_symbol,	link_elf_lookup_symbol),
154326e27d8SDoug Rabson 	KOBJMETHOD(linker_symbol_values,	link_elf_symbol_values),
155326e27d8SDoug Rabson 	KOBJMETHOD(linker_search_symbol,	link_elf_search_symbol),
156326e27d8SDoug Rabson 	KOBJMETHOD(linker_unload,		link_elf_unload_file),
15754823af2SPeter Wemm 	KOBJMETHOD(linker_load_file,		link_elf_load_file),
15854823af2SPeter Wemm 	KOBJMETHOD(linker_link_preload,		link_elf_link_preload),
15954823af2SPeter Wemm 	KOBJMETHOD(linker_link_preload_finish,	link_elf_link_preload_finish),
160f41325dbSPeter Wemm 	KOBJMETHOD(linker_lookup_set,		link_elf_lookup_set),
161bb9fe9ddSBrian Feldman 	KOBJMETHOD(linker_each_function_name,	link_elf_each_function_name),
162a2024a3eSJohn Birrell 	KOBJMETHOD(linker_each_function_nameval, link_elf_each_function_nameval),
163a2024a3eSJohn Birrell 	KOBJMETHOD(linker_ctf_get,		link_elf_ctf_get),
16400a5db46SStacey Son 	KOBJMETHOD(linker_symtab_get, 		link_elf_symtab_get),
16500a5db46SStacey Son 	KOBJMETHOD(linker_strtab_get, 		link_elf_strtab_get),
166326e27d8SDoug Rabson 	{ 0, 0 }
167326e27d8SDoug Rabson };
168326e27d8SDoug Rabson 
169326e27d8SDoug Rabson static struct linker_class link_elf_class = {
170326e27d8SDoug Rabson #if ELF_TARG_CLASS == ELFCLASS32
171e9eabf59SPeter Wemm 	"elf32_obj",
172326e27d8SDoug Rabson #else
173e9eabf59SPeter Wemm 	"elf64_obj",
174326e27d8SDoug Rabson #endif
175326e27d8SDoug Rabson 	link_elf_methods, sizeof(struct elf_file)
176326e27d8SDoug Rabson };
177326e27d8SDoug Rabson 
178326e27d8SDoug Rabson static int	relocate_file(elf_file_t ef);
1792832cd54SKonstantin Belousov static void	elf_obj_cleanup_globals_cache(elf_file_t);
180a4f67738SDoug Rabson 
181a4f67738SDoug Rabson static void
182552f9f63SEdwin Groothuis link_elf_error(const char *filename, const char *s)
1831720979bSMarcel Moolenaar {
184552f9f63SEdwin Groothuis 	if (filename == NULL)
1851720979bSMarcel Moolenaar 		printf("kldload: %s\n", s);
186552f9f63SEdwin Groothuis 	else
187552f9f63SEdwin Groothuis 		printf("kldload: %s: %s\n", filename, s);
1881720979bSMarcel Moolenaar }
1891720979bSMarcel Moolenaar 
1901720979bSMarcel Moolenaar static void
191a4f67738SDoug Rabson link_elf_init(void *arg)
192a4f67738SDoug Rabson {
193a4f67738SDoug Rabson 
194326e27d8SDoug Rabson 	linker_add_class(&link_elf_class);
195a4f67738SDoug Rabson }
196a4f67738SDoug Rabson 
197e9eabf59SPeter Wemm SYSINIT(link_elf_obj, SI_SUB_KLD, SI_ORDER_SECOND, link_elf_init, 0);
198a4f67738SDoug Rabson 
199a4f67738SDoug Rabson static int
200e9eabf59SPeter Wemm link_elf_link_preload(linker_class_t cls, const char *filename,
201e9eabf59SPeter Wemm     linker_file_t *result)
2022d636ab0SPeter Wemm {
20370b7ffeeSIan Dowse 	Elf_Ehdr *hdr;
20470b7ffeeSIan Dowse 	Elf_Shdr *shdr;
20570b7ffeeSIan Dowse 	Elf_Sym *es;
20670b7ffeeSIan Dowse 	void *modptr, *baseptr, *sizeptr;
20770b7ffeeSIan Dowse 	char *type;
20870b7ffeeSIan Dowse 	elf_file_t ef;
20970b7ffeeSIan Dowse 	linker_file_t lf;
21070b7ffeeSIan Dowse 	Elf_Addr off;
21170b7ffeeSIan Dowse 	int error, i, j, pb, ra, rl, shstrindex, symstrindex, symtabindex;
21270b7ffeeSIan Dowse 
21370b7ffeeSIan Dowse 	/* Look to see if we have the file preloaded */
21470b7ffeeSIan Dowse 	modptr = preload_search_by_name(filename);
21570b7ffeeSIan Dowse 	if (modptr == NULL)
21670b7ffeeSIan Dowse 		return ENOENT;
21770b7ffeeSIan Dowse 
21870b7ffeeSIan Dowse 	type = (char *)preload_search_info(modptr, MODINFO_TYPE);
21970b7ffeeSIan Dowse 	baseptr = preload_search_info(modptr, MODINFO_ADDR);
22070b7ffeeSIan Dowse 	sizeptr = preload_search_info(modptr, MODINFO_SIZE);
22170b7ffeeSIan Dowse 	hdr = (Elf_Ehdr *)preload_search_info(modptr, MODINFO_METADATA |
22270b7ffeeSIan Dowse 	    MODINFOMD_ELFHDR);
22370b7ffeeSIan Dowse 	shdr = (Elf_Shdr *)preload_search_info(modptr, MODINFO_METADATA |
22470b7ffeeSIan Dowse 	    MODINFOMD_SHDR);
22570b7ffeeSIan Dowse 	if (type == NULL || (strcmp(type, "elf" __XSTRING(__ELF_WORD_SIZE)
22670b7ffeeSIan Dowse 	    " obj module") != 0 &&
22770b7ffeeSIan Dowse 	    strcmp(type, "elf obj module") != 0)) {
228de78ca7eSPeter Wemm 		return (EFTYPE);
229de78ca7eSPeter Wemm 	}
23070b7ffeeSIan Dowse 	if (baseptr == NULL || sizeptr == NULL || hdr == NULL ||
23170b7ffeeSIan Dowse 	    shdr == NULL)
23270b7ffeeSIan Dowse 		return (EINVAL);
23370b7ffeeSIan Dowse 
23470b7ffeeSIan Dowse 	lf = linker_make_file(filename, &link_elf_class);
23570b7ffeeSIan Dowse 	if (lf == NULL)
23670b7ffeeSIan Dowse 		return (ENOMEM);
23770b7ffeeSIan Dowse 
23870b7ffeeSIan Dowse 	ef = (elf_file_t)lf;
23970b7ffeeSIan Dowse 	ef->preloaded = 1;
24070b7ffeeSIan Dowse 	ef->address = *(caddr_t *)baseptr;
24170b7ffeeSIan Dowse 	lf->address = *(caddr_t *)baseptr;
24270b7ffeeSIan Dowse 	lf->size = *(size_t *)sizeptr;
24370b7ffeeSIan Dowse 
24470b7ffeeSIan Dowse 	if (hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS ||
24570b7ffeeSIan Dowse 	    hdr->e_ident[EI_DATA] != ELF_TARG_DATA ||
24670b7ffeeSIan Dowse 	    hdr->e_ident[EI_VERSION] != EV_CURRENT ||
24770b7ffeeSIan Dowse 	    hdr->e_version != EV_CURRENT ||
24870b7ffeeSIan Dowse 	    hdr->e_type != ET_REL ||
24970b7ffeeSIan Dowse 	    hdr->e_machine != ELF_TARG_MACH) {
25070b7ffeeSIan Dowse 		error = EFTYPE;
25170b7ffeeSIan Dowse 		goto out;
25270b7ffeeSIan Dowse 	}
25370b7ffeeSIan Dowse 	ef->e_shdr = shdr;
25470b7ffeeSIan Dowse 
25570b7ffeeSIan Dowse 	/* Scan the section header for information and table sizing. */
25670b7ffeeSIan Dowse 	symtabindex = -1;
25770b7ffeeSIan Dowse 	symstrindex = -1;
25870b7ffeeSIan Dowse 	for (i = 0; i < hdr->e_shnum; i++) {
25970b7ffeeSIan Dowse 		switch (shdr[i].sh_type) {
26070b7ffeeSIan Dowse 		case SHT_PROGBITS:
26170b7ffeeSIan Dowse 		case SHT_NOBITS:
26213f28d96SKonstantin Belousov #ifdef __amd64__
263b715d9afSKonstantin Belousov 		case SHT_X86_64_UNWIND:
26413f28d96SKonstantin Belousov #endif
26570b7ffeeSIan Dowse 			ef->nprogtab++;
26670b7ffeeSIan Dowse 			break;
26770b7ffeeSIan Dowse 		case SHT_SYMTAB:
26870b7ffeeSIan Dowse 			symtabindex = i;
26970b7ffeeSIan Dowse 			symstrindex = shdr[i].sh_link;
27070b7ffeeSIan Dowse 			break;
27170b7ffeeSIan Dowse 		case SHT_REL:
272b474c780SDavid E. O'Brien 			ef->nreltab++;
27370b7ffeeSIan Dowse 			break;
27470b7ffeeSIan Dowse 		case SHT_RELA:
275b474c780SDavid E. O'Brien 			ef->nrelatab++;
27670b7ffeeSIan Dowse 			break;
27770b7ffeeSIan Dowse 		}
27870b7ffeeSIan Dowse 	}
27970b7ffeeSIan Dowse 
28070b7ffeeSIan Dowse 	shstrindex = hdr->e_shstrndx;
28170b7ffeeSIan Dowse 	if (ef->nprogtab == 0 || symstrindex < 0 ||
28270b7ffeeSIan Dowse 	    symstrindex >= hdr->e_shnum ||
28370b7ffeeSIan Dowse 	    shdr[symstrindex].sh_type != SHT_STRTAB || shstrindex == 0 ||
28470b7ffeeSIan Dowse 	    shstrindex >= hdr->e_shnum ||
28570b7ffeeSIan Dowse 	    shdr[shstrindex].sh_type != SHT_STRTAB) {
28670b7ffeeSIan Dowse 		printf("%s: bad/missing section headers\n", filename);
28770b7ffeeSIan Dowse 		error = ENOEXEC;
28870b7ffeeSIan Dowse 		goto out;
28970b7ffeeSIan Dowse 	}
29070b7ffeeSIan Dowse 
29170b7ffeeSIan Dowse 	/* Allocate space for tracking the load chunks */
29270b7ffeeSIan Dowse 	if (ef->nprogtab != 0)
29370b7ffeeSIan Dowse 		ef->progtab = malloc(ef->nprogtab * sizeof(*ef->progtab),
29470b7ffeeSIan Dowse 		    M_LINKER, M_WAITOK | M_ZERO);
295b474c780SDavid E. O'Brien 	if (ef->nreltab != 0)
296b474c780SDavid E. O'Brien 		ef->reltab = malloc(ef->nreltab * sizeof(*ef->reltab),
297b474c780SDavid E. O'Brien 		    M_LINKER, M_WAITOK | M_ZERO);
298b474c780SDavid E. O'Brien 	if (ef->nrelatab != 0)
299b474c780SDavid E. O'Brien 		ef->relatab = malloc(ef->nrelatab * sizeof(*ef->relatab),
300b474c780SDavid E. O'Brien 		    M_LINKER, M_WAITOK | M_ZERO);
30170b7ffeeSIan Dowse 	if ((ef->nprogtab != 0 && ef->progtab == NULL) ||
302b474c780SDavid E. O'Brien 	    (ef->nreltab != 0 && ef->reltab == NULL) ||
303b474c780SDavid E. O'Brien 	    (ef->nrelatab != 0 && ef->relatab == NULL)) {
30470b7ffeeSIan Dowse 		error = ENOMEM;
30570b7ffeeSIan Dowse 		goto out;
30670b7ffeeSIan Dowse 	}
30770b7ffeeSIan Dowse 
30870b7ffeeSIan Dowse 	/* XXX, relocate the sh_addr fields saved by the loader. */
30970b7ffeeSIan Dowse 	off = 0;
31070b7ffeeSIan Dowse 	for (i = 0; i < hdr->e_shnum; i++) {
31170b7ffeeSIan Dowse 		if (shdr[i].sh_addr != 0 && (off == 0 || shdr[i].sh_addr < off))
31270b7ffeeSIan Dowse 			off = shdr[i].sh_addr;
31370b7ffeeSIan Dowse 	}
31470b7ffeeSIan Dowse 	for (i = 0; i < hdr->e_shnum; i++) {
31570b7ffeeSIan Dowse 		if (shdr[i].sh_addr != 0)
31670b7ffeeSIan Dowse 			shdr[i].sh_addr = shdr[i].sh_addr - off +
31770b7ffeeSIan Dowse 			    (Elf_Addr)ef->address;
31870b7ffeeSIan Dowse 	}
31970b7ffeeSIan Dowse 
32070b7ffeeSIan Dowse 	ef->ddbsymcnt = shdr[symtabindex].sh_size / sizeof(Elf_Sym);
32170b7ffeeSIan Dowse 	ef->ddbsymtab = (Elf_Sym *)shdr[symtabindex].sh_addr;
32270b7ffeeSIan Dowse 	ef->ddbstrcnt = shdr[symstrindex].sh_size;
32370b7ffeeSIan Dowse 	ef->ddbstrtab = (char *)shdr[symstrindex].sh_addr;
32470b7ffeeSIan Dowse 	ef->shstrcnt = shdr[shstrindex].sh_size;
32570b7ffeeSIan Dowse 	ef->shstrtab = (char *)shdr[shstrindex].sh_addr;
32670b7ffeeSIan Dowse 
32770b7ffeeSIan Dowse 	/* Now fill out progtab and the relocation tables. */
32870b7ffeeSIan Dowse 	pb = 0;
32970b7ffeeSIan Dowse 	rl = 0;
33070b7ffeeSIan Dowse 	ra = 0;
33170b7ffeeSIan Dowse 	for (i = 0; i < hdr->e_shnum; i++) {
33270b7ffeeSIan Dowse 		switch (shdr[i].sh_type) {
33370b7ffeeSIan Dowse 		case SHT_PROGBITS:
33470b7ffeeSIan Dowse 		case SHT_NOBITS:
33513f28d96SKonstantin Belousov #ifdef __amd64__
336b715d9afSKonstantin Belousov 		case SHT_X86_64_UNWIND:
33713f28d96SKonstantin Belousov #endif
33870b7ffeeSIan Dowse 			ef->progtab[pb].addr = (void *)shdr[i].sh_addr;
33970b7ffeeSIan Dowse 			if (shdr[i].sh_type == SHT_PROGBITS)
34070b7ffeeSIan Dowse 				ef->progtab[pb].name = "<<PROGBITS>>";
34113f28d96SKonstantin Belousov #ifdef __amd64__
342b715d9afSKonstantin Belousov 			else if (shdr[i].sh_type == SHT_X86_64_UNWIND)
34313f28d96SKonstantin Belousov 				ef->progtab[pb].name = "<<UNWIND>>";
34413f28d96SKonstantin Belousov #endif
34570b7ffeeSIan Dowse 			else
34670b7ffeeSIan Dowse 				ef->progtab[pb].name = "<<NOBITS>>";
34770b7ffeeSIan Dowse 			ef->progtab[pb].size = shdr[i].sh_size;
34870b7ffeeSIan Dowse 			ef->progtab[pb].sec = i;
34970b7ffeeSIan Dowse 			if (ef->shstrtab && shdr[i].sh_name != 0)
35070b7ffeeSIan Dowse 				ef->progtab[pb].name =
35170b7ffeeSIan Dowse 				    ef->shstrtab + shdr[i].sh_name;
35250c202c5SJeff Roberson 			if (ef->progtab[pb].name != NULL &&
3535f67450dSDimitry Andric 			    !strcmp(ef->progtab[pb].name, DPCPU_SETNAME)) {
35450c202c5SJeff Roberson 				void *dpcpu;
35550c202c5SJeff Roberson 
35650c202c5SJeff Roberson 				dpcpu = dpcpu_alloc(shdr[i].sh_size);
35750c202c5SJeff Roberson 				if (dpcpu == NULL) {
35850c202c5SJeff Roberson 					error = ENOSPC;
35950c202c5SJeff Roberson 					goto out;
36050c202c5SJeff Roberson 				}
36150c202c5SJeff Roberson 				memcpy(dpcpu, ef->progtab[pb].addr,
36250c202c5SJeff Roberson 				    ef->progtab[pb].size);
36350c202c5SJeff Roberson 				dpcpu_copy(dpcpu, shdr[i].sh_size);
36450c202c5SJeff Roberson 				ef->progtab[pb].addr = dpcpu;
365eddfbb76SRobert Watson #ifdef VIMAGE
366eddfbb76SRobert Watson 			} else if (ef->progtab[pb].name != NULL &&
36717ef1febSRobert Watson 			    !strcmp(ef->progtab[pb].name, VNET_SETNAME)) {
368eddfbb76SRobert Watson 				void *vnet_data;
369eddfbb76SRobert Watson 
370eddfbb76SRobert Watson 				vnet_data = vnet_data_alloc(shdr[i].sh_size);
371eddfbb76SRobert Watson 				if (vnet_data == NULL) {
372eddfbb76SRobert Watson 					error = ENOSPC;
373eddfbb76SRobert Watson 					goto out;
374eddfbb76SRobert Watson 				}
375eddfbb76SRobert Watson 				memcpy(vnet_data, ef->progtab[pb].addr,
376eddfbb76SRobert Watson 				    ef->progtab[pb].size);
377eddfbb76SRobert Watson 				vnet_data_copy(vnet_data, shdr[i].sh_size);
378eddfbb76SRobert Watson 				ef->progtab[pb].addr = vnet_data;
379eddfbb76SRobert Watson #endif
3800067051fSMarcel Moolenaar 			} else if (ef->progtab[pb].name != NULL &&
3810067051fSMarcel Moolenaar 			    !strcmp(ef->progtab[pb].name, ".ctors")) {
3820067051fSMarcel Moolenaar 				lf->ctors_addr = ef->progtab[pb].addr;
3830067051fSMarcel Moolenaar 				lf->ctors_size = shdr[i].sh_size;
38450c202c5SJeff Roberson 			}
38570b7ffeeSIan Dowse 
38670b7ffeeSIan Dowse 			/* Update all symbol values with the offset. */
38770b7ffeeSIan Dowse 			for (j = 0; j < ef->ddbsymcnt; j++) {
38870b7ffeeSIan Dowse 				es = &ef->ddbsymtab[j];
38970b7ffeeSIan Dowse 				if (es->st_shndx != i)
39070b7ffeeSIan Dowse 					continue;
39170b7ffeeSIan Dowse 				es->st_value += (Elf_Addr)ef->progtab[pb].addr;
39270b7ffeeSIan Dowse 			}
39370b7ffeeSIan Dowse 			pb++;
39470b7ffeeSIan Dowse 			break;
39570b7ffeeSIan Dowse 		case SHT_REL:
39670b7ffeeSIan Dowse 			ef->reltab[rl].rel = (Elf_Rel *)shdr[i].sh_addr;
39770b7ffeeSIan Dowse 			ef->reltab[rl].nrel = shdr[i].sh_size / sizeof(Elf_Rel);
39870b7ffeeSIan Dowse 			ef->reltab[rl].sec = shdr[i].sh_info;
39970b7ffeeSIan Dowse 			rl++;
40070b7ffeeSIan Dowse 			break;
40170b7ffeeSIan Dowse 		case SHT_RELA:
40270b7ffeeSIan Dowse 			ef->relatab[ra].rela = (Elf_Rela *)shdr[i].sh_addr;
40370b7ffeeSIan Dowse 			ef->relatab[ra].nrela =
40470b7ffeeSIan Dowse 			    shdr[i].sh_size / sizeof(Elf_Rela);
40570b7ffeeSIan Dowse 			ef->relatab[ra].sec = shdr[i].sh_info;
40670b7ffeeSIan Dowse 			ra++;
40770b7ffeeSIan Dowse 			break;
40870b7ffeeSIan Dowse 		}
40970b7ffeeSIan Dowse 	}
4103cfce8e4SKonstantin Belousov 	if (pb != ef->nprogtab) {
4113cfce8e4SKonstantin Belousov 		printf("%s: lost progbits\n", filename);
4123cfce8e4SKonstantin Belousov 		error = ENOEXEC;
4133cfce8e4SKonstantin Belousov 		goto out;
4143cfce8e4SKonstantin Belousov 	}
4153cfce8e4SKonstantin Belousov 	if (rl != ef->nreltab) {
4163cfce8e4SKonstantin Belousov 		printf("%s: lost reltab\n", filename);
4173cfce8e4SKonstantin Belousov 		error = ENOEXEC;
4183cfce8e4SKonstantin Belousov 		goto out;
4193cfce8e4SKonstantin Belousov 	}
4203cfce8e4SKonstantin Belousov 	if (ra != ef->nrelatab) {
4213cfce8e4SKonstantin Belousov 		printf("%s: lost relatab\n", filename);
4223cfce8e4SKonstantin Belousov 		error = ENOEXEC;
4233cfce8e4SKonstantin Belousov 		goto out;
4243cfce8e4SKonstantin Belousov 	}
42570b7ffeeSIan Dowse 
42670b7ffeeSIan Dowse 	/* Local intra-module relocations */
4273cfce8e4SKonstantin Belousov 	error = link_elf_reloc_local(lf);
4283cfce8e4SKonstantin Belousov 	if (error != 0)
4293cfce8e4SKonstantin Belousov 		goto out;
43070b7ffeeSIan Dowse 
43170b7ffeeSIan Dowse 	*result = lf;
43270b7ffeeSIan Dowse 	return (0);
43370b7ffeeSIan Dowse 
43470b7ffeeSIan Dowse out:
43570b7ffeeSIan Dowse 	/* preload not done this way */
43670b7ffeeSIan Dowse 	linker_file_unload(lf, LINKER_UNLOAD_FORCE);
43770b7ffeeSIan Dowse 	return (error);
43870b7ffeeSIan Dowse }
439de78ca7eSPeter Wemm 
4400067051fSMarcel Moolenaar static void
4410067051fSMarcel Moolenaar link_elf_invoke_ctors(caddr_t addr, size_t size)
4420067051fSMarcel Moolenaar {
4430067051fSMarcel Moolenaar 	void (**ctor)(void);
4440067051fSMarcel Moolenaar 	size_t i, cnt;
4450067051fSMarcel Moolenaar 
4460067051fSMarcel Moolenaar 	if (addr == NULL || size == 0)
4470067051fSMarcel Moolenaar 		return;
4480067051fSMarcel Moolenaar 	cnt = size / sizeof(*ctor);
4490067051fSMarcel Moolenaar 	ctor = (void *)addr;
4500067051fSMarcel Moolenaar 	for (i = 0; i < cnt; i++) {
4510067051fSMarcel Moolenaar 		if (ctor[i] != NULL)
4520067051fSMarcel Moolenaar 			(*ctor[i])();
4530067051fSMarcel Moolenaar 	}
4540067051fSMarcel Moolenaar }
4550067051fSMarcel Moolenaar 
456de78ca7eSPeter Wemm static int
45754823af2SPeter Wemm link_elf_link_preload_finish(linker_file_t lf)
45854823af2SPeter Wemm {
45970b7ffeeSIan Dowse 	elf_file_t ef;
46070b7ffeeSIan Dowse 	int error;
46170b7ffeeSIan Dowse 
46270b7ffeeSIan Dowse 	ef = (elf_file_t)lf;
46370b7ffeeSIan Dowse 	error = relocate_file(ef);
46470b7ffeeSIan Dowse 	if (error)
46570b7ffeeSIan Dowse 		return error;
46670b7ffeeSIan Dowse 
46770b7ffeeSIan Dowse 	/* Notify MD code that a module is being loaded. */
46870b7ffeeSIan Dowse 	error = elf_cpu_load_file(lf);
46970b7ffeeSIan Dowse 	if (error)
47070b7ffeeSIan Dowse 		return (error);
47170b7ffeeSIan Dowse 
4720067051fSMarcel Moolenaar 	/* Invoke .ctors */
4730067051fSMarcel Moolenaar 	link_elf_invoke_ctors(lf->ctors_addr, lf->ctors_size);
47470b7ffeeSIan Dowse 	return (0);
47554823af2SPeter Wemm }
47654823af2SPeter Wemm 
47754823af2SPeter Wemm static int
478c143d6c2SMarcel Moolenaar link_elf_load_file(linker_class_t cls, const char *filename,
479c143d6c2SMarcel Moolenaar     linker_file_t *result)
480a4f67738SDoug Rabson {
481a344babfSGleb Smirnoff 	struct nameidata *nd;
482b40ce416SJulian Elischer 	struct thread *td = curthread;	/* XXX */
483caab6e90SPeter Wemm 	Elf_Ehdr *hdr;
484e9eabf59SPeter Wemm 	Elf_Shdr *shdr;
485a8774e39SPeter Wemm 	Elf_Sym *es;
486a8774e39SPeter Wemm 	int nbytes, i, j;
48720947801SPeter Wemm 	vm_offset_t mapbase;
488fe3db7c7SDoug Rabson 	size_t mapsize;
489a4f67738SDoug Rabson 	int error = 0;
490526d0bd5SKonstantin Belousov 	ssize_t resid;
491526d0bd5SKonstantin Belousov 	int flags;
492a4f67738SDoug Rabson 	elf_file_t ef;
493a4f67738SDoug Rabson 	linker_file_t lf;
494ca65d5c7SPeter Wemm 	int symtabindex;
495ca65d5c7SPeter Wemm 	int symstrindex;
496e9eabf59SPeter Wemm 	int shstrindex;
497e9eabf59SPeter Wemm 	int nsym;
49820947801SPeter Wemm 	int pb, rl, ra;
499e9eabf59SPeter Wemm 	int alignmask;
500ca65d5c7SPeter Wemm 
501ca65d5c7SPeter Wemm 	shdr = NULL;
502ca65d5c7SPeter Wemm 	lf = NULL;
503e9eabf59SPeter Wemm 	mapsize = 0;
504e9eabf59SPeter Wemm 	hdr = NULL;
505a4f67738SDoug Rabson 
506a344babfSGleb Smirnoff 	nd = malloc(sizeof(struct nameidata), M_TEMP, M_WAITOK);
507a344babfSGleb Smirnoff 	NDINIT(nd, LOOKUP, FOLLOW, UIO_SYSSPACE, filename, td);
508e6796b67SKirk McKusick 	flags = FREAD;
509a344babfSGleb Smirnoff 	error = vn_open(nd, &flags, 0, NULL);
510a344babfSGleb Smirnoff 	if (error) {
511a344babfSGleb Smirnoff 		free(nd, M_TEMP);
512a4f67738SDoug Rabson 		return error;
513a344babfSGleb Smirnoff 	}
514a344babfSGleb Smirnoff 	NDFREE(nd, NDF_ONLY_PNBUF);
515a344babfSGleb Smirnoff 	if (nd->ni_vp->v_type != VREG) {
5161f49b573SRuslan Ermilov 		error = ENOEXEC;
5171f49b573SRuslan Ermilov 		goto out;
5181f49b573SRuslan Ermilov 	}
519a3df768bSRobert Watson #ifdef MAC
520a344babfSGleb Smirnoff 	error = mac_kld_check_load(td->td_ucred, nd->ni_vp);
521a3df768bSRobert Watson 	if (error) {
522a3df768bSRobert Watson 		goto out;
523a3df768bSRobert Watson 	}
524a3df768bSRobert Watson #endif
525a4f67738SDoug Rabson 
526e9eabf59SPeter Wemm 	/* Read the elf header from the file. */
527e9eabf59SPeter Wemm 	hdr = malloc(sizeof(*hdr), M_LINKER, M_WAITOK);
528a344babfSGleb Smirnoff 	error = vn_rdwr(UIO_READ, nd->ni_vp, (void *)hdr, sizeof(*hdr), 0,
5299ca43589SRobert Watson 	    UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED,
5309ca43589SRobert Watson 	    &resid, td);
531a4f67738SDoug Rabson 	if (error)
532a4f67738SDoug Rabson 		goto out;
533e9eabf59SPeter Wemm 	if (resid != 0){
534e9eabf59SPeter Wemm 		error = ENOEXEC;
535e9eabf59SPeter Wemm 		goto out;
536e9eabf59SPeter Wemm 	}
537a4f67738SDoug Rabson 
538caab6e90SPeter Wemm 	if (!IS_ELF(*hdr)) {
539fe3db7c7SDoug Rabson 		error = ENOEXEC;
540a4f67738SDoug Rabson 		goto out;
541fe3db7c7SDoug Rabson 	}
542fe3db7c7SDoug Rabson 
543caab6e90SPeter Wemm 	if (hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS
544caab6e90SPeter Wemm 	    || hdr->e_ident[EI_DATA] != ELF_TARG_DATA) {
545552f9f63SEdwin Groothuis 		link_elf_error(filename, "Unsupported file layout");
546fe3db7c7SDoug Rabson 		error = ENOEXEC;
547fe3db7c7SDoug Rabson 		goto out;
548fe3db7c7SDoug Rabson 	}
549caab6e90SPeter Wemm 	if (hdr->e_ident[EI_VERSION] != EV_CURRENT
550caab6e90SPeter Wemm 	    || hdr->e_version != EV_CURRENT) {
551552f9f63SEdwin Groothuis 		link_elf_error(filename, "Unsupported file version");
552fe3db7c7SDoug Rabson 		error = ENOEXEC;
553fe3db7c7SDoug Rabson 		goto out;
554fe3db7c7SDoug Rabson 	}
555e9eabf59SPeter Wemm 	if (hdr->e_type != ET_REL) {
556a1d7ce03SAttilio Rao 		error = ENOSYS;
557fe3db7c7SDoug Rabson 		goto out;
558fe3db7c7SDoug Rabson 	}
559caab6e90SPeter Wemm 	if (hdr->e_machine != ELF_TARG_MACH) {
560552f9f63SEdwin Groothuis 		link_elf_error(filename, "Unsupported machine");
561fe3db7c7SDoug Rabson 		error = ENOEXEC;
562fe3db7c7SDoug Rabson 		goto out;
563fe3db7c7SDoug Rabson 	}
564a4f67738SDoug Rabson 
565326e27d8SDoug Rabson 	lf = linker_make_file(filename, &link_elf_class);
566326e27d8SDoug Rabson 	if (!lf) {
567326e27d8SDoug Rabson 		error = ENOMEM;
568326e27d8SDoug Rabson 		goto out;
569326e27d8SDoug Rabson 	}
570326e27d8SDoug Rabson 	ef = (elf_file_t) lf;
571e9eabf59SPeter Wemm 	ef->nprogtab = 0;
572e9eabf59SPeter Wemm 	ef->e_shdr = 0;
573b474c780SDavid E. O'Brien 	ef->nreltab = 0;
574b474c780SDavid E. O'Brien 	ef->nrelatab = 0;
575e9eabf59SPeter Wemm 
576e9eabf59SPeter Wemm 	/* Allocate and read in the section header */
577e9eabf59SPeter Wemm 	nbytes = hdr->e_shnum * hdr->e_shentsize;
578e9eabf59SPeter Wemm 	if (nbytes == 0 || hdr->e_shoff == 0 ||
579e9eabf59SPeter Wemm 	    hdr->e_shentsize != sizeof(Elf_Shdr)) {
580e9eabf59SPeter Wemm 		error = ENOEXEC;
581e9eabf59SPeter Wemm 		goto out;
582e9eabf59SPeter Wemm 	}
58320947801SPeter Wemm 	shdr = malloc(nbytes, M_LINKER, M_WAITOK);
584e9eabf59SPeter Wemm 	ef->e_shdr = shdr;
585a344babfSGleb Smirnoff 	error = vn_rdwr(UIO_READ, nd->ni_vp, (caddr_t)shdr, nbytes,
586a344babfSGleb Smirnoff 	    hdr->e_shoff, UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred,
587a344babfSGleb Smirnoff 	    NOCRED, &resid, td);
588e9eabf59SPeter Wemm 	if (error)
589e9eabf59SPeter Wemm 		goto out;
590e9eabf59SPeter Wemm 	if (resid) {
591e9eabf59SPeter Wemm 		error = ENOEXEC;
592e9eabf59SPeter Wemm 		goto out;
593e9eabf59SPeter Wemm 	}
594e9eabf59SPeter Wemm 
595e9eabf59SPeter Wemm 	/* Scan the section header for information and table sizing. */
596e9eabf59SPeter Wemm 	nsym = 0;
597e9eabf59SPeter Wemm 	symtabindex = -1;
598e9eabf59SPeter Wemm 	symstrindex = -1;
599e9eabf59SPeter Wemm 	for (i = 0; i < hdr->e_shnum; i++) {
600676799a0SAndriy Gapon 		if (shdr[i].sh_size == 0)
601676799a0SAndriy Gapon 			continue;
602e9eabf59SPeter Wemm 		switch (shdr[i].sh_type) {
603e9eabf59SPeter Wemm 		case SHT_PROGBITS:
604e9eabf59SPeter Wemm 		case SHT_NOBITS:
60513f28d96SKonstantin Belousov #ifdef __amd64__
606b715d9afSKonstantin Belousov 		case SHT_X86_64_UNWIND:
60713f28d96SKonstantin Belousov #endif
60820947801SPeter Wemm 			ef->nprogtab++;
609e9eabf59SPeter Wemm 			break;
610e9eabf59SPeter Wemm 		case SHT_SYMTAB:
611e9eabf59SPeter Wemm 			nsym++;
612e9eabf59SPeter Wemm 			symtabindex = i;
613e9eabf59SPeter Wemm 			symstrindex = shdr[i].sh_link;
614e9eabf59SPeter Wemm 			break;
615e9eabf59SPeter Wemm 		case SHT_REL:
616b474c780SDavid E. O'Brien 			ef->nreltab++;
617e9eabf59SPeter Wemm 			break;
618e9eabf59SPeter Wemm 		case SHT_RELA:
619b474c780SDavid E. O'Brien 			ef->nrelatab++;
620e9eabf59SPeter Wemm 			break;
621e9eabf59SPeter Wemm 		case SHT_STRTAB:
622e9eabf59SPeter Wemm 			break;
623e9eabf59SPeter Wemm 		}
624e9eabf59SPeter Wemm 	}
62520947801SPeter Wemm 	if (ef->nprogtab == 0) {
626552f9f63SEdwin Groothuis 		link_elf_error(filename, "file has no contents");
627e9eabf59SPeter Wemm 		error = ENOEXEC;
628e9eabf59SPeter Wemm 		goto out;
629e9eabf59SPeter Wemm 	}
630e9eabf59SPeter Wemm 	if (nsym != 1) {
631e9eabf59SPeter Wemm 		/* Only allow one symbol table for now */
632552f9f63SEdwin Groothuis 		link_elf_error(filename, "file has no valid symbol table");
633e9eabf59SPeter Wemm 		error = ENOEXEC;
634e9eabf59SPeter Wemm 		goto out;
635e9eabf59SPeter Wemm 	}
636e9eabf59SPeter Wemm 	if (symstrindex < 0 || symstrindex > hdr->e_shnum ||
637e9eabf59SPeter Wemm 	    shdr[symstrindex].sh_type != SHT_STRTAB) {
638552f9f63SEdwin Groothuis 		link_elf_error(filename, "file has invalid symbol strings");
639e9eabf59SPeter Wemm 		error = ENOEXEC;
640e9eabf59SPeter Wemm 		goto out;
641e9eabf59SPeter Wemm 	}
642e9eabf59SPeter Wemm 
643e9eabf59SPeter Wemm 	/* Allocate space for tracking the load chunks */
644e9eabf59SPeter Wemm 	if (ef->nprogtab != 0)
64520947801SPeter Wemm 		ef->progtab = malloc(ef->nprogtab * sizeof(*ef->progtab),
64620947801SPeter Wemm 		    M_LINKER, M_WAITOK | M_ZERO);
647b474c780SDavid E. O'Brien 	if (ef->nreltab != 0)
648b474c780SDavid E. O'Brien 		ef->reltab = malloc(ef->nreltab * sizeof(*ef->reltab),
649b474c780SDavid E. O'Brien 		    M_LINKER, M_WAITOK | M_ZERO);
650b474c780SDavid E. O'Brien 	if (ef->nrelatab != 0)
651b474c780SDavid E. O'Brien 		ef->relatab = malloc(ef->nrelatab * sizeof(*ef->relatab),
652b474c780SDavid E. O'Brien 		    M_LINKER, M_WAITOK | M_ZERO);
653e9eabf59SPeter Wemm 
6543cfce8e4SKonstantin Belousov 	if (symtabindex == -1) {
6553cfce8e4SKonstantin Belousov 		link_elf_error(filename, "lost symbol table index");
6563cfce8e4SKonstantin Belousov 		error = ENOEXEC;
6573cfce8e4SKonstantin Belousov 		goto out;
6583cfce8e4SKonstantin Belousov 	}
65920947801SPeter Wemm 	/* Allocate space for and load the symbol table */
660e9eabf59SPeter Wemm 	ef->ddbsymcnt = shdr[symtabindex].sh_size / sizeof(Elf_Sym);
661e9eabf59SPeter Wemm 	ef->ddbsymtab = malloc(shdr[symtabindex].sh_size, M_LINKER, M_WAITOK);
662a344babfSGleb Smirnoff 	error = vn_rdwr(UIO_READ, nd->ni_vp, (void *)ef->ddbsymtab,
66320947801SPeter Wemm 	    shdr[symtabindex].sh_size, shdr[symtabindex].sh_offset,
66420947801SPeter Wemm 	    UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED,
66520947801SPeter Wemm 	    &resid, td);
66620947801SPeter Wemm 	if (error)
66720947801SPeter Wemm 		goto out;
66820947801SPeter Wemm 	if (resid != 0){
66920947801SPeter Wemm 		error = EINVAL;
67020947801SPeter Wemm 		goto out;
67120947801SPeter Wemm 	}
672e9eabf59SPeter Wemm 
6733cfce8e4SKonstantin Belousov 	if (symstrindex == -1) {
6743cfce8e4SKonstantin Belousov 		link_elf_error(filename, "lost symbol string index");
6753cfce8e4SKonstantin Belousov 		error = ENOEXEC;
6763cfce8e4SKonstantin Belousov 		goto out;
6773cfce8e4SKonstantin Belousov 	}
67820947801SPeter Wemm 	/* Allocate space for and load the symbol strings */
679e9eabf59SPeter Wemm 	ef->ddbstrcnt = shdr[symstrindex].sh_size;
680e9eabf59SPeter Wemm 	ef->ddbstrtab = malloc(shdr[symstrindex].sh_size, M_LINKER, M_WAITOK);
681a344babfSGleb Smirnoff 	error = vn_rdwr(UIO_READ, nd->ni_vp, ef->ddbstrtab,
68220947801SPeter Wemm 	    shdr[symstrindex].sh_size, shdr[symstrindex].sh_offset,
68320947801SPeter Wemm 	    UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED,
68420947801SPeter Wemm 	    &resid, td);
68520947801SPeter Wemm 	if (error)
68620947801SPeter Wemm 		goto out;
68720947801SPeter Wemm 	if (resid != 0){
68820947801SPeter Wemm 		error = EINVAL;
68920947801SPeter Wemm 		goto out;
69020947801SPeter Wemm 	}
691e9eabf59SPeter Wemm 
692e9eabf59SPeter Wemm 	/* Do we have a string table for the section names?  */
693e9eabf59SPeter Wemm 	shstrindex = -1;
69420947801SPeter Wemm 	if (hdr->e_shstrndx != 0 &&
69520947801SPeter Wemm 	    shdr[hdr->e_shstrndx].sh_type == SHT_STRTAB) {
696e9eabf59SPeter Wemm 		shstrindex = hdr->e_shstrndx;
697e9eabf59SPeter Wemm 		ef->shstrcnt = shdr[shstrindex].sh_size;
69820947801SPeter Wemm 		ef->shstrtab = malloc(shdr[shstrindex].sh_size, M_LINKER,
69920947801SPeter Wemm 		    M_WAITOK);
700a344babfSGleb Smirnoff 		error = vn_rdwr(UIO_READ, nd->ni_vp, ef->shstrtab,
70120947801SPeter Wemm 		    shdr[shstrindex].sh_size, shdr[shstrindex].sh_offset,
702e9eabf59SPeter Wemm 		    UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED,
703e9eabf59SPeter Wemm 		    &resid, td);
704e9eabf59SPeter Wemm 		if (error)
705e9eabf59SPeter Wemm 			goto out;
70620947801SPeter Wemm 		if (resid != 0){
70720947801SPeter Wemm 			error = EINVAL;
70820947801SPeter Wemm 			goto out;
70920947801SPeter Wemm 		}
710e9eabf59SPeter Wemm 	}
711e9eabf59SPeter Wemm 
71220947801SPeter Wemm 	/* Size up code/data(progbits) and bss(nobits). */
713e9eabf59SPeter Wemm 	alignmask = 0;
714e9eabf59SPeter Wemm 	for (i = 0; i < hdr->e_shnum; i++) {
715676799a0SAndriy Gapon 		if (shdr[i].sh_size == 0)
716676799a0SAndriy Gapon 			continue;
717e9eabf59SPeter Wemm 		switch (shdr[i].sh_type) {
718e9eabf59SPeter Wemm 		case SHT_PROGBITS:
719e9eabf59SPeter Wemm 		case SHT_NOBITS:
72013f28d96SKonstantin Belousov #ifdef __amd64__
721b715d9afSKonstantin Belousov 		case SHT_X86_64_UNWIND:
72213f28d96SKonstantin Belousov #endif
723e9eabf59SPeter Wemm 			alignmask = shdr[i].sh_addralign - 1;
724e9eabf59SPeter Wemm 			mapsize += alignmask;
725e9eabf59SPeter Wemm 			mapsize &= ~alignmask;
726e9eabf59SPeter Wemm 			mapsize += shdr[i].sh_size;
727e9eabf59SPeter Wemm 			break;
728e9eabf59SPeter Wemm 		}
729e9eabf59SPeter Wemm 	}
730e9eabf59SPeter Wemm 
731e9eabf59SPeter Wemm 	/*
732e9eabf59SPeter Wemm 	 * We know how much space we need for the text/data/bss/etc.
733e9eabf59SPeter Wemm 	 * This stuff needs to be in a single chunk so that profiling etc
734e9eabf59SPeter Wemm 	 * can get the bounds and gdb can associate offsets with modules
735e9eabf59SPeter Wemm 	 */
73620947801SPeter Wemm 	ef->object = vm_object_allocate(OBJT_DEFAULT,
73720947801SPeter Wemm 	    round_page(mapsize) >> PAGE_SHIFT);
738fe3db7c7SDoug Rabson 	if (ef->object == NULL) {
739fe3db7c7SDoug Rabson 		error = ENOMEM;
740fe3db7c7SDoug Rabson 		goto out;
741fe3db7c7SDoug Rabson 	}
742fe3db7c7SDoug Rabson 	ef->address = (caddr_t) vm_map_min(kernel_map);
743ac68d1c9SAlan Cox 
744ac68d1c9SAlan Cox 	/*
745ac68d1c9SAlan Cox 	 * In order to satisfy amd64's architectural requirements on the
746ac68d1c9SAlan Cox 	 * location of code and data in the kernel's address space, request a
747ac68d1c9SAlan Cox 	 * mapping that is above the kernel.
748ac68d1c9SAlan Cox 	 */
7494104e835SOleksandr Tymoshenko #ifdef __amd64__
750ac68d1c9SAlan Cox 	mapbase = KERNBASE;
7514104e835SOleksandr Tymoshenko #else
7524104e835SOleksandr Tymoshenko 	mapbase = VM_MIN_KERNEL_ADDRESS;
7534104e835SOleksandr Tymoshenko #endif
75420947801SPeter Wemm 	error = vm_map_find(kernel_map, ef->object, 0, &mapbase,
755edb572a3SJohn Baldwin 	    round_page(mapsize), 0, VMFS_OPTIMAL_SPACE, VM_PROT_ALL,
756edb572a3SJohn Baldwin 	    VM_PROT_ALL, 0);
757fe3db7c7SDoug Rabson 	if (error) {
758fe3db7c7SDoug Rabson 		vm_object_deallocate(ef->object);
759326e27d8SDoug Rabson 		ef->object = 0;
760fe3db7c7SDoug Rabson 		goto out;
761fe3db7c7SDoug Rabson 	}
76220947801SPeter Wemm 
763e9eabf59SPeter Wemm 	/* Wire the pages */
7647f1ef325SAlan Cox 	error = vm_map_wire(kernel_map, mapbase,
76520947801SPeter Wemm 	    mapbase + round_page(mapsize),
766e9eabf59SPeter Wemm 	    VM_MAP_WIRE_SYSTEM|VM_MAP_WIRE_NOHOLES);
7677f1ef325SAlan Cox 	if (error != KERN_SUCCESS) {
7687f1ef325SAlan Cox 		error = ENOMEM;
7697f1ef325SAlan Cox 		goto out;
7707f1ef325SAlan Cox 	}
771a4f67738SDoug Rabson 
77220947801SPeter Wemm 	/* Inform the kld system about the situation */
77320947801SPeter Wemm 	lf->address = ef->address = (caddr_t)mapbase;
77420947801SPeter Wemm 	lf->size = mapsize;
775e9eabf59SPeter Wemm 
776e9eabf59SPeter Wemm 	/*
77720947801SPeter Wemm 	 * Now load code/data(progbits), zero bss(nobits), allocate space for
77820947801SPeter Wemm 	 * and load relocs
779e9eabf59SPeter Wemm 	 */
78020947801SPeter Wemm 	pb = 0;
78120947801SPeter Wemm 	rl = 0;
78220947801SPeter Wemm 	ra = 0;
78320947801SPeter Wemm 	alignmask = 0;
78420947801SPeter Wemm 	for (i = 0; i < hdr->e_shnum; i++) {
785676799a0SAndriy Gapon 		if (shdr[i].sh_size == 0)
786676799a0SAndriy Gapon 			continue;
78720947801SPeter Wemm 		switch (shdr[i].sh_type) {
78820947801SPeter Wemm 		case SHT_PROGBITS:
78920947801SPeter Wemm 		case SHT_NOBITS:
79013f28d96SKonstantin Belousov #ifdef __amd64__
791b715d9afSKonstantin Belousov 		case SHT_X86_64_UNWIND:
79213f28d96SKonstantin Belousov #endif
79320947801SPeter Wemm 			alignmask = shdr[i].sh_addralign - 1;
79420947801SPeter Wemm 			mapbase += alignmask;
79520947801SPeter Wemm 			mapbase &= ~alignmask;
7960067051fSMarcel Moolenaar 			if (ef->shstrtab != NULL && shdr[i].sh_name != 0) {
79750c202c5SJeff Roberson 				ef->progtab[pb].name =
79850c202c5SJeff Roberson 				    ef->shstrtab + shdr[i].sh_name;
7990067051fSMarcel Moolenaar 				if (!strcmp(ef->progtab[pb].name, ".ctors")) {
8000067051fSMarcel Moolenaar 					lf->ctors_addr = (caddr_t)mapbase;
8010067051fSMarcel Moolenaar 					lf->ctors_size = shdr[i].sh_size;
8020067051fSMarcel Moolenaar 				}
8030067051fSMarcel Moolenaar 			} else if (shdr[i].sh_type == SHT_PROGBITS)
80420947801SPeter Wemm 				ef->progtab[pb].name = "<<PROGBITS>>";
80513f28d96SKonstantin Belousov #ifdef __amd64__
806b715d9afSKonstantin Belousov 			else if (shdr[i].sh_type == SHT_X86_64_UNWIND)
80713f28d96SKonstantin Belousov 				ef->progtab[pb].name = "<<UNWIND>>";
80813f28d96SKonstantin Belousov #endif
80950c202c5SJeff Roberson 			else
81050c202c5SJeff Roberson 				ef->progtab[pb].name = "<<NOBITS>>";
81150c202c5SJeff Roberson 			if (ef->progtab[pb].name != NULL &&
8125f67450dSDimitry Andric 			    !strcmp(ef->progtab[pb].name, DPCPU_SETNAME))
81350c202c5SJeff Roberson 				ef->progtab[pb].addr =
81450c202c5SJeff Roberson 				    dpcpu_alloc(shdr[i].sh_size);
815eddfbb76SRobert Watson #ifdef VIMAGE
816eddfbb76SRobert Watson 			else if (ef->progtab[pb].name != NULL &&
81717ef1febSRobert Watson 			    !strcmp(ef->progtab[pb].name, VNET_SETNAME))
818eddfbb76SRobert Watson 				ef->progtab[pb].addr =
819eddfbb76SRobert Watson 				    vnet_data_alloc(shdr[i].sh_size);
820eddfbb76SRobert Watson #endif
82150c202c5SJeff Roberson 			else
82250c202c5SJeff Roberson 				ef->progtab[pb].addr =
82350c202c5SJeff Roberson 				    (void *)(uintptr_t)mapbase;
82450c202c5SJeff Roberson 			if (ef->progtab[pb].addr == NULL) {
82550c202c5SJeff Roberson 				error = ENOSPC;
82650c202c5SJeff Roberson 				goto out;
82750c202c5SJeff Roberson 			}
82850c202c5SJeff Roberson 			ef->progtab[pb].size = shdr[i].sh_size;
82950c202c5SJeff Roberson 			ef->progtab[pb].sec = i;
83013f28d96SKonstantin Belousov 			if (shdr[i].sh_type == SHT_PROGBITS
83113f28d96SKonstantin Belousov #ifdef __amd64__
832b715d9afSKonstantin Belousov 			    || shdr[i].sh_type == SHT_X86_64_UNWIND
83313f28d96SKonstantin Belousov #endif
83413f28d96SKonstantin Belousov 			    ) {
835a344babfSGleb Smirnoff 				error = vn_rdwr(UIO_READ, nd->ni_vp,
83620947801SPeter Wemm 				    ef->progtab[pb].addr,
83720947801SPeter Wemm 				    shdr[i].sh_size, shdr[i].sh_offset,
83820947801SPeter Wemm 				    UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred,
83920947801SPeter Wemm 				    NOCRED, &resid, td);
84020947801SPeter Wemm 				if (error)
84120947801SPeter Wemm 					goto out;
84220947801SPeter Wemm 				if (resid != 0){
84320947801SPeter Wemm 					error = EINVAL;
84420947801SPeter Wemm 					goto out;
84520947801SPeter Wemm 				}
846eddfbb76SRobert Watson 				/* Initialize the per-cpu or vnet area. */
847eddfbb76SRobert Watson 				if (ef->progtab[pb].addr != (void *)mapbase &&
8485f67450dSDimitry Andric 				    !strcmp(ef->progtab[pb].name, DPCPU_SETNAME))
84950c202c5SJeff Roberson 					dpcpu_copy(ef->progtab[pb].addr,
85050c202c5SJeff Roberson 					    shdr[i].sh_size);
851eddfbb76SRobert Watson #ifdef VIMAGE
852eddfbb76SRobert Watson 				else if (ef->progtab[pb].addr !=
853eddfbb76SRobert Watson 				    (void *)mapbase &&
85417ef1febSRobert Watson 				    !strcmp(ef->progtab[pb].name, VNET_SETNAME))
855eddfbb76SRobert Watson 					vnet_data_copy(ef->progtab[pb].addr,
856eddfbb76SRobert Watson 					    shdr[i].sh_size);
857eddfbb76SRobert Watson #endif
85850c202c5SJeff Roberson 			} else
85920947801SPeter Wemm 				bzero(ef->progtab[pb].addr, shdr[i].sh_size);
860a8774e39SPeter Wemm 
861a8774e39SPeter Wemm 			/* Update all symbol values with the offset. */
862a8774e39SPeter Wemm 			for (j = 0; j < ef->ddbsymcnt; j++) {
863a8774e39SPeter Wemm 				es = &ef->ddbsymtab[j];
864a8774e39SPeter Wemm 				if (es->st_shndx != i)
865a8774e39SPeter Wemm 					continue;
866a8774e39SPeter Wemm 				es->st_value += (Elf_Addr)ef->progtab[pb].addr;
867a8774e39SPeter Wemm 			}
86820947801SPeter Wemm 			mapbase += shdr[i].sh_size;
86920947801SPeter Wemm 			pb++;
87020947801SPeter Wemm 			break;
87120947801SPeter Wemm 		case SHT_REL:
87220947801SPeter Wemm 			ef->reltab[rl].rel = malloc(shdr[i].sh_size, M_LINKER,
87320947801SPeter Wemm 			    M_WAITOK);
87420947801SPeter Wemm 			ef->reltab[rl].nrel = shdr[i].sh_size / sizeof(Elf_Rel);
87520947801SPeter Wemm 			ef->reltab[rl].sec = shdr[i].sh_info;
876a344babfSGleb Smirnoff 			error = vn_rdwr(UIO_READ, nd->ni_vp,
87720947801SPeter Wemm 			    (void *)ef->reltab[rl].rel,
87820947801SPeter Wemm 			    shdr[i].sh_size, shdr[i].sh_offset,
879e9eabf59SPeter Wemm 			    UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED,
880e9eabf59SPeter Wemm 			    &resid, td);
881e9eabf59SPeter Wemm 			if (error)
882e9eabf59SPeter Wemm 				goto out;
88320947801SPeter Wemm 			if (resid != 0){
88420947801SPeter Wemm 				error = EINVAL;
88520947801SPeter Wemm 				goto out;
886e9eabf59SPeter Wemm 			}
88720947801SPeter Wemm 			rl++;
88820947801SPeter Wemm 			break;
88920947801SPeter Wemm 		case SHT_RELA:
89020947801SPeter Wemm 			ef->relatab[ra].rela = malloc(shdr[i].sh_size, M_LINKER,
89120947801SPeter Wemm 			    M_WAITOK);
89220947801SPeter Wemm 			ef->relatab[ra].nrela =
89320947801SPeter Wemm 			    shdr[i].sh_size / sizeof(Elf_Rela);
89420947801SPeter Wemm 			ef->relatab[ra].sec = shdr[i].sh_info;
895a344babfSGleb Smirnoff 			error = vn_rdwr(UIO_READ, nd->ni_vp,
89620947801SPeter Wemm 			    (void *)ef->relatab[ra].rela,
89720947801SPeter Wemm 			    shdr[i].sh_size, shdr[i].sh_offset,
898e9eabf59SPeter Wemm 			    UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED,
899e9eabf59SPeter Wemm 			    &resid, td);
900e9eabf59SPeter Wemm 			if (error)
901e9eabf59SPeter Wemm 				goto out;
90220947801SPeter Wemm 			if (resid != 0){
90320947801SPeter Wemm 				error = EINVAL;
90420947801SPeter Wemm 				goto out;
905e9eabf59SPeter Wemm 			}
90620947801SPeter Wemm 			ra++;
90720947801SPeter Wemm 			break;
90820947801SPeter Wemm 		}
90920947801SPeter Wemm 	}
9103cfce8e4SKonstantin Belousov 	if (pb != ef->nprogtab) {
9113cfce8e4SKonstantin Belousov 		link_elf_error(filename, "lost progbits");
9123cfce8e4SKonstantin Belousov 		error = ENOEXEC;
9133cfce8e4SKonstantin Belousov 		goto out;
9143cfce8e4SKonstantin Belousov 	}
9153cfce8e4SKonstantin Belousov 	if (rl != ef->nreltab) {
9163cfce8e4SKonstantin Belousov 		link_elf_error(filename, "lost reltab");
9173cfce8e4SKonstantin Belousov 		error = ENOEXEC;
9183cfce8e4SKonstantin Belousov 		goto out;
9193cfce8e4SKonstantin Belousov 	}
9203cfce8e4SKonstantin Belousov 	if (ra != ef->nrelatab) {
9213cfce8e4SKonstantin Belousov 		link_elf_error(filename, "lost relatab");
9223cfce8e4SKonstantin Belousov 		error = ENOEXEC;
9233cfce8e4SKonstantin Belousov 		goto out;
9243cfce8e4SKonstantin Belousov 	}
9253cfce8e4SKonstantin Belousov 	if (mapbase != (vm_offset_t)ef->address + mapsize) {
9263cfce8e4SKonstantin Belousov 		printf(
9273cfce8e4SKonstantin Belousov 		    "%s: mapbase 0x%lx != address %p + mapsize 0x%lx (0x%lx)\n",
9283cfce8e4SKonstantin Belousov 		    filename != NULL ? filename : "<none>",
9296f3c6327SNeel Natu 		    (u_long)mapbase, ef->address, (u_long)mapsize,
9306f3c6327SNeel Natu 		    (u_long)(vm_offset_t)ef->address + mapsize);
9313cfce8e4SKonstantin Belousov 		error = ENOMEM;
9323cfce8e4SKonstantin Belousov 		goto out;
9333cfce8e4SKonstantin Belousov 	}
934e9eabf59SPeter Wemm 
935e9eabf59SPeter Wemm 	/* Local intra-module relocations */
9363cfce8e4SKonstantin Belousov 	error = link_elf_reloc_local(lf);
9373cfce8e4SKonstantin Belousov 	if (error != 0)
9383cfce8e4SKonstantin Belousov 		goto out;
9397251b4bfSJake Burkholder 
940e9eabf59SPeter Wemm 	/* Pull in dependencies */
941a344babfSGleb Smirnoff 	VOP_UNLOCK(nd->ni_vp, 0);
9427b9716baSIan Dowse 	error = linker_load_dependencies(lf);
943a344babfSGleb Smirnoff 	vn_lock(nd->ni_vp, LK_EXCLUSIVE | LK_RETRY);
944ca65d5c7SPeter Wemm 	if (error)
945de78ca7eSPeter Wemm 		goto out;
946e9eabf59SPeter Wemm 
947e9eabf59SPeter Wemm 	/* External relocations */
948326e27d8SDoug Rabson 	error = relocate_file(ef);
949ca65d5c7SPeter Wemm 	if (error)
950ca65d5c7SPeter Wemm 		goto out;
951ca65d5c7SPeter Wemm 
952e9eabf59SPeter Wemm 	/* Notify MD code that a module is being loaded. */
953e9eabf59SPeter Wemm 	error = elf_cpu_load_file(lf);
954ca65d5c7SPeter Wemm 	if (error)
955ca65d5c7SPeter Wemm 		goto out;
956a4f67738SDoug Rabson 
9570067051fSMarcel Moolenaar 	/* Invoke .ctors */
9580067051fSMarcel Moolenaar 	link_elf_invoke_ctors(lf->ctors_addr, lf->ctors_size);
9590067051fSMarcel Moolenaar 
960a4f67738SDoug Rabson 	*result = lf;
961a4f67738SDoug Rabson 
962a4f67738SDoug Rabson out:
963a344babfSGleb Smirnoff 	VOP_UNLOCK(nd->ni_vp, 0);
964a344babfSGleb Smirnoff 	vn_close(nd->ni_vp, FREAD, td->td_ucred, td);
965a344babfSGleb Smirnoff 	free(nd, M_TEMP);
966ca65d5c7SPeter Wemm 	if (error && lf)
96765a311fcSPoul-Henning Kamp 		linker_file_unload(lf, LINKER_UNLOAD_FORCE);
968e9eabf59SPeter Wemm 	free(hdr, M_LINKER);
969a4f67738SDoug Rabson 
970a4f67738SDoug Rabson 	return error;
971a4f67738SDoug Rabson }
972a4f67738SDoug Rabson 
973a4f67738SDoug Rabson static void
974de78ca7eSPeter Wemm link_elf_unload_file(linker_file_t file)
975a4f67738SDoug Rabson {
976326e27d8SDoug Rabson 	elf_file_t ef = (elf_file_t) file;
97720947801SPeter Wemm 	int i;
978a4f67738SDoug Rabson 
9791aeb23cdSMarcel Moolenaar 	/* Notify MD code that a module is being unloaded. */
9801aeb23cdSMarcel Moolenaar 	elf_cpu_unload_file(file);
9811aeb23cdSMarcel Moolenaar 
98250c202c5SJeff Roberson 	if (ef->progtab) {
98350c202c5SJeff Roberson 		for (i = 0; i < ef->nprogtab; i++) {
98450c202c5SJeff Roberson 			if (ef->progtab[i].size == 0)
98550c202c5SJeff Roberson 				continue;
98650c202c5SJeff Roberson 			if (ef->progtab[i].name == NULL)
98750c202c5SJeff Roberson 				continue;
9885f67450dSDimitry Andric 			if (!strcmp(ef->progtab[i].name, DPCPU_SETNAME))
98950c202c5SJeff Roberson 				dpcpu_free(ef->progtab[i].addr,
99050c202c5SJeff Roberson 				    ef->progtab[i].size);
991eddfbb76SRobert Watson #ifdef VIMAGE
99217ef1febSRobert Watson 			else if (!strcmp(ef->progtab[i].name, VNET_SETNAME))
993eddfbb76SRobert Watson 				vnet_data_free(ef->progtab[i].addr,
994eddfbb76SRobert Watson 				    ef->progtab[i].size);
995eddfbb76SRobert Watson #endif
99650c202c5SJeff Roberson 		}
99750c202c5SJeff Roberson 	}
99870b7ffeeSIan Dowse 	if (ef->preloaded) {
99970b7ffeeSIan Dowse 		free(ef->reltab, M_LINKER);
100070b7ffeeSIan Dowse 		free(ef->relatab, M_LINKER);
100170b7ffeeSIan Dowse 		free(ef->progtab, M_LINKER);
1002a2024a3eSJohn Birrell 		free(ef->ctftab, M_LINKER);
1003a2024a3eSJohn Birrell 		free(ef->ctfoff, M_LINKER);
1004a2024a3eSJohn Birrell 		free(ef->typoff, M_LINKER);
100570b7ffeeSIan Dowse 		if (file->filename != NULL)
100670b7ffeeSIan Dowse 			preload_delete_name(file->filename);
100770b7ffeeSIan Dowse 		/* XXX reclaim module memory? */
100870b7ffeeSIan Dowse 		return;
100970b7ffeeSIan Dowse 	}
101070b7ffeeSIan Dowse 
1011b474c780SDavid E. O'Brien 	for (i = 0; i < ef->nreltab; i++)
101220947801SPeter Wemm 		free(ef->reltab[i].rel, M_LINKER);
1013b474c780SDavid E. O'Brien 	for (i = 0; i < ef->nrelatab; i++)
101420947801SPeter Wemm 		free(ef->relatab[i].rela, M_LINKER);
101520947801SPeter Wemm 	free(ef->reltab, M_LINKER);
101620947801SPeter Wemm 	free(ef->relatab, M_LINKER);
101720947801SPeter Wemm 	free(ef->progtab, M_LINKER);
101820947801SPeter Wemm 
1019fe3db7c7SDoug Rabson 	if (ef->object) {
1020fe3db7c7SDoug Rabson 		vm_map_remove(kernel_map, (vm_offset_t) ef->address,
102120947801SPeter Wemm 		    (vm_offset_t) ef->address +
102220947801SPeter Wemm 		    (ef->object->size << PAGE_SHIFT));
1023fe3db7c7SDoug Rabson 	}
1024e9eabf59SPeter Wemm 	free(ef->e_shdr, M_LINKER);
1025e9eabf59SPeter Wemm 	free(ef->ddbsymtab, M_LINKER);
1026e9eabf59SPeter Wemm 	free(ef->ddbstrtab, M_LINKER);
102720947801SPeter Wemm 	free(ef->shstrtab, M_LINKER);
1028a2024a3eSJohn Birrell 	free(ef->ctftab, M_LINKER);
1029a2024a3eSJohn Birrell 	free(ef->ctfoff, M_LINKER);
1030a2024a3eSJohn Birrell 	free(ef->typoff, M_LINKER);
1031de78ca7eSPeter Wemm }
1032de78ca7eSPeter Wemm 
1033fe3db7c7SDoug Rabson static const char *
1034757686b1SMarcel Moolenaar symbol_name(elf_file_t ef, Elf_Size r_info)
1035a4f67738SDoug Rabson {
1036fe3db7c7SDoug Rabson 	const Elf_Sym *ref;
1037a4f67738SDoug Rabson 
1038aa855a59SPeter Wemm 	if (ELF_R_SYM(r_info)) {
1039e9eabf59SPeter Wemm 		ref = ef->ddbsymtab + ELF_R_SYM(r_info);
1040e9eabf59SPeter Wemm 		return ef->ddbstrtab + ref->st_name;
1041fe3db7c7SDoug Rabson 	} else
1042fe3db7c7SDoug Rabson 		return NULL;
1043a4f67738SDoug Rabson }
1044a4f67738SDoug Rabson 
1045e9eabf59SPeter Wemm static Elf_Addr
1046e9eabf59SPeter Wemm findbase(elf_file_t ef, int sec)
1047e9eabf59SPeter Wemm {
1048e9eabf59SPeter Wemm 	int i;
1049e9eabf59SPeter Wemm 	Elf_Addr base = 0;
1050e9eabf59SPeter Wemm 
1051e9eabf59SPeter Wemm 	for (i = 0; i < ef->nprogtab; i++) {
1052a8774e39SPeter Wemm 		if (sec == ef->progtab[i].sec) {
1053e9eabf59SPeter Wemm 			base = (Elf_Addr)ef->progtab[i].addr;
1054a8774e39SPeter Wemm 			break;
1055e9eabf59SPeter Wemm 		}
1056a8774e39SPeter Wemm 	}
1057e9eabf59SPeter Wemm 	return base;
1058e9eabf59SPeter Wemm }
1059e9eabf59SPeter Wemm 
1060a4f67738SDoug Rabson static int
1061326e27d8SDoug Rabson relocate_file(elf_file_t ef)
1062a4f67738SDoug Rabson {
1063fe3db7c7SDoug Rabson 	const Elf_Rel *rellim;
1064fe3db7c7SDoug Rabson 	const Elf_Rel *rel;
1065fe3db7c7SDoug Rabson 	const Elf_Rela *relalim;
1066fe3db7c7SDoug Rabson 	const Elf_Rela *rela;
1067aa855a59SPeter Wemm 	const char *symname;
1068e9eabf59SPeter Wemm 	const Elf_Sym *sym;
1069e9eabf59SPeter Wemm 	int i;
1070757686b1SMarcel Moolenaar 	Elf_Size symidx;
1071e9eabf59SPeter Wemm 	Elf_Addr base;
1072e9eabf59SPeter Wemm 
1073a4f67738SDoug Rabson 
1074fe3db7c7SDoug Rabson 	/* Perform relocations without addend if there are any: */
1075b474c780SDavid E. O'Brien 	for (i = 0; i < ef->nreltab; i++) {
1076e9eabf59SPeter Wemm 		rel = ef->reltab[i].rel;
10773cfce8e4SKonstantin Belousov 		if (rel == NULL) {
10783cfce8e4SKonstantin Belousov 			link_elf_error(ef->lf.filename, "lost a reltab!");
10793cfce8e4SKonstantin Belousov 			return (ENOEXEC);
10803cfce8e4SKonstantin Belousov 		}
108120947801SPeter Wemm 		rellim = rel + ef->reltab[i].nrel;
1082e9eabf59SPeter Wemm 		base = findbase(ef, ef->reltab[i].sec);
10833cfce8e4SKonstantin Belousov 		if (base == 0) {
10843cfce8e4SKonstantin Belousov 			link_elf_error(ef->lf.filename, "lost base for reltab");
10853cfce8e4SKonstantin Belousov 			return (ENOEXEC);
10863cfce8e4SKonstantin Belousov 		}
108720947801SPeter Wemm 		for ( ; rel < rellim; rel++) {
1088e9eabf59SPeter Wemm 			symidx = ELF_R_SYM(rel->r_info);
108920947801SPeter Wemm 			if (symidx >= ef->ddbsymcnt)
109020947801SPeter Wemm 				continue;
1091e9eabf59SPeter Wemm 			sym = ef->ddbsymtab + symidx;
109220947801SPeter Wemm 			/* Local relocs are already done */
109320947801SPeter Wemm 			if (ELF_ST_BIND(sym->st_info) == STB_LOCAL)
109420947801SPeter Wemm 				continue;
109520947801SPeter Wemm 			if (elf_reloc(&ef->lf, base, rel, ELF_RELOC_REL,
109620947801SPeter Wemm 			    elf_obj_lookup)) {
1097aa855a59SPeter Wemm 				symname = symbol_name(ef, rel->r_info);
109820947801SPeter Wemm 				printf("link_elf_obj: symbol %s undefined\n",
109920947801SPeter Wemm 				    symname);
11003cfce8e4SKonstantin Belousov 				return (ENOENT);
1101a13ddfb6SPeter Wemm 			}
1102aa855a59SPeter Wemm 		}
1103a4f67738SDoug Rabson 	}
1104a4f67738SDoug Rabson 
1105fe3db7c7SDoug Rabson 	/* Perform relocations with addend if there are any: */
1106b474c780SDavid E. O'Brien 	for (i = 0; i < ef->nrelatab; i++) {
1107e9eabf59SPeter Wemm 		rela = ef->relatab[i].rela;
11083cfce8e4SKonstantin Belousov 		if (rela == NULL) {
11093cfce8e4SKonstantin Belousov 			link_elf_error(ef->lf.filename, "lost a relatab!");
11103cfce8e4SKonstantin Belousov 			return (ENOEXEC);
11113cfce8e4SKonstantin Belousov 		}
111220947801SPeter Wemm 		relalim = rela + ef->relatab[i].nrela;
1113e9eabf59SPeter Wemm 		base = findbase(ef, ef->relatab[i].sec);
11143cfce8e4SKonstantin Belousov 		if (base == 0) {
11153cfce8e4SKonstantin Belousov 			link_elf_error(ef->lf.filename,
11163cfce8e4SKonstantin Belousov 			    "lost base for relatab");
11173cfce8e4SKonstantin Belousov 			return (ENOEXEC);
11183cfce8e4SKonstantin Belousov 		}
111920947801SPeter Wemm 		for ( ; rela < relalim; rela++) {
1120e9eabf59SPeter Wemm 			symidx = ELF_R_SYM(rela->r_info);
112120947801SPeter Wemm 			if (symidx >= ef->ddbsymcnt)
112220947801SPeter Wemm 				continue;
1123e9eabf59SPeter Wemm 			sym = ef->ddbsymtab + symidx;
112420947801SPeter Wemm 			/* Local relocs are already done */
112520947801SPeter Wemm 			if (ELF_ST_BIND(sym->st_info) == STB_LOCAL)
112620947801SPeter Wemm 				continue;
112720947801SPeter Wemm 			if (elf_reloc(&ef->lf, base, rela, ELF_RELOC_RELA,
112820947801SPeter Wemm 			    elf_obj_lookup)) {
1129aa855a59SPeter Wemm 				symname = symbol_name(ef, rela->r_info);
113020947801SPeter Wemm 				printf("link_elf_obj: symbol %s undefined\n",
113120947801SPeter Wemm 				    symname);
11323cfce8e4SKonstantin Belousov 				return (ENOENT);
1133a13ddfb6SPeter Wemm 			}
1134e9eabf59SPeter Wemm 		}
1135e9eabf59SPeter Wemm 	}
1136a4f67738SDoug Rabson 
11372832cd54SKonstantin Belousov 	/*
1138e3043798SPedro F. Giffuni 	 * Only clean SHN_FBSD_CACHED for successful return.  If we
11392832cd54SKonstantin Belousov 	 * modified symbol table for the object but found an
11402832cd54SKonstantin Belousov 	 * unresolved symbol, there is no reason to roll back.
11412832cd54SKonstantin Belousov 	 */
11422832cd54SKonstantin Belousov 	elf_obj_cleanup_globals_cache(ef);
11432832cd54SKonstantin Belousov 
11443cfce8e4SKonstantin Belousov 	return (0);
1145a4f67738SDoug Rabson }
1146a4f67738SDoug Rabson 
114737c84183SPoul-Henning Kamp static int
1148d254af07SMatthew Dillon link_elf_lookup_symbol(linker_file_t lf, const char *name, c_linker_sym_t *sym)
1149a4f67738SDoug Rabson {
1150326e27d8SDoug Rabson 	elf_file_t ef = (elf_file_t) lf;
11512d636ab0SPeter Wemm 	const Elf_Sym *symp;
11522d636ab0SPeter Wemm 	const char *strp;
1153a4f67738SDoug Rabson 	int i;
1154a4f67738SDoug Rabson 
11552d636ab0SPeter Wemm 	for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) {
11562d636ab0SPeter Wemm 		strp = ef->ddbstrtab + symp->st_name;
1157a8774e39SPeter Wemm 		if (symp->st_shndx != SHN_UNDEF && strcmp(name, strp) == 0) {
1158d254af07SMatthew Dillon 			*sym = (c_linker_sym_t) symp;
11592d636ab0SPeter Wemm 			return 0;
11602d636ab0SPeter Wemm 		}
11612d636ab0SPeter Wemm 	}
1162a4f67738SDoug Rabson 	return ENOENT;
1163a4f67738SDoug Rabson }
1164a4f67738SDoug Rabson 
1165de78ca7eSPeter Wemm static int
116620947801SPeter Wemm link_elf_symbol_values(linker_file_t lf, c_linker_sym_t sym,
116720947801SPeter Wemm     linker_symval_t *symval)
1168a4f67738SDoug Rabson {
1169326e27d8SDoug Rabson 	elf_file_t ef = (elf_file_t) lf;
11708aef1712SMatthew Dillon 	const Elf_Sym *es = (const Elf_Sym*) sym;
1171a4f67738SDoug Rabson 
11725cf87418SMarcel Moolenaar 	if (es >= ef->ddbsymtab && es < (ef->ddbsymtab + ef->ddbsymcnt)) {
11732d636ab0SPeter Wemm 		symval->name = ef->ddbstrtab + es->st_name;
1174a8774e39SPeter Wemm 		symval->value = (caddr_t)es->st_value;
11752d636ab0SPeter Wemm 		symval->size = es->st_size;
11762d636ab0SPeter Wemm 		return 0;
11772d636ab0SPeter Wemm 	}
11782d636ab0SPeter Wemm 	return ENOENT;
11792d636ab0SPeter Wemm }
1180a4f67738SDoug Rabson 
1181a4f67738SDoug Rabson static int
1182a4f67738SDoug Rabson link_elf_search_symbol(linker_file_t lf, caddr_t value,
1183d254af07SMatthew Dillon     c_linker_sym_t *sym, long *diffp)
1184a4f67738SDoug Rabson {
1185326e27d8SDoug Rabson 	elf_file_t ef = (elf_file_t) lf;
1186586453feSBruce Evans 	u_long off = (uintptr_t) (void *) value;
1187a4f67738SDoug Rabson 	u_long diff = off;
1188586453feSBruce Evans 	u_long st_value;
1189fe3db7c7SDoug Rabson 	const Elf_Sym *es;
1190b85f65afSPedro F. Giffuni 	const Elf_Sym *best = NULL;
1191a4f67738SDoug Rabson 	int i;
1192a4f67738SDoug Rabson 
11932d636ab0SPeter Wemm 	for (i = 0, es = ef->ddbsymtab; i < ef->ddbsymcnt; i++, es++) {
1194a4f67738SDoug Rabson 		if (es->st_name == 0)
1195a4f67738SDoug Rabson 			continue;
1196a8774e39SPeter Wemm 		st_value = es->st_value;
1197b5abfb70SPeter Wemm 		if (off >= st_value) {
1198b5abfb70SPeter Wemm 			if (off - st_value < diff) {
1199b5abfb70SPeter Wemm 				diff = off - st_value;
1200a4f67738SDoug Rabson 				best = es;
1201a4f67738SDoug Rabson 				if (diff == 0)
1202a4f67738SDoug Rabson 					break;
1203b5abfb70SPeter Wemm 			} else if (off - st_value == diff) {
1204a4f67738SDoug Rabson 				best = es;
1205a4f67738SDoug Rabson 			}
1206a4f67738SDoug Rabson 		}
1207a4f67738SDoug Rabson 	}
1208b85f65afSPedro F. Giffuni 	if (best == NULL)
1209a4f67738SDoug Rabson 		*diffp = off;
1210a4f67738SDoug Rabson 	else
1211a4f67738SDoug Rabson 		*diffp = diff;
1212d254af07SMatthew Dillon 	*sym = (c_linker_sym_t) best;
1213a4f67738SDoug Rabson 
1214a4f67738SDoug Rabson 	return 0;
1215a4f67738SDoug Rabson }
1216f41325dbSPeter Wemm 
1217f41325dbSPeter Wemm /*
1218f41325dbSPeter Wemm  * Look up a linker set on an ELF system.
1219f41325dbSPeter Wemm  */
1220f41325dbSPeter Wemm static int
1221f41325dbSPeter Wemm link_elf_lookup_set(linker_file_t lf, const char *name,
1222f41325dbSPeter Wemm     void ***startp, void ***stopp, int *countp)
1223f41325dbSPeter Wemm {
1224e9eabf59SPeter Wemm 	elf_file_t ef = (elf_file_t)lf;
1225f41325dbSPeter Wemm 	void **start, **stop;
1226e9eabf59SPeter Wemm 	int i, count;
1227f41325dbSPeter Wemm 
1228e9eabf59SPeter Wemm 	/* Relative to section number */
1229e9eabf59SPeter Wemm 	for (i = 0; i < ef->nprogtab; i++) {
1230e9eabf59SPeter Wemm 		if ((strncmp(ef->progtab[i].name, "set_", 4) == 0) &&
1231e9eabf59SPeter Wemm 		    strcmp(ef->progtab[i].name + 4, name) == 0) {
1232e9eabf59SPeter Wemm 			start  = (void **)ef->progtab[i].addr;
123320947801SPeter Wemm 			stop = (void **)((char *)ef->progtab[i].addr +
123420947801SPeter Wemm 			    ef->progtab[i].size);
1235f41325dbSPeter Wemm 			count = stop - start;
1236f41325dbSPeter Wemm 			if (startp)
1237f41325dbSPeter Wemm 				*startp = start;
1238f41325dbSPeter Wemm 			if (stopp)
1239f41325dbSPeter Wemm 				*stopp = stop;
1240f41325dbSPeter Wemm 			if (countp)
1241f41325dbSPeter Wemm 				*countp = count;
1242e9eabf59SPeter Wemm 			return (0);
1243e9eabf59SPeter Wemm 		}
1244e9eabf59SPeter Wemm 	}
1245e9eabf59SPeter Wemm 	return (ESRCH);
1246f41325dbSPeter Wemm }
1247bb9fe9ddSBrian Feldman 
1248bb9fe9ddSBrian Feldman static int
1249bb9fe9ddSBrian Feldman link_elf_each_function_name(linker_file_t file,
1250e9eabf59SPeter Wemm     int (*callback)(const char *, void *), void *opaque)
1251e9eabf59SPeter Wemm {
1252bb9fe9ddSBrian Feldman 	elf_file_t ef = (elf_file_t)file;
1253bb9fe9ddSBrian Feldman 	const Elf_Sym *symp;
1254bb9fe9ddSBrian Feldman 	int i, error;
1255bb9fe9ddSBrian Feldman 
1256bb9fe9ddSBrian Feldman 	/* Exhaustive search */
1257bb9fe9ddSBrian Feldman 	for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) {
1258bb9fe9ddSBrian Feldman 		if (symp->st_value != 0 &&
1259bb9fe9ddSBrian Feldman 		    ELF_ST_TYPE(symp->st_info) == STT_FUNC) {
1260bb9fe9ddSBrian Feldman 			error = callback(ef->ddbstrtab + symp->st_name, opaque);
1261bb9fe9ddSBrian Feldman 			if (error)
1262bb9fe9ddSBrian Feldman 				return (error);
1263bb9fe9ddSBrian Feldman 		}
1264bb9fe9ddSBrian Feldman 	}
1265bb9fe9ddSBrian Feldman 	return (0);
1266bb9fe9ddSBrian Feldman }
126784201059SMarcel Moolenaar 
1268a2024a3eSJohn Birrell static int
1269a2024a3eSJohn Birrell link_elf_each_function_nameval(linker_file_t file,
1270a2024a3eSJohn Birrell     linker_function_nameval_callback_t callback, void *opaque)
1271a2024a3eSJohn Birrell {
1272a2024a3eSJohn Birrell 	linker_symval_t symval;
1273a2024a3eSJohn Birrell 	elf_file_t ef = (elf_file_t)file;
1274a2024a3eSJohn Birrell 	const Elf_Sym* symp;
1275a2024a3eSJohn Birrell 	int i, error;
1276a2024a3eSJohn Birrell 
1277a2024a3eSJohn Birrell 	/* Exhaustive search */
1278a2024a3eSJohn Birrell 	for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) {
1279a2024a3eSJohn Birrell 		if (symp->st_value != 0 &&
1280a2024a3eSJohn Birrell 		    ELF_ST_TYPE(symp->st_info) == STT_FUNC) {
1281a2024a3eSJohn Birrell 			error = link_elf_symbol_values(file, (c_linker_sym_t) symp, &symval);
1282a2024a3eSJohn Birrell 			if (error)
1283a2024a3eSJohn Birrell 				return (error);
1284a2024a3eSJohn Birrell 			error = callback(file, i, &symval, opaque);
1285a2024a3eSJohn Birrell 			if (error)
1286a2024a3eSJohn Birrell 				return (error);
1287a2024a3eSJohn Birrell 		}
1288a2024a3eSJohn Birrell 	}
1289a2024a3eSJohn Birrell 	return (0);
1290a2024a3eSJohn Birrell }
1291a2024a3eSJohn Birrell 
12922832cd54SKonstantin Belousov static void
12932832cd54SKonstantin Belousov elf_obj_cleanup_globals_cache(elf_file_t ef)
12942832cd54SKonstantin Belousov {
12952832cd54SKonstantin Belousov 	Elf_Sym *sym;
12962832cd54SKonstantin Belousov 	Elf_Size i;
12972832cd54SKonstantin Belousov 
12982832cd54SKonstantin Belousov 	for (i = 0; i < ef->ddbsymcnt; i++) {
12992832cd54SKonstantin Belousov 		sym = ef->ddbsymtab + i;
13002832cd54SKonstantin Belousov 		if (sym->st_shndx == SHN_FBSD_CACHED) {
13012832cd54SKonstantin Belousov 			sym->st_shndx = SHN_UNDEF;
13022832cd54SKonstantin Belousov 			sym->st_value = 0;
13032832cd54SKonstantin Belousov 		}
13042832cd54SKonstantin Belousov 	}
13052832cd54SKonstantin Belousov }
13062832cd54SKonstantin Belousov 
1307d297ad16SMarcel Moolenaar /*
1308d297ad16SMarcel Moolenaar  * Symbol lookup function that can be used when the symbol index is known (ie
1309d297ad16SMarcel Moolenaar  * in relocations). It uses the symbol index instead of doing a fully fledged
1310d297ad16SMarcel Moolenaar  * hash table based lookup when such is valid. For example for local symbols.
1311d297ad16SMarcel Moolenaar  * This is not only more efficient, it's also more correct. It's not always
1312d297ad16SMarcel Moolenaar  * the case that the symbol can be found through the hash table.
1313d297ad16SMarcel Moolenaar  */
1314cff8c6f2SKonstantin Belousov static int
1315cff8c6f2SKonstantin Belousov elf_obj_lookup(linker_file_t lf, Elf_Size symidx, int deps, Elf_Addr *res)
1316d297ad16SMarcel Moolenaar {
1317d297ad16SMarcel Moolenaar 	elf_file_t ef = (elf_file_t)lf;
13182832cd54SKonstantin Belousov 	Elf_Sym *sym;
1319d297ad16SMarcel Moolenaar 	const char *symbol;
1320cff8c6f2SKonstantin Belousov 	Elf_Addr res1;
1321d297ad16SMarcel Moolenaar 
1322d297ad16SMarcel Moolenaar 	/* Don't even try to lookup the symbol if the index is bogus. */
1323cff8c6f2SKonstantin Belousov 	if (symidx >= ef->ddbsymcnt) {
1324cff8c6f2SKonstantin Belousov 		*res = 0;
1325cff8c6f2SKonstantin Belousov 		return (EINVAL);
1326cff8c6f2SKonstantin Belousov 	}
1327d297ad16SMarcel Moolenaar 
1328e9eabf59SPeter Wemm 	sym = ef->ddbsymtab + symidx;
1329d297ad16SMarcel Moolenaar 
13304cec6f5dSPeter Wemm 	/* Quick answer if there is a definition included. */
1331cff8c6f2SKonstantin Belousov 	if (sym->st_shndx != SHN_UNDEF) {
1332cff8c6f2SKonstantin Belousov 		*res = sym->st_value;
1333cff8c6f2SKonstantin Belousov 		return (0);
1334cff8c6f2SKonstantin Belousov 	}
13354cec6f5dSPeter Wemm 
13364cec6f5dSPeter Wemm 	/* If we get here, then it is undefined and needs a lookup. */
13374cec6f5dSPeter Wemm 	switch (ELF_ST_BIND(sym->st_info)) {
13384cec6f5dSPeter Wemm 	case STB_LOCAL:
13394cec6f5dSPeter Wemm 		/* Local, but undefined? huh? */
1340cff8c6f2SKonstantin Belousov 		*res = 0;
1341cff8c6f2SKonstantin Belousov 		return (EINVAL);
1342d297ad16SMarcel Moolenaar 
1343e9eabf59SPeter Wemm 	case STB_GLOBAL:
1344cff8c6f2SKonstantin Belousov 	case STB_WEAK:
1345e9eabf59SPeter Wemm 		/* Relative to Data or Function name */
1346e9eabf59SPeter Wemm 		symbol = ef->ddbstrtab + sym->st_name;
1347d297ad16SMarcel Moolenaar 
1348d297ad16SMarcel Moolenaar 		/* Force a lookup failure if the symbol name is bogus. */
1349cff8c6f2SKonstantin Belousov 		if (*symbol == 0) {
1350cff8c6f2SKonstantin Belousov 			*res = 0;
1351cff8c6f2SKonstantin Belousov 			return (EINVAL);
1352cff8c6f2SKonstantin Belousov 		}
1353cff8c6f2SKonstantin Belousov 		res1 = (Elf_Addr)linker_file_lookup_symbol(lf, symbol, deps);
13542832cd54SKonstantin Belousov 
13552832cd54SKonstantin Belousov 		/*
13562832cd54SKonstantin Belousov 		 * Cache global lookups during module relocation. The failure
13572832cd54SKonstantin Belousov 		 * case is particularly expensive for callers, who must scan
13582832cd54SKonstantin Belousov 		 * through the entire globals table doing strcmp(). Cache to
13592832cd54SKonstantin Belousov 		 * avoid doing such work repeatedly.
13602832cd54SKonstantin Belousov 		 *
13612832cd54SKonstantin Belousov 		 * After relocation is complete, undefined globals will be
13622832cd54SKonstantin Belousov 		 * restored to SHN_UNDEF in elf_obj_cleanup_globals_cache(),
13632832cd54SKonstantin Belousov 		 * above.
13642832cd54SKonstantin Belousov 		 */
1365cff8c6f2SKonstantin Belousov 		if (res1 != 0) {
13662832cd54SKonstantin Belousov 			sym->st_shndx = SHN_FBSD_CACHED;
1367cff8c6f2SKonstantin Belousov 			sym->st_value = res1;
1368cff8c6f2SKonstantin Belousov 			*res = res1;
1369e9eabf59SPeter Wemm 			return (0);
1370cff8c6f2SKonstantin Belousov 		} else if (ELF_ST_BIND(sym->st_info) == STB_WEAK) {
1371cff8c6f2SKonstantin Belousov 			sym->st_value = 0;
1372cff8c6f2SKonstantin Belousov 			*res = 0;
1373cff8c6f2SKonstantin Belousov 			return (0);
1374cff8c6f2SKonstantin Belousov 		}
1375cff8c6f2SKonstantin Belousov 		return (EINVAL);
1376e9eabf59SPeter Wemm 
1377e9eabf59SPeter Wemm 	default:
1378cff8c6f2SKonstantin Belousov 		return (EINVAL);
1379d297ad16SMarcel Moolenaar 	}
1380e9eabf59SPeter Wemm }
1381e9eabf59SPeter Wemm 
13827251b4bfSJake Burkholder static void
13837226306eSKonstantin Belousov link_elf_fix_link_set(elf_file_t ef)
13847226306eSKonstantin Belousov {
13857226306eSKonstantin Belousov 	static const char startn[] = "__start_";
13867226306eSKonstantin Belousov 	static const char stopn[] = "__stop_";
13877226306eSKonstantin Belousov 	Elf_Sym *sym;
13887226306eSKonstantin Belousov 	const char *sym_name, *linkset_name;
13897226306eSKonstantin Belousov 	Elf_Addr startp, stopp;
13907226306eSKonstantin Belousov 	Elf_Size symidx;
13917226306eSKonstantin Belousov 	int start, i;
13927226306eSKonstantin Belousov 
13937226306eSKonstantin Belousov 	startp = stopp = 0;
13947226306eSKonstantin Belousov 	for (symidx = 1 /* zero entry is special */;
13957226306eSKonstantin Belousov 		symidx < ef->ddbsymcnt; symidx++) {
13967226306eSKonstantin Belousov 		sym = ef->ddbsymtab + symidx;
13977226306eSKonstantin Belousov 		if (sym->st_shndx != SHN_UNDEF)
13987226306eSKonstantin Belousov 			continue;
13997226306eSKonstantin Belousov 
14007226306eSKonstantin Belousov 		sym_name = ef->ddbstrtab + sym->st_name;
14017226306eSKonstantin Belousov 		if (strncmp(sym_name, startn, sizeof(startn) - 1) == 0) {
14027226306eSKonstantin Belousov 			start = 1;
14037226306eSKonstantin Belousov 			linkset_name = sym_name + sizeof(startn) - 1;
14047226306eSKonstantin Belousov 		}
14057226306eSKonstantin Belousov 		else if (strncmp(sym_name, stopn, sizeof(stopn) - 1) == 0) {
14067226306eSKonstantin Belousov 			start = 0;
14077226306eSKonstantin Belousov 			linkset_name = sym_name + sizeof(stopn) - 1;
14087226306eSKonstantin Belousov 		}
14097226306eSKonstantin Belousov 		else
14107226306eSKonstantin Belousov 			continue;
14117226306eSKonstantin Belousov 
14127226306eSKonstantin Belousov 		for (i = 0; i < ef->nprogtab; i++) {
14137226306eSKonstantin Belousov 			if (strcmp(ef->progtab[i].name, linkset_name) == 0) {
14147226306eSKonstantin Belousov 				startp = (Elf_Addr)ef->progtab[i].addr;
14157226306eSKonstantin Belousov 				stopp = (Elf_Addr)(startp + ef->progtab[i].size);
14167226306eSKonstantin Belousov 				break;
14177226306eSKonstantin Belousov 			}
14187226306eSKonstantin Belousov 		}
14197226306eSKonstantin Belousov 		if (i == ef->nprogtab)
14207226306eSKonstantin Belousov 			continue;
14217226306eSKonstantin Belousov 
14227226306eSKonstantin Belousov 		sym->st_value = start ? startp : stopp;
14237226306eSKonstantin Belousov 		sym->st_shndx = i;
14247226306eSKonstantin Belousov 	}
14257226306eSKonstantin Belousov }
14267226306eSKonstantin Belousov 
14273cfce8e4SKonstantin Belousov static int
14287251b4bfSJake Burkholder link_elf_reloc_local(linker_file_t lf)
14297251b4bfSJake Burkholder {
1430e9eabf59SPeter Wemm 	elf_file_t ef = (elf_file_t)lf;
14317251b4bfSJake Burkholder 	const Elf_Rel *rellim;
14327251b4bfSJake Burkholder 	const Elf_Rel *rel;
14337251b4bfSJake Burkholder 	const Elf_Rela *relalim;
14347251b4bfSJake Burkholder 	const Elf_Rela *rela;
1435e9eabf59SPeter Wemm 	const Elf_Sym *sym;
1436e9eabf59SPeter Wemm 	Elf_Addr base;
1437e9eabf59SPeter Wemm 	int i;
1438757686b1SMarcel Moolenaar 	Elf_Size symidx;
1439e9eabf59SPeter Wemm 
14407226306eSKonstantin Belousov 	link_elf_fix_link_set(ef);
14417226306eSKonstantin Belousov 
14427251b4bfSJake Burkholder 	/* Perform relocations without addend if there are any: */
1443b474c780SDavid E. O'Brien 	for (i = 0; i < ef->nreltab; i++) {
1444e9eabf59SPeter Wemm 		rel = ef->reltab[i].rel;
14453cfce8e4SKonstantin Belousov 		if (rel == NULL) {
14463cfce8e4SKonstantin Belousov 			link_elf_error(ef->lf.filename, "lost a reltab");
14473cfce8e4SKonstantin Belousov 			return (ENOEXEC);
14483cfce8e4SKonstantin Belousov 		}
144920947801SPeter Wemm 		rellim = rel + ef->reltab[i].nrel;
1450e9eabf59SPeter Wemm 		base = findbase(ef, ef->reltab[i].sec);
14513cfce8e4SKonstantin Belousov 		if (base == 0) {
14523cfce8e4SKonstantin Belousov 			link_elf_error(ef->lf.filename, "lost base for reltab");
14533cfce8e4SKonstantin Belousov 			return (ENOEXEC);
14543cfce8e4SKonstantin Belousov 		}
145520947801SPeter Wemm 		for ( ; rel < rellim; rel++) {
1456e9eabf59SPeter Wemm 			symidx = ELF_R_SYM(rel->r_info);
145720947801SPeter Wemm 			if (symidx >= ef->ddbsymcnt)
145820947801SPeter Wemm 				continue;
1459e9eabf59SPeter Wemm 			sym = ef->ddbsymtab + symidx;
146020947801SPeter Wemm 			/* Only do local relocs */
146120947801SPeter Wemm 			if (ELF_ST_BIND(sym->st_info) != STB_LOCAL)
146220947801SPeter Wemm 				continue;
146320947801SPeter Wemm 			elf_reloc_local(lf, base, rel, ELF_RELOC_REL,
146420947801SPeter Wemm 			    elf_obj_lookup);
14657251b4bfSJake Burkholder 		}
1466e9eabf59SPeter Wemm 	}
14677251b4bfSJake Burkholder 
14687251b4bfSJake Burkholder 	/* Perform relocations with addend if there are any: */
1469b474c780SDavid E. O'Brien 	for (i = 0; i < ef->nrelatab; i++) {
1470e9eabf59SPeter Wemm 		rela = ef->relatab[i].rela;
14713cfce8e4SKonstantin Belousov 		if (rela == NULL) {
14723cfce8e4SKonstantin Belousov 			link_elf_error(ef->lf.filename, "lost a relatab!");
14733cfce8e4SKonstantin Belousov 			return (ENOEXEC);
14743cfce8e4SKonstantin Belousov 		}
147520947801SPeter Wemm 		relalim = rela + ef->relatab[i].nrela;
1476e9eabf59SPeter Wemm 		base = findbase(ef, ef->relatab[i].sec);
14773cfce8e4SKonstantin Belousov 		if (base == 0) {
14783cfce8e4SKonstantin Belousov 			link_elf_error(ef->lf.filename, "lost base for reltab");
14793cfce8e4SKonstantin Belousov 			return (ENOEXEC);
14803cfce8e4SKonstantin Belousov 		}
148120947801SPeter Wemm 		for ( ; rela < relalim; rela++) {
1482e9eabf59SPeter Wemm 			symidx = ELF_R_SYM(rela->r_info);
148320947801SPeter Wemm 			if (symidx >= ef->ddbsymcnt)
148420947801SPeter Wemm 				continue;
1485e9eabf59SPeter Wemm 			sym = ef->ddbsymtab + symidx;
148620947801SPeter Wemm 			/* Only do local relocs */
148720947801SPeter Wemm 			if (ELF_ST_BIND(sym->st_info) != STB_LOCAL)
148820947801SPeter Wemm 				continue;
148920947801SPeter Wemm 			elf_reloc_local(lf, base, rela, ELF_RELOC_RELA,
149020947801SPeter Wemm 			    elf_obj_lookup);
14917251b4bfSJake Burkholder 		}
14927251b4bfSJake Burkholder 	}
14933cfce8e4SKonstantin Belousov 	return (0);
1494e9eabf59SPeter Wemm }
149500a5db46SStacey Son 
149600a5db46SStacey Son static long
1497e76f11f4SAndriy Gapon link_elf_symtab_get(linker_file_t lf, const Elf_Sym **symtab)
149800a5db46SStacey Son {
149900a5db46SStacey Son     elf_file_t ef = (elf_file_t)lf;
150000a5db46SStacey Son 
150100a5db46SStacey Son     *symtab = ef->ddbsymtab;
150200a5db46SStacey Son 
150300a5db46SStacey Son     if (*symtab == NULL)
150400a5db46SStacey Son         return (0);
150500a5db46SStacey Son 
150600a5db46SStacey Son     return (ef->ddbsymcnt);
150700a5db46SStacey Son }
150800a5db46SStacey Son 
150900a5db46SStacey Son static long
151000a5db46SStacey Son link_elf_strtab_get(linker_file_t lf, caddr_t *strtab)
151100a5db46SStacey Son {
151200a5db46SStacey Son     elf_file_t ef = (elf_file_t)lf;
151300a5db46SStacey Son 
151400a5db46SStacey Son     *strtab = ef->ddbstrtab;
151500a5db46SStacey Son 
151600a5db46SStacey Son     if (*strtab == NULL)
151700a5db46SStacey Son         return (0);
151800a5db46SStacey Son 
151900a5db46SStacey Son     return (ef->ddbstrcnt);
152000a5db46SStacey Son }
1521