lib/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2025-09-02 16:01:20 +03:00
Code Activity

* Makerules ($(common-objpfx)libc.so): Depend on $(elfobjdir)/ld.so.

Browse Source 
* 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.
This commit is contained in:
Roland McGrath
1996-06-10 20:19:39 +00:00
parent 567c63af19
commit ba79d61b44
17 changed files with 659 additions and 391 deletions
Download Patch File Download Diff File Expand all files Collapse all files

79
elf/rtld.c
View File

@@ -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);
{
/* 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). */
/* 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 ();
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);
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);
/* 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 */;