link_elf.c revision 105147
118334Speter/*-
218334Speter * Copyright (c) 1998-2000 Doug Rabson
390075Sobrien * All rights reserved.
496263Sobrien *
518334Speter * Redistribution and use in source and binary forms, with or without
690075Sobrien * modification, are permitted provided that the following conditions
718334Speter * are met:
890075Sobrien * 1. Redistributions of source code must retain the above copyright
990075Sobrien *    notice, this list of conditions and the following disclaimer.
1090075Sobrien * 2. Redistributions in binary form must reproduce the above copyright
1190075Sobrien *    notice, this list of conditions and the following disclaimer in the
1218334Speter *    documentation and/or other materials provided with the distribution.
1390075Sobrien *
1490075Sobrien * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
1590075Sobrien * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1690075Sobrien * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1718334Speter * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
1818334Speter * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
1990075Sobrien * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
2090075Sobrien * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
2190075Sobrien * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
2218334Speter * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
2390075Sobrien * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
2490075Sobrien * SUCH DAMAGE.
2590075Sobrien *
2618334Speter * $FreeBSD: head/sys/kern/link_elf.c 105147 2002-10-15 05:40:07Z marcel $
2790075Sobrien */
2818334Speter
2918334Speter#include "opt_ddb.h"
3018334Speter
3190075Sobrien#include <sys/param.h>
3218334Speter#include <sys/systm.h>
3318334Speter#include <sys/kernel.h>
3418334Speter#include <sys/lock.h>
3590075Sobrien#include <sys/malloc.h>
3618334Speter#include <sys/mutex.h>
3718334Speter#include <sys/proc.h>
3818334Speter#include <sys/namei.h>
3990075Sobrien#include <sys/fcntl.h>
4018334Speter#include <sys/vnode.h>
4190075Sobrien#include <sys/linker.h>
4218334Speter
4318334Speter#include <machine/elf.h>
4490075Sobrien#ifdef GPROF
4518334Speter#include <machine/profile.h>
4618334Speter#endif
4790075Sobrien
4818334Speter#include <vm/vm.h>
4918334Speter#include <vm/vm_param.h>
5018334Speter#ifdef SPARSE_MAPPING
5118334Speter#include <vm/vm_object.h>
5290075Sobrien#include <vm/vm_kern.h>
5318334Speter#include <vm/vm_extern.h>
5418334Speter#endif
5518334Speter#include <vm/pmap.h>
5690075Sobrien#include <vm/vm_map.h>
5718334Speter
5818334Speter#include <sys/link_elf.h>
5918334Speter
6018334Speter#include "linker_if.h"
6118334Speter
6218334Spetertypedef struct elf_file {
6390075Sobrien    struct linker_file	lf;		/* Common fields */
6418334Speter    int			preloaded;	/* Was file pre-loaded */
6518334Speter    caddr_t		address;	/* Relocation address */
6618334Speter#ifdef SPARSE_MAPPING
6718334Speter    vm_object_t		object;		/* VM object to hold file pages */
6890075Sobrien#endif
6918334Speter    Elf_Dyn*		dynamic;	/* Symbol table etc. */
7018334Speter    Elf_Hashelt		nbuckets;	/* DT_HASH info */
7190075Sobrien    Elf_Hashelt		nchains;
7218334Speter    const Elf_Hashelt*	buckets;
7318334Speter    const Elf_Hashelt*	chains;
7418334Speter    caddr_t		hash;
7518334Speter    caddr_t		strtab;		/* DT_STRTAB */
7690075Sobrien    int			strsz;		/* DT_STRSZ */
7718334Speter    const Elf_Sym*	symtab;		/* DT_SYMTAB */
7818334Speter    Elf_Addr*		got;		/* DT_PLTGOT */
7918334Speter    const Elf_Rel*	pltrel;		/* DT_JMPREL */
8090075Sobrien    int			pltrelsize;	/* DT_PLTRELSZ */
8118334Speter    const Elf_Rela*	pltrela;	/* DT_JMPREL */
8218334Speter    int			pltrelasize;	/* DT_PLTRELSZ */
8318334Speter    const Elf_Rel*	rel;		/* DT_REL */
8496263Sobrien    int			relsize;	/* DT_RELSZ */
8518334Speter    const Elf_Rela*	rela;		/* DT_RELA */
8618334Speter    int			relasize;	/* DT_RELASZ */
8718334Speter    caddr_t		modptr;
8890075Sobrien    const Elf_Sym*	ddbsymtab;	/* The symbol table we are using */
8918334Speter    long		ddbsymcnt;	/* Number of symbols */
9050397Sobrien    caddr_t		ddbstrtab;	/* String table */
9150397Sobrien    long		ddbstrcnt;	/* number of bytes in string table */
9250397Sobrien    caddr_t		symbase;	/* malloc'ed symbold base */
9390075Sobrien    caddr_t		strbase;	/* malloc'ed string base */
9450397Sobrien#ifdef DDB
9552284Sobrien    struct link_map	gdb;		/* hooks for gdb */
9652284Sobrien#endif
9790075Sobrien} *elf_file_t;
9852284Sobrien
9918334Speterstatic int	link_elf_link_preload(linker_class_t cls,
10090075Sobrien				      const char*, linker_file_t*);
10118334Speterstatic int	link_elf_link_preload_finish(linker_file_t);
10218334Speterstatic int	link_elf_load_file(linker_class_t, const char*, linker_file_t*);
10318334Speterstatic int	link_elf_lookup_symbol(linker_file_t, const char*,
10490075Sobrien				       c_linker_sym_t*);
10518334Speterstatic int	link_elf_symbol_values(linker_file_t, c_linker_sym_t, linker_symval_t*);
10618334Speterstatic int	link_elf_search_symbol(linker_file_t, caddr_t value,
10718334Speter				       c_linker_sym_t* sym, long* diffp);
10818334Speter
10990075Sobrienstatic void	link_elf_unload_file(linker_file_t);
11018334Speterstatic void	link_elf_unload_preload(linker_file_t);
11118334Speterstatic int	link_elf_lookup_set(linker_file_t, const char *,
11218334Speter				    void ***, void ***, int *);
11390075Sobrienstatic int	link_elf_each_function_name(linker_file_t,
11418334Speter				int (*)(const char *, void *),
11518334Speter				void *);
11618334Speter
11790075Sobrienstatic kobj_method_t link_elf_methods[] = {
11818334Speter    KOBJMETHOD(linker_lookup_symbol,	link_elf_lookup_symbol),
11918334Speter    KOBJMETHOD(linker_symbol_values,	link_elf_symbol_values),
12090075Sobrien    KOBJMETHOD(linker_search_symbol,	link_elf_search_symbol),
12118334Speter    KOBJMETHOD(linker_unload,		link_elf_unload_file),
12290075Sobrien    KOBJMETHOD(linker_load_file,	link_elf_load_file),
12390075Sobrien    KOBJMETHOD(linker_link_preload,	link_elf_link_preload),
12490075Sobrien    KOBJMETHOD(linker_link_preload_finish, link_elf_link_preload_finish),
12590075Sobrien    KOBJMETHOD(linker_lookup_set,	link_elf_lookup_set),
12690075Sobrien    KOBJMETHOD(linker_each_function_name, link_elf_each_function_name),
12718334Speter    { 0, 0 }
12818334Speter};
12990075Sobrien
13018334Speterstatic struct linker_class link_elf_class = {
13118334Speter#if ELF_TARG_CLASS == ELFCLASS32
13218334Speter    "elf32",
13390075Sobrien#else
13450397Sobrien    "elf64",
13590075Sobrien#endif
13690075Sobrien    link_elf_methods, sizeof(struct elf_file)
13790075Sobrien};
13890075Sobrien
13990075Sobrienstatic int		parse_dynamic(elf_file_t ef);
14090075Sobrienstatic int		relocate_file(elf_file_t ef);
14190075Sobrienstatic int		link_elf_preload_parse_symbols(elf_file_t ef);
14250397Sobrien
14390075Sobrien#ifdef DDB
14490075Sobrienstatic void		r_debug_state(struct r_debug *dummy_one,
14590075Sobrien				      struct link_map *dummy_two);
14690075Sobrien
14790075Sobrien/*
14890075Sobrien * A list of loaded modules for GDB to use for loading symbols.
14918334Speter */
15018334Speterstruct r_debug r_debug;
15118334Speter
15218334Speter#define GDB_STATE(s)	r_debug.r_state = s; r_debug_state(NULL, NULL);
15318334Speter
15490075Sobrien/*
15518334Speter * Function for the debugger to set a breakpoint on to gain control.
15618334Speter */
15790075Sobrienstatic void
15818334Speterr_debug_state(struct r_debug *dummy_one __unused,
15952284Sobrien	      struct link_map *dummy_two __unused)
16090075Sobrien{
16152284Sobrien}
16218334Speter
16318334Speter#endif
16490075Sobrien
16518334Speter#ifdef __ia64__
16690075SobrienElf_Addr link_elf_get_gp(linker_file_t);
16790075Sobrien#endif
16818334Speter
16990075Sobrien/*
17090075Sobrien * The kernel symbol table starts here.
17150397Sobrien */
17250397Sobrienextern struct _dynamic _DYNAMIC;
17390075Sobrien
17490075Sobrienstatic void
17590075Sobrienlink_elf_init(void* arg)
17690075Sobrien{
17790075Sobrien    Elf_Dyn	*dp;
17890075Sobrien    caddr_t	modptr, baseptr, sizeptr;
17990075Sobrien    elf_file_t	ef;
18090075Sobrien    char	*modname;
18190075Sobrien#ifdef DDB
18290075Sobrien    char *newfilename;
18390075Sobrien#endif
18490075Sobrien
18590075Sobrien    linker_add_class(&link_elf_class);
18690075Sobrien
18790075Sobrien    dp = (Elf_Dyn*) &_DYNAMIC;
18890075Sobrien    modname = NULL;
18990075Sobrien    modptr = preload_search_by_type("elf kernel");
19090075Sobrien    if (modptr)
19190075Sobrien	modname = (char *)preload_search_info(modptr, MODINFO_NAME);
19290075Sobrien    if (modname == NULL)
19390075Sobrien	modname = "kernel";
19490075Sobrien    linker_kernel_file = linker_make_file(modname, &link_elf_class);
19590075Sobrien    if (linker_kernel_file == NULL)
19690075Sobrien	panic("link_elf_init: Can't create linker structures for kernel");
19790075Sobrien
19890075Sobrien    ef = (elf_file_t) linker_kernel_file;
19990075Sobrien    ef->preloaded = 1;
20090075Sobrien    ef->address = 0;
20190075Sobrien#ifdef SPARSE_MAPPING
20290075Sobrien    ef->object = 0;
20390075Sobrien#endif
20490075Sobrien    ef->dynamic = dp;
20590075Sobrien
20690075Sobrien    if (dp)
20790075Sobrien	parse_dynamic(ef);
20890075Sobrien    linker_kernel_file->address = (caddr_t) KERNBASE;
20990075Sobrien    linker_kernel_file->size = -(intptr_t)linker_kernel_file->address;
21090075Sobrien
21190075Sobrien    if (modptr) {
21290075Sobrien	ef->modptr = modptr;
21318334Speter	baseptr = preload_search_info(modptr, MODINFO_ADDR);
21418334Speter	if (baseptr)
21518334Speter	    linker_kernel_file->address = *(caddr_t *)baseptr;
21650397Sobrien	sizeptr = preload_search_info(modptr, MODINFO_SIZE);
21750397Sobrien	if (sizeptr)
21890075Sobrien	    linker_kernel_file->size = *(size_t *)sizeptr;
21918334Speter    }
22018334Speter    (void)link_elf_preload_parse_symbols(ef);
22190075Sobrien
22218334Speter#ifdef DDB
22390075Sobrien    ef->gdb.l_addr = linker_kernel_file->address;
22490075Sobrien    newfilename = malloc(strlen(modname) + 1, M_LINKER, M_WAITOK);
22590075Sobrien    strcpy(newfilename, modname);
22650397Sobrien    ef->gdb.l_name = newfilename;
22790075Sobrien    ef->gdb.l_ld = dp;
22890075Sobrien    ef->gdb.l_prev = 0;
22990075Sobrien    ef->gdb.l_next = 0;
23090075Sobrien
23118334Speter    r_debug.r_map = &ef->gdb;
23250397Sobrien    r_debug.r_brk = r_debug_state;
23390075Sobrien    r_debug.r_state = RT_CONSISTENT;
23496263Sobrien
23596263Sobrien    r_debug_state(NULL, NULL);	/* say hello to gdb! */
23650397Sobrien#endif
23750397Sobrien}
23850397Sobrien
23990075SobrienSYSINIT(link_elf, SI_SUB_KLD, SI_ORDER_SECOND, link_elf_init, 0);
24050397Sobrien
24118334Speterstatic int
24218334Speterlink_elf_preload_parse_symbols(elf_file_t ef)
24318334Speter{
24418334Speter    caddr_t	pointer;
24518334Speter    caddr_t	ssym, esym, base;
24618334Speter    caddr_t	strtab;
24718334Speter    int		strcnt;
24890075Sobrien    Elf_Sym*	symtab;
24918334Speter    int		symcnt;
25050397Sobrien
25118334Speter    if (ef->modptr == NULL)
25218334Speter	return 0;
25390075Sobrien    pointer = preload_search_info(ef->modptr, MODINFO_METADATA|MODINFOMD_SSYM);
25418334Speter    if (pointer == NULL)
25518334Speter	return 0;
25690075Sobrien    ssym = *(caddr_t *)pointer;
25718334Speter    pointer = preload_search_info(ef->modptr, MODINFO_METADATA|MODINFOMD_ESYM);
25890075Sobrien    if (pointer == NULL)
25950397Sobrien	return 0;
26018334Speter    esym = *(caddr_t *)pointer;
26118334Speter
26290075Sobrien    base = ssym;
26318334Speter
26418334Speter    symcnt = *(long *)base;
26518334Speter    base += sizeof(long);
26618334Speter    symtab = (Elf_Sym *)base;
26718334Speter    base += roundup(symcnt, sizeof(long));
26890075Sobrien
26918334Speter    if (base > esym || base < ssym) {
27018334Speter	printf("Symbols are corrupt!\n");
27118334Speter	return EINVAL;
27290075Sobrien    }
27318334Speter
27418334Speter    strcnt = *(long *)base;
27518334Speter    base += sizeof(long);
27618334Speter    strtab = base;
27718334Speter    base += roundup(strcnt, sizeof(long));
27818334Speter
27918334Speter    if (base > esym || base < ssym) {
28018334Speter	printf("Symbols are corrupt!\n");
28118334Speter	return EINVAL;
28218334Speter    }
28390075Sobrien
28418334Speter    ef->ddbsymtab = symtab;
28518334Speter    ef->ddbsymcnt = symcnt / sizeof(Elf_Sym);
28618334Speter    ef->ddbstrtab = strtab;
28718334Speter    ef->ddbstrcnt = strcnt;
28890075Sobrien
28950397Sobrien    return 0;
29018334Speter}
29190075Sobrien
29290075Sobrienstatic int
29390075Sobrienparse_dynamic(elf_file_t ef)
29490075Sobrien{
29590075Sobrien    Elf_Dyn *dp;
29690075Sobrien    int plttype = DT_REL;
29790075Sobrien
29890075Sobrien    for (dp = ef->dynamic; dp->d_tag != DT_NULL; dp++) {
29990075Sobrien	switch (dp->d_tag) {
30090075Sobrien	case DT_HASH:
30118334Speter	{
30218334Speter	    /* From src/libexec/rtld-elf/rtld.c */
30390075Sobrien	    const Elf_Hashelt *hashtab = (const Elf_Hashelt *)
30418334Speter		(ef->address + dp->d_un.d_ptr);
30518334Speter	    ef->nbuckets = hashtab[0];
30618334Speter	    ef->nchains = hashtab[1];
30790075Sobrien	    ef->buckets = hashtab + 2;
30818334Speter	    ef->chains = ef->buckets + ef->nbuckets;
30918334Speter	    break;
31090075Sobrien	}
31190075Sobrien	case DT_STRTAB:
31218334Speter	    ef->strtab = (caddr_t) (ef->address + dp->d_un.d_ptr);
31318334Speter	    break;
31418334Speter	case DT_STRSZ:
31518334Speter	    ef->strsz = dp->d_un.d_val;
31618334Speter	    break;
31718334Speter	case DT_SYMTAB:
31890075Sobrien	    ef->symtab = (Elf_Sym*) (ef->address + dp->d_un.d_ptr);
31918334Speter	    break;
32090075Sobrien	case DT_SYMENT:
32190075Sobrien	    if (dp->d_un.d_val != sizeof(Elf_Sym))
32290075Sobrien		return ENOEXEC;
32390075Sobrien	    break;
32490075Sobrien	case DT_PLTGOT:
32590075Sobrien	    ef->got = (Elf_Addr *) (ef->address + dp->d_un.d_ptr);
32690075Sobrien	    break;
32790075Sobrien	case DT_REL:
32890075Sobrien	    ef->rel = (const Elf_Rel *) (ef->address + dp->d_un.d_ptr);
32918334Speter	    break;
33090075Sobrien	case DT_RELSZ:
33190075Sobrien	    ef->relsize = dp->d_un.d_val;
33290075Sobrien	    break;
33318334Speter	case DT_RELENT:
33490075Sobrien	    if (dp->d_un.d_val != sizeof(Elf_Rel))
33590075Sobrien		return ENOEXEC;
33618334Speter	    break;
33790075Sobrien	case DT_JMPREL:
33890075Sobrien	    ef->pltrel = (const Elf_Rel *) (ef->address + dp->d_un.d_ptr);
33990075Sobrien	    break;
34090075Sobrien	case DT_PLTRELSZ:
34190075Sobrien	    ef->pltrelsize = dp->d_un.d_val;
34290075Sobrien	    break;
34390075Sobrien	case DT_RELA:
34490075Sobrien	    ef->rela = (const Elf_Rela *) (ef->address + dp->d_un.d_ptr);
34590075Sobrien	    break;
34690075Sobrien	case DT_RELASZ:
34790075Sobrien	    ef->relasize = dp->d_un.d_val;
34890075Sobrien	    break;
34990075Sobrien	case DT_RELAENT:
35018334Speter	    if (dp->d_un.d_val != sizeof(Elf_Rela))
35190075Sobrien		return ENOEXEC;
35290075Sobrien	    break;
35390075Sobrien	case DT_PLTREL:
35418334Speter	    plttype = dp->d_un.d_val;
35518334Speter	    if (plttype != DT_REL && plttype != DT_RELA)
35618334Speter		return ENOEXEC;
35718334Speter	    break;
35818334Speter#ifdef DDB
35918334Speter	case DT_DEBUG:
36090075Sobrien	    dp->d_un.d_ptr = (Elf_Addr) &r_debug;
36118334Speter	    break;
36218334Speter#endif
36390075Sobrien	}
36418334Speter    }
36518334Speter
36618334Speter    if (plttype == DT_RELA) {
36790075Sobrien	ef->pltrela = (const Elf_Rela *) ef->pltrel;
36818334Speter	ef->pltrel = NULL;
36918334Speter	ef->pltrelasize = ef->pltrelsize;
37090075Sobrien	ef->pltrelsize = 0;
37118334Speter    }
37290075Sobrien
37390075Sobrien    ef->ddbsymtab = ef->symtab;
37490075Sobrien    ef->ddbsymcnt = ef->nchains;
37590075Sobrien    ef->ddbstrtab = ef->strtab;
37618334Speter    ef->ddbstrcnt = ef->strsz;
37718334Speter
37890075Sobrien    return 0;
37918334Speter}
38090075Sobrien
38190075Sobrienstatic void
38290075Sobrienlink_elf_error(const char *s)
38390075Sobrien{
38490075Sobrien    printf("kldload: %s\n", s);
38590075Sobrien}
38690075Sobrien
38790075Sobrien#ifdef DDB
38890075Sobrien
38990075Sobrienstatic void
39090075Sobrienlink_elf_add_gdb(struct link_map *l)
39118334Speter{
39218334Speter    struct link_map *prev;
39318334Speter
39418334Speter    /*
39518334Speter     * Scan to the end of the list.
39690075Sobrien     */
39790075Sobrien    for (prev = r_debug.r_map; prev->l_next != NULL; prev = prev->l_next)
39890075Sobrien	;
39990075Sobrien
40090075Sobrien    /* Link in the new entry. */
40118334Speter    l->l_prev = prev;
40218334Speter    l->l_next = prev->l_next;
40318334Speter    prev->l_next = l;
40418334Speter}
40518334Speter
40618334Speterstatic void
40718334Speterlink_elf_delete_gdb(struct link_map *l)
40818334Speter{
40918334Speter    if (l->l_prev == NULL) {
41018334Speter	if ((r_debug.r_map = l->l_next) != NULL)
41118334Speter	    l->l_next->l_prev = NULL;
41218334Speter	return;
41390075Sobrien    }
41490075Sobrien
41518334Speter    if ((l->l_prev->l_next = l->l_next) != NULL)
41690075Sobrien	l->l_next->l_prev = l->l_prev;
41790075Sobrien}
41890075Sobrien
41918334Speter#endif /* DDB */
42090075Sobrien
42118334Speterstatic int
42290075Sobrienlink_elf_link_preload(linker_class_t cls,
42390075Sobrien		      const char* filename, linker_file_t *result)
42490075Sobrien{
42518334Speter    caddr_t		modptr, baseptr, sizeptr, dynptr;
42690075Sobrien    char		*type;
42790075Sobrien    elf_file_t		ef;
42818334Speter    linker_file_t	lf;
42990075Sobrien    int			error;
43090075Sobrien    vm_offset_t		dp;
43118334Speter
43252284Sobrien    /* Look to see if we have the file preloaded */
43352284Sobrien    modptr = preload_search_by_name(filename);
43452284Sobrien    if (modptr == NULL)
43590075Sobrien	return ENOENT;
43652284Sobrien
43752284Sobrien    type = (char *)preload_search_info(modptr, MODINFO_TYPE);
43852284Sobrien    baseptr = preload_search_info(modptr, MODINFO_ADDR);
43990075Sobrien    sizeptr = preload_search_info(modptr, MODINFO_SIZE);
44090075Sobrien    dynptr = preload_search_info(modptr, MODINFO_METADATA|MODINFOMD_DYNAMIC);
44190075Sobrien    if (type == NULL || strcmp(type, "elf module") != 0)
44290075Sobrien	return (EFTYPE);
44390075Sobrien    if (baseptr == NULL || sizeptr == NULL || dynptr == NULL)
44452284Sobrien	return (EINVAL);
44552284Sobrien
44690075Sobrien    lf = linker_make_file(filename, &link_elf_class);
44752284Sobrien    if (lf == NULL) {
44852284Sobrien	return ENOMEM;
44952284Sobrien    }
45052284Sobrien
45152284Sobrien    ef = (elf_file_t) lf;
45252284Sobrien    ef->preloaded = 1;
45352284Sobrien    ef->modptr = modptr;
45452284Sobrien    ef->address = *(caddr_t *)baseptr;
45552284Sobrien#ifdef SPARSE_MAPPING
45652284Sobrien    ef->object = 0;
45752284Sobrien#endif
45852284Sobrien    dp = (vm_offset_t)ef->address + *(vm_offset_t *)dynptr;
45952284Sobrien    ef->dynamic = (Elf_Dyn *)dp;
46052284Sobrien    lf->address = ef->address;
46152284Sobrien    lf->size = *(size_t *)sizeptr;
46290075Sobrien
46390075Sobrien    error = parse_dynamic(ef);
46490075Sobrien    if (error) {
46590075Sobrien	linker_file_unload(lf);
46690075Sobrien	return error;
46790075Sobrien    }
46850397Sobrien    *result = lf;
46950397Sobrien    return (0);
47050397Sobrien}
47150397Sobrien
47250397Sobrienstatic int
47350397Sobrienlink_elf_link_preload_finish(linker_file_t lf)
47450397Sobrien{
47550397Sobrien    elf_file_t		ef;
47650397Sobrien    int error;
47750397Sobrien#ifdef DDB
47852284Sobrien    char *newfilename;
47952284Sobrien#endif
48052284Sobrien
48152284Sobrien    ef = (elf_file_t) lf;
48252284Sobrien#if 0	/* this will be more trouble than it's worth for now */
48352284Sobrien    for (dp = ef->dynamic; dp->d_tag != DT_NULL; dp++) {
48452284Sobrien	if (dp->d_tag != DT_NEEDED)
48552284Sobrien	    continue;
48652284Sobrien	modname = ef->strtab + dp->d_un.d_val;
48752284Sobrien	error = linker_load_module(modname, lf);
48852284Sobrien	if (error)
48990075Sobrien	    goto out;
49090075Sobrien    }
49190075Sobrien#endif
49290075Sobrien    error = relocate_file(ef);
49390075Sobrien    if (error)
49490075Sobrien	return error;
49590075Sobrien    (void)link_elf_preload_parse_symbols(ef);
49690075Sobrien
49790075Sobrien#ifdef DDB
49890075Sobrien    GDB_STATE(RT_ADD);
49990075Sobrien    ef->gdb.l_addr = lf->address;
50090075Sobrien    newfilename = malloc(strlen(lf->filename) + 1, M_LINKER, M_WAITOK);
50190075Sobrien    strcpy(newfilename, lf->filename);
50290075Sobrien    ef->gdb.l_name = newfilename;
50390075Sobrien    ef->gdb.l_ld = ef->dynamic;
50490075Sobrien    link_elf_add_gdb(&ef->gdb);
50590075Sobrien    GDB_STATE(RT_CONSISTENT);
50690075Sobrien#endif
50790075Sobrien
50890075Sobrien    return (0);
50990075Sobrien}
51090075Sobrien
51190075Sobrienstatic int
51290075Sobrienlink_elf_load_file(linker_class_t cls, const char* filename, linker_file_t* result)
51390075Sobrien{
51496263Sobrien    struct nameidata nd;
51596263Sobrien    struct thread* td = curthread;	/* XXX */
51690075Sobrien    Elf_Ehdr *hdr;
51790075Sobrien    caddr_t firstpage;
51890075Sobrien    int nbytes, i;
51990075Sobrien    Elf_Phdr *phdr;
52090075Sobrien    Elf_Phdr *phlimit;
52190075Sobrien    Elf_Phdr *segs[2];
52290075Sobrien    int nsegs;
52390075Sobrien    Elf_Phdr *phdyn;
52490075Sobrien    Elf_Phdr *phphdr;
52590075Sobrien    caddr_t mapbase;
52690075Sobrien    size_t mapsize;
52790075Sobrien    Elf_Off base_offset;
52890075Sobrien    Elf_Addr base_vaddr;
52990075Sobrien    Elf_Addr base_vlimit;
53090075Sobrien    int error = 0;
53190075Sobrien    int resid, flags;
53290075Sobrien    elf_file_t ef;
53390075Sobrien    linker_file_t lf;
53490075Sobrien    Elf_Shdr *shdr;
53590075Sobrien    int symtabindex;
53690075Sobrien    int symstrindex;
53790075Sobrien    int symcnt;
53890075Sobrien    int strcnt;
53990075Sobrien#ifdef DDB
54090075Sobrien    char *newfilename;
54190075Sobrien#endif
54290075Sobrien
54390075Sobrien    GIANT_REQUIRED;
54490075Sobrien
54590075Sobrien    shdr = NULL;
54690075Sobrien    lf = NULL;
547
548    NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, filename, td);
549    flags = FREAD;
550    error = vn_open(&nd, &flags, 0);
551    if (error)
552	return error;
553    NDFREE(&nd, NDF_ONLY_PNBUF);
554
555    /*
556     * Read the elf header from the file.
557     */
558    firstpage = malloc(PAGE_SIZE, M_LINKER, M_WAITOK);
559    if (firstpage == NULL) {
560	error = ENOMEM;
561	goto out;
562    }
563    hdr = (Elf_Ehdr *)firstpage;
564    error = vn_rdwr(UIO_READ, nd.ni_vp, firstpage, PAGE_SIZE, 0,
565		    UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED,
566		    &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, td->td_ucred, NOCRED,
706			&resid, td);
707	if (error) {
708	    goto out;
709	}
710	bzero(segbase + segs[i]->p_filesz,
711	      segs[i]->p_memsz - segs[i]->p_filesz);
712
713#ifdef SPARSE_MAPPING
714	/*
715	 * Wire down the pages
716	 */
717	vm_map_wire(kernel_map,
718		    (vm_offset_t) segbase,
719		    (vm_offset_t) segbase + segs[i]->p_memsz,
720		    FALSE);
721#endif
722    }
723
724#ifdef GPROF
725    /* Update profiling information with the new text segment. */
726    kmupetext((uintfptr_t)(mapbase + segs[0]->p_vaddr - base_vaddr +
727	segs[0]->p_memsz));
728#endif
729
730    ef->dynamic = (Elf_Dyn *) (mapbase + phdyn->p_vaddr - base_vaddr);
731
732    lf->address = ef->address;
733    lf->size = mapsize;
734
735    error = parse_dynamic(ef);
736    if (error)
737	goto out;
738    error = linker_load_dependencies(lf);
739    if (error)
740	goto out;
741#if 0	/* this will be more trouble than it's worth for now */
742    for (dp = ef->dynamic; dp->d_tag != DT_NULL; dp++) {
743	if (dp->d_tag != DT_NEEDED)
744	    continue;
745	modname = ef->strtab + dp->d_un.d_val;
746	error = linker_load_module(modname, lf);
747	if (error)
748	    goto out;
749    }
750#endif
751    error = relocate_file(ef);
752    if (error)
753	goto out;
754
755    /* Try and load the symbol table if it's present.  (you can strip it!) */
756    nbytes = hdr->e_shnum * hdr->e_shentsize;
757    if (nbytes == 0 || hdr->e_shoff == 0)
758	goto nosyms;
759    shdr = malloc(nbytes, M_LINKER, M_WAITOK | M_ZERO);
760    if (shdr == NULL) {
761	error = ENOMEM;
762	goto out;
763    }
764    error = vn_rdwr(UIO_READ, nd.ni_vp,
765		    (caddr_t)shdr, nbytes, hdr->e_shoff,
766		    UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED,
767		    &resid, td);
768    if (error)
769	goto out;
770    symtabindex = -1;
771    symstrindex = -1;
772    for (i = 0; i < hdr->e_shnum; i++) {
773	if (shdr[i].sh_type == SHT_SYMTAB) {
774	    symtabindex = i;
775	    symstrindex = shdr[i].sh_link;
776	}
777    }
778    if (symtabindex < 0 || symstrindex < 0)
779	goto nosyms;
780
781    symcnt = shdr[symtabindex].sh_size;
782    ef->symbase = malloc(symcnt, M_LINKER, M_WAITOK);
783    strcnt = shdr[symstrindex].sh_size;
784    ef->strbase = malloc(strcnt, M_LINKER, M_WAITOK);
785
786    if (ef->symbase == NULL || ef->strbase == NULL) {
787	error = ENOMEM;
788	goto out;
789    }
790    error = vn_rdwr(UIO_READ, nd.ni_vp,
791		    ef->symbase, symcnt, shdr[symtabindex].sh_offset,
792		    UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED,
793		    &resid, td);
794    if (error)
795	goto out;
796    error = vn_rdwr(UIO_READ, nd.ni_vp,
797		    ef->strbase, strcnt, shdr[symstrindex].sh_offset,
798		    UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED,
799		    &resid, td);
800    if (error)
801	goto out;
802
803    ef->ddbsymcnt = symcnt / sizeof(Elf_Sym);
804    ef->ddbsymtab = (const Elf_Sym *)ef->symbase;
805    ef->ddbstrcnt = strcnt;
806    ef->ddbstrtab = ef->strbase;
807
808#ifdef DDB
809    GDB_STATE(RT_ADD);
810    ef->gdb.l_addr = lf->address;
811    newfilename = malloc(strlen(filename) + 1, M_LINKER, M_WAITOK);
812    strcpy(newfilename, filename);
813    ef->gdb.l_name = (const char *)newfilename;
814    ef->gdb.l_ld = ef->dynamic;
815    link_elf_add_gdb(&ef->gdb);
816    GDB_STATE(RT_CONSISTENT);
817#endif
818
819nosyms:
820
821    *result = lf;
822
823out:
824    if (error && lf)
825	linker_file_unload(lf);
826    if (shdr)
827	free(shdr, M_LINKER);
828    if (firstpage)
829	free(firstpage, M_LINKER);
830    VOP_UNLOCK(nd.ni_vp, 0, td);
831    vn_close(nd.ni_vp, FREAD, td->td_ucred, td);
832
833    return error;
834}
835
836static void
837link_elf_unload_file(linker_file_t file)
838{
839    elf_file_t ef = (elf_file_t) file;
840
841#ifdef DDB
842    if (ef->gdb.l_ld) {
843	GDB_STATE(RT_DELETE);
844	free((void *)(uintptr_t)ef->gdb.l_name, M_LINKER);
845	link_elf_delete_gdb(&ef->gdb);
846	GDB_STATE(RT_CONSISTENT);
847    }
848#endif
849
850    if (ef->preloaded) {
851	link_elf_unload_preload(file);
852	return;
853    }
854#ifdef SPARSE_MAPPING
855    if (ef->object) {
856	vm_map_remove(kernel_map, (vm_offset_t) ef->address,
857		      (vm_offset_t) ef->address
858		      + (ef->object->size << PAGE_SHIFT));
859	vm_object_deallocate(ef->object);
860    }
861#else
862    if (ef->address)
863	free(ef->address, M_LINKER);
864#endif
865    if (ef->symbase)
866	free(ef->symbase, M_LINKER);
867    if (ef->strbase)
868	free(ef->strbase, M_LINKER);
869}
870
871static void
872link_elf_unload_preload(linker_file_t file)
873{
874    if (file->filename)
875	preload_delete_name(file->filename);
876}
877
878static const char *
879symbol_name(elf_file_t ef, Elf_Word r_info)
880{
881    const Elf_Sym *ref;
882
883    if (ELF_R_SYM(r_info)) {
884	ref = ef->symtab + ELF_R_SYM(r_info);
885	return ef->strtab + ref->st_name;
886    } else
887	return NULL;
888}
889
890static int
891relocate_file(elf_file_t ef)
892{
893    const Elf_Rel *rellim;
894    const Elf_Rel *rel;
895    const Elf_Rela *relalim;
896    const Elf_Rela *rela;
897    const char *symname;
898
899    /* Perform relocations without addend if there are any: */
900    rel = ef->rel;
901    if (rel) {
902	rellim = (const Elf_Rel *)((const char *)ef->rel + ef->relsize);
903	while (rel < rellim) {
904	    if (elf_reloc(&ef->lf, rel, ELF_RELOC_REL)) {
905		symname = symbol_name(ef, rel->r_info);
906		printf("link_elf: symbol %s undefined\n", symname);
907		return ENOENT;
908	    }
909	    rel++;
910	}
911    }
912
913    /* Perform relocations with addend if there are any: */
914    rela = ef->rela;
915    if (rela) {
916	relalim = (const Elf_Rela *)((const char *)ef->rela + ef->relasize);
917	while (rela < relalim) {
918	    if (elf_reloc(&ef->lf, rela, ELF_RELOC_RELA)) {
919		symname = symbol_name(ef, rela->r_info);
920		printf("link_elf: symbol %s undefined\n", symname);
921		return ENOENT;
922	    }
923	    rela++;
924	}
925    }
926
927    /* Perform PLT relocations without addend if there are any: */
928    rel = ef->pltrel;
929    if (rel) {
930	rellim = (const Elf_Rel *)((const char *)ef->pltrel + ef->pltrelsize);
931	while (rel < rellim) {
932	    if (elf_reloc(&ef->lf, rel, ELF_RELOC_REL)) {
933		symname = symbol_name(ef, rel->r_info);
934		printf("link_elf: symbol %s undefined\n", symname);
935		return ENOENT;
936	    }
937	    rel++;
938	}
939    }
940
941    /* Perform relocations with addend if there are any: */
942    rela = ef->pltrela;
943    if (rela) {
944	relalim = (const Elf_Rela *)((const char *)ef->pltrela + ef->pltrelasize);
945	while (rela < relalim) {
946	    if (elf_reloc(&ef->lf, rela, ELF_RELOC_RELA)) {
947		symname = symbol_name(ef, rela->r_info);
948		printf("link_elf: symbol %s undefined\n", symname);
949		return ENOENT;
950	    }
951	    rela++;
952	}
953    }
954
955    return 0;
956}
957
958/*
959 * Hash function for symbol table lookup.  Don't even think about changing
960 * this.  It is specified by the System V ABI.
961 */
962static unsigned long
963elf_hash(const char *name)
964{
965    const unsigned char *p = (const unsigned char *) name;
966    unsigned long h = 0;
967    unsigned long g;
968
969    while (*p != '\0') {
970	h = (h << 4) + *p++;
971	if ((g = h & 0xf0000000) != 0)
972	    h ^= g >> 24;
973	h &= ~g;
974    }
975    return h;
976}
977
978static int
979link_elf_lookup_symbol(linker_file_t lf, const char* name, c_linker_sym_t* sym)
980{
981    elf_file_t ef = (elf_file_t) lf;
982    unsigned long symnum;
983    const Elf_Sym* symp;
984    const char *strp;
985    unsigned long hash;
986    int i;
987
988    /* First, search hashed global symbols */
989    hash = elf_hash(name);
990    symnum = ef->buckets[hash % ef->nbuckets];
991
992    while (symnum != STN_UNDEF) {
993	if (symnum >= ef->nchains) {
994	    printf("link_elf_lookup_symbol: corrupt symbol table\n");
995	    return ENOENT;
996	}
997
998	symp = ef->symtab + symnum;
999	if (symp->st_name == 0) {
1000	    printf("link_elf_lookup_symbol: corrupt symbol table\n");
1001	    return ENOENT;
1002	}
1003
1004	strp = ef->strtab + symp->st_name;
1005
1006	if (strcmp(name, strp) == 0) {
1007	    if (symp->st_shndx != SHN_UNDEF ||
1008		(symp->st_value != 0 &&
1009		 ELF_ST_TYPE(symp->st_info) == STT_FUNC)) {
1010		*sym = (c_linker_sym_t) symp;
1011		return 0;
1012	    } else
1013		return ENOENT;
1014	}
1015
1016	symnum = ef->chains[symnum];
1017    }
1018
1019    /* If we have not found it, look at the full table (if loaded) */
1020    if (ef->symtab == ef->ddbsymtab)
1021	return ENOENT;
1022
1023    /* Exhaustive search */
1024    for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) {
1025	strp = ef->ddbstrtab + symp->st_name;
1026	if (strcmp(name, strp) == 0) {
1027	    if (symp->st_shndx != SHN_UNDEF ||
1028		(symp->st_value != 0 &&
1029		 ELF_ST_TYPE(symp->st_info) == STT_FUNC)) {
1030		*sym = (c_linker_sym_t) symp;
1031		return 0;
1032	    } else
1033		return ENOENT;
1034	}
1035    }
1036
1037    return ENOENT;
1038}
1039
1040static int
1041link_elf_symbol_values(linker_file_t lf, c_linker_sym_t sym, linker_symval_t* symval)
1042{
1043	elf_file_t ef = (elf_file_t) lf;
1044	const Elf_Sym* es = (const Elf_Sym*) sym;
1045
1046	if (es >= ef->symtab && es < (ef->symtab + ef->nchains)) {
1047	    symval->name = ef->strtab + es->st_name;
1048	    symval->value = (caddr_t) ef->address + es->st_value;
1049	    symval->size = es->st_size;
1050	    return 0;
1051	}
1052	if (ef->symtab == ef->ddbsymtab)
1053	    return ENOENT;
1054	if (es >= ef->ddbsymtab && es < (ef->ddbsymtab + ef->ddbsymcnt)) {
1055	    symval->name = ef->ddbstrtab + es->st_name;
1056	    symval->value = (caddr_t) ef->address + es->st_value;
1057	    symval->size = es->st_size;
1058	    return 0;
1059	}
1060	return ENOENT;
1061}
1062
1063static int
1064link_elf_search_symbol(linker_file_t lf, caddr_t value,
1065		       c_linker_sym_t* sym, long* diffp)
1066{
1067	elf_file_t ef = (elf_file_t) lf;
1068	u_long off = (uintptr_t) (void *) value;
1069	u_long diff = off;
1070	u_long st_value;
1071	const Elf_Sym* es;
1072	const Elf_Sym* best = 0;
1073	int i;
1074
1075	for (i = 0, es = ef->ddbsymtab; i < ef->ddbsymcnt; i++, es++) {
1076		if (es->st_name == 0)
1077			continue;
1078		st_value = es->st_value + (uintptr_t) (void *) ef->address;
1079		if (off >= st_value) {
1080			if (off - st_value < diff) {
1081				diff = off - st_value;
1082				best = es;
1083				if (diff == 0)
1084					break;
1085			} else if (off - st_value == diff) {
1086				best = es;
1087			}
1088		}
1089	}
1090	if (best == 0)
1091		*diffp = off;
1092	else
1093		*diffp = diff;
1094	*sym = (c_linker_sym_t) best;
1095
1096	return 0;
1097}
1098
1099/*
1100 * Look up a linker set on an ELF system.
1101 */
1102static int
1103link_elf_lookup_set(linker_file_t lf, const char *name,
1104		    void ***startp, void ***stopp, int *countp)
1105{
1106	c_linker_sym_t sym;
1107	linker_symval_t symval;
1108	char *setsym;
1109	void **start, **stop;
1110	int len, error = 0, count;
1111
1112	len = strlen(name) + sizeof("__start_set_"); /* sizeof includes \0 */
1113	setsym = malloc(len, M_LINKER, M_WAITOK);
1114	if (setsym == NULL)
1115		return ENOMEM;
1116
1117	/* get address of first entry */
1118	snprintf(setsym, len, "%s%s", "__start_set_", name);
1119	error = link_elf_lookup_symbol(lf, setsym, &sym);
1120	if (error)
1121		goto out;
1122	link_elf_symbol_values(lf, sym, &symval);
1123	if (symval.value == 0) {
1124		error = ESRCH;
1125		goto out;
1126	}
1127	start = (void **)symval.value;
1128
1129	/* get address of last entry */
1130	snprintf(setsym, len, "%s%s", "__stop_set_", name);
1131	error = link_elf_lookup_symbol(lf, setsym, &sym);
1132	if (error)
1133		goto out;
1134	link_elf_symbol_values(lf, sym, &symval);
1135	if (symval.value == 0) {
1136		error = ESRCH;
1137		goto out;
1138	}
1139	stop = (void **)symval.value;
1140
1141	/* and the number of entries */
1142	count = stop - start;
1143
1144	/* and copy out */
1145	if (startp)
1146		*startp = start;
1147	if (stopp)
1148		*stopp = stop;
1149	if (countp)
1150		*countp = count;
1151
1152out:
1153	free(setsym, M_LINKER);
1154	return error;
1155}
1156
1157static int
1158link_elf_each_function_name(linker_file_t file,
1159  int (*callback)(const char *, void *), void *opaque) {
1160    elf_file_t ef = (elf_file_t)file;
1161    const Elf_Sym* symp;
1162    int i, error;
1163
1164    /* Exhaustive search */
1165    for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) {
1166	if (symp->st_value != 0 &&
1167	    ELF_ST_TYPE(symp->st_info) == STT_FUNC) {
1168		error = callback(ef->ddbstrtab + symp->st_name, opaque);
1169		if (error)
1170		    return (error);
1171	}
1172    }
1173    return (0);
1174}
1175
1176#ifdef __ia64__
1177/*
1178 * Each KLD has its own GP. The GP value for each load module is given by
1179 * DT_PLTGOT on ia64. We need GP to construct function descriptors, but
1180 * don't have direct access to the ELF file structure. The link_elf_get_gp()
1181 * function returns the GP given a pointer to a generic linker file struct.
1182 */
1183Elf_Addr
1184link_elf_get_gp(linker_file_t lf)
1185{
1186	elf_file_t ef = (elf_file_t)lf;
1187	return (Elf_Addr)ef->got;
1188}
1189#endif
1190
1191const Elf_Sym *
1192elf_get_sym(linker_file_t lf, Elf_Word symidx)
1193{
1194	elf_file_t ef = (elf_file_t)lf;
1195
1196	if (symidx >= ef->nchains)
1197		return (NULL);
1198	return (ef->symtab + symidx);
1199}
1200
1201const char *
1202elf_get_symname(linker_file_t lf, Elf_Word symidx)
1203{
1204	elf_file_t ef = (elf_file_t)lf;
1205	const Elf_Sym *sym;
1206
1207	if (symidx >= ef->nchains)
1208		return (NULL);
1209	sym = ef->symtab + symidx;
1210	return (ef->strtab + sym->st_name);
1211}
1212
1213/*
1214 * Symbol lookup function that can be used when the symbol index is known (ie
1215 * in relocations). It uses the symbol index instead of doing a fully fledged
1216 * hash table based lookup when such is valid. For example for local symbols.
1217 * This is not only more efficient, it's also more correct. It's not always
1218 * the case that the symbol can be found through the hash table.
1219 */
1220Elf_Addr
1221elf_lookup(linker_file_t lf, Elf_Word symidx, int deps)
1222{
1223	elf_file_t ef = (elf_file_t)lf;
1224	const Elf_Sym *sym;
1225	const char *symbol;
1226
1227	/* Don't even try to lookup the symbol if the index is bogus. */
1228	if (symidx >= ef->nchains)
1229		return (0);
1230
1231	sym = ef->symtab + symidx;
1232
1233	/*
1234	 * Don't do a full lookup when the symbol is local. It may even
1235	 * fail because it may not be found through the hash table.
1236	 */
1237	if (ELF_ST_BIND(sym->st_info) == STB_LOCAL) {
1238		/* Force lookup failure when we have an insanity. */
1239		if (sym->st_shndx == SHN_UNDEF || sym->st_value == 0)
1240			return (0);
1241		return ((Elf_Addr)ef->address + sym->st_value);
1242	}
1243
1244	/*
1245	 * XXX we can avoid doing a hash table based lookup for global
1246	 * symbols as well. This however is not always valid, so we'll
1247	 * just do it the hard way for now. Performance tweaks can
1248	 * always be added.
1249	 */
1250
1251	symbol = ef->strtab + sym->st_name;
1252
1253	/* Force a lookup failure if the symbol name is bogus. */
1254	if (*symbol == 0)
1255		return (0);
1256
1257	return ((Elf_Addr)linker_file_lookup_symbol(lf, symbol, deps));
1258}
1259