From ba79d61b44be92bb81cba28076792a856585c4a0 Mon Sep 17 00:00:00 2001 From: Roland McGrath Date: Mon, 10 Jun 1996 20:19:39 +0000 Subject: * Makerules ($(common-objpfx)libc.so): Depend on $(elfobjdir)/ld.so. * elf/dl-close.c: New file. * elf/link.h: Declare _dl_close. * elf/Makefile (routines): Add dl-close. * elf/dlclose.c (dlclose): Use _dl_close. * elf/Makefile ($(objpfx)librtld.so): Remove libelf from deps. * elf/dl-runtime.c (_dl_global_scope): New variable. (_dl_object_relocation_scope): New function. (fixup): Use it. * elf/rtld.c (dl_main): Use it. * elf/dl-open.c (_dl_open): Use it. If (MODE & RTLD_GLOBAL), set the l_global bit and append the new map to _dl_global_scope. * elf/link.h: Declare _dl_global_scope, _dl_global_scope_alloc, and _dl_object_relocation_scope. * elf/link.h (struct link_map): Add l_loader member. Remove _dl_map_object_from_fd decl. * elf/dl-load.c (_dl_map_object): Pass LOADER to ... (_dl_map_object_from_fd): Take new arg LOADER and set l_loader member. (_dl_map_object): Try DT_RPATH from all loaders up the chain. * elf/dl-object.c (_dl_loaded): Variable removed. (_dl_default_scope): New variable replaces it. * elf/link.h (_dl_loaded): Remove variable decl; instead define as macro for _dl_default_scope[2]. (_dl_default_scope): Declare it. * sysdeps/i386/dl-machine.h (RTLD_START): Use _dl_default_scope[2] instead of _dl_loaded. * sysdeps/m68k/dl-machine.h (RTLD_START): Likewise. * elf/rtld.c (dl_main): Use _dl_default_scope for symbol lookups. * elf/dl-reloc.c (_dl_relocate_object): Remove check for _dl_rtld_map. * elf/rtld.c (dl_main): Pass 0 for LAZY flag when re-relocating self. * elf/link.h (struct link_map.l_type): Remove lt_interpreter. (struct link_map): Add new flag member l_global. * elf/dl-reloc.c (_dl_relocate_object): Check for _dl_rtld_map directly instead of looking for lt_interpreter. * sysdeps/i386/dl-machine.h (elf_machine_rel): Likewise. * elf/rtld.c (_dl_start): Don't bother setting BOOTSTRAP_MAP.l_type. (dl_main): Set _dl_rtld_map.l_type to lt_library. * elf/dl-deps.c (_dl_map_object_deps): Propagate MAP->l_type to dependencies loaded, downgrading lt_executable -> lt_library. * elf/dl-load.c (_dl_map_object_from_fd): Take new arg TYPE and set l_type from that, translating lt_library->lt_executable based on the file's ELF type. (_dl_map_object): Likewise. * elf/link.h: Update prototypes. * elf/dl-open.c: Pass type lt_loaded. * elf/rtld.c: Pass type lt_library. * elf/dl-load.c (_dl_map_object_from_fd): Handle null return from _dl_new_object. (_dl_map_object_from_fd: lose): Unchain and free L if it's not null. Free REALNAME, and just use NAME in error message. * elf/dl-object.c (_dl_new_object): If malloc fails, return null instead of calling _dl_signal_error. * elf/dl-load.c (_dl_map_object_from_fd): Close FD before signalling error for _dl_zerofd setup failure. * elf/dl-object.c (_dl_startup_loaded): Variable removed. * elf/link.h: Remove its decl. * elf/dl-reloc.c (_dl_relocate_object): Take new SCOPE arg and pass it through to _dl_lookup_symbol. * elf/link.h (_dl_relocate_object): Update comment and prototype. * elf/rtld.c (dl_main): Pass scope vector to _dl_relocate_object. * elf/dl-lookup.c (_dl_lookup_symbol): Arg SYMBOL_SCOPE is now a null-terminated vector of pointers, no longer a vector of exactly two. * elf/link.h (_dl_lookup_symbol): Update comment and prototype. * elf/dl-runtime.c (fixup): Set up scope for symbol lookup properly as done in _dl_relocate_object. * elf/dlopen.c: Pass "" to _dl_open when FILE is null. --- elf/rtld.c | 83 +++++++++++++++++++++++++++++++------------------------------- 1 file changed, 41 insertions(+), 42 deletions(-) (limited to 'elf/rtld.c') diff --git a/elf/rtld.c b/elf/rtld.c index bc1f71b..6647727 100644 --- a/elf/rtld.c +++ b/elf/rtld.c @@ -75,13 +75,6 @@ _dl_start (void *arg) /* Relocate ourselves so we can do normal function calls and data access using the global offset table. */ - /* We must initialize `l_type' to make sure it is not `lt_interpreter'. - That is the type to describe us, but not during bootstrapping--it - indicates to elf_machine_rel{,a} that we were already relocated during - bootstrapping, so it must anti-perform each bootstrapping relocation - before applying the final relocation when ld.so is linked in as - normal a shared library. */ - bootstrap_map.l_type = lt_library; ELF_DYNAMIC_RELOCATE (&bootstrap_map, 0, NULL); @@ -178,7 +171,7 @@ of this helper program; chances are you did not intend to run this program.\n", --_dl_argc; ++_dl_argv; - l = _dl_map_object (NULL, _dl_argv[0]); + l = _dl_map_object (NULL, _dl_argv[0], lt_library); phdr = l->l_phdr; phent = l->l_phnum; l->l_name = (char *) ""; @@ -188,7 +181,7 @@ of this helper program; chances are you did not intend to run this program.\n", { /* Create a link_map for the executable itself. This will be what dlopen on "" returns. */ - l = _dl_new_object ((char *) "", "", lt_executable); + l = _dl_new_object ((char *) "", "", lt_library); l->l_phdr = phdr; l->l_phnum = phent; interpreter_name = 0; @@ -245,7 +238,7 @@ of this helper program; chances are you did not intend to run this program.\n", /* Put the link_map for ourselves on the chain so it can be found by name. */ _dl_rtld_map.l_name = (char *) _dl_rtld_map.l_libname = interpreter_name; - _dl_rtld_map.l_type = lt_interpreter; + _dl_rtld_map.l_type = lt_library; while (l->l_next) l = l->l_next; l->l_next = &_dl_rtld_map; @@ -293,9 +286,9 @@ of this helper program; chances are you did not intend to run this program.\n", for (i = 1; i < _dl_argc; ++i) { const ElfW(Sym) *ref = NULL; - struct link_map *scope[2] ={ _dl_loaded, NULL }; - ElfW(Addr) loadbase - = _dl_lookup_symbol (_dl_argv[i], &ref, scope, "argument", 0, 0); + ElfW(Addr) loadbase = _dl_lookup_symbol (_dl_argv[i], &ref, + &_dl_default_scope[2], + "argument", 0, 0); char buf[20], *bp; buf[sizeof buf - 1] = '\0'; bp = _itoa (ref->st_value, &buf[sizeof buf - 1], 16, 0); @@ -314,35 +307,41 @@ of this helper program; chances are you did not intend to run this program.\n", lazy = !_dl_secure && *(getenv ("LD_BIND_NOW") ?: "") == '\0'; - /* Now we have all the objects loaded. Relocate them all except for - the dynamic linker itself. We do this in reverse order so that - copy relocs of earlier objects overwrite the data written by later - objects. We do not re-relocate the dynamic linker itself in this - loop because that could result in the GOT entries for functions we - call being changed, and that would break us. It is safe to - relocate the dynamic linker out of order because it has no copy - relocs (we know that because it is self-contained). */ - l = _dl_loaded; - while (l->l_next) - l = l->l_next; - do - { - if (l != &_dl_rtld_map) - _dl_relocate_object (l, lazy); - l = l->l_prev; - } while (l); - - /* Do any necessary cleanups for the startup OS interface code. - We do these now so that no calls are made after rtld re-relocation - which might be resolved to different functions than we expect. - We cannot do this before relocating the other objects because - _dl_relocate_object might need to call `mprotect' for DT_TEXTREL. */ - _dl_sysdep_start_cleanup (); - - if (_dl_rtld_map.l_opencount > 0) - /* There was an explicit ref to the dynamic linker as a shared lib. - Re-relocate ourselves with user-controlled symbol definitions. */ - _dl_relocate_object (&_dl_rtld_map, lazy); + { + /* Now we have all the objects loaded. Relocate them all except for + the dynamic linker itself. We do this in reverse order so that copy + relocs of earlier objects overwrite the data written by later + objects. We do not re-relocate the dynamic linker itself in this + loop because that could result in the GOT entries for functions we + call being changed, and that would break us. It is safe to relocate + the dynamic linker out of order because it has no copy relocs (we + know that because it is self-contained). */ + + l = _dl_loaded; + while (l->l_next) + l = l->l_next; + do + { + if (l != &_dl_rtld_map) + { + _dl_relocate_object (l, _dl_object_relocation_scope (l), lazy); + *_dl_global_scope_end = NULL; + } + l = l->l_prev; + } while (l); + + /* Do any necessary cleanups for the startup OS interface code. + We do these now so that no calls are made after rtld re-relocation + which might be resolved to different functions than we expect. + We cannot do this before relocating the other objects because + _dl_relocate_object might need to call `mprotect' for DT_TEXTREL. */ + _dl_sysdep_start_cleanup (); + + if (_dl_rtld_map.l_opencount > 0) + /* There was an explicit ref to the dynamic linker as a shared lib. + Re-relocate ourselves with user-controlled symbol definitions. */ + _dl_relocate_object (&_dl_rtld_map, &_dl_default_scope[2], 0); + } /* Tell the debugger where to find the map of loaded objects. */ _dl_r_debug.r_version = 1 /* R_DEBUG_VERSION XXX */; -- cgit v1.1