link_elf.c revision 85735 
1/*-
2 * Copyright (c) 1998-2000 Doug Rabson
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 *
26 * $FreeBSD: head/sys/kern/link_elf.c 85735 2001-10-30 15:10:16Z green $
27 */
28
29#include "opt_ddb.h"
30
31#include <sys/param.h>
32#include <sys/systm.h>
33#include <sys/kernel.h>
34#include <sys/lock.h>
35#include <sys/malloc.h>
36#include <sys/mutex.h>
37#include <sys/proc.h>
38#include <sys/namei.h>
39#include <sys/fcntl.h>
40#include <sys/vnode.h>
41#include <sys/linker.h>
42
43#include <machine/elf.h>
44#ifdef GPROF
45#include <machine/profile.h>
46#endif
47
48#include <vm/vm.h>
49#include <vm/vm_param.h>
50#ifdef SPARSE_MAPPING
51#include <vm/vm_object.h>
52#include <vm/vm_kern.h>
53#include <vm/vm_extern.h>
54#endif
55#include <vm/pmap.h>
56#include <vm/vm_map.h>
57
58#ifdef __AOUT__
59#include <nlist.h>
60#endif
61#include <link.h>
62
63#include "linker_if.h"
64
65typedef struct elf_file {
66    struct linker_file	lf;		/* Common fields */
67    int			preloaded;	/* Was file pre-loaded */
68    caddr_t		address;	/* Relocation address */
69#ifdef SPARSE_MAPPING
70    vm_object_t		object;		/* VM object to hold file pages */
71#endif
72    Elf_Dyn*		dynamic;	/* Symbol table etc. */
73    Elf_Hashelt		nbuckets;	/* DT_HASH info */
74    Elf_Hashelt		nchains;
75    const Elf_Hashelt*	buckets;
76    const Elf_Hashelt*	chains;
77    caddr_t		hash;
78    caddr_t		strtab;		/* DT_STRTAB */
79    int			strsz;		/* DT_STRSZ */
80    const Elf_Sym*	symtab;		/* DT_SYMTAB */
81    Elf_Addr*		got;		/* DT_PLTGOT */
82    const Elf_Rel*	pltrel;		/* DT_JMPREL */
83    int			pltrelsize;	/* DT_PLTRELSZ */
84    const Elf_Rela*	pltrela;	/* DT_JMPREL */
85    int			pltrelasize;	/* DT_PLTRELSZ */
86    const Elf_Rel*	rel;		/* DT_REL */
87    int			relsize;	/* DT_RELSZ */
88    const Elf_Rela*	rela;		/* DT_RELA */
89    int			relasize;	/* DT_RELASZ */
90    caddr_t		modptr;
91    const Elf_Sym*	ddbsymtab;	/* The symbol table we are using */
92    long		ddbsymcnt;	/* Number of symbols */
93    caddr_t		ddbstrtab;	/* String table */
94    long		ddbstrcnt;	/* number of bytes in string table */
95    caddr_t		symbase;	/* malloc'ed symbold base */
96    caddr_t		strbase;	/* malloc'ed string base */
97#ifdef DDB
98    struct link_map	gdb;		/* hooks for gdb */
99#endif
100} *elf_file_t;
101
102static int	link_elf_link_preload(linker_class_t cls,
103				      const char*, linker_file_t*);
104static int	link_elf_link_preload_finish(linker_file_t);
105static int	link_elf_load_file(linker_class_t, const char*, linker_file_t*);
106static int	link_elf_lookup_symbol(linker_file_t, const char*,
107				       c_linker_sym_t*);
108static int	link_elf_symbol_values(linker_file_t, c_linker_sym_t, linker_symval_t*);
109static int	link_elf_search_symbol(linker_file_t, caddr_t value,
110				       c_linker_sym_t* sym, long* diffp);
111
112static void	link_elf_unload_file(linker_file_t);
113static void	link_elf_unload_preload(linker_file_t);
114static int	link_elf_lookup_set(linker_file_t, const char *,
115				    void ***, void ***, int *);
116
117static kobj_method_t link_elf_methods[] = {
118    KOBJMETHOD(linker_lookup_symbol,	link_elf_lookup_symbol),
119    KOBJMETHOD(linker_symbol_values,	link_elf_symbol_values),
120    KOBJMETHOD(linker_search_symbol,	link_elf_search_symbol),
121    KOBJMETHOD(linker_unload,		link_elf_unload_file),
122    KOBJMETHOD(linker_load_file,	link_elf_load_file),
123    KOBJMETHOD(linker_link_preload,	link_elf_link_preload),
124    KOBJMETHOD(linker_link_preload_finish, link_elf_link_preload_finish),
125    KOBJMETHOD(linker_lookup_set,	link_elf_lookup_set),
126    { 0, 0 }
127};
128
129static struct linker_class link_elf_class = {
130#if ELF_TARG_CLASS == ELFCLASS32
131    "elf32",
132#else
133    "elf64",
134#endif
135    link_elf_methods, sizeof(struct elf_file)
136};
137
138static int		parse_dynamic(elf_file_t ef);
139static int		relocate_file(elf_file_t ef);
140static int		link_elf_preload_parse_symbols(elf_file_t ef);
141
142#ifdef DDB
143static void		r_debug_state(struct r_debug *dummy_one,
144				      struct link_map *dummy_two);
145
146/*
147 * A list of loaded modules for GDB to use for loading symbols.
148 */
149struct r_debug r_debug;
150
151#define GDB_STATE(s)	r_debug.r_state = s; r_debug_state(NULL, NULL);
152
153/*
154 * Function for the debugger to set a breakpoint on to gain control.
155 */
156void
157r_debug_state(struct r_debug *dummy_one __unused,
158	      struct link_map *dummy_two __unused)
159{
160}
161
162#endif
163
164/*
165 * The kernel symbol table starts here.
166 */
167extern struct _dynamic _DYNAMIC;
168
169static void
170link_elf_init(void* arg)
171{
172#ifdef __ELF__
173    Elf_Dyn	*dp;
174    caddr_t	modptr, baseptr, sizeptr;
175    elf_file_t	ef;
176    char	*modname;
177#ifdef DDB
178    char *newfilename;
179#endif
180#endif
181
182    linker_add_class(&link_elf_class);
183
184#ifdef __ELF__
185    dp = (Elf_Dyn*) &_DYNAMIC;
186    modname = NULL;
187    modptr = preload_search_by_type("elf kernel");
188    if (modptr)
189	modname = (char *)preload_search_info(modptr, MODINFO_NAME);
190    if (modname == NULL)
191	modname = "kernel";
192    linker_kernel_file = linker_make_file(modname, &link_elf_class);
193    if (linker_kernel_file == NULL)
194	panic("link_elf_init: Can't create linker structures for kernel");
195
196    ef = (elf_file_t) linker_kernel_file;
197    ef->preloaded = 1;
198    ef->address = 0;
199#ifdef SPARSE_MAPPING
200    ef->object = 0;
201#endif
202    ef->dynamic = dp;
203
204    if (dp)
205	parse_dynamic(ef);
206    linker_kernel_file->address = (caddr_t) KERNBASE;
207    linker_kernel_file->size = -(intptr_t)linker_kernel_file->address;
208
209    if (modptr) {
210	ef->modptr = modptr;
211	baseptr = preload_search_info(modptr, MODINFO_ADDR);
212	if (baseptr)
213	    linker_kernel_file->address = *(caddr_t *)baseptr;
214	sizeptr = preload_search_info(modptr, MODINFO_SIZE);
215	if (sizeptr)
216	    linker_kernel_file->size = *(size_t *)sizeptr;
217    }
218    (void)link_elf_preload_parse_symbols(ef);
219
220#ifdef DDB
221    ef->gdb.l_addr = linker_kernel_file->address;
222    newfilename = malloc(strlen(modname) + 1, M_LINKER, M_WAITOK);
223    strcpy(newfilename, modname);
224    ef->gdb.l_name = newfilename;
225    ef->gdb.l_ld = dp;
226    ef->gdb.l_prev = 0;
227    ef->gdb.l_next = 0;
228
229    r_debug.r_map = &ef->gdb;
230    r_debug.r_brk = r_debug_state;
231    r_debug.r_state = RT_CONSISTENT;
232
233    r_debug_state(NULL, NULL);	/* say hello to gdb! */
234#endif
235
236#endif
237}
238
239SYSINIT(link_elf, SI_SUB_KLD, SI_ORDER_SECOND, link_elf_init, 0);
240
241static int
242link_elf_preload_parse_symbols(elf_file_t ef)
243{
244    caddr_t	pointer;
245    caddr_t	ssym, esym, base;
246    caddr_t	strtab;
247    int		strcnt;
248    Elf_Sym*	symtab;
249    int		symcnt;
250
251    if (ef->modptr == NULL)
252	return 0;
253    pointer = preload_search_info(ef->modptr, MODINFO_METADATA|MODINFOMD_SSYM);
254    if (pointer == NULL)
255	return 0;
256    ssym = *(caddr_t *)pointer;
257    pointer = preload_search_info(ef->modptr, MODINFO_METADATA|MODINFOMD_ESYM);
258    if (pointer == NULL)
259	return 0;
260    esym = *(caddr_t *)pointer;
261
262    base = ssym;
263
264    symcnt = *(long *)base;
265    base += sizeof(long);
266    symtab = (Elf_Sym *)base;
267    base += roundup(symcnt, sizeof(long));
268
269    if (base > esym || base < ssym) {
270	printf("Symbols are corrupt!\n");
271	return EINVAL;
272    }
273
274    strcnt = *(long *)base;
275    base += sizeof(long);
276    strtab = base;
277    base += roundup(strcnt, sizeof(long));
278
279    if (base > esym || base < ssym) {
280	printf("Symbols are corrupt!\n");
281	return EINVAL;
282    }
283
284    ef->ddbsymtab = symtab;
285    ef->ddbsymcnt = symcnt / sizeof(Elf_Sym);
286    ef->ddbstrtab = strtab;
287    ef->ddbstrcnt = strcnt;
288
289    return 0;
290}
291
292static int
293parse_dynamic(elf_file_t ef)
294{
295    Elf_Dyn *dp;
296    int plttype = DT_REL;
297
298    for (dp = ef->dynamic; dp->d_tag != DT_NULL; dp++) {
299	switch (dp->d_tag) {
300	case DT_HASH:
301	{
302	    /* From src/libexec/rtld-elf/rtld.c */
303	    const Elf_Hashelt *hashtab = (const Elf_Hashelt *)
304		(ef->address + dp->d_un.d_ptr);
305	    ef->nbuckets = hashtab[0];
306	    ef->nchains = hashtab[1];
307	    ef->buckets = hashtab + 2;
308	    ef->chains = ef->buckets + ef->nbuckets;
309	    break;
310	}
311	case DT_STRTAB:
312	    ef->strtab = (caddr_t) (ef->address + dp->d_un.d_ptr);
313	    break;
314	case DT_STRSZ:
315	    ef->strsz = dp->d_un.d_val;
316	    break;
317	case DT_SYMTAB:
318	    ef->symtab = (Elf_Sym*) (ef->address + dp->d_un.d_ptr);
319	    break;
320	case DT_SYMENT:
321	    if (dp->d_un.d_val != sizeof(Elf_Sym))
322		return ENOEXEC;
323	    break;
324	case DT_PLTGOT:
325	    ef->got = (Elf_Addr *) (ef->address + dp->d_un.d_ptr);
326	    break;
327	case DT_REL:
328	    ef->rel = (const Elf_Rel *) (ef->address + dp->d_un.d_ptr);
329	    break;
330	case DT_RELSZ:
331	    ef->relsize = dp->d_un.d_val;
332	    break;
333	case DT_RELENT:
334	    if (dp->d_un.d_val != sizeof(Elf_Rel))
335		return ENOEXEC;
336	    break;
337	case DT_JMPREL:
338	    ef->pltrel = (const Elf_Rel *) (ef->address + dp->d_un.d_ptr);
339	    break;
340	case DT_PLTRELSZ:
341	    ef->pltrelsize = dp->d_un.d_val;
342	    break;
343	case DT_RELA:
344	    ef->rela = (const Elf_Rela *) (ef->address + dp->d_un.d_ptr);
345	    break;
346	case DT_RELASZ:
347	    ef->relasize = dp->d_un.d_val;
348	    break;
349	case DT_RELAENT:
350	    if (dp->d_un.d_val != sizeof(Elf_Rela))
351		return ENOEXEC;
352	    break;
353	case DT_PLTREL:
354	    plttype = dp->d_un.d_val;
355	    if (plttype != DT_REL && plttype != DT_RELA)
356		return ENOEXEC;
357	    break;
358#ifdef DDB
359	case DT_DEBUG:
360	    dp->d_un.d_ptr = (Elf_Addr) &r_debug;
361	    break;
362#endif
363	}
364    }
365
366    if (plttype == DT_RELA) {
367	ef->pltrela = (const Elf_Rela *) ef->pltrel;
368	ef->pltrel = NULL;
369	ef->pltrelasize = ef->pltrelsize;
370	ef->pltrelsize = 0;
371    }
372
373    ef->ddbsymtab = ef->symtab;
374    ef->ddbsymcnt = ef->nchains;
375    ef->ddbstrtab = ef->strtab;
376    ef->ddbstrcnt = ef->strsz;
377
378    return 0;
379}
380
381static void
382link_elf_error(const char *s)
383{
384    printf("kldload: %s\n", s);
385}
386
387#ifdef DDB
388
389static void
390link_elf_add_gdb(struct link_map *l)
391{
392    struct link_map *prev;
393
394    /*
395     * Scan to the end of the list.
396     */
397    for (prev = r_debug.r_map; prev->l_next != NULL; prev = prev->l_next)
398	;
399
400    /* Link in the new entry. */
401    l->l_prev = prev;
402    l->l_next = prev->l_next;
403    prev->l_next = l;
404}
405
406static void
407link_elf_delete_gdb(struct link_map *l)
408{
409    if (l->l_prev == NULL) {
410	if ((r_debug.r_map = l->l_next) != NULL)
411	    l->l_next->l_prev = NULL;
412	return;
413    }
414
415    if ((l->l_prev->l_next = l->l_next) != NULL)
416	l->l_next->l_prev = l->l_prev;
417}
418
419#endif /* DDB */
420
421static int
422link_elf_link_preload(linker_class_t cls,
423		      const char* filename, linker_file_t *result)
424{
425    caddr_t		modptr, baseptr, sizeptr, dynptr;
426    char		*type;
427    elf_file_t		ef;
428    linker_file_t	lf;
429    int			error;
430    vm_offset_t		dp;
431
432    /* Look to see if we have the file preloaded */
433    modptr = preload_search_by_name(filename);
434    if (modptr == NULL)
435	return ENOENT;
436
437    type = (char *)preload_search_info(modptr, MODINFO_TYPE);
438    baseptr = preload_search_info(modptr, MODINFO_ADDR);
439    sizeptr = preload_search_info(modptr, MODINFO_SIZE);
440    dynptr = preload_search_info(modptr, MODINFO_METADATA|MODINFOMD_DYNAMIC);
441    if (type == NULL || strcmp(type, "elf module") != 0)
442	return (EFTYPE);
443    if (baseptr == NULL || sizeptr == NULL || dynptr == NULL)
444	return (EINVAL);
445
446    lf = linker_make_file(filename, &link_elf_class);
447    if (lf == NULL) {
448	return ENOMEM;
449    }
450
451    ef = (elf_file_t) lf;
452    ef->preloaded = 1;
453    ef->modptr = modptr;
454    ef->address = *(caddr_t *)baseptr;
455#ifdef SPARSE_MAPPING
456    ef->object = 0;
457#endif
458    dp = (vm_offset_t)ef->address + *(vm_offset_t *)dynptr;
459    ef->dynamic = (Elf_Dyn *)dp;
460    lf->address = ef->address;
461    lf->size = *(size_t *)sizeptr;
462
463    error = parse_dynamic(ef);
464    if (error) {
465	linker_file_unload(lf);
466	return error;
467    }
468    *result = lf;
469    return (0);
470}
471
472static int
473link_elf_link_preload_finish(linker_file_t lf)
474{
475    elf_file_t		ef;
476    int error;
477#ifdef DDB
478    char *newfilename;
479#endif
480
481    ef = (elf_file_t) lf;
482#if 0	/* this will be more trouble than it's worth for now */
483    for (dp = ef->dynamic; dp->d_tag != DT_NULL; dp++) {
484	if (dp->d_tag != DT_NEEDED)
485	    continue;
486	modname = ef->strtab + dp->d_un.d_val;
487	error = linker_load_module(modname, lf);
488	if (error)
489	    goto out;
490    }
491#endif
492    error = relocate_file(ef);
493    if (error)
494	return error;
495    (void)link_elf_preload_parse_symbols(ef);
496
497#ifdef DDB
498    GDB_STATE(RT_ADD);
499    ef->gdb.l_addr = lf->address;
500    newfilename = malloc(strlen(lf->filename) + 1, M_LINKER, M_WAITOK);
501    strcpy(newfilename, lf->filename);
502    ef->gdb.l_name = newfilename;
503    ef->gdb.l_ld = ef->dynamic;
504    link_elf_add_gdb(&ef->gdb);
505    GDB_STATE(RT_CONSISTENT);
506#endif
507
508    return (0);
509}
510
511static int
512link_elf_load_file(linker_class_t cls, const char* filename, linker_file_t* result)
513{
514    struct nameidata nd;
515    struct thread* td = curthread;	/* XXX */
516    struct proc* p = td->td_proc;	/* XXX */
517    Elf_Ehdr *hdr;
518    caddr_t firstpage;
519    int nbytes, i;
520    Elf_Phdr *phdr;
521    Elf_Phdr *phlimit;
522    Elf_Phdr *segs[2];
523    int nsegs;
524    Elf_Phdr *phdyn;
525    Elf_Phdr *phphdr;
526    caddr_t mapbase;
527    size_t mapsize;
528    Elf_Off base_offset;
529    Elf_Addr base_vaddr;
530    Elf_Addr base_vlimit;
531    int error = 0;
532    int resid, flags;
533    elf_file_t ef;
534    linker_file_t lf;
535    Elf_Shdr *shdr;
536    int symtabindex;
537    int symstrindex;
538    int symcnt;
539    int strcnt;
540#ifdef DDB
541    char *newfilename;
542#endif
543
544    GIANT_REQUIRED;
545
546    shdr = NULL;
547    lf = NULL;
548
549    NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, filename, td);
550    flags = FREAD;
551    error = vn_open(&nd, &flags, 0);
552    if (error)
553	return error;
554    NDFREE(&nd, NDF_ONLY_PNBUF);
555
556    /*
557     * Read the elf header from the file.
558     */
559    firstpage = malloc(PAGE_SIZE, M_LINKER, M_WAITOK);
560    if (firstpage == NULL) {
561	error = ENOMEM;
562	goto out;
563    }
564    hdr = (Elf_Ehdr *)firstpage;
565    error = vn_rdwr(UIO_READ, nd.ni_vp, firstpage, PAGE_SIZE, 0,
566		    UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, td);
567    nbytes = PAGE_SIZE - resid;
568    if (error)
569	goto out;
570
571    if (!IS_ELF(*hdr)) {
572	error = ENOEXEC;
573	goto out;
574    }
575
576    if (hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS
577      || hdr->e_ident[EI_DATA] != ELF_TARG_DATA) {
578	link_elf_error("Unsupported file layout");
579	error = ENOEXEC;
580	goto out;
581    }
582    if (hdr->e_ident[EI_VERSION] != EV_CURRENT
583      || hdr->e_version != EV_CURRENT) {
584	link_elf_error("Unsupported file version");
585	error = ENOEXEC;
586	goto out;
587    }
588    if (hdr->e_type != ET_EXEC && hdr->e_type != ET_DYN) {
589	link_elf_error("Unsupported file type");
590	error = ENOEXEC;
591	goto out;
592    }
593    if (hdr->e_machine != ELF_TARG_MACH) {
594	link_elf_error("Unsupported machine");
595	error = ENOEXEC;
596	goto out;
597    }
598
599    /*
600     * We rely on the program header being in the first page.  This is
601     * not strictly required by the ABI specification, but it seems to
602     * always true in practice.  And, it simplifies things considerably.
603     */
604    if (!((hdr->e_phentsize == sizeof(Elf_Phdr)) &&
605	  (hdr->e_phoff + hdr->e_phnum*sizeof(Elf_Phdr) <= PAGE_SIZE) &&
606	  (hdr->e_phoff + hdr->e_phnum*sizeof(Elf_Phdr) <= nbytes)))
607	link_elf_error("Unreadable program headers");
608
609    /*
610     * Scan the program header entries, and save key information.
611     *
612     * We rely on there being exactly two load segments, text and data,
613     * in that order.
614     */
615    phdr = (Elf_Phdr *) (firstpage + hdr->e_phoff);
616    phlimit = phdr + hdr->e_phnum;
617    nsegs = 0;
618    phdyn = NULL;
619    phphdr = NULL;
620    while (phdr < phlimit) {
621	switch (phdr->p_type) {
622
623	case PT_LOAD:
624	    if (nsegs == 2) {
625		link_elf_error("Too many sections");
626		error = ENOEXEC;
627		goto out;
628	    }
629	    segs[nsegs] = phdr;
630	    ++nsegs;
631	    break;
632
633	case PT_PHDR:
634	    phphdr = phdr;
635	    break;
636
637	case PT_DYNAMIC:
638	    phdyn = phdr;
639	    break;
640
641	case PT_INTERP:
642	    link_elf_error("Unsupported file type");
643	    error = ENOEXEC;
644	    goto out;
645	}
646
647	++phdr;
648    }
649    if (phdyn == NULL) {
650	link_elf_error("Object is not dynamically-linked");
651	error = ENOEXEC;
652	goto out;
653    }
654
655    /*
656     * Allocate the entire address space of the object, to stake out our
657     * contiguous region, and to establish the base address for relocation.
658     */
659    base_offset = trunc_page(segs[0]->p_offset);
660    base_vaddr = trunc_page(segs[0]->p_vaddr);
661    base_vlimit = round_page(segs[1]->p_vaddr + segs[1]->p_memsz);
662    mapsize = base_vlimit - base_vaddr;
663
664    lf = linker_make_file(filename, &link_elf_class);
665    if (!lf) {
666	error = ENOMEM;
667	goto out;
668    }
669
670    ef = (elf_file_t) lf;
671#ifdef SPARSE_MAPPING
672    ef->object = vm_object_allocate(OBJT_DEFAULT, mapsize >> PAGE_SHIFT);
673    if (ef->object == NULL) {
674	free(ef, M_LINKER);
675	error = ENOMEM;
676	goto out;
677    }
678    vm_object_reference(ef->object);
679    ef->address = (caddr_t) vm_map_min(kernel_map);
680    error = vm_map_find(kernel_map, ef->object, 0,
681			(vm_offset_t *) &ef->address,
682			mapsize, 1,
683			VM_PROT_ALL, VM_PROT_ALL, 0);
684    if (error) {
685	vm_object_deallocate(ef->object);
686	ef->object = 0;
687	goto out;
688    }
689#else
690    ef->address = malloc(mapsize, M_LINKER, M_WAITOK);
691    if (!ef->address) {
692	error = ENOMEM;
693	goto out;
694    }
695#endif
696    mapbase = ef->address;
697
698    /*
699     * Read the text and data sections and zero the bss.
700     */
701    for (i = 0; i < 2; i++) {
702	caddr_t segbase = mapbase + segs[i]->p_vaddr - base_vaddr;
703	error = vn_rdwr(UIO_READ, nd.ni_vp,
704			segbase, segs[i]->p_filesz, segs[i]->p_offset,
705			UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, td);
706	if (error) {
707	    goto out;
708	}
709	bzero(segbase + segs[i]->p_filesz,
710	      segs[i]->p_memsz - segs[i]->p_filesz);
711
712#ifdef SPARSE_MAPPING
713	/*
714	 * Wire down the pages
715	 */
716	vm_map_pageable(kernel_map,
717			(vm_offset_t) segbase,
718			(vm_offset_t) segbase + segs[i]->p_memsz,
719			FALSE);
720#endif
721    }
722
723#ifdef GPROF
724    /* Update profiling information with the new text segment. */
725    kmupetext((uintfptr_t)(mapbase + segs[0]->p_vaddr - base_vaddr +
726	segs[0]->p_memsz));
727#endif
728
729    ef->dynamic = (Elf_Dyn *) (mapbase + phdyn->p_vaddr - base_vaddr);
730
731    lf->address = ef->address;
732    lf->size = mapsize;
733
734    error = parse_dynamic(ef);
735    if (error)
736	goto out;
737    error = linker_load_dependancies(lf);
738    if (error)
739	goto out;
740#if 0	/* this will be more trouble than it's worth for now */
741    for (dp = ef->dynamic; dp->d_tag != DT_NULL; dp++) {
742	if (dp->d_tag != DT_NEEDED)
743	    continue;
744	modname = ef->strtab + dp->d_un.d_val;
745	error = linker_load_module(modname, lf);
746	if (error)
747	    goto out;
748    }
749#endif
750    error = relocate_file(ef);
751    if (error)
752	goto out;
753
754    /* Try and load the symbol table if it's present.  (you can strip it!) */
755    nbytes = hdr->e_shnum * hdr->e_shentsize;
756    if (nbytes == 0 || hdr->e_shoff == 0)
757	goto nosyms;
758    shdr = malloc(nbytes, M_LINKER, M_WAITOK | M_ZERO);
759    if (shdr == NULL) {
760	error = ENOMEM;
761	goto out;
762    }
763    error = vn_rdwr(UIO_READ, nd.ni_vp,
764		    (caddr_t)shdr, nbytes, hdr->e_shoff,
765		    UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, td);
766    if (error)
767	goto out;
768    symtabindex = -1;
769    symstrindex = -1;
770    for (i = 0; i < hdr->e_shnum; i++) {
771	if (shdr[i].sh_type == SHT_SYMTAB) {
772	    symtabindex = i;
773	    symstrindex = shdr[i].sh_link;
774	}
775    }
776    if (symtabindex < 0 || symstrindex < 0)
777	goto nosyms;
778
779    symcnt = shdr[symtabindex].sh_size;
780    ef->symbase = malloc(symcnt, M_LINKER, M_WAITOK);
781    strcnt = shdr[symstrindex].sh_size;
782    ef->strbase = malloc(strcnt, M_LINKER, M_WAITOK);
783
784    if (ef->symbase == NULL || ef->strbase == NULL) {
785	error = ENOMEM;
786	goto out;
787    }
788    error = vn_rdwr(UIO_READ, nd.ni_vp,
789		    ef->symbase, symcnt, shdr[symtabindex].sh_offset,
790		    UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, td);
791    if (error)
792	goto out;
793    error = vn_rdwr(UIO_READ, nd.ni_vp,
794		    ef->strbase, strcnt, shdr[symstrindex].sh_offset,
795		    UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, td);
796    if (error)
797	goto out;
798
799    ef->ddbsymcnt = symcnt / sizeof(Elf_Sym);
800    ef->ddbsymtab = (const Elf_Sym *)ef->symbase;
801    ef->ddbstrcnt = strcnt;
802    ef->ddbstrtab = ef->strbase;
803
804#ifdef DDB
805    GDB_STATE(RT_ADD);
806    ef->gdb.l_addr = lf->address;
807    newfilename = malloc(strlen(filename) + 1, M_LINKER, M_WAITOK);
808    strcpy(newfilename, filename);
809    ef->gdb.l_name = (const char *)newfilename;
810    ef->gdb.l_ld = ef->dynamic;
811    link_elf_add_gdb(&ef->gdb);
812    GDB_STATE(RT_CONSISTENT);
813#endif
814
815nosyms:
816
817    *result = lf;
818
819out:
820    if (error && lf)
821	linker_file_unload(lf);
822    if (shdr)
823	free(shdr, M_LINKER);
824    if (firstpage)
825	free(firstpage, M_LINKER);
826    VOP_UNLOCK(nd.ni_vp, 0, td);
827    vn_close(nd.ni_vp, FREAD, p->p_ucred, td);
828
829    return error;
830}
831
832static void
833link_elf_unload_file(linker_file_t file)
834{
835    elf_file_t ef = (elf_file_t) file;
836
837#ifdef DDB
838    if (ef->gdb.l_ld) {
839	GDB_STATE(RT_DELETE);
840	free((void *)(uintptr_t)ef->gdb.l_name, M_LINKER);
841	link_elf_delete_gdb(&ef->gdb);
842	GDB_STATE(RT_CONSISTENT);
843    }
844#endif
845
846    if (ef->preloaded) {
847	link_elf_unload_preload(file);
848	return;
849    }
850#ifdef SPARSE_MAPPING
851    if (ef->object) {
852	vm_map_remove(kernel_map, (vm_offset_t) ef->address,
853		      (vm_offset_t) ef->address
854		      + (ef->object->size << PAGE_SHIFT));
855	vm_object_deallocate(ef->object);
856    }
857#else
858    if (ef->address)
859	free(ef->address, M_LINKER);
860#endif
861    if (ef->symbase)
862	free(ef->symbase, M_LINKER);
863    if (ef->strbase)
864	free(ef->strbase, M_LINKER);
865}
866
867static void
868link_elf_unload_preload(linker_file_t file)
869{
870    if (file->filename)
871	preload_delete_name(file->filename);
872}
873
874static const char *
875symbol_name(elf_file_t ef, Elf_Word r_info)
876{
877    const Elf_Sym *ref;
878
879    if (ELF_R_SYM(r_info)) {
880	ref = ef->symtab + ELF_R_SYM(r_info);
881	return ef->strtab + ref->st_name;
882    } else
883	return NULL;
884}
885
886static int
887relocate_file(elf_file_t ef)
888{
889    const Elf_Rel *rellim;
890    const Elf_Rel *rel;
891    const Elf_Rela *relalim;
892    const Elf_Rela *rela;
893    const char *symname;
894
895    /* Perform relocations without addend if there are any: */
896    rel = ef->rel;
897    if (rel) {
898	rellim = (const Elf_Rel *)((const char *)ef->rel + ef->relsize);
899	while (rel < rellim) {
900	    symname = symbol_name(ef, rel->r_info);
901	    if (elf_reloc(&ef->lf, rel, ELF_RELOC_REL, symname)) {
902		printf("link_elf: symbol %s undefined\n", symname);
903		return ENOENT;
904	    }
905	    rel++;
906	}
907    }
908
909    /* Perform relocations with addend if there are any: */
910    rela = ef->rela;
911    if (rela) {
912	relalim = (const Elf_Rela *)((const char *)ef->rela + ef->relasize);
913	while (rela < relalim) {
914	    symname = symbol_name(ef, rela->r_info);
915	    if (elf_reloc(&ef->lf, rela, ELF_RELOC_RELA, symname)) {
916		printf("link_elf: symbol %s undefined\n", symname);
917		return ENOENT;
918	    }
919	    rela++;
920	}
921    }
922
923    /* Perform PLT relocations without addend if there are any: */
924    rel = ef->pltrel;
925    if (rel) {
926	rellim = (const Elf_Rel *)((const char *)ef->pltrel + ef->pltrelsize);
927	while (rel < rellim) {
928	    symname = symbol_name(ef, rel->r_info);
929	    if (elf_reloc(&ef->lf, rel, ELF_RELOC_REL, symname)) {
930		printf("link_elf: symbol %s undefined\n", symname);
931		return ENOENT;
932	    }
933	    rel++;
934	}
935    }
936
937    /* Perform relocations with addend if there are any: */
938    rela = ef->pltrela;
939    if (rela) {
940	relalim = (const Elf_Rela *)((const char *)ef->pltrela + ef->pltrelasize);
941	while (rela < relalim) {
942	    symname = symbol_name(ef, rela->r_info);
943	    if (elf_reloc(&ef->lf, rela, ELF_RELOC_RELA, symname)) {
944		printf("link_elf: symbol %s undefined\n", symname);
945		return ENOENT;
946	    }
947	    rela++;
948	}
949    }
950
951    return 0;
952}
953
954/*
955 * Hash function for symbol table lookup.  Don't even think about changing
956 * this.  It is specified by the System V ABI.
957 */
958static unsigned long
959elf_hash(const char *name)
960{
961    const unsigned char *p = (const unsigned char *) name;
962    unsigned long h = 0;
963    unsigned long g;
964
965    while (*p != '\0') {
966	h = (h << 4) + *p++;
967	if ((g = h & 0xf0000000) != 0)
968	    h ^= g >> 24;
969	h &= ~g;
970    }
971    return h;
972}
973
974int
975link_elf_lookup_symbol(linker_file_t lf, const char* name, c_linker_sym_t* sym)
976{
977    elf_file_t ef = (elf_file_t) lf;
978    unsigned long symnum;
979    const Elf_Sym* symp;
980    const char *strp;
981    unsigned long hash;
982    int i;
983
984    /* First, search hashed global symbols */
985    hash = elf_hash(name);
986    symnum = ef->buckets[hash % ef->nbuckets];
987
988    while (symnum != STN_UNDEF) {
989	if (symnum >= ef->nchains) {
990	    printf("link_elf_lookup_symbol: corrupt symbol table\n");
991	    return ENOENT;
992	}
993
994	symp = ef->symtab + symnum;
995	if (symp->st_name == 0) {
996	    printf("link_elf_lookup_symbol: corrupt symbol table\n");
997	    return ENOENT;
998	}
999
1000	strp = ef->strtab + symp->st_name;
1001
1002	if (strcmp(name, strp) == 0) {
1003	    if (symp->st_shndx != SHN_UNDEF ||
1004		(symp->st_value != 0 &&
1005		 ELF_ST_TYPE(symp->st_info) == STT_FUNC)) {
1006		*sym = (c_linker_sym_t) symp;
1007		return 0;
1008	    } else
1009		return ENOENT;
1010	}
1011
1012	symnum = ef->chains[symnum];
1013    }
1014
1015    /* If we have not found it, look at the full table (if loaded) */
1016    if (ef->symtab == ef->ddbsymtab)
1017	return ENOENT;
1018
1019    /* Exhaustive search */
1020    for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) {
1021	strp = ef->ddbstrtab + symp->st_name;
1022	if (strcmp(name, strp) == 0) {
1023	    if (symp->st_shndx != SHN_UNDEF ||
1024		(symp->st_value != 0 &&
1025		 ELF_ST_TYPE(symp->st_info) == STT_FUNC)) {
1026		*sym = (c_linker_sym_t) symp;
1027		return 0;
1028	    } else
1029		return ENOENT;
1030	}
1031    }
1032
1033    return ENOENT;
1034}
1035
1036static int
1037link_elf_symbol_values(linker_file_t lf, c_linker_sym_t sym, linker_symval_t* symval)
1038{
1039	elf_file_t ef = (elf_file_t) lf;
1040	const Elf_Sym* es = (const Elf_Sym*) sym;
1041
1042	if (es >= ef->symtab && ((es - ef->symtab) < ef->nchains)) {
1043	    symval->name = ef->strtab + es->st_name;
1044	    symval->value = (caddr_t) ef->address + es->st_value;
1045	    symval->size = es->st_size;
1046	    return 0;
1047	}
1048	if (ef->symtab == ef->ddbsymtab)
1049	    return ENOENT;
1050	if (es >= ef->ddbsymtab && ((es - ef->ddbsymtab) < ef->ddbsymcnt)) {
1051	    symval->name = ef->ddbstrtab + es->st_name;
1052	    symval->value = (caddr_t) ef->address + es->st_value;
1053	    symval->size = es->st_size;
1054	    return 0;
1055	}
1056	return ENOENT;
1057}
1058
1059static int
1060link_elf_search_symbol(linker_file_t lf, caddr_t value,
1061		       c_linker_sym_t* sym, long* diffp)
1062{
1063	elf_file_t ef = (elf_file_t) lf;
1064	u_long off = (uintptr_t) (void *) value;
1065	u_long diff = off;
1066	u_long st_value;
1067	const Elf_Sym* es;
1068	const Elf_Sym* best = 0;
1069	int i;
1070
1071	for (i = 0, es = ef->ddbsymtab; i < ef->ddbsymcnt; i++, es++) {
1072		if (es->st_name == 0)
1073			continue;
1074		st_value = es->st_value + (uintptr_t) (void *) ef->address;
1075		if (off >= st_value) {
1076			if (off - st_value < diff) {
1077				diff = off - st_value;
1078				best = es;
1079				if (diff == 0)
1080					break;
1081			} else if (off - st_value == diff) {
1082				best = es;
1083			}
1084		}
1085	}
1086	if (best == 0)
1087		*diffp = off;
1088	else
1089		*diffp = diff;
1090	*sym = (c_linker_sym_t) best;
1091
1092	return 0;
1093}
1094
1095/*
1096 * Look up a linker set on an ELF system.
1097 */
1098static int
1099link_elf_lookup_set(linker_file_t lf, const char *name,
1100		    void ***startp, void ***stopp, int *countp)
1101{
1102	c_linker_sym_t sym;
1103	linker_symval_t symval;
1104	char *setsym;
1105	void **start, **stop;
1106	int len, error = 0, count;
1107
1108	len = strlen(name) + sizeof("__start_set_"); /* sizeof includes \0 */
1109	setsym = malloc(len, M_LINKER, M_WAITOK);
1110	if (setsym == NULL)
1111		return ENOMEM;
1112
1113	/* get address of first entry */
1114	snprintf(setsym, len, "%s%s", "__start_set_", name);
1115	error = link_elf_lookup_symbol(lf, setsym, &sym);
1116	if (error)
1117		goto out;
1118	link_elf_symbol_values(lf, sym, &symval);
1119	if (symval.value == 0) {
1120		error = ESRCH;
1121		goto out;
1122	}
1123	start = (void **)symval.value;
1124
1125	/* get address of last entry */
1126	snprintf(setsym, len, "%s%s", "__stop_set_", name);
1127	error = link_elf_lookup_symbol(lf, setsym, &sym);
1128	if (error)
1129		goto out;
1130	link_elf_symbol_values(lf, sym, &symval);
1131	if (symval.value == 0) {
1132		error = ESRCH;
1133		goto out;
1134	}
1135	stop = (void **)symval.value;
1136
1137	/* and the number of entries */
1138	count = stop - start;
1139
1140	/* and copy out */
1141	if (startp)
1142		*startp = start;
1143	if (stopp)
1144		*stopp = stop;
1145	if (countp)
1146		*countp = count;
1147
1148out:
1149	free(setsym, M_LINKER);
1150	return error;
1151}
1152