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