Deleted Added
sdiff udiff text old ( 59744 ) new ( 59751 )
full compact
link_elf.c (59744) link_elf.c (59751)
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 unchanged lines hidden (view full) ---

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 *
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 unchanged lines hidden (view full) ---

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 59744 2000-04-29 11:21:44Z peter $
26 * $FreeBSD: head/sys/kern/link_elf.c 59751 2000-04-29 13:19:31Z peter $
27 */
28
29#include "opt_ddb.h"
30
31#include <sys/param.h>
32#include <sys/kernel.h>
33#include <sys/systm.h>
34#include <sys/malloc.h>

--- 51 unchanged lines hidden (view full) ---

86 long ddbstrcnt; /* number of bytes in string table */
87 caddr_t symbase; /* malloc'ed symbold base */
88 caddr_t strbase; /* malloc'ed string base */
89#ifdef DDB
90 struct link_map gdb; /* hooks for gdb */
91#endif
92} *elf_file_t;
93
27 */
28
29#include "opt_ddb.h"
30
31#include <sys/param.h>
32#include <sys/kernel.h>
33#include <sys/systm.h>
34#include <sys/malloc.h>

--- 51 unchanged lines hidden (view full) ---

86 long ddbstrcnt; /* number of bytes in string table */
87 caddr_t symbase; /* malloc'ed symbold base */
88 caddr_t strbase; /* malloc'ed string base */
89#ifdef DDB
90 struct link_map gdb; /* hooks for gdb */
91#endif
92} *elf_file_t;
93
94static int link_elf_load_module(linker_class_t cls,
95 const char*, linker_file_t*);
96static int link_elf_load_file(const char*, linker_file_t*);
94static int link_elf_link_preload(linker_class_t cls,
95 const char*, linker_file_t*);
96static int link_elf_link_preload_finish(linker_file_t);
97static int link_elf_load_file(linker_class_t, const char*, linker_file_t*);
97static int link_elf_lookup_symbol(linker_file_t, const char*,
98 c_linker_sym_t*);
99static int link_elf_symbol_values(linker_file_t, c_linker_sym_t, linker_symval_t*);
100static int link_elf_search_symbol(linker_file_t, caddr_t value,
101 c_linker_sym_t* sym, long* diffp);
102
103static void link_elf_unload_file(linker_file_t);
98static int link_elf_lookup_symbol(linker_file_t, const char*,
99 c_linker_sym_t*);
100static int link_elf_symbol_values(linker_file_t, c_linker_sym_t, linker_symval_t*);
101static int link_elf_search_symbol(linker_file_t, caddr_t value,
102 c_linker_sym_t* sym, long* diffp);
103
104static void link_elf_unload_file(linker_file_t);
104static void link_elf_unload_module(linker_file_t);
105static void link_elf_unload_preload(linker_file_t);
105
106static kobj_method_t link_elf_methods[] = {
107 KOBJMETHOD(linker_lookup_symbol, link_elf_lookup_symbol),
108 KOBJMETHOD(linker_symbol_values, link_elf_symbol_values),
109 KOBJMETHOD(linker_search_symbol, link_elf_search_symbol),
110 KOBJMETHOD(linker_unload, link_elf_unload_file),
106
107static kobj_method_t link_elf_methods[] = {
108 KOBJMETHOD(linker_lookup_symbol, link_elf_lookup_symbol),
109 KOBJMETHOD(linker_symbol_values, link_elf_symbol_values),
110 KOBJMETHOD(linker_search_symbol, link_elf_search_symbol),
111 KOBJMETHOD(linker_unload, link_elf_unload_file),
111 KOBJMETHOD(linker_load_file, link_elf_load_module),
112 KOBJMETHOD(linker_load_file, link_elf_load_file),
113 KOBJMETHOD(linker_link_preload, link_elf_link_preload),
114 KOBJMETHOD(linker_link_preload_finish, link_elf_link_preload_finish),
112 { 0, 0 }
113};
114
115static struct linker_class link_elf_class = {
116#if ELF_TARG_CLASS == ELFCLASS32
117 "elf32",
118#else
119 "elf64",
120#endif
121 link_elf_methods, sizeof(struct elf_file)
122};
123
124static int parse_dynamic(elf_file_t ef);
115 { 0, 0 }
116};
117
118static struct linker_class link_elf_class = {
119#if ELF_TARG_CLASS == ELFCLASS32
120 "elf32",
121#else
122 "elf64",
123#endif
124 link_elf_methods, sizeof(struct elf_file)
125};
126
127static int parse_dynamic(elf_file_t ef);
125static int load_dependancies(elf_file_t ef);
126static int relocate_file(elf_file_t ef);
128static int relocate_file(elf_file_t ef);
127static int parse_module_symbols(elf_file_t ef);
129static int link_elf_preload_parse_symbols(elf_file_t ef);
128
129#ifdef DDB
130
131/*
132 * A list of loaded modules for GDB to use for loading symbols.
133 */
134struct r_debug r_debug;
135

--- 35 unchanged lines hidden (view full) ---

171 modname = (char *)preload_search_info(modptr, MODINFO_NAME);
172 if (modname == NULL)
173 modname = "kernel";
174 linker_kernel_file = linker_make_file(modname, &link_elf_class);
175 if (linker_kernel_file == NULL)
176 panic("link_elf_init: Can't create linker structures for kernel");
177
178 ef = (elf_file_t) linker_kernel_file;
130
131#ifdef DDB
132
133/*
134 * A list of loaded modules for GDB to use for loading symbols.
135 */
136struct r_debug r_debug;
137

--- 35 unchanged lines hidden (view full) ---

173 modname = (char *)preload_search_info(modptr, MODINFO_NAME);
174 if (modname == NULL)
175 modname = "kernel";
176 linker_kernel_file = linker_make_file(modname, &link_elf_class);
177 if (linker_kernel_file == NULL)
178 panic("link_elf_init: Can't create linker structures for kernel");
179
180 ef = (elf_file_t) linker_kernel_file;
181 ef->preloaded = 1;
179 ef->address = 0;
180#ifdef SPARSE_MAPPING
181 ef->object = 0;
182#endif
183 ef->dynamic = dp;
184
185 parse_dynamic(ef);
186 linker_kernel_file->address = (caddr_t) KERNBASE;
187 linker_kernel_file->size = -(intptr_t)linker_kernel_file->address;
188
189 if (modptr) {
190 ef->modptr = modptr;
191 baseptr = preload_search_info(modptr, MODINFO_ADDR);
192 if (baseptr)
193 linker_kernel_file->address = *(caddr_t *)baseptr;
194 sizeptr = preload_search_info(modptr, MODINFO_SIZE);
195 if (sizeptr)
196 linker_kernel_file->size = *(size_t *)sizeptr;
197 }
182 ef->address = 0;
183#ifdef SPARSE_MAPPING
184 ef->object = 0;
185#endif
186 ef->dynamic = dp;
187
188 parse_dynamic(ef);
189 linker_kernel_file->address = (caddr_t) KERNBASE;
190 linker_kernel_file->size = -(intptr_t)linker_kernel_file->address;
191
192 if (modptr) {
193 ef->modptr = modptr;
194 baseptr = preload_search_info(modptr, MODINFO_ADDR);
195 if (baseptr)
196 linker_kernel_file->address = *(caddr_t *)baseptr;
197 sizeptr = preload_search_info(modptr, MODINFO_SIZE);
198 if (sizeptr)
199 linker_kernel_file->size = *(size_t *)sizeptr;
200 }
198 (void)parse_module_symbols(ef);
199 linker_current_file = linker_kernel_file;
200 linker_kernel_file->flags |= LINKER_FILE_LINKED;
201 (void)link_elf_preload_parse_symbols(ef);
201
202#ifdef DDB
203 ef->gdb.l_addr = linker_kernel_file->address;
204 ef->gdb.l_name = modname;
205 ef->gdb.l_ld = dp;
206 ef->gdb.l_prev = 0;
207 ef->gdb.l_next = 0;
208

--- 6 unchanged lines hidden (view full) ---

215
216 }
217#endif
218}
219
220SYSINIT(link_elf, SI_SUB_KLD, SI_ORDER_SECOND, link_elf_init, 0);
221
222static int
202
203#ifdef DDB
204 ef->gdb.l_addr = linker_kernel_file->address;
205 ef->gdb.l_name = modname;
206 ef->gdb.l_ld = dp;
207 ef->gdb.l_prev = 0;
208 ef->gdb.l_next = 0;
209

--- 6 unchanged lines hidden (view full) ---

216
217 }
218#endif
219}
220
221SYSINIT(link_elf, SI_SUB_KLD, SI_ORDER_SECOND, link_elf_init, 0);
222
223static int
223parse_module_symbols(elf_file_t ef)
224link_elf_preload_parse_symbols(elf_file_t ef)
224{
225 caddr_t pointer;
226 caddr_t ssym, esym, base;
227 caddr_t strtab;
228 int strcnt;
229 Elf_Sym* symtab;
230 int symcnt;
231

--- 163 unchanged lines hidden (view full) ---

395
396 if ((l->l_prev->l_next = l->l_next) != NULL)
397 l->l_next->l_prev = l->l_prev;
398}
399
400#endif /* DDB */
401
402static int
225{
226 caddr_t pointer;
227 caddr_t ssym, esym, base;
228 caddr_t strtab;
229 int strcnt;
230 Elf_Sym* symtab;
231 int symcnt;
232

--- 163 unchanged lines hidden (view full) ---

396
397 if ((l->l_prev->l_next = l->l_next) != NULL)
398 l->l_next->l_prev = l->l_prev;
399}
400
401#endif /* DDB */
402
403static int
403link_elf_load_module(linker_class_t cls,
404 const char *filename, linker_file_t *result)
404link_elf_link_preload(linker_class_t cls,
405 const char* filename, linker_file_t *result)
405{
406 caddr_t modptr, baseptr, sizeptr, dynptr;
407 char *type;
408 elf_file_t ef;
409 linker_file_t lf;
410 int error;
411 vm_offset_t dp;
412
406{
407 caddr_t modptr, baseptr, sizeptr, dynptr;
408 char *type;
409 elf_file_t ef;
410 linker_file_t lf;
411 int error;
412 vm_offset_t dp;
413
413 /* Look to see if we have the module preloaded */
414 /* Look to see if we have the file preloaded */
414 modptr = preload_search_by_name(filename);
415 if (modptr == NULL)
415 modptr = preload_search_by_name(filename);
416 if (modptr == NULL)
416 return (link_elf_load_file(filename, result));
417 return ENOENT;
417
418
418 /* It's preloaded, check we can handle it and collect information */
419 type = (char *)preload_search_info(modptr, MODINFO_TYPE);
420 baseptr = preload_search_info(modptr, MODINFO_ADDR);
421 sizeptr = preload_search_info(modptr, MODINFO_SIZE);
422 dynptr = preload_search_info(modptr, MODINFO_METADATA|MODINFOMD_DYNAMIC);
423 if (type == NULL || strcmp(type, "elf module") != 0)
424 return (EFTYPE);
425 if (baseptr == NULL || sizeptr == NULL || dynptr == NULL)
426 return (EINVAL);

--- 7 unchanged lines hidden (view full) ---

434 ef->preloaded = 1;
435 ef->modptr = modptr;
436 ef->address = *(caddr_t *)baseptr;
437#ifdef SPARSE_MAPPING
438 ef->object = 0;
439#endif
440 dp = (vm_offset_t)ef->address + *(vm_offset_t *)dynptr;
441 ef->dynamic = (Elf_Dyn *)dp;
419 type = (char *)preload_search_info(modptr, MODINFO_TYPE);
420 baseptr = preload_search_info(modptr, MODINFO_ADDR);
421 sizeptr = preload_search_info(modptr, MODINFO_SIZE);
422 dynptr = preload_search_info(modptr, MODINFO_METADATA|MODINFOMD_DYNAMIC);
423 if (type == NULL || strcmp(type, "elf module") != 0)
424 return (EFTYPE);
425 if (baseptr == NULL || sizeptr == NULL || dynptr == NULL)
426 return (EINVAL);

--- 7 unchanged lines hidden (view full) ---

434 ef->preloaded = 1;
435 ef->modptr = modptr;
436 ef->address = *(caddr_t *)baseptr;
437#ifdef SPARSE_MAPPING
438 ef->object = 0;
439#endif
440 dp = (vm_offset_t)ef->address + *(vm_offset_t *)dynptr;
441 ef->dynamic = (Elf_Dyn *)dp;
442
443 lf->address = ef->address;
444 lf->size = *(size_t *)sizeptr;
445
446 error = parse_dynamic(ef);
447 if (error) {
448 linker_file_unload(lf);
449 return error;
450 }
442 lf->address = ef->address;
443 lf->size = *(size_t *)sizeptr;
444
445 error = parse_dynamic(ef);
446 if (error) {
447 linker_file_unload(lf);
448 return error;
449 }
451 error = load_dependancies(ef);
452 if (error) {
453 linker_file_unload(lf);
454 return error;
450 *result = lf;
451 return (0);
452}
453
454static int
455link_elf_link_preload_finish(linker_file_t lf)
456{
457 elf_file_t ef;
458 int error;
459
460 ef = (elf_file_t) lf;
461#if 0 /* this will be more trouble than it's worth for now */
462 for (dp = ef->dynamic; dp->d_tag != DT_NULL; dp++) {
463 if (dp->d_tag != DT_NEEDED)
464 continue;
465 modname = ef->strtab + dp->d_un.d_val;
466 error = linker_load_module(modname, lf);
467 if (error)
468 goto out;
455 }
469 }
470#endif
456 error = relocate_file(ef);
471 error = relocate_file(ef);
457 if (error) {
458 linker_file_unload(lf);
472 if (error)
459 return error;
473 return error;
460 }
461 (void)parse_module_symbols(ef);
462 lf->flags |= LINKER_FILE_LINKED;
474 (void)link_elf_preload_parse_symbols(ef);
463
464#ifdef DDB
465 GDB_STATE(RT_ADD);
466 ef->gdb.l_addr = lf->address;
475
476#ifdef DDB
477 GDB_STATE(RT_ADD);
478 ef->gdb.l_addr = lf->address;
467 ef->gdb.l_name = filename;
479 ef->gdb.l_name = lf->filename;
468 ef->gdb.l_ld = ef->dynamic;
469 link_elf_add_gdb(&ef->gdb);
470 GDB_STATE(RT_CONSISTENT);
471#endif
472
480 ef->gdb.l_ld = ef->dynamic;
481 link_elf_add_gdb(&ef->gdb);
482 GDB_STATE(RT_CONSISTENT);
483#endif
484
473 *result = lf;
474 return (0);
475}
476
477static int
485 return (0);
486}
487
488static int
478link_elf_load_file(const char* filename, linker_file_t* result)
489link_elf_load_file(linker_class_t cls, const char* filename, linker_file_t* result)
479{
480 struct nameidata nd;
481 struct proc* p = curproc; /* XXX */
482 Elf_Ehdr *hdr;
483 caddr_t firstpage;
484 int nbytes, i;
485 Elf_Phdr *phdr;
486 Elf_Phdr *phlimit;

--- 5 unchanged lines hidden (view full) ---

492 size_t mapsize;
493 Elf_Off base_offset;
494 Elf_Addr base_vaddr;
495 Elf_Addr base_vlimit;
496 int error = 0;
497 int resid;
498 elf_file_t ef;
499 linker_file_t lf;
490{
491 struct nameidata nd;
492 struct proc* p = curproc; /* XXX */
493 Elf_Ehdr *hdr;
494 caddr_t firstpage;
495 int nbytes, i;
496 Elf_Phdr *phdr;
497 Elf_Phdr *phlimit;

--- 5 unchanged lines hidden (view full) ---

503 size_t mapsize;
504 Elf_Off base_offset;
505 Elf_Addr base_vaddr;
506 Elf_Addr base_vlimit;
507 int error = 0;
508 int resid;
509 elf_file_t ef;
510 linker_file_t lf;
500 char *pathname;
501 Elf_Shdr *shdr;
502 int symtabindex;
503 int symstrindex;
504 int symcnt;
505 int strcnt;
506
507 shdr = NULL;
508 lf = NULL;
509
511 Elf_Shdr *shdr;
512 int symtabindex;
513 int symstrindex;
514 int symcnt;
515 int strcnt;
516
517 shdr = NULL;
518 lf = NULL;
519
510 pathname = linker_search_path(filename);
511 if (pathname == NULL)
512 return ENOENT;
513
514 NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, pathname, p);
520 NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, filename, p);
515 error = vn_open(&nd, FREAD, 0);
521 error = vn_open(&nd, FREAD, 0);
516 free(pathname, M_LINKER);
517 if (error)
518 return error;
519 NDFREE(&nd, NDF_ONLY_PNBUF);
520
521 /*
522 * Read the elf header from the file.
523 */
524 firstpage = malloc(PAGE_SIZE, M_LINKER, M_WAITOK);

--- 158 unchanged lines hidden (view full) ---

683 ef->dynamic = (Elf_Dyn *) (mapbase + phdyn->p_vaddr - base_vaddr);
684
685 lf->address = ef->address;
686 lf->size = mapsize;
687
688 error = parse_dynamic(ef);
689 if (error)
690 goto out;
522 if (error)
523 return error;
524 NDFREE(&nd, NDF_ONLY_PNBUF);
525
526 /*
527 * Read the elf header from the file.
528 */
529 firstpage = malloc(PAGE_SIZE, M_LINKER, M_WAITOK);

--- 158 unchanged lines hidden (view full) ---

688 ef->dynamic = (Elf_Dyn *) (mapbase + phdyn->p_vaddr - base_vaddr);
689
690 lf->address = ef->address;
691 lf->size = mapsize;
692
693 error = parse_dynamic(ef);
694 if (error)
695 goto out;
691 error = load_dependancies(ef);
696 error = linker_load_dependancies(lf);
692 if (error)
693 goto out;
697 if (error)
698 goto out;
699#if 0 /* this will be more trouble than it's worth for now */
700 for (dp = ef->dynamic; dp->d_tag != DT_NULL; dp++) {
701 if (dp->d_tag != DT_NEEDED)
702 continue;
703 modname = ef->strtab + dp->d_un.d_val;
704 error = linker_load_module(modname, lf);
705 if (error)
706 goto out;
707 }
708#endif
694 error = relocate_file(ef);
695 if (error)
696 goto out;
697
698 /* Try and load the symbol table if it's present. (you can strip it!) */
699 nbytes = hdr->e_shnum * hdr->e_shentsize;
700 if (nbytes == 0 || hdr->e_shoff == 0)
701 goto nosyms;

--- 39 unchanged lines hidden (view full) ---

741 if (error)
742 goto out;
743
744 ef->ddbsymcnt = symcnt / sizeof(Elf_Sym);
745 ef->ddbsymtab = (const Elf_Sym *)ef->symbase;
746 ef->ddbstrcnt = strcnt;
747 ef->ddbstrtab = ef->strbase;
748
709 error = relocate_file(ef);
710 if (error)
711 goto out;
712
713 /* Try and load the symbol table if it's present. (you can strip it!) */
714 nbytes = hdr->e_shnum * hdr->e_shentsize;
715 if (nbytes == 0 || hdr->e_shoff == 0)
716 goto nosyms;

--- 39 unchanged lines hidden (view full) ---

756 if (error)
757 goto out;
758
759 ef->ddbsymcnt = symcnt / sizeof(Elf_Sym);
760 ef->ddbsymtab = (const Elf_Sym *)ef->symbase;
761 ef->ddbstrcnt = strcnt;
762 ef->ddbstrtab = ef->strbase;
763
749 lf->flags |= LINKER_FILE_LINKED;
750
751#ifdef DDB
752 GDB_STATE(RT_ADD);
753 ef->gdb.l_addr = lf->address;
764#ifdef DDB
765 GDB_STATE(RT_ADD);
766 ef->gdb.l_addr = lf->address;
754 ef->gdb.l_name = linker_search_path(filename);
767 ef->gdb.l_name = filename;
755 ef->gdb.l_ld = ef->dynamic;
756 link_elf_add_gdb(&ef->gdb);
757 GDB_STATE(RT_CONSISTENT);
758#endif
759
760nosyms:
761
762 *result = lf;

--- 16 unchanged lines hidden (view full) ---

779{
780 elf_file_t ef = (elf_file_t) file;
781
782#ifdef DDB
783 if (ef->gdb.l_ld) {
784 GDB_STATE(RT_DELETE);
785 link_elf_delete_gdb(&ef->gdb);
786 GDB_STATE(RT_CONSISTENT);
768 ef->gdb.l_ld = ef->dynamic;
769 link_elf_add_gdb(&ef->gdb);
770 GDB_STATE(RT_CONSISTENT);
771#endif
772
773nosyms:
774
775 *result = lf;

--- 16 unchanged lines hidden (view full) ---

792{
793 elf_file_t ef = (elf_file_t) file;
794
795#ifdef DDB
796 if (ef->gdb.l_ld) {
797 GDB_STATE(RT_DELETE);
798 link_elf_delete_gdb(&ef->gdb);
799 GDB_STATE(RT_CONSISTENT);
787 /* The strange cast is to quieten a 'discarding const' warning. */
788 free((caddr_t) (uintptr_t) ef->gdb.l_name, M_LINKER);
789 }
790#endif
791
792 if (ef->preloaded) {
800 }
801#endif
802
803 if (ef->preloaded) {
793 link_elf_unload_module(file);
804 link_elf_unload_preload(file);
794 return;
795 }
796#ifdef SPARSE_MAPPING
797 if (ef->object) {
798 vm_map_remove(kernel_map, (vm_offset_t) ef->address,
799 (vm_offset_t) ef->address
800 + (ef->object->size << PAGE_SHIFT));
801 vm_object_deallocate(ef->object);

--- 4 unchanged lines hidden (view full) ---

806#endif
807 if (ef->symbase)
808 free(ef->symbase, M_LINKER);
809 if (ef->strbase)
810 free(ef->strbase, M_LINKER);
811}
812
813static void
805 return;
806 }
807#ifdef SPARSE_MAPPING
808 if (ef->object) {
809 vm_map_remove(kernel_map, (vm_offset_t) ef->address,
810 (vm_offset_t) ef->address
811 + (ef->object->size << PAGE_SHIFT));
812 vm_object_deallocate(ef->object);

--- 4 unchanged lines hidden (view full) ---

817#endif
818 if (ef->symbase)
819 free(ef->symbase, M_LINKER);
820 if (ef->strbase)
821 free(ef->strbase, M_LINKER);
822}
823
824static void
814link_elf_unload_module(linker_file_t file)
825link_elf_unload_preload(linker_file_t file)
815{
816 if (file->filename)
817 preload_delete_name(file->filename);
818}
819
826{
827 if (file->filename)
828 preload_delete_name(file->filename);
829}
830
820static int
821load_dependancies(elf_file_t ef)
822{
823 linker_file_t lfdep;
824 char* name;
825 const Elf_Dyn *dp;
826 int error = 0;
827
828 /*
829 * All files are dependant on /kernel.
830 */
831 if (linker_kernel_file) {
832 linker_kernel_file->refs++;
833 linker_file_add_dependancy(&ef->lf, linker_kernel_file);
834 }
835
836 for (dp = ef->dynamic; dp->d_tag != DT_NULL; dp++) {
837 if (dp->d_tag == DT_NEEDED) {
838 name = ef->strtab + dp->d_un.d_val;
839
840 error = linker_load_file(name, &lfdep);
841 if (error)
842 goto out;
843 error = linker_file_add_dependancy(&ef->lf, lfdep);
844 if (error)
845 goto out;
846 }
847 }
848
849out:
850 return error;
851}
852
853static const char *
854symbol_name(elf_file_t ef, Elf_Word r_info)
855{
856 const Elf_Sym *ref;
857
858 if (ELF_R_SYM(r_info)) {
859 ref = ef->symtab + ELF_R_SYM(r_info);
860 return ef->strtab + ref->st_name;

--- 212 unchanged lines hidden --- 		831static const char *
832symbol_name(elf_file_t ef, Elf_Word r_info)
833{
834 const Elf_Sym *ref;
835
836 if (ELF_R_SYM(r_info)) {
837 ref = ef->symtab + ELF_R_SYM(r_info);
838 return ef->strtab + ref->st_name;

--- 212 unchanged lines hidden ---