xref: /freebsd/sys/kern/link_elf_obj.c (revision 50c202c592c4019c36a40d861f498c3a243946f4)
1a4f67738SDoug Rabson /*-
2326e27d8SDoug Rabson  * Copyright (c) 1998-2000 Doug Rabson
3e9eabf59SPeter Wemm  * Copyright (c) 2004 Peter Wemm
4a4f67738SDoug Rabson  * All rights reserved.
5a4f67738SDoug Rabson  *
6a4f67738SDoug Rabson  * Redistribution and use in source and binary forms, with or without
7a4f67738SDoug Rabson  * modification, are permitted provided that the following conditions
8a4f67738SDoug Rabson  * are met:
9a4f67738SDoug Rabson  * 1. Redistributions of source code must retain the above copyright
10a4f67738SDoug Rabson  *    notice, this list of conditions and the following disclaimer.
11a4f67738SDoug Rabson  * 2. Redistributions in binary form must reproduce the above copyright
12a4f67738SDoug Rabson  *    notice, this list of conditions and the following disclaimer in the
13a4f67738SDoug Rabson  *    documentation and/or other materials provided with the distribution.
14a4f67738SDoug Rabson  *
15a4f67738SDoug Rabson  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16a4f67738SDoug Rabson  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17a4f67738SDoug Rabson  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18a4f67738SDoug Rabson  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19a4f67738SDoug Rabson  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20a4f67738SDoug Rabson  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21a4f67738SDoug Rabson  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22a4f67738SDoug Rabson  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23a4f67738SDoug Rabson  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24a4f67738SDoug Rabson  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25a4f67738SDoug Rabson  * SUCH DAMAGE.
26a4f67738SDoug Rabson  */
27a4f67738SDoug Rabson 
28677b542eSDavid E. O'Brien #include <sys/cdefs.h>
29677b542eSDavid E. O'Brien __FBSDID("$FreeBSD$");
30677b542eSDavid E. O'Brien 
31326e27d8SDoug Rabson #include "opt_ddb.h"
32326e27d8SDoug Rabson 
33a4f67738SDoug Rabson #include <sys/param.h>
34a4f67738SDoug Rabson #include <sys/systm.h>
35fb919e4dSMark Murray #include <sys/kernel.h>
36fb919e4dSMark Murray #include <sys/lock.h>
37a4f67738SDoug Rabson #include <sys/malloc.h>
38c0b824f9SDima Dorfman #include <sys/mutex.h>
3962d615d5SJohn Baldwin #include <sys/mount.h>
40a4f67738SDoug Rabson #include <sys/proc.h>
41a4f67738SDoug Rabson #include <sys/namei.h>
42a4f67738SDoug Rabson #include <sys/fcntl.h>
43a4f67738SDoug Rabson #include <sys/vnode.h>
44a4f67738SDoug Rabson #include <sys/linker.h>
45fb919e4dSMark Murray 
46a4f67738SDoug Rabson #include <machine/elf.h>
47a4f67738SDoug Rabson 
48aed55708SRobert Watson #include <security/mac/mac_framework.h>
49aed55708SRobert Watson 
50fe3db7c7SDoug Rabson #include <vm/vm.h>
51fe3db7c7SDoug Rabson #include <vm/vm_param.h>
52fe3db7c7SDoug Rabson #include <vm/vm_object.h>
53fe3db7c7SDoug Rabson #include <vm/vm_kern.h>
54fe3db7c7SDoug Rabson #include <vm/vm_extern.h>
55fe3db7c7SDoug Rabson #include <vm/pmap.h>
56fe3db7c7SDoug Rabson #include <vm/vm_map.h>
57fb919e4dSMark Murray 
58f9980387SPeter Wemm #include <sys/link_elf.h>
59fe3db7c7SDoug Rabson 
60a2024a3eSJohn Birrell #ifdef DDB_CTF
61a2024a3eSJohn Birrell #include <net/zlib.h>
62a2024a3eSJohn Birrell #endif
63a2024a3eSJohn Birrell 
64326e27d8SDoug Rabson #include "linker_if.h"
65a4f67738SDoug Rabson 
66e9eabf59SPeter Wemm typedef struct {
67e9eabf59SPeter Wemm 	void		*addr;
6820947801SPeter Wemm 	Elf_Off		size;
69e9eabf59SPeter Wemm 	int		flags;
70e9eabf59SPeter Wemm 	int		sec;	/* Original section */
71e9eabf59SPeter Wemm 	char		*name;
72e9eabf59SPeter Wemm } Elf_progent;
73e9eabf59SPeter Wemm 
74e9eabf59SPeter Wemm typedef struct {
75e9eabf59SPeter Wemm 	Elf_Rel		*rel;
7620947801SPeter Wemm 	int		nrel;
77e9eabf59SPeter Wemm 	int		sec;
78e9eabf59SPeter Wemm } Elf_relent;
79e9eabf59SPeter Wemm 
80e9eabf59SPeter Wemm typedef struct {
81e9eabf59SPeter Wemm 	Elf_Rela	*rela;
8220947801SPeter Wemm 	int		nrela;
83e9eabf59SPeter Wemm 	int		sec;
84e9eabf59SPeter Wemm } Elf_relaent;
85e9eabf59SPeter Wemm 
86e9eabf59SPeter Wemm 
87a4f67738SDoug Rabson typedef struct elf_file {
88326e27d8SDoug Rabson 	struct linker_file lf;		/* Common fields */
8920947801SPeter Wemm 
9070b7ffeeSIan Dowse 	int		preloaded;
91fe3db7c7SDoug Rabson 	caddr_t		address;	/* Relocation address */
92fe3db7c7SDoug Rabson 	vm_object_t	object;		/* VM object to hold file pages */
93e9eabf59SPeter Wemm 	Elf_Shdr	*e_shdr;
94e9eabf59SPeter Wemm 
95e9eabf59SPeter Wemm 	Elf_progent	*progtab;
96e9eabf59SPeter Wemm 	int		nprogtab;
97e9eabf59SPeter Wemm 
98e9eabf59SPeter Wemm 	Elf_relaent	*relatab;
99b474c780SDavid E. O'Brien 	int		nrelatab;
100e9eabf59SPeter Wemm 
101e9eabf59SPeter Wemm 	Elf_relent	*reltab;
102b474c780SDavid E. O'Brien 	int		nreltab;
103e9eabf59SPeter Wemm 
104e9eabf59SPeter Wemm 	Elf_Sym		*ddbsymtab;	/* The symbol table we are using */
1052d636ab0SPeter Wemm 	long		ddbsymcnt;	/* Number of symbols */
1062d636ab0SPeter Wemm 	caddr_t		ddbstrtab;	/* String table */
1072d636ab0SPeter Wemm 	long		ddbstrcnt;	/* number of bytes in string table */
108e9eabf59SPeter Wemm 
109e9eabf59SPeter Wemm 	caddr_t		shstrtab;	/* Section name string table */
110e9eabf59SPeter Wemm 	long		shstrcnt;	/* number of bytes in string table */
111e9eabf59SPeter Wemm 
112a2024a3eSJohn Birrell 	caddr_t		ctftab;		/* CTF table */
113a2024a3eSJohn Birrell 	long		ctfcnt;		/* number of bytes in CTF table */
114a2024a3eSJohn Birrell 	caddr_t		ctfoff;		/* CTF offset table */
115a2024a3eSJohn Birrell 	caddr_t		typoff;		/* Type offset table */
116a2024a3eSJohn Birrell 	long		typlen;		/* Number of type entries. */
117a2024a3eSJohn Birrell 
118a4f67738SDoug Rabson } *elf_file_t;
119a4f67738SDoug Rabson 
120a2024a3eSJohn Birrell #include <kern/kern_ctf.c>
121a2024a3eSJohn Birrell 
12254823af2SPeter Wemm static int	link_elf_link_preload(linker_class_t cls,
123326e27d8SDoug Rabson 		    const char *, linker_file_t *);
12454823af2SPeter Wemm static int	link_elf_link_preload_finish(linker_file_t);
12554823af2SPeter Wemm static int	link_elf_load_file(linker_class_t, const char *, linker_file_t *);
126326e27d8SDoug Rabson static int	link_elf_lookup_symbol(linker_file_t, const char *,
127326e27d8SDoug Rabson 		    c_linker_sym_t *);
128e9eabf59SPeter Wemm static int	link_elf_symbol_values(linker_file_t, c_linker_sym_t,
129e9eabf59SPeter Wemm 		    linker_symval_t *);
130326e27d8SDoug Rabson static int	link_elf_search_symbol(linker_file_t, caddr_t value,
131326e27d8SDoug Rabson 		    c_linker_sym_t *sym, long *diffp);
132326e27d8SDoug Rabson 
133326e27d8SDoug Rabson static void	link_elf_unload_file(linker_file_t);
134f41325dbSPeter Wemm static int	link_elf_lookup_set(linker_file_t, const char *,
135f41325dbSPeter Wemm 		    void ***, void ***, int *);
136bb9fe9ddSBrian Feldman static int	link_elf_each_function_name(linker_file_t,
137e9eabf59SPeter Wemm 		    int (*)(const char *, void *), void *);
138a2024a3eSJohn Birrell static int	link_elf_each_function_nameval(linker_file_t,
139a2024a3eSJohn Birrell 				linker_function_nameval_callback_t,
140a2024a3eSJohn Birrell 				void *);
1417251b4bfSJake Burkholder static void	link_elf_reloc_local(linker_file_t);
142e76f11f4SAndriy Gapon static long	link_elf_symtab_get(linker_file_t, const Elf_Sym **);
14300a5db46SStacey Son static long	link_elf_strtab_get(linker_file_t, caddr_t *);
144326e27d8SDoug Rabson 
145757686b1SMarcel Moolenaar static Elf_Addr elf_obj_lookup(linker_file_t lf, Elf_Size symidx, int deps);
146e9eabf59SPeter Wemm 
147326e27d8SDoug Rabson static kobj_method_t link_elf_methods[] = {
148326e27d8SDoug Rabson 	KOBJMETHOD(linker_lookup_symbol,	link_elf_lookup_symbol),
149326e27d8SDoug Rabson 	KOBJMETHOD(linker_symbol_values,	link_elf_symbol_values),
150326e27d8SDoug Rabson 	KOBJMETHOD(linker_search_symbol,	link_elf_search_symbol),
151326e27d8SDoug Rabson 	KOBJMETHOD(linker_unload,		link_elf_unload_file),
15254823af2SPeter Wemm 	KOBJMETHOD(linker_load_file,		link_elf_load_file),
15354823af2SPeter Wemm 	KOBJMETHOD(linker_link_preload,		link_elf_link_preload),
15454823af2SPeter Wemm 	KOBJMETHOD(linker_link_preload_finish,	link_elf_link_preload_finish),
155f41325dbSPeter Wemm 	KOBJMETHOD(linker_lookup_set,		link_elf_lookup_set),
156bb9fe9ddSBrian Feldman 	KOBJMETHOD(linker_each_function_name,	link_elf_each_function_name),
157a2024a3eSJohn Birrell 	KOBJMETHOD(linker_each_function_nameval, link_elf_each_function_nameval),
158a2024a3eSJohn Birrell 	KOBJMETHOD(linker_ctf_get,		link_elf_ctf_get),
15900a5db46SStacey Son 	KOBJMETHOD(linker_symtab_get, 		link_elf_symtab_get),
16000a5db46SStacey Son 	KOBJMETHOD(linker_strtab_get, 		link_elf_strtab_get),
161326e27d8SDoug Rabson 	{ 0, 0 }
162326e27d8SDoug Rabson };
163326e27d8SDoug Rabson 
164326e27d8SDoug Rabson static struct linker_class link_elf_class = {
165326e27d8SDoug Rabson #if ELF_TARG_CLASS == ELFCLASS32
166e9eabf59SPeter Wemm 	"elf32_obj",
167326e27d8SDoug Rabson #else
168e9eabf59SPeter Wemm 	"elf64_obj",
169326e27d8SDoug Rabson #endif
170326e27d8SDoug Rabson 	link_elf_methods, sizeof(struct elf_file)
171326e27d8SDoug Rabson };
172326e27d8SDoug Rabson 
173326e27d8SDoug Rabson static int	relocate_file(elf_file_t ef);
174a4f67738SDoug Rabson 
175a4f67738SDoug Rabson static void
176552f9f63SEdwin Groothuis link_elf_error(const char *filename, const char *s)
1771720979bSMarcel Moolenaar {
178552f9f63SEdwin Groothuis 	if (filename == NULL)
1791720979bSMarcel Moolenaar 		printf("kldload: %s\n", s);
180552f9f63SEdwin Groothuis 	else
181552f9f63SEdwin Groothuis 		printf("kldload: %s: %s\n", filename, s);
1821720979bSMarcel Moolenaar }
1831720979bSMarcel Moolenaar 
1841720979bSMarcel Moolenaar static void
185a4f67738SDoug Rabson link_elf_init(void *arg)
186a4f67738SDoug Rabson {
187a4f67738SDoug Rabson 
188326e27d8SDoug Rabson 	linker_add_class(&link_elf_class);
189a4f67738SDoug Rabson }
190a4f67738SDoug Rabson 
191e9eabf59SPeter Wemm SYSINIT(link_elf_obj, SI_SUB_KLD, SI_ORDER_SECOND, link_elf_init, 0);
192a4f67738SDoug Rabson 
193a4f67738SDoug Rabson static int
194e9eabf59SPeter Wemm link_elf_link_preload(linker_class_t cls, const char *filename,
195e9eabf59SPeter Wemm     linker_file_t *result)
1962d636ab0SPeter Wemm {
19770b7ffeeSIan Dowse 	Elf_Ehdr *hdr;
19870b7ffeeSIan Dowse 	Elf_Shdr *shdr;
19970b7ffeeSIan Dowse 	Elf_Sym *es;
20070b7ffeeSIan Dowse 	void *modptr, *baseptr, *sizeptr;
20170b7ffeeSIan Dowse 	char *type;
20270b7ffeeSIan Dowse 	elf_file_t ef;
20370b7ffeeSIan Dowse 	linker_file_t lf;
20470b7ffeeSIan Dowse 	Elf_Addr off;
20570b7ffeeSIan Dowse 	int error, i, j, pb, ra, rl, shstrindex, symstrindex, symtabindex;
20670b7ffeeSIan Dowse 
20770b7ffeeSIan Dowse 	/* Look to see if we have the file preloaded */
20870b7ffeeSIan Dowse 	modptr = preload_search_by_name(filename);
20970b7ffeeSIan Dowse 	if (modptr == NULL)
21070b7ffeeSIan Dowse 		return ENOENT;
21170b7ffeeSIan Dowse 
21270b7ffeeSIan Dowse 	type = (char *)preload_search_info(modptr, MODINFO_TYPE);
21370b7ffeeSIan Dowse 	baseptr = preload_search_info(modptr, MODINFO_ADDR);
21470b7ffeeSIan Dowse 	sizeptr = preload_search_info(modptr, MODINFO_SIZE);
21570b7ffeeSIan Dowse 	hdr = (Elf_Ehdr *)preload_search_info(modptr, MODINFO_METADATA |
21670b7ffeeSIan Dowse 	    MODINFOMD_ELFHDR);
21770b7ffeeSIan Dowse 	shdr = (Elf_Shdr *)preload_search_info(modptr, MODINFO_METADATA |
21870b7ffeeSIan Dowse 	    MODINFOMD_SHDR);
21970b7ffeeSIan Dowse 	if (type == NULL || (strcmp(type, "elf" __XSTRING(__ELF_WORD_SIZE)
22070b7ffeeSIan Dowse 	    " obj module") != 0 &&
22170b7ffeeSIan Dowse 	    strcmp(type, "elf obj module") != 0)) {
222de78ca7eSPeter Wemm 		return (EFTYPE);
223de78ca7eSPeter Wemm 	}
22470b7ffeeSIan Dowse 	if (baseptr == NULL || sizeptr == NULL || hdr == NULL ||
22570b7ffeeSIan Dowse 	    shdr == NULL)
22670b7ffeeSIan Dowse 		return (EINVAL);
22770b7ffeeSIan Dowse 
22870b7ffeeSIan Dowse 	lf = linker_make_file(filename, &link_elf_class);
22970b7ffeeSIan Dowse 	if (lf == NULL)
23070b7ffeeSIan Dowse 		return (ENOMEM);
23170b7ffeeSIan Dowse 
23270b7ffeeSIan Dowse 	ef = (elf_file_t)lf;
23370b7ffeeSIan Dowse 	ef->preloaded = 1;
23470b7ffeeSIan Dowse 	ef->address = *(caddr_t *)baseptr;
23570b7ffeeSIan Dowse 	lf->address = *(caddr_t *)baseptr;
23670b7ffeeSIan Dowse 	lf->size = *(size_t *)sizeptr;
23770b7ffeeSIan Dowse 
23870b7ffeeSIan Dowse 	if (hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS ||
23970b7ffeeSIan Dowse 	    hdr->e_ident[EI_DATA] != ELF_TARG_DATA ||
24070b7ffeeSIan Dowse 	    hdr->e_ident[EI_VERSION] != EV_CURRENT ||
24170b7ffeeSIan Dowse 	    hdr->e_version != EV_CURRENT ||
24270b7ffeeSIan Dowse 	    hdr->e_type != ET_REL ||
24370b7ffeeSIan Dowse 	    hdr->e_machine != ELF_TARG_MACH) {
24470b7ffeeSIan Dowse 		error = EFTYPE;
24570b7ffeeSIan Dowse 		goto out;
24670b7ffeeSIan Dowse 	}
24770b7ffeeSIan Dowse 	ef->e_shdr = shdr;
24870b7ffeeSIan Dowse 
24970b7ffeeSIan Dowse 	/* Scan the section header for information and table sizing. */
25070b7ffeeSIan Dowse 	symtabindex = -1;
25170b7ffeeSIan Dowse 	symstrindex = -1;
25270b7ffeeSIan Dowse 	for (i = 0; i < hdr->e_shnum; i++) {
25370b7ffeeSIan Dowse 		switch (shdr[i].sh_type) {
25470b7ffeeSIan Dowse 		case SHT_PROGBITS:
25570b7ffeeSIan Dowse 		case SHT_NOBITS:
25670b7ffeeSIan Dowse 			ef->nprogtab++;
25770b7ffeeSIan Dowse 			break;
25870b7ffeeSIan Dowse 		case SHT_SYMTAB:
25970b7ffeeSIan Dowse 			symtabindex = i;
26070b7ffeeSIan Dowse 			symstrindex = shdr[i].sh_link;
26170b7ffeeSIan Dowse 			break;
26270b7ffeeSIan Dowse 		case SHT_REL:
263b474c780SDavid E. O'Brien 			ef->nreltab++;
26470b7ffeeSIan Dowse 			break;
26570b7ffeeSIan Dowse 		case SHT_RELA:
266b474c780SDavid E. O'Brien 			ef->nrelatab++;
26770b7ffeeSIan Dowse 			break;
26870b7ffeeSIan Dowse 		}
26970b7ffeeSIan Dowse 	}
27070b7ffeeSIan Dowse 
27170b7ffeeSIan Dowse 	shstrindex = hdr->e_shstrndx;
27270b7ffeeSIan Dowse 	if (ef->nprogtab == 0 || symstrindex < 0 ||
27370b7ffeeSIan Dowse 	    symstrindex >= hdr->e_shnum ||
27470b7ffeeSIan Dowse 	    shdr[symstrindex].sh_type != SHT_STRTAB || shstrindex == 0 ||
27570b7ffeeSIan Dowse 	    shstrindex >= hdr->e_shnum ||
27670b7ffeeSIan Dowse 	    shdr[shstrindex].sh_type != SHT_STRTAB) {
27770b7ffeeSIan Dowse 		printf("%s: bad/missing section headers\n", filename);
27870b7ffeeSIan Dowse 		error = ENOEXEC;
27970b7ffeeSIan Dowse 		goto out;
28070b7ffeeSIan Dowse 	}
28170b7ffeeSIan Dowse 
28270b7ffeeSIan Dowse 	/* Allocate space for tracking the load chunks */
28370b7ffeeSIan Dowse 	if (ef->nprogtab != 0)
28470b7ffeeSIan Dowse 		ef->progtab = malloc(ef->nprogtab * sizeof(*ef->progtab),
28570b7ffeeSIan Dowse 		    M_LINKER, M_WAITOK | M_ZERO);
286b474c780SDavid E. O'Brien 	if (ef->nreltab != 0)
287b474c780SDavid E. O'Brien 		ef->reltab = malloc(ef->nreltab * sizeof(*ef->reltab),
288b474c780SDavid E. O'Brien 		    M_LINKER, M_WAITOK | M_ZERO);
289b474c780SDavid E. O'Brien 	if (ef->nrelatab != 0)
290b474c780SDavid E. O'Brien 		ef->relatab = malloc(ef->nrelatab * sizeof(*ef->relatab),
291b474c780SDavid E. O'Brien 		    M_LINKER, M_WAITOK | M_ZERO);
29270b7ffeeSIan Dowse 	if ((ef->nprogtab != 0 && ef->progtab == NULL) ||
293b474c780SDavid E. O'Brien 	    (ef->nreltab != 0 && ef->reltab == NULL) ||
294b474c780SDavid E. O'Brien 	    (ef->nrelatab != 0 && ef->relatab == NULL)) {
29570b7ffeeSIan Dowse 		error = ENOMEM;
29670b7ffeeSIan Dowse 		goto out;
29770b7ffeeSIan Dowse 	}
29870b7ffeeSIan Dowse 
29970b7ffeeSIan Dowse 	/* XXX, relocate the sh_addr fields saved by the loader. */
30070b7ffeeSIan Dowse 	off = 0;
30170b7ffeeSIan Dowse 	for (i = 0; i < hdr->e_shnum; i++) {
30270b7ffeeSIan Dowse 		if (shdr[i].sh_addr != 0 && (off == 0 || shdr[i].sh_addr < off))
30370b7ffeeSIan Dowse 			off = shdr[i].sh_addr;
30470b7ffeeSIan Dowse 	}
30570b7ffeeSIan Dowse 	for (i = 0; i < hdr->e_shnum; i++) {
30670b7ffeeSIan Dowse 		if (shdr[i].sh_addr != 0)
30770b7ffeeSIan Dowse 			shdr[i].sh_addr = shdr[i].sh_addr - off +
30870b7ffeeSIan Dowse 			    (Elf_Addr)ef->address;
30970b7ffeeSIan Dowse 	}
31070b7ffeeSIan Dowse 
31170b7ffeeSIan Dowse 	ef->ddbsymcnt = shdr[symtabindex].sh_size / sizeof(Elf_Sym);
31270b7ffeeSIan Dowse 	ef->ddbsymtab = (Elf_Sym *)shdr[symtabindex].sh_addr;
31370b7ffeeSIan Dowse 	ef->ddbstrcnt = shdr[symstrindex].sh_size;
31470b7ffeeSIan Dowse 	ef->ddbstrtab = (char *)shdr[symstrindex].sh_addr;
31570b7ffeeSIan Dowse 	ef->shstrcnt = shdr[shstrindex].sh_size;
31670b7ffeeSIan Dowse 	ef->shstrtab = (char *)shdr[shstrindex].sh_addr;
31770b7ffeeSIan Dowse 
31870b7ffeeSIan Dowse 	/* Now fill out progtab and the relocation tables. */
31970b7ffeeSIan Dowse 	pb = 0;
32070b7ffeeSIan Dowse 	rl = 0;
32170b7ffeeSIan Dowse 	ra = 0;
32270b7ffeeSIan Dowse 	for (i = 0; i < hdr->e_shnum; i++) {
32370b7ffeeSIan Dowse 		switch (shdr[i].sh_type) {
32470b7ffeeSIan Dowse 		case SHT_PROGBITS:
32570b7ffeeSIan Dowse 		case SHT_NOBITS:
32670b7ffeeSIan Dowse 			ef->progtab[pb].addr = (void *)shdr[i].sh_addr;
32770b7ffeeSIan Dowse 			if (shdr[i].sh_type == SHT_PROGBITS)
32870b7ffeeSIan Dowse 				ef->progtab[pb].name = "<<PROGBITS>>";
32970b7ffeeSIan Dowse 			else
33070b7ffeeSIan Dowse 				ef->progtab[pb].name = "<<NOBITS>>";
33170b7ffeeSIan Dowse 			ef->progtab[pb].size = shdr[i].sh_size;
33270b7ffeeSIan Dowse 			ef->progtab[pb].sec = i;
33370b7ffeeSIan Dowse 			if (ef->shstrtab && shdr[i].sh_name != 0)
33470b7ffeeSIan Dowse 				ef->progtab[pb].name =
33570b7ffeeSIan Dowse 				    ef->shstrtab + shdr[i].sh_name;
33650c202c5SJeff Roberson 			if (ef->progtab[pb].name != NULL &&
33750c202c5SJeff Roberson 			    !strcmp(ef->progtab[pb].name, "set_pcpu")) {
33850c202c5SJeff Roberson 				void *dpcpu;
33950c202c5SJeff Roberson 
34050c202c5SJeff Roberson 				dpcpu = dpcpu_alloc(shdr[i].sh_size);
34150c202c5SJeff Roberson 				if (dpcpu == NULL) {
34250c202c5SJeff Roberson 					error = ENOSPC;
34350c202c5SJeff Roberson 					goto out;
34450c202c5SJeff Roberson 				}
34550c202c5SJeff Roberson 				memcpy(dpcpu, ef->progtab[pb].addr,
34650c202c5SJeff Roberson 				    ef->progtab[pb].size);
34750c202c5SJeff Roberson 				dpcpu_copy(dpcpu, shdr[i].sh_size);
34850c202c5SJeff Roberson 				ef->progtab[pb].addr = dpcpu;
34950c202c5SJeff Roberson 			}
35070b7ffeeSIan Dowse 
35170b7ffeeSIan Dowse 			/* Update all symbol values with the offset. */
35270b7ffeeSIan Dowse 			for (j = 0; j < ef->ddbsymcnt; j++) {
35370b7ffeeSIan Dowse 				es = &ef->ddbsymtab[j];
35470b7ffeeSIan Dowse 				if (es->st_shndx != i)
35570b7ffeeSIan Dowse 					continue;
35670b7ffeeSIan Dowse 				es->st_value += (Elf_Addr)ef->progtab[pb].addr;
35770b7ffeeSIan Dowse 			}
35870b7ffeeSIan Dowse 			pb++;
35970b7ffeeSIan Dowse 			break;
36070b7ffeeSIan Dowse 		case SHT_REL:
36170b7ffeeSIan Dowse 			ef->reltab[rl].rel = (Elf_Rel *)shdr[i].sh_addr;
36270b7ffeeSIan Dowse 			ef->reltab[rl].nrel = shdr[i].sh_size / sizeof(Elf_Rel);
36370b7ffeeSIan Dowse 			ef->reltab[rl].sec = shdr[i].sh_info;
36470b7ffeeSIan Dowse 			rl++;
36570b7ffeeSIan Dowse 			break;
36670b7ffeeSIan Dowse 		case SHT_RELA:
36770b7ffeeSIan Dowse 			ef->relatab[ra].rela = (Elf_Rela *)shdr[i].sh_addr;
36870b7ffeeSIan Dowse 			ef->relatab[ra].nrela =
36970b7ffeeSIan Dowse 			    shdr[i].sh_size / sizeof(Elf_Rela);
37070b7ffeeSIan Dowse 			ef->relatab[ra].sec = shdr[i].sh_info;
37170b7ffeeSIan Dowse 			ra++;
37270b7ffeeSIan Dowse 			break;
37370b7ffeeSIan Dowse 		}
37470b7ffeeSIan Dowse 	}
37570b7ffeeSIan Dowse 	if (pb != ef->nprogtab)
37670b7ffeeSIan Dowse 		panic("lost progbits");
377b474c780SDavid E. O'Brien 	if (rl != ef->nreltab)
378b474c780SDavid E. O'Brien 		panic("lost reltab");
379b474c780SDavid E. O'Brien 	if (ra != ef->nrelatab)
380b474c780SDavid E. O'Brien 		panic("lost relatab");
38170b7ffeeSIan Dowse 
38270b7ffeeSIan Dowse 	/* Local intra-module relocations */
38370b7ffeeSIan Dowse 	link_elf_reloc_local(lf);
38470b7ffeeSIan Dowse 
38570b7ffeeSIan Dowse 	*result = lf;
38670b7ffeeSIan Dowse 	return (0);
38770b7ffeeSIan Dowse 
38870b7ffeeSIan Dowse out:
38970b7ffeeSIan Dowse 	/* preload not done this way */
39070b7ffeeSIan Dowse 	linker_file_unload(lf, LINKER_UNLOAD_FORCE);
39170b7ffeeSIan Dowse 	return (error);
39270b7ffeeSIan Dowse }
393de78ca7eSPeter Wemm 
394de78ca7eSPeter Wemm static int
39554823af2SPeter Wemm link_elf_link_preload_finish(linker_file_t lf)
39654823af2SPeter Wemm {
39770b7ffeeSIan Dowse 	elf_file_t ef;
39870b7ffeeSIan Dowse 	int error;
39970b7ffeeSIan Dowse 
40070b7ffeeSIan Dowse 	ef = (elf_file_t)lf;
40170b7ffeeSIan Dowse 	error = relocate_file(ef);
40270b7ffeeSIan Dowse 	if (error)
40370b7ffeeSIan Dowse 		return error;
40470b7ffeeSIan Dowse 
40570b7ffeeSIan Dowse 	/* Notify MD code that a module is being loaded. */
40670b7ffeeSIan Dowse 	error = elf_cpu_load_file(lf);
40770b7ffeeSIan Dowse 	if (error)
40870b7ffeeSIan Dowse 		return (error);
40970b7ffeeSIan Dowse 
41070b7ffeeSIan Dowse 	return (0);
41154823af2SPeter Wemm }
41254823af2SPeter Wemm 
41354823af2SPeter Wemm static int
414c143d6c2SMarcel Moolenaar link_elf_load_file(linker_class_t cls, const char *filename,
415c143d6c2SMarcel Moolenaar     linker_file_t *result)
416a4f67738SDoug Rabson {
417a4f67738SDoug Rabson 	struct nameidata nd;
418b40ce416SJulian Elischer 	struct thread *td = curthread;	/* XXX */
419caab6e90SPeter Wemm 	Elf_Ehdr *hdr;
420e9eabf59SPeter Wemm 	Elf_Shdr *shdr;
421a8774e39SPeter Wemm 	Elf_Sym *es;
422a8774e39SPeter Wemm 	int nbytes, i, j;
42320947801SPeter Wemm 	vm_offset_t mapbase;
424fe3db7c7SDoug Rabson 	size_t mapsize;
425a4f67738SDoug Rabson 	int error = 0;
426e6796b67SKirk McKusick 	int resid, flags;
427a4f67738SDoug Rabson 	elf_file_t ef;
428a4f67738SDoug Rabson 	linker_file_t lf;
429ca65d5c7SPeter Wemm 	int symtabindex;
430ca65d5c7SPeter Wemm 	int symstrindex;
431e9eabf59SPeter Wemm 	int shstrindex;
432e9eabf59SPeter Wemm 	int nsym;
43320947801SPeter Wemm 	int pb, rl, ra;
434e9eabf59SPeter Wemm 	int alignmask;
43562d615d5SJohn Baldwin 	int vfslocked;
436ca65d5c7SPeter Wemm 
437ca65d5c7SPeter Wemm 	shdr = NULL;
438ca65d5c7SPeter Wemm 	lf = NULL;
439e9eabf59SPeter Wemm 	mapsize = 0;
440e9eabf59SPeter Wemm 	hdr = NULL;
441a4f67738SDoug Rabson 
44262d615d5SJohn Baldwin 	NDINIT(&nd, LOOKUP, FOLLOW | MPSAFE, UIO_SYSSPACE, filename, td);
443e6796b67SKirk McKusick 	flags = FREAD;
4449e223287SKonstantin Belousov 	error = vn_open(&nd, &flags, 0, NULL);
445a4f67738SDoug Rabson 	if (error)
446a4f67738SDoug Rabson 		return error;
44762d615d5SJohn Baldwin 	vfslocked = NDHASGIANT(&nd);
448762e6b85SEivind Eklund 	NDFREE(&nd, NDF_ONLY_PNBUF);
4491f49b573SRuslan Ermilov 	if (nd.ni_vp->v_type != VREG) {
4501f49b573SRuslan Ermilov 		error = ENOEXEC;
4511f49b573SRuslan Ermilov 		goto out;
4521f49b573SRuslan Ermilov 	}
453a3df768bSRobert Watson #ifdef MAC
45430d239bcSRobert Watson 	error = mac_kld_check_load(td->td_ucred, nd.ni_vp);
455a3df768bSRobert Watson 	if (error) {
456a3df768bSRobert Watson 		goto out;
457a3df768bSRobert Watson 	}
458a3df768bSRobert Watson #endif
459a4f67738SDoug Rabson 
460e9eabf59SPeter Wemm 	/* Read the elf header from the file. */
461e9eabf59SPeter Wemm 	hdr = malloc(sizeof(*hdr), M_LINKER, M_WAITOK);
462e9eabf59SPeter Wemm 	if (hdr == NULL) {
463caab6e90SPeter Wemm 		error = ENOMEM;
464caab6e90SPeter Wemm 		goto out;
465caab6e90SPeter Wemm 	}
466e9eabf59SPeter Wemm 	error = vn_rdwr(UIO_READ, nd.ni_vp, (void *)hdr, sizeof(*hdr), 0,
4679ca43589SRobert Watson 	    UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED,
4689ca43589SRobert Watson 	    &resid, td);
469a4f67738SDoug Rabson 	if (error)
470a4f67738SDoug Rabson 		goto out;
471e9eabf59SPeter Wemm 	if (resid != 0){
472e9eabf59SPeter Wemm 		error = ENOEXEC;
473e9eabf59SPeter Wemm 		goto out;
474e9eabf59SPeter Wemm 	}
475a4f67738SDoug Rabson 
476caab6e90SPeter Wemm 	if (!IS_ELF(*hdr)) {
477fe3db7c7SDoug Rabson 		error = ENOEXEC;
478a4f67738SDoug Rabson 		goto out;
479fe3db7c7SDoug Rabson 	}
480fe3db7c7SDoug Rabson 
481caab6e90SPeter Wemm 	if (hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS
482caab6e90SPeter Wemm 	    || hdr->e_ident[EI_DATA] != ELF_TARG_DATA) {
483552f9f63SEdwin Groothuis 		link_elf_error(filename, "Unsupported file layout");
484fe3db7c7SDoug Rabson 		error = ENOEXEC;
485fe3db7c7SDoug Rabson 		goto out;
486fe3db7c7SDoug Rabson 	}
487caab6e90SPeter Wemm 	if (hdr->e_ident[EI_VERSION] != EV_CURRENT
488caab6e90SPeter Wemm 	    || hdr->e_version != EV_CURRENT) {
489552f9f63SEdwin Groothuis 		link_elf_error(filename, "Unsupported file version");
490fe3db7c7SDoug Rabson 		error = ENOEXEC;
491fe3db7c7SDoug Rabson 		goto out;
492fe3db7c7SDoug Rabson 	}
493e9eabf59SPeter Wemm 	if (hdr->e_type != ET_REL) {
494a1d7ce03SAttilio Rao 		error = ENOSYS;
495fe3db7c7SDoug Rabson 		goto out;
496fe3db7c7SDoug Rabson 	}
497caab6e90SPeter Wemm 	if (hdr->e_machine != ELF_TARG_MACH) {
498552f9f63SEdwin Groothuis 		link_elf_error(filename, "Unsupported machine");
499fe3db7c7SDoug Rabson 		error = ENOEXEC;
500fe3db7c7SDoug Rabson 		goto out;
501fe3db7c7SDoug Rabson 	}
502a4f67738SDoug Rabson 
503326e27d8SDoug Rabson 	lf = linker_make_file(filename, &link_elf_class);
504326e27d8SDoug Rabson 	if (!lf) {
505326e27d8SDoug Rabson 		error = ENOMEM;
506326e27d8SDoug Rabson 		goto out;
507326e27d8SDoug Rabson 	}
508326e27d8SDoug Rabson 	ef = (elf_file_t) lf;
509e9eabf59SPeter Wemm 	ef->nprogtab = 0;
510e9eabf59SPeter Wemm 	ef->e_shdr = 0;
511b474c780SDavid E. O'Brien 	ef->nreltab = 0;
512b474c780SDavid E. O'Brien 	ef->nrelatab = 0;
513e9eabf59SPeter Wemm 
514e9eabf59SPeter Wemm 	/* Allocate and read in the section header */
515e9eabf59SPeter Wemm 	nbytes = hdr->e_shnum * hdr->e_shentsize;
516e9eabf59SPeter Wemm 	if (nbytes == 0 || hdr->e_shoff == 0 ||
517e9eabf59SPeter Wemm 	    hdr->e_shentsize != sizeof(Elf_Shdr)) {
518e9eabf59SPeter Wemm 		error = ENOEXEC;
519e9eabf59SPeter Wemm 		goto out;
520e9eabf59SPeter Wemm 	}
52120947801SPeter Wemm 	shdr = malloc(nbytes, M_LINKER, M_WAITOK);
522e9eabf59SPeter Wemm 	if (shdr == NULL) {
523e9eabf59SPeter Wemm 		error = ENOMEM;
524e9eabf59SPeter Wemm 		goto out;
525e9eabf59SPeter Wemm 	}
526e9eabf59SPeter Wemm 	ef->e_shdr = shdr;
527e9eabf59SPeter Wemm 	error = vn_rdwr(UIO_READ, nd.ni_vp, (caddr_t)shdr, nbytes, hdr->e_shoff,
528e9eabf59SPeter Wemm 	    UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, &resid, td);
529e9eabf59SPeter Wemm 	if (error)
530e9eabf59SPeter Wemm 		goto out;
531e9eabf59SPeter Wemm 	if (resid) {
532e9eabf59SPeter Wemm 		error = ENOEXEC;
533e9eabf59SPeter Wemm 		goto out;
534e9eabf59SPeter Wemm 	}
535e9eabf59SPeter Wemm 
536e9eabf59SPeter Wemm 	/* Scan the section header for information and table sizing. */
537e9eabf59SPeter Wemm 	nsym = 0;
538e9eabf59SPeter Wemm 	symtabindex = -1;
539e9eabf59SPeter Wemm 	symstrindex = -1;
540e9eabf59SPeter Wemm 	for (i = 0; i < hdr->e_shnum; i++) {
541e9eabf59SPeter Wemm 		switch (shdr[i].sh_type) {
542e9eabf59SPeter Wemm 		case SHT_PROGBITS:
543e9eabf59SPeter Wemm 		case SHT_NOBITS:
54420947801SPeter Wemm 			ef->nprogtab++;
545e9eabf59SPeter Wemm 			break;
546e9eabf59SPeter Wemm 		case SHT_SYMTAB:
547e9eabf59SPeter Wemm 			nsym++;
548e9eabf59SPeter Wemm 			symtabindex = i;
549e9eabf59SPeter Wemm 			symstrindex = shdr[i].sh_link;
550e9eabf59SPeter Wemm 			break;
551e9eabf59SPeter Wemm 		case SHT_REL:
552b474c780SDavid E. O'Brien 			ef->nreltab++;
553e9eabf59SPeter Wemm 			break;
554e9eabf59SPeter Wemm 		case SHT_RELA:
555b474c780SDavid E. O'Brien 			ef->nrelatab++;
556e9eabf59SPeter Wemm 			break;
557e9eabf59SPeter Wemm 		case SHT_STRTAB:
558e9eabf59SPeter Wemm 			break;
559e9eabf59SPeter Wemm 		}
560e9eabf59SPeter Wemm 	}
56120947801SPeter Wemm 	if (ef->nprogtab == 0) {
562552f9f63SEdwin Groothuis 		link_elf_error(filename, "file has no contents");
563e9eabf59SPeter Wemm 		error = ENOEXEC;
564e9eabf59SPeter Wemm 		goto out;
565e9eabf59SPeter Wemm 	}
566e9eabf59SPeter Wemm 	if (nsym != 1) {
567e9eabf59SPeter Wemm 		/* Only allow one symbol table for now */
568552f9f63SEdwin Groothuis 		link_elf_error(filename, "file has no valid symbol table");
569e9eabf59SPeter Wemm 		error = ENOEXEC;
570e9eabf59SPeter Wemm 		goto out;
571e9eabf59SPeter Wemm 	}
572e9eabf59SPeter Wemm 	if (symstrindex < 0 || symstrindex > hdr->e_shnum ||
573e9eabf59SPeter Wemm 	    shdr[symstrindex].sh_type != SHT_STRTAB) {
574552f9f63SEdwin Groothuis 		link_elf_error(filename, "file has invalid symbol strings");
575e9eabf59SPeter Wemm 		error = ENOEXEC;
576e9eabf59SPeter Wemm 		goto out;
577e9eabf59SPeter Wemm 	}
578e9eabf59SPeter Wemm 
579e9eabf59SPeter Wemm 	/* Allocate space for tracking the load chunks */
580e9eabf59SPeter Wemm 	if (ef->nprogtab != 0)
58120947801SPeter Wemm 		ef->progtab = malloc(ef->nprogtab * sizeof(*ef->progtab),
58220947801SPeter Wemm 		    M_LINKER, M_WAITOK | M_ZERO);
583b474c780SDavid E. O'Brien 	if (ef->nreltab != 0)
584b474c780SDavid E. O'Brien 		ef->reltab = malloc(ef->nreltab * sizeof(*ef->reltab),
585b474c780SDavid E. O'Brien 		    M_LINKER, M_WAITOK | M_ZERO);
586b474c780SDavid E. O'Brien 	if (ef->nrelatab != 0)
587b474c780SDavid E. O'Brien 		ef->relatab = malloc(ef->nrelatab * sizeof(*ef->relatab),
588b474c780SDavid E. O'Brien 		    M_LINKER, M_WAITOK | M_ZERO);
58920947801SPeter Wemm 	if ((ef->nprogtab != 0 && ef->progtab == NULL) ||
590b474c780SDavid E. O'Brien 	    (ef->nreltab != 0 && ef->reltab == NULL) ||
591b474c780SDavid E. O'Brien 	    (ef->nrelatab != 0 && ef->relatab == NULL)) {
59220947801SPeter Wemm 		error = ENOMEM;
59320947801SPeter Wemm 		goto out;
59420947801SPeter Wemm 	}
595e9eabf59SPeter Wemm 
59620947801SPeter Wemm 	if (symtabindex == -1)
59720947801SPeter Wemm 		panic("lost symbol table index");
59820947801SPeter Wemm 	/* Allocate space for and load the symbol table */
599e9eabf59SPeter Wemm 	ef->ddbsymcnt = shdr[symtabindex].sh_size / sizeof(Elf_Sym);
600e9eabf59SPeter Wemm 	ef->ddbsymtab = malloc(shdr[symtabindex].sh_size, M_LINKER, M_WAITOK);
60120947801SPeter Wemm 	if (ef->ddbsymtab == NULL) {
60220947801SPeter Wemm 		error = ENOMEM;
60320947801SPeter Wemm 		goto out;
60420947801SPeter Wemm 	}
60520947801SPeter Wemm 	error = vn_rdwr(UIO_READ, nd.ni_vp, (void *)ef->ddbsymtab,
60620947801SPeter Wemm 	    shdr[symtabindex].sh_size, shdr[symtabindex].sh_offset,
60720947801SPeter Wemm 	    UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED,
60820947801SPeter Wemm 	    &resid, td);
60920947801SPeter Wemm 	if (error)
61020947801SPeter Wemm 		goto out;
61120947801SPeter Wemm 	if (resid != 0){
61220947801SPeter Wemm 		error = EINVAL;
61320947801SPeter Wemm 		goto out;
61420947801SPeter Wemm 	}
615e9eabf59SPeter Wemm 
61620947801SPeter Wemm 	if (symstrindex == -1)
61720947801SPeter Wemm 		panic("lost symbol string index");
61820947801SPeter Wemm 	/* Allocate space for and load the symbol strings */
619e9eabf59SPeter Wemm 	ef->ddbstrcnt = shdr[symstrindex].sh_size;
620e9eabf59SPeter Wemm 	ef->ddbstrtab = malloc(shdr[symstrindex].sh_size, M_LINKER, M_WAITOK);
62120947801SPeter Wemm 	if (ef->ddbstrtab == NULL) {
622e9eabf59SPeter Wemm 		error = ENOMEM;
623e9eabf59SPeter Wemm 		goto out;
624e9eabf59SPeter Wemm 	}
62520947801SPeter Wemm 	error = vn_rdwr(UIO_READ, nd.ni_vp, ef->ddbstrtab,
62620947801SPeter Wemm 	    shdr[symstrindex].sh_size, shdr[symstrindex].sh_offset,
62720947801SPeter Wemm 	    UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED,
62820947801SPeter Wemm 	    &resid, td);
62920947801SPeter Wemm 	if (error)
63020947801SPeter Wemm 		goto out;
63120947801SPeter Wemm 	if (resid != 0){
63220947801SPeter Wemm 		error = EINVAL;
63320947801SPeter Wemm 		goto out;
63420947801SPeter Wemm 	}
635e9eabf59SPeter Wemm 
636e9eabf59SPeter Wemm 	/* Do we have a string table for the section names?  */
637e9eabf59SPeter Wemm 	shstrindex = -1;
63820947801SPeter Wemm 	if (hdr->e_shstrndx != 0 &&
63920947801SPeter Wemm 	    shdr[hdr->e_shstrndx].sh_type == SHT_STRTAB) {
640e9eabf59SPeter Wemm 		shstrindex = hdr->e_shstrndx;
641e9eabf59SPeter Wemm 		ef->shstrcnt = shdr[shstrindex].sh_size;
64220947801SPeter Wemm 		ef->shstrtab = malloc(shdr[shstrindex].sh_size, M_LINKER,
64320947801SPeter Wemm 		    M_WAITOK);
644e9eabf59SPeter Wemm 		if (ef->shstrtab == NULL) {
645e9eabf59SPeter Wemm 			error = ENOMEM;
646e9eabf59SPeter Wemm 			goto out;
647e9eabf59SPeter Wemm 		}
64820947801SPeter Wemm 		error = vn_rdwr(UIO_READ, nd.ni_vp, ef->shstrtab,
64920947801SPeter Wemm 		    shdr[shstrindex].sh_size, shdr[shstrindex].sh_offset,
650e9eabf59SPeter Wemm 		    UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED,
651e9eabf59SPeter Wemm 		    &resid, td);
652e9eabf59SPeter Wemm 		if (error)
653e9eabf59SPeter Wemm 			goto out;
65420947801SPeter Wemm 		if (resid != 0){
65520947801SPeter Wemm 			error = EINVAL;
65620947801SPeter Wemm 			goto out;
65720947801SPeter Wemm 		}
658e9eabf59SPeter Wemm 	}
659e9eabf59SPeter Wemm 
66020947801SPeter Wemm 	/* Size up code/data(progbits) and bss(nobits). */
661e9eabf59SPeter Wemm 	alignmask = 0;
662e9eabf59SPeter Wemm 	for (i = 0; i < hdr->e_shnum; i++) {
663e9eabf59SPeter Wemm 		switch (shdr[i].sh_type) {
664e9eabf59SPeter Wemm 		case SHT_PROGBITS:
665e9eabf59SPeter Wemm 		case SHT_NOBITS:
666e9eabf59SPeter Wemm 			alignmask = shdr[i].sh_addralign - 1;
667e9eabf59SPeter Wemm 			mapsize += alignmask;
668e9eabf59SPeter Wemm 			mapsize &= ~alignmask;
669e9eabf59SPeter Wemm 			mapsize += shdr[i].sh_size;
670e9eabf59SPeter Wemm 			break;
671e9eabf59SPeter Wemm 		}
672e9eabf59SPeter Wemm 	}
673e9eabf59SPeter Wemm 
674e9eabf59SPeter Wemm 	/*
675e9eabf59SPeter Wemm 	 * We know how much space we need for the text/data/bss/etc.
676e9eabf59SPeter Wemm 	 * This stuff needs to be in a single chunk so that profiling etc
677e9eabf59SPeter Wemm 	 * can get the bounds and gdb can associate offsets with modules
678e9eabf59SPeter Wemm 	 */
67920947801SPeter Wemm 	ef->object = vm_object_allocate(OBJT_DEFAULT,
68020947801SPeter Wemm 	    round_page(mapsize) >> PAGE_SHIFT);
681fe3db7c7SDoug Rabson 	if (ef->object == NULL) {
682fe3db7c7SDoug Rabson 		error = ENOMEM;
683fe3db7c7SDoug Rabson 		goto out;
684fe3db7c7SDoug Rabson 	}
685fe3db7c7SDoug Rabson 	ef->address = (caddr_t) vm_map_min(kernel_map);
686ac68d1c9SAlan Cox 
687ac68d1c9SAlan Cox 	/*
688ac68d1c9SAlan Cox 	 * In order to satisfy amd64's architectural requirements on the
689ac68d1c9SAlan Cox 	 * location of code and data in the kernel's address space, request a
690ac68d1c9SAlan Cox 	 * mapping that is above the kernel.
691ac68d1c9SAlan Cox 	 */
692ac68d1c9SAlan Cox 	mapbase = KERNBASE;
69320947801SPeter Wemm 	error = vm_map_find(kernel_map, ef->object, 0, &mapbase,
69420947801SPeter Wemm 	    round_page(mapsize), TRUE, VM_PROT_ALL, VM_PROT_ALL, FALSE);
695fe3db7c7SDoug Rabson 	if (error) {
696fe3db7c7SDoug Rabson 		vm_object_deallocate(ef->object);
697326e27d8SDoug Rabson 		ef->object = 0;
698fe3db7c7SDoug Rabson 		goto out;
699fe3db7c7SDoug Rabson 	}
70020947801SPeter Wemm 
701e9eabf59SPeter Wemm 	/* Wire the pages */
7027f1ef325SAlan Cox 	error = vm_map_wire(kernel_map, mapbase,
70320947801SPeter Wemm 	    mapbase + round_page(mapsize),
704e9eabf59SPeter Wemm 	    VM_MAP_WIRE_SYSTEM|VM_MAP_WIRE_NOHOLES);
7057f1ef325SAlan Cox 	if (error != KERN_SUCCESS) {
7067f1ef325SAlan Cox 		error = ENOMEM;
7077f1ef325SAlan Cox 		goto out;
7087f1ef325SAlan Cox 	}
709a4f67738SDoug Rabson 
71020947801SPeter Wemm 	/* Inform the kld system about the situation */
71120947801SPeter Wemm 	lf->address = ef->address = (caddr_t)mapbase;
71220947801SPeter Wemm 	lf->size = mapsize;
713e9eabf59SPeter Wemm 
714e9eabf59SPeter Wemm 	/*
71520947801SPeter Wemm 	 * Now load code/data(progbits), zero bss(nobits), allocate space for
71620947801SPeter Wemm 	 * and load relocs
717e9eabf59SPeter Wemm 	 */
71820947801SPeter Wemm 	pb = 0;
71920947801SPeter Wemm 	rl = 0;
72020947801SPeter Wemm 	ra = 0;
72120947801SPeter Wemm 	alignmask = 0;
72220947801SPeter Wemm 	for (i = 0; i < hdr->e_shnum; i++) {
72320947801SPeter Wemm 		switch (shdr[i].sh_type) {
72420947801SPeter Wemm 		case SHT_PROGBITS:
72520947801SPeter Wemm 		case SHT_NOBITS:
72620947801SPeter Wemm 			alignmask = shdr[i].sh_addralign - 1;
72720947801SPeter Wemm 			mapbase += alignmask;
72820947801SPeter Wemm 			mapbase &= ~alignmask;
72950c202c5SJeff Roberson 			if (ef->shstrtab && shdr[i].sh_name != 0)
73050c202c5SJeff Roberson 				ef->progtab[pb].name =
73150c202c5SJeff Roberson 				    ef->shstrtab + shdr[i].sh_name;
73250c202c5SJeff Roberson 			else if (shdr[i].sh_type == SHT_PROGBITS)
73320947801SPeter Wemm 				ef->progtab[pb].name = "<<PROGBITS>>";
73450c202c5SJeff Roberson 			else
73550c202c5SJeff Roberson 				ef->progtab[pb].name = "<<NOBITS>>";
73650c202c5SJeff Roberson 			if (ef->progtab[pb].name != NULL &&
73750c202c5SJeff Roberson 			    !strcmp(ef->progtab[pb].name, "set_pcpu"))
73850c202c5SJeff Roberson 				ef->progtab[pb].addr =
73950c202c5SJeff Roberson 				    dpcpu_alloc(shdr[i].sh_size);
74050c202c5SJeff Roberson 			else
74150c202c5SJeff Roberson 				ef->progtab[pb].addr =
74250c202c5SJeff Roberson 				    (void *)(uintptr_t)mapbase;
74350c202c5SJeff Roberson 			if (ef->progtab[pb].addr == NULL) {
74450c202c5SJeff Roberson 				error = ENOSPC;
74550c202c5SJeff Roberson 				goto out;
74650c202c5SJeff Roberson 			}
74750c202c5SJeff Roberson 			ef->progtab[pb].size = shdr[i].sh_size;
74850c202c5SJeff Roberson 			ef->progtab[pb].sec = i;
74950c202c5SJeff Roberson 			if (shdr[i].sh_type == SHT_PROGBITS) {
750e9eabf59SPeter Wemm 				error = vn_rdwr(UIO_READ, nd.ni_vp,
75120947801SPeter Wemm 				    ef->progtab[pb].addr,
75220947801SPeter Wemm 				    shdr[i].sh_size, shdr[i].sh_offset,
75320947801SPeter Wemm 				    UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred,
75420947801SPeter Wemm 				    NOCRED, &resid, td);
75520947801SPeter Wemm 				if (error)
75620947801SPeter Wemm 					goto out;
75720947801SPeter Wemm 				if (resid != 0){
75820947801SPeter Wemm 					error = EINVAL;
75920947801SPeter Wemm 					goto out;
76020947801SPeter Wemm 				}
76150c202c5SJeff Roberson 				/* Initialize the per-cpu area. */
76250c202c5SJeff Roberson 				if (ef->progtab[pb].addr != (void *)mapbase)
76350c202c5SJeff Roberson 					dpcpu_copy(ef->progtab[pb].addr,
76450c202c5SJeff Roberson 					    shdr[i].sh_size);
76550c202c5SJeff Roberson 			} else
76620947801SPeter Wemm 				bzero(ef->progtab[pb].addr, shdr[i].sh_size);
767a8774e39SPeter Wemm 
768a8774e39SPeter Wemm 			/* Update all symbol values with the offset. */
769a8774e39SPeter Wemm 			for (j = 0; j < ef->ddbsymcnt; j++) {
770a8774e39SPeter Wemm 				es = &ef->ddbsymtab[j];
771a8774e39SPeter Wemm 				if (es->st_shndx != i)
772a8774e39SPeter Wemm 					continue;
773a8774e39SPeter Wemm 				es->st_value += (Elf_Addr)ef->progtab[pb].addr;
774a8774e39SPeter Wemm 			}
77520947801SPeter Wemm 			mapbase += shdr[i].sh_size;
77620947801SPeter Wemm 			pb++;
77720947801SPeter Wemm 			break;
77820947801SPeter Wemm 		case SHT_REL:
77920947801SPeter Wemm 			ef->reltab[rl].rel = malloc(shdr[i].sh_size, M_LINKER,
78020947801SPeter Wemm 			    M_WAITOK);
78120947801SPeter Wemm 			ef->reltab[rl].nrel = shdr[i].sh_size / sizeof(Elf_Rel);
78220947801SPeter Wemm 			ef->reltab[rl].sec = shdr[i].sh_info;
78320947801SPeter Wemm 			error = vn_rdwr(UIO_READ, nd.ni_vp,
78420947801SPeter Wemm 			    (void *)ef->reltab[rl].rel,
78520947801SPeter Wemm 			    shdr[i].sh_size, shdr[i].sh_offset,
786e9eabf59SPeter Wemm 			    UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED,
787e9eabf59SPeter Wemm 			    &resid, td);
788e9eabf59SPeter Wemm 			if (error)
789e9eabf59SPeter Wemm 				goto out;
79020947801SPeter Wemm 			if (resid != 0){
79120947801SPeter Wemm 				error = EINVAL;
79220947801SPeter Wemm 				goto out;
793e9eabf59SPeter Wemm 			}
79420947801SPeter Wemm 			rl++;
79520947801SPeter Wemm 			break;
79620947801SPeter Wemm 		case SHT_RELA:
79720947801SPeter Wemm 			ef->relatab[ra].rela = malloc(shdr[i].sh_size, M_LINKER,
79820947801SPeter Wemm 			    M_WAITOK);
79920947801SPeter Wemm 			ef->relatab[ra].nrela =
80020947801SPeter Wemm 			    shdr[i].sh_size / sizeof(Elf_Rela);
80120947801SPeter Wemm 			ef->relatab[ra].sec = shdr[i].sh_info;
802e9eabf59SPeter Wemm 			error = vn_rdwr(UIO_READ, nd.ni_vp,
80320947801SPeter Wemm 			    (void *)ef->relatab[ra].rela,
80420947801SPeter Wemm 			    shdr[i].sh_size, shdr[i].sh_offset,
805e9eabf59SPeter Wemm 			    UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED,
806e9eabf59SPeter Wemm 			    &resid, td);
807e9eabf59SPeter Wemm 			if (error)
808e9eabf59SPeter Wemm 				goto out;
80920947801SPeter Wemm 			if (resid != 0){
81020947801SPeter Wemm 				error = EINVAL;
81120947801SPeter Wemm 				goto out;
812e9eabf59SPeter Wemm 			}
81320947801SPeter Wemm 			ra++;
81420947801SPeter Wemm 			break;
81520947801SPeter Wemm 		}
81620947801SPeter Wemm 	}
81720947801SPeter Wemm 	if (pb != ef->nprogtab)
81820947801SPeter Wemm 		panic("lost progbits");
819b474c780SDavid E. O'Brien 	if (rl != ef->nreltab)
820b474c780SDavid E. O'Brien 		panic("lost reltab");
821b474c780SDavid E. O'Brien 	if (ra != ef->nrelatab)
822b474c780SDavid E. O'Brien 		panic("lost relatab");
82320947801SPeter Wemm 	if (mapbase != (vm_offset_t)ef->address + mapsize)
8245b201fdcSPeter Wemm 		panic("mapbase 0x%lx != address %p + mapsize 0x%lx (0x%lx)\n",
8255b201fdcSPeter Wemm 		    mapbase, ef->address, mapsize,
8265b201fdcSPeter Wemm 		    (vm_offset_t)ef->address + mapsize);
827e9eabf59SPeter Wemm 
828e9eabf59SPeter Wemm 	/* Local intra-module relocations */
8297251b4bfSJake Burkholder 	link_elf_reloc_local(lf);
8307251b4bfSJake Burkholder 
831e9eabf59SPeter Wemm 	/* Pull in dependencies */
8324f7afc20SKonstantin Belousov 	VOP_UNLOCK(nd.ni_vp, 0);
8337b9716baSIan Dowse 	error = linker_load_dependencies(lf);
8344f7afc20SKonstantin Belousov 	vn_lock(nd.ni_vp, LK_EXCLUSIVE | LK_RETRY);
835ca65d5c7SPeter Wemm 	if (error)
836de78ca7eSPeter Wemm 		goto out;
837e9eabf59SPeter Wemm 
838e9eabf59SPeter Wemm 	/* External relocations */
839326e27d8SDoug Rabson 	error = relocate_file(ef);
840ca65d5c7SPeter Wemm 	if (error)
841ca65d5c7SPeter Wemm 		goto out;
842ca65d5c7SPeter Wemm 
843e9eabf59SPeter Wemm 	/* Notify MD code that a module is being loaded. */
844e9eabf59SPeter Wemm 	error = elf_cpu_load_file(lf);
845ca65d5c7SPeter Wemm 	if (error)
846ca65d5c7SPeter Wemm 		goto out;
847a4f67738SDoug Rabson 
848a4f67738SDoug Rabson 	*result = lf;
849a4f67738SDoug Rabson 
850a4f67738SDoug Rabson out:
851ca65d5c7SPeter Wemm 	if (error && lf)
85265a311fcSPoul-Henning Kamp 		linker_file_unload(lf, LINKER_UNLOAD_FORCE);
853e9eabf59SPeter Wemm 	if (hdr)
854e9eabf59SPeter Wemm 		free(hdr, M_LINKER);
85522db15c0SAttilio Rao 	VOP_UNLOCK(nd.ni_vp, 0);
856a854ed98SJohn Baldwin 	vn_close(nd.ni_vp, FREAD, td->td_ucred, td);
85762d615d5SJohn Baldwin 	VFS_UNLOCK_GIANT(vfslocked);
858a4f67738SDoug Rabson 
859a4f67738SDoug Rabson 	return error;
860a4f67738SDoug Rabson }
861a4f67738SDoug Rabson 
862a4f67738SDoug Rabson static void
863de78ca7eSPeter Wemm link_elf_unload_file(linker_file_t file)
864a4f67738SDoug Rabson {
865326e27d8SDoug Rabson 	elf_file_t ef = (elf_file_t) file;
86620947801SPeter Wemm 	int i;
867a4f67738SDoug Rabson 
8681aeb23cdSMarcel Moolenaar 	/* Notify MD code that a module is being unloaded. */
8691aeb23cdSMarcel Moolenaar 	elf_cpu_unload_file(file);
8701aeb23cdSMarcel Moolenaar 
87150c202c5SJeff Roberson 	if (ef->progtab) {
87250c202c5SJeff Roberson 		for (i = 0; i < ef->nprogtab; i++) {
87350c202c5SJeff Roberson 			if (ef->progtab[i].size == 0)
87450c202c5SJeff Roberson 				continue;
87550c202c5SJeff Roberson 			if (ef->progtab[i].name == NULL)
87650c202c5SJeff Roberson 				continue;
87750c202c5SJeff Roberson 			if (!strcmp(ef->progtab[i].name, "set_pcpu"))
87850c202c5SJeff Roberson 				dpcpu_free(ef->progtab[i].addr,
87950c202c5SJeff Roberson 				    ef->progtab[i].size);
88050c202c5SJeff Roberson 		}
88150c202c5SJeff Roberson 	}
88270b7ffeeSIan Dowse 	if (ef->preloaded) {
88370b7ffeeSIan Dowse 		if (ef->reltab)
88470b7ffeeSIan Dowse 			free(ef->reltab, M_LINKER);
88570b7ffeeSIan Dowse 		if (ef->relatab)
88670b7ffeeSIan Dowse 			free(ef->relatab, M_LINKER);
88770b7ffeeSIan Dowse 		if (ef->progtab)
88870b7ffeeSIan Dowse 			free(ef->progtab, M_LINKER);
889a2024a3eSJohn Birrell 		if (ef->ctftab)
890a2024a3eSJohn Birrell 			free(ef->ctftab, M_LINKER);
891a2024a3eSJohn Birrell 		if (ef->ctfoff)
892a2024a3eSJohn Birrell 			free(ef->ctfoff, M_LINKER);
893a2024a3eSJohn Birrell 		if (ef->typoff)
894a2024a3eSJohn Birrell 			free(ef->typoff, M_LINKER);
89570b7ffeeSIan Dowse 		if (file->filename != NULL)
89670b7ffeeSIan Dowse 			preload_delete_name(file->filename);
89770b7ffeeSIan Dowse 		/* XXX reclaim module memory? */
89870b7ffeeSIan Dowse 		return;
89970b7ffeeSIan Dowse 	}
90070b7ffeeSIan Dowse 
901b474c780SDavid E. O'Brien 	for (i = 0; i < ef->nreltab; i++)
90220947801SPeter Wemm 		if (ef->reltab[i].rel)
90320947801SPeter Wemm 			free(ef->reltab[i].rel, M_LINKER);
904b474c780SDavid E. O'Brien 	for (i = 0; i < ef->nrelatab; i++)
90520947801SPeter Wemm 		if (ef->relatab[i].rela)
90620947801SPeter Wemm 			free(ef->relatab[i].rela, M_LINKER);
90720947801SPeter Wemm 	if (ef->reltab)
90820947801SPeter Wemm 		free(ef->reltab, M_LINKER);
90920947801SPeter Wemm 	if (ef->relatab)
91020947801SPeter Wemm 		free(ef->relatab, M_LINKER);
91120947801SPeter Wemm 	if (ef->progtab)
91220947801SPeter Wemm 		free(ef->progtab, M_LINKER);
91320947801SPeter Wemm 
914fe3db7c7SDoug Rabson 	if (ef->object) {
915fe3db7c7SDoug Rabson 		vm_map_remove(kernel_map, (vm_offset_t) ef->address,
91620947801SPeter Wemm 		    (vm_offset_t) ef->address +
91720947801SPeter Wemm 		    (ef->object->size << PAGE_SHIFT));
918fe3db7c7SDoug Rabson 	}
919e9eabf59SPeter Wemm 	if (ef->e_shdr)
920e9eabf59SPeter Wemm 		free(ef->e_shdr, M_LINKER);
921e9eabf59SPeter Wemm 	if (ef->ddbsymtab)
922e9eabf59SPeter Wemm 		free(ef->ddbsymtab, M_LINKER);
923e9eabf59SPeter Wemm 	if (ef->ddbstrtab)
924e9eabf59SPeter Wemm 		free(ef->ddbstrtab, M_LINKER);
92520947801SPeter Wemm 	if (ef->shstrtab)
92620947801SPeter Wemm 		free(ef->shstrtab, M_LINKER);
927a2024a3eSJohn Birrell 	if (ef->ctftab)
928a2024a3eSJohn Birrell 		free(ef->ctftab, M_LINKER);
929a2024a3eSJohn Birrell 	if (ef->ctfoff)
930a2024a3eSJohn Birrell 		free(ef->ctfoff, M_LINKER);
931a2024a3eSJohn Birrell 	if (ef->typoff)
932a2024a3eSJohn Birrell 		free(ef->typoff, M_LINKER);
933de78ca7eSPeter Wemm }
934de78ca7eSPeter Wemm 
935fe3db7c7SDoug Rabson static const char *
936757686b1SMarcel Moolenaar symbol_name(elf_file_t ef, Elf_Size r_info)
937a4f67738SDoug Rabson {
938fe3db7c7SDoug Rabson 	const Elf_Sym *ref;
939a4f67738SDoug Rabson 
940aa855a59SPeter Wemm 	if (ELF_R_SYM(r_info)) {
941e9eabf59SPeter Wemm 		ref = ef->ddbsymtab + ELF_R_SYM(r_info);
942e9eabf59SPeter Wemm 		return ef->ddbstrtab + ref->st_name;
943fe3db7c7SDoug Rabson 	} else
944fe3db7c7SDoug Rabson 		return NULL;
945a4f67738SDoug Rabson }
946a4f67738SDoug Rabson 
947e9eabf59SPeter Wemm static Elf_Addr
948e9eabf59SPeter Wemm findbase(elf_file_t ef, int sec)
949e9eabf59SPeter Wemm {
950e9eabf59SPeter Wemm 	int i;
951e9eabf59SPeter Wemm 	Elf_Addr base = 0;
952e9eabf59SPeter Wemm 
953e9eabf59SPeter Wemm 	for (i = 0; i < ef->nprogtab; i++) {
954a8774e39SPeter Wemm 		if (sec == ef->progtab[i].sec) {
955e9eabf59SPeter Wemm 			base = (Elf_Addr)ef->progtab[i].addr;
956a8774e39SPeter Wemm 			break;
957e9eabf59SPeter Wemm 		}
958a8774e39SPeter Wemm 	}
959e9eabf59SPeter Wemm 	return base;
960e9eabf59SPeter Wemm }
961e9eabf59SPeter Wemm 
962a4f67738SDoug Rabson static int
963326e27d8SDoug Rabson relocate_file(elf_file_t ef)
964a4f67738SDoug Rabson {
965fe3db7c7SDoug Rabson 	const Elf_Rel *rellim;
966fe3db7c7SDoug Rabson 	const Elf_Rel *rel;
967fe3db7c7SDoug Rabson 	const Elf_Rela *relalim;
968fe3db7c7SDoug Rabson 	const Elf_Rela *rela;
969aa855a59SPeter Wemm 	const char *symname;
970e9eabf59SPeter Wemm 	const Elf_Sym *sym;
971e9eabf59SPeter Wemm 	int i;
972757686b1SMarcel Moolenaar 	Elf_Size symidx;
973e9eabf59SPeter Wemm 	Elf_Addr base;
974e9eabf59SPeter Wemm 
975a4f67738SDoug Rabson 
976fe3db7c7SDoug Rabson 	/* Perform relocations without addend if there are any: */
977b474c780SDavid E. O'Brien 	for (i = 0; i < ef->nreltab; i++) {
978e9eabf59SPeter Wemm 		rel = ef->reltab[i].rel;
97920947801SPeter Wemm 		if (rel == NULL)
98082d0d1a0SPeter Wemm 			panic("lost a reltab!");
98120947801SPeter Wemm 		rellim = rel + ef->reltab[i].nrel;
982e9eabf59SPeter Wemm 		base = findbase(ef, ef->reltab[i].sec);
983a8774e39SPeter Wemm 		if (base == 0)
984a8774e39SPeter Wemm 			panic("lost base for reltab");
98520947801SPeter Wemm 		for ( ; rel < rellim; rel++) {
986e9eabf59SPeter Wemm 			symidx = ELF_R_SYM(rel->r_info);
98720947801SPeter Wemm 			if (symidx >= ef->ddbsymcnt)
98820947801SPeter Wemm 				continue;
989e9eabf59SPeter Wemm 			sym = ef->ddbsymtab + symidx;
99020947801SPeter Wemm 			/* Local relocs are already done */
99120947801SPeter Wemm 			if (ELF_ST_BIND(sym->st_info) == STB_LOCAL)
99220947801SPeter Wemm 				continue;
99320947801SPeter Wemm 			if (elf_reloc(&ef->lf, base, rel, ELF_RELOC_REL,
99420947801SPeter Wemm 			    elf_obj_lookup)) {
995aa855a59SPeter Wemm 				symname = symbol_name(ef, rel->r_info);
99620947801SPeter Wemm 				printf("link_elf_obj: symbol %s undefined\n",
99720947801SPeter Wemm 				    symname);
998a4f67738SDoug Rabson 				return ENOENT;
999a13ddfb6SPeter Wemm 			}
1000aa855a59SPeter Wemm 		}
1001a4f67738SDoug Rabson 	}
1002a4f67738SDoug Rabson 
1003fe3db7c7SDoug Rabson 	/* Perform relocations with addend if there are any: */
1004b474c780SDavid E. O'Brien 	for (i = 0; i < ef->nrelatab; i++) {
1005e9eabf59SPeter Wemm 		rela = ef->relatab[i].rela;
100620947801SPeter Wemm 		if (rela == NULL)
100782d0d1a0SPeter Wemm 			panic("lost a relatab!");
100820947801SPeter Wemm 		relalim = rela + ef->relatab[i].nrela;
1009e9eabf59SPeter Wemm 		base = findbase(ef, ef->relatab[i].sec);
1010a8774e39SPeter Wemm 		if (base == 0)
1011a8774e39SPeter Wemm 			panic("lost base for relatab");
101220947801SPeter Wemm 		for ( ; rela < relalim; rela++) {
1013e9eabf59SPeter Wemm 			symidx = ELF_R_SYM(rela->r_info);
101420947801SPeter Wemm 			if (symidx >= ef->ddbsymcnt)
101520947801SPeter Wemm 				continue;
1016e9eabf59SPeter Wemm 			sym = ef->ddbsymtab + symidx;
101720947801SPeter Wemm 			/* Local relocs are already done */
101820947801SPeter Wemm 			if (ELF_ST_BIND(sym->st_info) == STB_LOCAL)
101920947801SPeter Wemm 				continue;
102020947801SPeter Wemm 			if (elf_reloc(&ef->lf, base, rela, ELF_RELOC_RELA,
102120947801SPeter Wemm 			    elf_obj_lookup)) {
1022aa855a59SPeter Wemm 				symname = symbol_name(ef, rela->r_info);
102320947801SPeter Wemm 				printf("link_elf_obj: symbol %s undefined\n",
102420947801SPeter Wemm 				    symname);
1025fe3db7c7SDoug Rabson 				return ENOENT;
1026a13ddfb6SPeter Wemm 			}
1027e9eabf59SPeter Wemm 		}
1028e9eabf59SPeter Wemm 	}
1029a4f67738SDoug Rabson 
1030a4f67738SDoug Rabson 	return 0;
1031a4f67738SDoug Rabson }
1032a4f67738SDoug Rabson 
103337c84183SPoul-Henning Kamp static int
1034d254af07SMatthew Dillon link_elf_lookup_symbol(linker_file_t lf, const char *name, c_linker_sym_t *sym)
1035a4f67738SDoug Rabson {
1036326e27d8SDoug Rabson 	elf_file_t ef = (elf_file_t) lf;
10372d636ab0SPeter Wemm 	const Elf_Sym *symp;
10382d636ab0SPeter Wemm 	const char *strp;
1039a4f67738SDoug Rabson 	int i;
1040a4f67738SDoug Rabson 
10412d636ab0SPeter Wemm 	for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) {
10422d636ab0SPeter Wemm 		strp = ef->ddbstrtab + symp->st_name;
1043a8774e39SPeter Wemm 		if (symp->st_shndx != SHN_UNDEF && strcmp(name, strp) == 0) {
1044d254af07SMatthew Dillon 			*sym = (c_linker_sym_t) symp;
10452d636ab0SPeter Wemm 			return 0;
10462d636ab0SPeter Wemm 		}
10472d636ab0SPeter Wemm 	}
1048a4f67738SDoug Rabson 	return ENOENT;
1049a4f67738SDoug Rabson }
1050a4f67738SDoug Rabson 
1051de78ca7eSPeter Wemm static int
105220947801SPeter Wemm link_elf_symbol_values(linker_file_t lf, c_linker_sym_t sym,
105320947801SPeter Wemm     linker_symval_t *symval)
1054a4f67738SDoug Rabson {
1055326e27d8SDoug Rabson 	elf_file_t ef = (elf_file_t) lf;
10568aef1712SMatthew Dillon 	const Elf_Sym *es = (const Elf_Sym*) sym;
1057a4f67738SDoug Rabson 
10585cf87418SMarcel Moolenaar 	if (es >= ef->ddbsymtab && es < (ef->ddbsymtab + ef->ddbsymcnt)) {
10592d636ab0SPeter Wemm 		symval->name = ef->ddbstrtab + es->st_name;
1060a8774e39SPeter Wemm 		symval->value = (caddr_t)es->st_value;
10612d636ab0SPeter Wemm 		symval->size = es->st_size;
10622d636ab0SPeter Wemm 		return 0;
10632d636ab0SPeter Wemm 	}
10642d636ab0SPeter Wemm 	return ENOENT;
10652d636ab0SPeter Wemm }
1066a4f67738SDoug Rabson 
1067a4f67738SDoug Rabson static int
1068a4f67738SDoug Rabson link_elf_search_symbol(linker_file_t lf, caddr_t value,
1069d254af07SMatthew Dillon     c_linker_sym_t *sym, long *diffp)
1070a4f67738SDoug Rabson {
1071326e27d8SDoug Rabson 	elf_file_t ef = (elf_file_t) lf;
1072586453feSBruce Evans 	u_long off = (uintptr_t) (void *) value;
1073a4f67738SDoug Rabson 	u_long diff = off;
1074586453feSBruce Evans 	u_long st_value;
1075fe3db7c7SDoug Rabson 	const Elf_Sym *es;
1076fe3db7c7SDoug Rabson 	const Elf_Sym *best = 0;
1077a4f67738SDoug Rabson 	int i;
1078a4f67738SDoug Rabson 
10792d636ab0SPeter Wemm 	for (i = 0, es = ef->ddbsymtab; i < ef->ddbsymcnt; i++, es++) {
1080a4f67738SDoug Rabson 		if (es->st_name == 0)
1081a4f67738SDoug Rabson 			continue;
1082a8774e39SPeter Wemm 		st_value = es->st_value;
1083b5abfb70SPeter Wemm 		if (off >= st_value) {
1084b5abfb70SPeter Wemm 			if (off - st_value < diff) {
1085b5abfb70SPeter Wemm 				diff = off - st_value;
1086a4f67738SDoug Rabson 				best = es;
1087a4f67738SDoug Rabson 				if (diff == 0)
1088a4f67738SDoug Rabson 					break;
1089b5abfb70SPeter Wemm 			} else if (off - st_value == diff) {
1090a4f67738SDoug Rabson 				best = es;
1091a4f67738SDoug Rabson 			}
1092a4f67738SDoug Rabson 		}
1093a4f67738SDoug Rabson 	}
1094a4f67738SDoug Rabson 	if (best == 0)
1095a4f67738SDoug Rabson 		*diffp = off;
1096a4f67738SDoug Rabson 	else
1097a4f67738SDoug Rabson 		*diffp = diff;
1098d254af07SMatthew Dillon 	*sym = (c_linker_sym_t) best;
1099a4f67738SDoug Rabson 
1100a4f67738SDoug Rabson 	return 0;
1101a4f67738SDoug Rabson }
1102f41325dbSPeter Wemm 
1103f41325dbSPeter Wemm /*
1104f41325dbSPeter Wemm  * Look up a linker set on an ELF system.
1105f41325dbSPeter Wemm  */
1106f41325dbSPeter Wemm static int
1107f41325dbSPeter Wemm link_elf_lookup_set(linker_file_t lf, const char *name,
1108f41325dbSPeter Wemm     void ***startp, void ***stopp, int *countp)
1109f41325dbSPeter Wemm {
1110e9eabf59SPeter Wemm 	elf_file_t ef = (elf_file_t)lf;
1111f41325dbSPeter Wemm 	void **start, **stop;
1112e9eabf59SPeter Wemm 	int i, count;
1113f41325dbSPeter Wemm 
1114e9eabf59SPeter Wemm 	/* Relative to section number */
1115e9eabf59SPeter Wemm 	for (i = 0; i < ef->nprogtab; i++) {
1116e9eabf59SPeter Wemm 		if ((strncmp(ef->progtab[i].name, "set_", 4) == 0) &&
1117e9eabf59SPeter Wemm 		    strcmp(ef->progtab[i].name + 4, name) == 0) {
1118e9eabf59SPeter Wemm 			start  = (void **)ef->progtab[i].addr;
111920947801SPeter Wemm 			stop = (void **)((char *)ef->progtab[i].addr +
112020947801SPeter Wemm 			    ef->progtab[i].size);
1121f41325dbSPeter Wemm 			count = stop - start;
1122f41325dbSPeter Wemm 			if (startp)
1123f41325dbSPeter Wemm 				*startp = start;
1124f41325dbSPeter Wemm 			if (stopp)
1125f41325dbSPeter Wemm 				*stopp = stop;
1126f41325dbSPeter Wemm 			if (countp)
1127f41325dbSPeter Wemm 				*countp = count;
1128e9eabf59SPeter Wemm 			return (0);
1129e9eabf59SPeter Wemm 		}
1130e9eabf59SPeter Wemm 	}
1131e9eabf59SPeter Wemm 	return (ESRCH);
1132f41325dbSPeter Wemm }
1133bb9fe9ddSBrian Feldman 
1134bb9fe9ddSBrian Feldman static int
1135bb9fe9ddSBrian Feldman link_elf_each_function_name(linker_file_t file,
1136e9eabf59SPeter Wemm     int (*callback)(const char *, void *), void *opaque)
1137e9eabf59SPeter Wemm {
1138bb9fe9ddSBrian Feldman 	elf_file_t ef = (elf_file_t)file;
1139bb9fe9ddSBrian Feldman 	const Elf_Sym *symp;
1140bb9fe9ddSBrian Feldman 	int i, error;
1141bb9fe9ddSBrian Feldman 
1142bb9fe9ddSBrian Feldman 	/* Exhaustive search */
1143bb9fe9ddSBrian Feldman 	for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) {
1144bb9fe9ddSBrian Feldman 		if (symp->st_value != 0 &&
1145bb9fe9ddSBrian Feldman 		    ELF_ST_TYPE(symp->st_info) == STT_FUNC) {
1146bb9fe9ddSBrian Feldman 			error = callback(ef->ddbstrtab + symp->st_name, opaque);
1147bb9fe9ddSBrian Feldman 			if (error)
1148bb9fe9ddSBrian Feldman 				return (error);
1149bb9fe9ddSBrian Feldman 		}
1150bb9fe9ddSBrian Feldman 	}
1151bb9fe9ddSBrian Feldman 	return (0);
1152bb9fe9ddSBrian Feldman }
115384201059SMarcel Moolenaar 
1154a2024a3eSJohn Birrell static int
1155a2024a3eSJohn Birrell link_elf_each_function_nameval(linker_file_t file,
1156a2024a3eSJohn Birrell     linker_function_nameval_callback_t callback, void *opaque)
1157a2024a3eSJohn Birrell {
1158a2024a3eSJohn Birrell 	linker_symval_t symval;
1159a2024a3eSJohn Birrell 	elf_file_t ef = (elf_file_t)file;
1160a2024a3eSJohn Birrell 	const Elf_Sym* symp;
1161a2024a3eSJohn Birrell 	int i, error;
1162a2024a3eSJohn Birrell 
1163a2024a3eSJohn Birrell 	/* Exhaustive search */
1164a2024a3eSJohn Birrell 	for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) {
1165a2024a3eSJohn Birrell 		if (symp->st_value != 0 &&
1166a2024a3eSJohn Birrell 		    ELF_ST_TYPE(symp->st_info) == STT_FUNC) {
1167a2024a3eSJohn Birrell 			error = link_elf_symbol_values(file, (c_linker_sym_t) symp, &symval);
1168a2024a3eSJohn Birrell 			if (error)
1169a2024a3eSJohn Birrell 				return (error);
1170a2024a3eSJohn Birrell 			error = callback(file, i, &symval, opaque);
1171a2024a3eSJohn Birrell 			if (error)
1172a2024a3eSJohn Birrell 				return (error);
1173a2024a3eSJohn Birrell 		}
1174a2024a3eSJohn Birrell 	}
1175a2024a3eSJohn Birrell 	return (0);
1176a2024a3eSJohn Birrell }
1177a2024a3eSJohn Birrell 
1178d297ad16SMarcel Moolenaar /*
1179d297ad16SMarcel Moolenaar  * Symbol lookup function that can be used when the symbol index is known (ie
1180d297ad16SMarcel Moolenaar  * in relocations). It uses the symbol index instead of doing a fully fledged
1181d297ad16SMarcel Moolenaar  * hash table based lookup when such is valid. For example for local symbols.
1182d297ad16SMarcel Moolenaar  * This is not only more efficient, it's also more correct. It's not always
1183d297ad16SMarcel Moolenaar  * the case that the symbol can be found through the hash table.
1184d297ad16SMarcel Moolenaar  */
1185e9eabf59SPeter Wemm static Elf_Addr
1186757686b1SMarcel Moolenaar elf_obj_lookup(linker_file_t lf, Elf_Size symidx, int deps)
1187d297ad16SMarcel Moolenaar {
1188d297ad16SMarcel Moolenaar 	elf_file_t ef = (elf_file_t)lf;
1189d297ad16SMarcel Moolenaar 	const Elf_Sym *sym;
1190d297ad16SMarcel Moolenaar 	const char *symbol;
1191e9eabf59SPeter Wemm 	Elf_Addr ret;
1192d297ad16SMarcel Moolenaar 
1193d297ad16SMarcel Moolenaar 	/* Don't even try to lookup the symbol if the index is bogus. */
1194e9eabf59SPeter Wemm 	if (symidx >= ef->ddbsymcnt)
1195d297ad16SMarcel Moolenaar 		return (0);
1196d297ad16SMarcel Moolenaar 
1197e9eabf59SPeter Wemm 	sym = ef->ddbsymtab + symidx;
1198d297ad16SMarcel Moolenaar 
11994cec6f5dSPeter Wemm 	/* Quick answer if there is a definition included. */
1200a8774e39SPeter Wemm 	if (sym->st_shndx != SHN_UNDEF)
1201a8774e39SPeter Wemm 		return (sym->st_value);
12024cec6f5dSPeter Wemm 
12034cec6f5dSPeter Wemm 	/* If we get here, then it is undefined and needs a lookup. */
12044cec6f5dSPeter Wemm 	switch (ELF_ST_BIND(sym->st_info)) {
12054cec6f5dSPeter Wemm 	case STB_LOCAL:
12064cec6f5dSPeter Wemm 		/* Local, but undefined? huh? */
12074cec6f5dSPeter Wemm 		return (0);
1208d297ad16SMarcel Moolenaar 
1209e9eabf59SPeter Wemm 	case STB_GLOBAL:
1210e9eabf59SPeter Wemm 		/* Relative to Data or Function name */
1211e9eabf59SPeter Wemm 		symbol = ef->ddbstrtab + sym->st_name;
1212d297ad16SMarcel Moolenaar 
1213d297ad16SMarcel Moolenaar 		/* Force a lookup failure if the symbol name is bogus. */
1214d297ad16SMarcel Moolenaar 		if (*symbol == 0)
1215d297ad16SMarcel Moolenaar 			return (0);
1216e9eabf59SPeter Wemm 		ret = ((Elf_Addr)linker_file_lookup_symbol(lf, symbol, deps));
1217e9eabf59SPeter Wemm 		return ret;
1218d297ad16SMarcel Moolenaar 
1219e9eabf59SPeter Wemm 	case STB_WEAK:
122020947801SPeter Wemm 		printf("link_elf_obj: Weak symbols not supported\n");
1221e9eabf59SPeter Wemm 		return (0);
1222e9eabf59SPeter Wemm 
1223e9eabf59SPeter Wemm 	default:
1224e9eabf59SPeter Wemm 		return (0);
1225d297ad16SMarcel Moolenaar 	}
1226e9eabf59SPeter Wemm }
1227e9eabf59SPeter Wemm 
12287251b4bfSJake Burkholder static void
12297226306eSKonstantin Belousov link_elf_fix_link_set(elf_file_t ef)
12307226306eSKonstantin Belousov {
12317226306eSKonstantin Belousov 	static const char startn[] = "__start_";
12327226306eSKonstantin Belousov 	static const char stopn[] = "__stop_";
12337226306eSKonstantin Belousov 	Elf_Sym *sym;
12347226306eSKonstantin Belousov 	const char *sym_name, *linkset_name;
12357226306eSKonstantin Belousov 	Elf_Addr startp, stopp;
12367226306eSKonstantin Belousov 	Elf_Size symidx;
12377226306eSKonstantin Belousov 	int start, i;
12387226306eSKonstantin Belousov 
12397226306eSKonstantin Belousov 	startp = stopp = 0;
12407226306eSKonstantin Belousov 	for (symidx = 1 /* zero entry is special */;
12417226306eSKonstantin Belousov 		symidx < ef->ddbsymcnt; symidx++) {
12427226306eSKonstantin Belousov 		sym = ef->ddbsymtab + symidx;
12437226306eSKonstantin Belousov 		if (sym->st_shndx != SHN_UNDEF)
12447226306eSKonstantin Belousov 			continue;
12457226306eSKonstantin Belousov 
12467226306eSKonstantin Belousov 		sym_name = ef->ddbstrtab + sym->st_name;
12477226306eSKonstantin Belousov 		if (strncmp(sym_name, startn, sizeof(startn) - 1) == 0) {
12487226306eSKonstantin Belousov 			start = 1;
12497226306eSKonstantin Belousov 			linkset_name = sym_name + sizeof(startn) - 1;
12507226306eSKonstantin Belousov 		}
12517226306eSKonstantin Belousov 		else if (strncmp(sym_name, stopn, sizeof(stopn) - 1) == 0) {
12527226306eSKonstantin Belousov 			start = 0;
12537226306eSKonstantin Belousov 			linkset_name = sym_name + sizeof(stopn) - 1;
12547226306eSKonstantin Belousov 		}
12557226306eSKonstantin Belousov 		else
12567226306eSKonstantin Belousov 			continue;
12577226306eSKonstantin Belousov 
12587226306eSKonstantin Belousov 		for (i = 0; i < ef->nprogtab; i++) {
12597226306eSKonstantin Belousov 			if (strcmp(ef->progtab[i].name, linkset_name) == 0) {
12607226306eSKonstantin Belousov 				startp = (Elf_Addr)ef->progtab[i].addr;
12617226306eSKonstantin Belousov 				stopp = (Elf_Addr)(startp + ef->progtab[i].size);
12627226306eSKonstantin Belousov 				break;
12637226306eSKonstantin Belousov 			}
12647226306eSKonstantin Belousov 		}
12657226306eSKonstantin Belousov 		if (i == ef->nprogtab)
12667226306eSKonstantin Belousov 			continue;
12677226306eSKonstantin Belousov 
12687226306eSKonstantin Belousov 		sym->st_value = start ? startp : stopp;
12697226306eSKonstantin Belousov 		sym->st_shndx = i;
12707226306eSKonstantin Belousov 	}
12717226306eSKonstantin Belousov }
12727226306eSKonstantin Belousov 
12737226306eSKonstantin Belousov static void
12747251b4bfSJake Burkholder link_elf_reloc_local(linker_file_t lf)
12757251b4bfSJake Burkholder {
1276e9eabf59SPeter Wemm 	elf_file_t ef = (elf_file_t)lf;
12777251b4bfSJake Burkholder 	const Elf_Rel *rellim;
12787251b4bfSJake Burkholder 	const Elf_Rel *rel;
12797251b4bfSJake Burkholder 	const Elf_Rela *relalim;
12807251b4bfSJake Burkholder 	const Elf_Rela *rela;
1281e9eabf59SPeter Wemm 	const Elf_Sym *sym;
1282e9eabf59SPeter Wemm 	Elf_Addr base;
1283e9eabf59SPeter Wemm 	int i;
1284757686b1SMarcel Moolenaar 	Elf_Size symidx;
1285e9eabf59SPeter Wemm 
12867226306eSKonstantin Belousov 	link_elf_fix_link_set(ef);
12877226306eSKonstantin Belousov 
12887251b4bfSJake Burkholder 	/* Perform relocations without addend if there are any: */
1289b474c780SDavid E. O'Brien 	for (i = 0; i < ef->nreltab; i++) {
1290e9eabf59SPeter Wemm 		rel = ef->reltab[i].rel;
129120947801SPeter Wemm 		if (rel == NULL)
129282d0d1a0SPeter Wemm 			panic("lost a reltab!");
129320947801SPeter Wemm 		rellim = rel + ef->reltab[i].nrel;
1294e9eabf59SPeter Wemm 		base = findbase(ef, ef->reltab[i].sec);
1295a8774e39SPeter Wemm 		if (base == 0)
1296a8774e39SPeter Wemm 			panic("lost base for reltab");
129720947801SPeter Wemm 		for ( ; rel < rellim; rel++) {
1298e9eabf59SPeter Wemm 			symidx = ELF_R_SYM(rel->r_info);
129920947801SPeter Wemm 			if (symidx >= ef->ddbsymcnt)
130020947801SPeter Wemm 				continue;
1301e9eabf59SPeter Wemm 			sym = ef->ddbsymtab + symidx;
130220947801SPeter Wemm 			/* Only do local relocs */
130320947801SPeter Wemm 			if (ELF_ST_BIND(sym->st_info) != STB_LOCAL)
130420947801SPeter Wemm 				continue;
130520947801SPeter Wemm 			elf_reloc_local(lf, base, rel, ELF_RELOC_REL,
130620947801SPeter Wemm 			    elf_obj_lookup);
13077251b4bfSJake Burkholder 		}
1308e9eabf59SPeter Wemm 	}
13097251b4bfSJake Burkholder 
13107251b4bfSJake Burkholder 	/* Perform relocations with addend if there are any: */
1311b474c780SDavid E. O'Brien 	for (i = 0; i < ef->nrelatab; i++) {
1312e9eabf59SPeter Wemm 		rela = ef->relatab[i].rela;
131320947801SPeter Wemm 		if (rela == NULL)
131482d0d1a0SPeter Wemm 			panic("lost a relatab!");
131520947801SPeter Wemm 		relalim = rela + ef->relatab[i].nrela;
1316e9eabf59SPeter Wemm 		base = findbase(ef, ef->relatab[i].sec);
1317a8774e39SPeter Wemm 		if (base == 0)
1318a8774e39SPeter Wemm 			panic("lost base for relatab");
131920947801SPeter Wemm 		for ( ; rela < relalim; rela++) {
1320e9eabf59SPeter Wemm 			symidx = ELF_R_SYM(rela->r_info);
132120947801SPeter Wemm 			if (symidx >= ef->ddbsymcnt)
132220947801SPeter Wemm 				continue;
1323e9eabf59SPeter Wemm 			sym = ef->ddbsymtab + symidx;
132420947801SPeter Wemm 			/* Only do local relocs */
132520947801SPeter Wemm 			if (ELF_ST_BIND(sym->st_info) != STB_LOCAL)
132620947801SPeter Wemm 				continue;
132720947801SPeter Wemm 			elf_reloc_local(lf, base, rela, ELF_RELOC_RELA,
132820947801SPeter Wemm 			    elf_obj_lookup);
13297251b4bfSJake Burkholder 		}
13307251b4bfSJake Burkholder 	}
1331e9eabf59SPeter Wemm }
133200a5db46SStacey Son 
133300a5db46SStacey Son static long
1334e76f11f4SAndriy Gapon link_elf_symtab_get(linker_file_t lf, const Elf_Sym **symtab)
133500a5db46SStacey Son {
133600a5db46SStacey Son     elf_file_t ef = (elf_file_t)lf;
133700a5db46SStacey Son 
133800a5db46SStacey Son     *symtab = ef->ddbsymtab;
133900a5db46SStacey Son 
134000a5db46SStacey Son     if (*symtab == NULL)
134100a5db46SStacey Son         return (0);
134200a5db46SStacey Son 
134300a5db46SStacey Son     return (ef->ddbsymcnt);
134400a5db46SStacey Son }
134500a5db46SStacey Son 
134600a5db46SStacey Son static long
134700a5db46SStacey Son link_elf_strtab_get(linker_file_t lf, caddr_t *strtab)
134800a5db46SStacey Son {
134900a5db46SStacey Son     elf_file_t ef = (elf_file_t)lf;
135000a5db46SStacey Son 
135100a5db46SStacey Son     *strtab = ef->ddbstrtab;
135200a5db46SStacey Son 
135300a5db46SStacey Son     if (*strtab == NULL)
135400a5db46SStacey Son         return (0);
135500a5db46SStacey Son 
135600a5db46SStacey Son     return (ef->ddbstrcnt);
135700a5db46SStacey Son }
1358