+1998-09-06 09:00 Ulrich Drepper <drepper@cygnus.com>
+
+ * version.h (VERSION): Bump to 2.0.96.
+
+ Rewrite runtime linker to be truly thread-safe. There is now no
+ global variable specifying the scope. We create all needed
+ scopes at the time the link maps are created.
+ * elf/Versions [GLIBC_2.1]: Add _dl_loaded and _dl_main_searchlist.
+ * elf/link.h: Add struct r_scope_elem and use this for l_searchlist,
+ l_symbolic_searchlist, l_scope, and l_local_scope elements in
+ struct link_map.
+ * elf/dl-close.c: Rewritten accordingly.
+ * elf/dl-deps.c: Likewise.
+ * elf/dl-error.c: Likewise.
+ * elf/dl-init.c: Likewise.
+ * elf/dl-load.c: Likewise.
+ * elf/dl-lookup.c: Likewise.
+ * elf/dl-object.c: Likewise.
+ * elf/dl-open.c: Likewise.
+ * elf/dl-reloc.c: Likewise.
+ * elf/dl-runtime.c: Likewise.
+ * elf/dl-support.c: Likewise.
+ * elf/dl-symbol.c: Likewise.
+ * elf/dl-version.c: Likewise.
+ * elf/dlfcn.h: Likewise.
+ * elf/dlsym.c: Likewise.
+ * elf/dlvsym.c: Likewise.
+ * elf/ldsodefs.h: Likewise.
+ * elf/rtld.c: Likewise.
+ * iconv/gconv_dl.c: Likewise.
+ * nss/nsswitch.c: Likewise.
+ * sysdeps/i386/dl-machine.h: Likewise.
+ * sysdeps/unix/sysv/linux/i386/dl-librecon.h: Likewise.
+
1998-09-05 Mark Kettenis <kettenis@phys.uva.nl>
* sysdeps/mach/hurd/i386/init-first.c (init1): Call
GLIBC_2.1 {
# global variables
_dl_profile; _dl_profile_map; _dl_profile_output; _dl_start_profile;
+ _dl_loaded; _dl_main_searchlist;
# functions used in other libraries
_dl_mcount; _dl_mcount_wrapper; _dl_mcount_wrapper_check; _dl_unload_cache;
return;
}
- list = map->l_searchlist;
- nsearchlist = map->l_nsearchlist;
+ list = map->l_searchlist.r_list;
+ nsearchlist = map->l_searchlist.r_nlist;
/* Call all termination functions at once. */
for (i = 0; i < nsearchlist; ++i)
if (imap->l_global)
{
/* This object is in the global scope list. Remove it. */
- struct link_map **tail = _dl_global_scope_end;
+ unsigned int cnt = _dl_main_searchlist->r_nlist;
+
do
- --tail;
- while (*tail != imap);
- while (tail < _dl_global_scope_end)
+ --cnt;
+ while (_dl_main_searchlist->r_list[cnt] != imap);
+ while (cnt < _dl_main_searchlist->r_nlist)
{
- tail[0] = tail[1];
- ++tail;
+ _dl_main_searchlist->r_list[0]
+ = _dl_main_searchlist->r_list[1];
+ ++cnt;
}
- --_dl_global_scope_end;
+ --_dl_main_searchlist->r_nlist;
}
/* We can unmap all the maps at once. We determined the
#endif
if (imap->l_next)
imap->l_next->l_prev = imap->l_prev;
- if (imap->l_searchlist && imap->l_searchlist != list)
- free (imap->l_searchlist);
if (imap->l_versions != NULL)
free (imap->l_versions);
while (lnp != NULL);
/* Remove the searchlists. */
- if (imap->l_dupsearchlist != imap->l_searchlist)
+ if (imap->l_searchlist.r_duplist != imap->l_searchlist.r_list)
{
- /* If a l_searchlist object exists there always also is
- a l_dupsearchlist object. */
- assert (imap->l_dupsearchlist != NULL);
- free (imap->l_dupsearchlist);
+ /* If a r_list exists there always also is a r_duplist. */
+ assert (imap->l_searchlist.r_list != NULL);
+ free (imap->l_searchlist.r_duplist);
}
- if (imap != map && imap->l_searchlist != NULL)
- free (imap->l_searchlist);
+ if (imap != map && imap->l_searchlist.r_list != NULL)
+ free (imap->l_searchlist.r_list);
free (imap);
}
/* Store the search list we built in the object. It will be used for
searches in the scope of this object. */
- map->l_searchlist = malloc (nlist * sizeof (struct link_map *));
- if (map->l_searchlist == NULL)
+ map->l_searchlist.r_list = malloc (nlist * sizeof (struct link_map *));
+ if (map->l_searchlist.r_list == NULL)
_dl_signal_error (ENOMEM, map->l_name,
"cannot allocate symbol search list");
- map->l_nsearchlist = nlist;
+ map->l_searchlist.r_nlist = nlist;
for (nlist = 0, runp = known; runp; runp = runp->unique)
{
- map->l_searchlist[nlist++] = runp->map;
+ map->l_searchlist.r_list[nlist++] = runp->map;
/* Now clear all the mark bits we set in the objects on the search list
to avoid duplicates, so the next call starts fresh. */
runp->map->l_reserved = 0;
}
- map->l_ndupsearchlist = nduplist;
+ map->l_searchlist.r_nduplist = nduplist;
if (nlist == nduplist)
- map->l_dupsearchlist = map->l_searchlist;
+ map->l_searchlist.r_duplist = map->l_searchlist.r_list;
else
{
- map->l_dupsearchlist = malloc (nduplist * sizeof (struct link_map *));
- if (map->l_dupsearchlist == NULL)
+ map->l_searchlist.r_duplist = malloc (nduplist
+ * sizeof (struct link_map *));
+ if (map->l_searchlist.r_duplist == NULL)
_dl_signal_error (ENOMEM, map->l_name,
"cannot allocate symbol search list");
for (nlist = 0, runp = known; runp; runp = runp->dup)
- map->l_dupsearchlist[nlist++] = runp->map;
+ map->l_searchlist.r_duplist[nlist++] = runp->map;
}
}
#include <string.h>
#include <unistd.h>
#include <elf/ldsodefs.h>
+#include <bits/libc-lock.h>
/* This structure communicates state between _dl_catch_error and
_dl_signal_error. */
jmp_buf env; /* longjmp here on error. */
};
-/* This points to such a structure during a call to _dl_catch_error.
- During implicit startup and run-time work for needed shared libraries,
- this is null. */
+/* Multiple threads at once can use the `_dl_catch_error' function. The
+ calls can come from the `_dl_map_object_deps', `_dlerror_run', or from
+ any of the libc functionality which loads dynamic objects (NSS, iconv).
+ Therefore we have to be prepared to safe the state in thread-local
+ memory. `catch' will only be used for the non-threaded case.
+
+ Please note the horrible kludge we have to use to check for the
+ thread functions to be defined. The problem is that while running
+ ld.so standalone (i.e., before the relocation with the libc symbols
+ available) we do not have a real handling of undefined weak symbols.
+ All symbols are relocated, regardless of the availability. They are
+ relocated relative to the load address of the dynamic linker. Adding
+ this start address to zero (the value in the GOT for undefined symbols)
+ leads to an address which is the load address of ld.so. Once we have
+ relocated with the libc values the value is NULL if the function is
+ not available. Our "solution" is to regard NULL and the ld.so load
+ address as indicators for unavailable weak symbols. */
static struct catch *catch;
+#ifdef PIC
+# define tsd_setspecific(data) \
+ if (__libc_internal_tsd_set != (void *) _dl_rtld_map.l_addr \
+ && __libc_internal_tsd_set != NULL) \
+ __libc_internal_tsd_set (_LIBC_TSD_KEY_DL_ERROR, data); \
+ else \
+ catch = (data)
+# define tsd_getspecific() \
+ (__libc_internal_tsd_set != (void *) _dl_rtld_map.l_addr \
+ && __libc_internal_tsd_set != NULL \
+ ? (struct catch *) __libc_internal_tsd_get (_LIBC_TSD_KEY_DL_ERROR) \
+ : catch)
+#else
+# define tsd_setspecific(data) \
+ if (__libc_internal_tsd_set != NULL) \
+ __libc_internal_tsd_set (_LIBC_TSD_KEY_DL_ERROR, data); \
+ else \
+ catch = (data)
+# define tsd_getspecific() \
+ (__libc_internal_tsd_set != NULL \
+ ? (struct catch *) __libc_internal_tsd_get (_LIBC_TSD_KEY_DL_ERROR) \
+ : catch)
+#endif
+
+
/* This points to a function which is called when an error is
received. Unlike the handling of `catch' this function may return.
- The arguments will be the `errstring' and `objname'. */
+ The arguments will be the `errstring' and `objname'.
+
+ Since this functionality is not used in normal programs (only in ld.so)
+ we do not care about multi-threaded programs here. We keep this as a
+ global variable. */
static receiver_fct receiver;
const char *objname,
const char *errstring)
{
+ struct catch *lcatch;
+
if (! errstring)
errstring = "DYNAMIC LINKER BUG!!!";
- if (catch)
+ lcatch = tsd_getspecific ();
+ if (lcatch != NULL)
{
/* We are inside _dl_catch_error. Return to it. We have to
duplicate the error string since it might be allocated on the
stack. */
size_t objname_len = objname ? strlen (objname) + 2 : 0;
size_t errstring_len = strlen (errstring) + 1;
- catch->errstring = malloc (objname_len + errstring_len);
- if (catch->errstring != NULL)
+ lcatch->errstring = malloc (objname_len + errstring_len);
+ if (lcatch->errstring != NULL)
{
if (objname_len > 0)
{
- memcpy (catch->errstring, objname, objname_len - 2);
- memcpy (catch->errstring + objname_len - 2, ": ", 2);
+ memcpy (lcatch->errstring, objname, objname_len - 2);
+ memcpy (lcatch->errstring + objname_len - 2, ": ", 2);
}
- memcpy (catch->errstring + objname_len, errstring, errstring_len);
+ memcpy (lcatch->errstring + objname_len, errstring, errstring_len);
}
- longjmp (catch->env, errcode ?: -1);
+ longjmp (lcatch->env, errcode ?: -1);
}
else if (receiver)
{
inefficient. So we initialize `c' by hand. */
c.errstring = NULL;
- old = catch;
+ old = tsd_getspecific ();
errcode = setjmp (c.env);
if (errcode == 0)
{
- catch = &c;
+ tsd_setspecific (&c);
(*operate) (args);
- catch = old;
+ tsd_setspecific (old);
*errstring = NULL;
return 0;
}
/* We get here only if we longjmp'd out of OPERATE. */
- catch = old;
+ tsd_setspecific (old);
*errstring = c.errstring;
return errcode == -1 ? 0 : errcode;
}
struct catch *old_catch;
receiver_fct old_receiver;
- old_catch = catch;
+ old_catch = tsd_getspecific ();
old_receiver = receiver;
/* Set the new values. */
- catch = NULL;
+ tsd_setspecific (NULL);
receiver = fct;
(*operate) (args);
- catch = old_catch;
+ tsd_setspecific (old_catch);
receiver = old_receiver;
}
ElfW(Addr)
internal_function
-_dl_init_next (struct link_map *map)
+_dl_init_next (struct r_scope_elem *searchlist)
{
unsigned int i;
dependency order, so processing that list from back to front gets us
breadth-first leaf-to-root order. */
- i = map->l_nsearchlist;
+ i = searchlist->r_nlist;
while (i-- > 0)
{
- struct link_map *l = map->l_searchlist[i];
+ struct link_map *l = searchlist->r_list[i];
if (l->l_init_called)
/* This object is all done. */
continue;
}
- if (l->l_info[DT_INIT] &&
- !(l->l_name[0] == '\0' && l->l_type == lt_executable))
+ if (l->l_info[DT_INIT]
+ && (l->l_name[0] != '\0' || l->l_type != lt_executable))
{
/* Run this object's initializer. */
l->l_init_running = 1;
l = _dl_loaded;
if (l != NULL)
{
- if (l->l_type != lt_loaded && l->l_info[DT_RPATH])
+ /* We should never get here when initializing in a static application.
+ If this is a dynamically linked application _dl_loaded always
+ points to the main map which is not dlopen()ed. */
+ assert (l->l_type != lt_loaded);
+
+ if (l->l_info[DT_RPATH])
{
/* Allocate room for the search path and fill in information
from RPATH. */
#endif
/* Enter the new object in the list of loaded objects. */
- l = _dl_new_object (realname, name, l_type);
+ l = _dl_new_object (realname, name, l_type, loader);
if (! l)
lose (ENOMEM, "cannot create shared object descriptor");
l->l_opencount = 1;
- l->l_loader = loader;
/* Extract the remaining details we need from the ELF header
and then read in the program header table. */
if (l->l_info[DT_HASH])
_dl_setup_hash (l);
+ /* If this object has DT_SYMBOLIC set modify now its scope. We don't
+ have to do this for the main map. */
+ if (l->l_info[DT_SYMBOLIC] && &l->l_searchlist != l->l_scope[0])
+ {
+ /* Create an appropriate searchlist. It contains only this map.
+
+ XXX This is the definition of DT_SYMBOLIC in SysVr4. The old
+ GNU ld.so implementation had a different interpretation which
+ is more reasonable. We are prepared to add this possibility
+ back as part of a GNU extension of the ELF format. */
+ l->l_symbolic_searchlist.r_list =
+ (struct link_map **) malloc (sizeof (struct link_map *));
+
+ if (l->l_symbolic_searchlist.r_list == NULL)
+ lose (ENOMEM, "cannot create searchlist");
+
+ l->l_symbolic_searchlist.r_list[0] = l;
+ l->l_symbolic_searchlist.r_nlist = 1;
+ l->l_symbolic_searchlist.r_duplist = l->l_symbolic_searchlist.r_list;
+ l->l_symbolic_searchlist.r_nduplist = 1;
+
+ /* Now move the existing entries one back. */
+ memmove (&l->l_scope[1], &l->l_scope[0],
+ 3 * sizeof (struct r_scope_elem *));
+
+ /* Now add the new entry. */
+ l->l_scope[0] = &l->l_symbolic_searchlist;
+ }
+
return l;
}
\f
/* Enter the new object in the list of loaded objects. */
if ((name_copy = local_strdup (name)) == NULL
- || (l = _dl_new_object (name_copy, name, type)) == NULL)
+ || (l = _dl_new_object (name_copy, name, type, loader)) == NULL)
_dl_signal_error (ENOMEM, name,
"cannot create shared object descriptor");
/* We use an opencount of 0 as a sign for the faked entry. */
static inline int
do_lookup (const char *undef_name, unsigned long int hash,
const ElfW(Sym) *ref, struct sym_val *result,
- struct link_map *scope, size_t i, const char *reference_name,
+ struct r_scope_elem *scope, size_t i, const char *reference_name,
const struct r_found_version *version, struct link_map *skip,
int reloc_type)
{
- struct link_map **list = scope->l_searchlist;
- size_t n = scope->l_nsearchlist;
+ struct link_map **list = scope->r_list;
+ size_t n = scope->r_nlist;
struct link_map *map;
for (; i < n; ++i)
ElfW(Addr)
internal_function
_dl_lookup_symbol (const char *undef_name, const ElfW(Sym) **ref,
- struct link_map *symbol_scope[],
+ struct r_scope_elem *symbol_scope[],
const char *reference_name,
int reloc_type)
{
const unsigned long int hash = _dl_elf_hash (undef_name);
struct sym_val current_value = { NULL, NULL };
- struct link_map **scope;
+ struct r_scope_elem **scope;
/* Search the relevant loaded objects for a definition. */
for (scope = symbol_scope; *scope; ++scope)
ElfW(Addr)
internal_function
_dl_lookup_symbol_skip (const char *undef_name, const ElfW(Sym) **ref,
- struct link_map *symbol_scope[],
+ struct r_scope_elem *symbol_scope[],
const char *reference_name,
struct link_map *skip_map)
{
const unsigned long int hash = _dl_elf_hash (undef_name);
struct sym_val current_value = { NULL, NULL };
- struct link_map **scope;
+ struct r_scope_elem **scope;
size_t i;
/* Search the relevant loaded objects for a definition. */
scope = symbol_scope;
- for (i = 0; (*scope)->l_dupsearchlist[i] != skip_map; ++i)
- assert (i < (*scope)->l_ndupsearchlist);
+ for (i = 0; (*scope)->r_duplist[i] != skip_map; ++i)
+ assert (i < (*scope)->r_nduplist);
if (! do_lookup (undef_name, hash, *ref, ¤t_value,
*scope, i, reference_name, NULL, skip_map, 0))
ElfW(Addr)
internal_function
_dl_lookup_versioned_symbol (const char *undef_name, const ElfW(Sym) **ref,
- struct link_map *symbol_scope[],
+ struct r_scope_elem *symbol_scope[],
const char *reference_name,
const struct r_found_version *version,
int reloc_type)
{
const unsigned long int hash = _dl_elf_hash (undef_name);
struct sym_val current_value = { NULL, NULL };
- struct link_map **scope;
+ struct r_scope_elem **scope;
/* Search the relevant loaded objects for a definition. */
for (scope = symbol_scope; *scope; ++scope)
internal_function
_dl_lookup_versioned_symbol_skip (const char *undef_name,
const ElfW(Sym) **ref,
- struct link_map *symbol_scope[],
+ struct r_scope_elem *symbol_scope[],
const char *reference_name,
const struct r_found_version *version,
struct link_map *skip_map)
{
const unsigned long int hash = _dl_elf_hash (undef_name);
struct sym_val current_value = { NULL, NULL };
- struct link_map **scope;
+ struct r_scope_elem **scope;
size_t i;
/* Search the relevant loaded objects for a definition. */
scope = symbol_scope;
- for (i = 0; (*scope)->l_dupsearchlist[i] != skip_map; ++i)
- assert (i < (*scope)->l_ndupsearchlist);
+ for (i = 0; (*scope)->r_duplist[i] != skip_map; ++i)
+ assert (i < (*scope)->r_nduplist);
if (! do_lookup (undef_name, hash, *ref, ¤t_value,
*scope, i, reference_name, version, skip_map, 0))
#include <assert.h>
-/* List of objects currently loaded is [2] of this, aka _dl_loaded. */
-struct link_map *_dl_default_scope[5];
/* Allocate a `struct link_map' for a new object being loaded,
and enter it into the _dl_loaded list. */
struct link_map *
internal_function
-_dl_new_object (char *realname, const char *libname, int type)
+_dl_new_object (char *realname, const char *libname, int type,
+ struct link_map *loader)
{
+ struct link_map *l;
+ int idx;
size_t libname_len = strlen (libname) + 1;
struct link_map *new = calloc (sizeof *new, 1);
struct libname_list *newname = malloc (sizeof *newname + libname_len);
newname->next = NULL;
new->l_libname = newname;
new->l_type = type;
+ new->l_loader = loader;
- if (_dl_loaded == NULL)
- {
- new->l_prev = new->l_next = NULL;
- _dl_loaded = new;
- }
- else
+ /* Counter for the scopes we have to handle. */
+ idx = 0;
+
+ if (_dl_loaded != NULL)
{
- struct link_map *l = _dl_loaded;
+ l = _dl_loaded;
while (l->l_next)
l = l->l_next;
new->l_prev = l;
- new->l_next = NULL;
+ /* new->l_next = NULL; Would be necesary but we use calloc. */
l->l_next = new;
- }
- /* Don't try to find the origin for the main map. */
- if (realname[0] == '\0')
- new->l_origin = NULL;
+ /* Add the global scope. */
+ new->l_scope[idx++] = &_dl_loaded->l_searchlist;
+ }
+ /* This is our local scope. */
+ if (loader != NULL)
+ {
+ while (loader->l_loader != NULL)
+ loader = loader->l_loader;
+ new->l_scope[idx] = &loader->l_searchlist;
+ }
else
+ new->l_scope[idx] = &new->l_searchlist;
+
+ new->l_local_scope[0] = new->l_scope[idx];
+
+ /* Don't try to find the origin for the main map which has the name "". */
+ if (realname[0] != '\0')
{
char *origin;
/* Load the named object. */
args->map = new = _dl_map_object (NULL, file, 0, lt_loaded, 0);
- if (new->l_searchlist)
+ if (new->l_searchlist.r_list)
/* It was already open. */
return;
{
if (! l->l_relocated)
{
- /* We use an indirect call call for _dl_relocate_object because
- we must avoid using the PLT in the call. If our PLT entry for
- _dl_relocate_object hasn't been used yet, then the dynamic
- linker fixup routine will clobber _dl_global_scope during its
- work. We must be sure that nothing will require a PLT fixup
- between when _dl_object_relocation_scope returns and when we
- enter the dynamic linker's code (_dl_relocate_object). */
- __typeof (_dl_relocate_object) *reloc = &_dl_relocate_object;
-
- /* GCC is very clever. If we wouldn't add some magic it would
- simply optimize away our nice little variable `reloc' and we
- would result in a not working binary. So let's swing the
- magic ward. */
- asm ("" : "=r" (reloc) : "0" (reloc));
-
#ifdef PIC
if (_dl_profile != NULL)
{
start the profiling. */
struct link_map *old_profile_map = _dl_profile_map;
- (*reloc) (l, _dl_object_relocation_scope (l), 1, 1);
+ _dl_relocate_object (l, l->l_scope, 1, 1);
if (old_profile_map == NULL && _dl_profile_map != NULL)
/* We must prepare the profiling. */
}
else
#endif
- (*reloc) (l, _dl_object_relocation_scope (l),
- (mode & RTLD_BINDING_MASK) == RTLD_LAZY, 0);
-
- *_dl_global_scope_end = NULL;
+ _dl_relocate_object (l, l->l_scope,
+ (mode & RTLD_BINDING_MASK) == RTLD_LAZY, 0);
}
if (l == new)
{
/* The symbols of the new object and its dependencies are to be
introduced into the global scope that will be used to resolve
- references from other dynamically-loaded objects. */
-
+ references from other dynamically-loaded objects.
+
+ The global scope is the searchlist in the main link map. We
+ extend this list if necessary. There is one problem though:
+ since this structure was allocated very early (before the libc
+ is loaded) the memory it uses is allocated by the malloc()-stub
+ in the ld.so. When we come here these functions are not used
+ anymore. Instead the malloc() implementation of the libc is
+ used. But this means the block from the main map cannot be used
+ in an realloc() call. Therefore we allocate a completely new
+ array the first time we have to add something to the locale scope. */
if (_dl_global_scope_alloc == 0)
{
/* This is the first dynamic object given global scope. */
- _dl_global_scope_alloc = 8;
- _dl_global_scope = malloc (_dl_global_scope_alloc
- * sizeof (struct link_map *));
- if (! _dl_global_scope)
+ struct link_map **new_global;
+
+ _dl_global_scope_alloc = _dl_main_searchlist->r_nlist + 8;
+ new_global = (struct link_map **)
+ malloc (_dl_global_scope_alloc * sizeof (struct link_map *));
+ if (new_global == NULL)
{
- _dl_global_scope = _dl_default_scope;
+ _dl_global_scope_alloc = 0;
nomem:
new->l_global = 0;
_dl_signal_error (ENOMEM, file, "cannot extend global scope");
}
- _dl_global_scope[2] = _dl_default_scope[2];
- _dl_global_scope[3] = new;
- _dl_global_scope[4] = NULL;
- _dl_global_scope[5] = NULL;
- _dl_global_scope_end = &_dl_global_scope [4];
+
+ /* Copy over the old entries. */
+ memcpy (new_global, _dl_main_searchlist->r_list,
+ (_dl_main_searchlist->r_nlist * sizeof (struct link_map *)));
+
+ _dl_main_searchlist->r_list = new_global;
}
- else
+ else if (_dl_main_searchlist->r_nlist == _dl_global_scope_alloc)
{
- if (_dl_global_scope_end + 3
- > _dl_global_scope + _dl_global_scope_alloc)
- {
- /* Must extend the list. */
- struct link_map **new = realloc (_dl_global_scope,
- _dl_global_scope_alloc * 2
- * sizeof (struct link_map *));
- if (! new)
- goto nomem;
- _dl_global_scope = new;
- _dl_global_scope_end = new + _dl_global_scope_alloc - 2;
- _dl_global_scope_alloc *= 2;
- }
+ /* We have to extend the existing array of link maps in the
+ main map. */
+ struct link_map **new_global;
+
+ new_global = (struct link_map **)
+ malloc ((_dl_global_scope_alloc + 8) * sizeof (struct link_map *));
+ if (new_global == NULL)
+ goto nomem;
- /* Append the new object and re-terminate the list. */
- *_dl_global_scope_end++ = new;
- /* We keep the list double-terminated so the last element
- can be filled in for symbol lookups. */
- _dl_global_scope_end[0] = NULL;
- _dl_global_scope_end[1] = NULL;
+ _dl_global_scope_alloc += 8;
+ _dl_main_searchlist->r_list = new_global;
}
+
+ /* Now add the new entry. */
+ _dl_main_searchlist->r_list[_dl_main_searchlist->r_nlist] = new;
+
+ /* XXX Do we have to add something to r_dupsearchlist??? --drepper */
}
_dl_debug_state ();
/* Run the initializer functions of new objects. */
- while (init = _dl_init_next (new))
+ while (init = _dl_init_next (&new->l_searchlist))
(*(void (*) (int, char **, char **)) init) (__libc_argc, __libc_argv,
__environ);
+ if (new->l_global)
+ /* Now we can make the new map available in the global scope. */
+ ++_dl_main_searchlist->r_nlist;
+
if (_dl_sysdep_start == NULL)
/* We must be the static _dl_open in libc.a. A static program that
has loaded a dynamic object now has competition. */
/* Some error occured during loading. */
char *local_errstring;
- /* Reset the global scope. */
- *_dl_global_scope_end = NULL;
-
/* Remove the object from memory. It may be in an inconsistent
state if relocation failed, for example. */
if (args.map)
void
-_dl_relocate_object (struct link_map *l, struct link_map *scope[], int lazy,
- int consider_profiling)
+_dl_relocate_object (struct link_map *l, struct r_scope_elem *scope[],
+ int lazy, int consider_profiling)
{
if (l->l_relocated)
return;
#include <unistd.h>
#include <elf/ldsodefs.h>
-
-
-/* The global scope we will use for symbol lookups.
- This will be modified by _dl_open if RTLD_GLOBAL is used. */
-struct link_map **_dl_global_scope = _dl_default_scope;
-struct link_map **_dl_global_scope_end = &_dl_default_scope[3];
-
-
-/* Hack _dl_global_scope[0] and [1] as necessary, and return a pointer into
- _dl_global_scope that should be passed to _dl_lookup_symbol for symbol
- references made in the object L's relocations. */
-inline struct link_map **
-internal_function
-_dl_object_relocation_scope (struct link_map *l)
-{
- if (l->l_info[DT_SYMBOLIC])
- {
- /* This object's global references are to be resolved first
- in the object itself, and only secondarily in more global
- scopes. */
-
- if (! l->l_searchlist)
- /* We must construct the searchlist for this object. */
- _dl_map_object_deps (l, NULL, 0, 0);
-
- /* The primary scope is this object itself and its
- dependencies.
-
- XXX This is wrong. Only the object must be searched, not
- the dependencies. --drepper */
- _dl_global_scope[0] = l;
-
- /* Secondary is the dependency tree that reached L; the object
- requested directly by the user is at the root of that tree. */
- while (l->l_loader)
- l = l->l_loader;
- _dl_global_scope[1] = l;
-
- /* Finally, the global scope follows. */
-
- return _dl_global_scope;
- }
- else
- {
- /* Use first the global scope, and then the scope of the root of the
- dependency tree that first caused this object to be loaded. */
- while (l->l_loader)
- l = l->l_loader;
- /* There is no point in searching the same list twice. This isn't
- guaranteed to always find all duplicates if new objects are added
- to the global scope, but is good enough most of the time. */
- if (_dl_global_scope[2] != l)
- *_dl_global_scope_end = l;
- return &_dl_global_scope[2];
- }
-}
-\f
#include "dynamic-link.h"
#if !defined ELF_MACHINE_NO_RELA || ELF_MACHINE_NO_REL
void *const rel_addr = (void *)(l->l_addr + reloc->r_offset);
ElfW(Addr) value;
- /* Set up the scope to find symbols referenced by this object. */
- struct link_map **scope = _dl_object_relocation_scope (l);
-
/* Sanity check that we're really looking at a PLT relocation. */
assert (ELFW(R_TYPE)(reloc->r_info) == ELF_MACHINE_JMP_SLOT);
if (version->hash != 0)
{
value = _dl_lookup_versioned_symbol(strtab + sym->st_name,
- &sym, scope, l->l_name,
+ &sym, l->l_scope, l->l_name,
version, ELF_MACHINE_JMP_SLOT);
break;
}
}
case 0:
- value = _dl_lookup_symbol (strtab + sym->st_name, &sym, scope,
+ value = _dl_lookup_symbol (strtab + sym->st_name, &sym, l->l_scope,
l->l_name, ELF_MACHINE_JMP_SLOT);
}
/* Finally, fix up the plt itself. */
elf_machine_fixup_plt (l, reloc, rel_addr, value);
- *_dl_global_scope_end = NULL;
-
return value;
}
reloc_offset);
const ElfW(Sym) *sym = &symtab[ELFW(R_SYM) (reloc->r_info)];
- /* Set up the scope to find symbols referenced by this object. */
- struct link_map **scope = _dl_object_relocation_scope (l);
-
/* Sanity check that we're really looking at a PLT relocation. */
assert (ELFW(R_TYPE)(reloc->r_info) == ELF_MACHINE_JMP_SLOT);
if (version->hash != 0)
{
value = _dl_lookup_versioned_symbol(strtab + sym->st_name,
- &sym, scope, l->l_name,
- version,
+ &sym, l->l_scope,
+ l->l_name, version,
ELF_MACHINE_JMP_SLOT);
break;
}
}
case 0:
- value = _dl_lookup_symbol (strtab + sym->st_name, &sym, scope,
+ value = _dl_lookup_symbol (strtab + sym->st_name, &sym, l->l_scope,
l->l_name, ELF_MACHINE_JMP_SLOT);
}
/* And now perhaps the relocation addend. */
value = elf_machine_plt_value (l, reloc, value);
- *_dl_global_scope_end = NULL;
-
/* Store the result for later runs. */
*resultp = value;
}
/* Path where the binary is found. */
const char *_dl_origin_path;
+/* Initially empty list of loaded objects. */
+struct link_map *_dl_loaded;
+
+/* Fake scope. In dynamically linked binaries this is the scope of the
+ main application but here we don't have something like this. So
+ create a fake scope containing nothing. */
+static struct r_scope_elem fake_scope;
+/* Variable which can be used in lookup to process the global scope. */
+struct r_scope_elem *_dl_global_scope[2] = { &fake_scope, NULL };
+/* This is a global pointer to this structure which is public. It is
+ used by dlopen/dlclose to add and remove objects from what is regarded
+ to be the global scope. */
+struct r_scope_elem *_dl_main_searchlist = &fake_scope;
+
static void non_dynamic_init (void) __attribute__ ((unused));
{
ElfW(Addr) loadbase;
const ElfW(Sym) *ref = NULL;
- struct link_map *scope[2] = { map, NULL };
- loadbase = _dl_lookup_symbol (name, &ref, scope, map->l_name, 0);
+ loadbase = _dl_lookup_symbol (name, &ref, map->l_local_scope, map->l_name,
+ 0);
return loadbase + ref->st_value;
}
/* The required object is not in the global scope, look to see if it is
a dependency of the current object. */
- for (n = 0; n < map->l_nsearchlist; n++)
- if (_dl_name_match_p (name, map->l_searchlist[n]))
- return map->l_searchlist[n];
+ for (n = 0; n < map->l_searchlist.r_nlist; n++)
+ if (_dl_name_match_p (name, map->l_searchlist.r_list[n]))
+ return map->l_searchlist.r_list[n];
/* Should never happen. */
return NULL;
#define _DLFCN_H 1
#include <features.h>
+#define __need_NULL
+#include <stddef.h>
/* Collect various system dependand definitions and declarations. */
#include <bits/dlfcn.h>
-/* If the first argument of `dlsym' is set to RTLD_NEXT the run-time
- address of the symbol called NAME in the next shared object is
- returned. The "next" relation is defined by the order the shared
- objects were loaded. */
+/* If the first argument of `dlsym' or `dlvsym' is set to RTLD_NEXT
+ the run-time address of the symbol called NAME in the next shared
+ object is returned. The "next" relation is defined by the order
+ the shared objects were loaded. */
#define RTLD_NEXT ((void *) -1l)
+/* If the first argument to `dlsym' or `dlvsym' is set to RTLD_DEFAULT
+ the run-time address of the symbol called NAME in the global scope
+ is returned. */
+#define RTLD_DEFAULT NULL
+
__BEGIN_DECLS
/* Open the shared object FILE and map it in; return a handle that can be
the error string so that a following call returns null. */
extern char *dlerror __P ((void));
+#ifdef __USE_GNU
/* Fill in *INFO with the following information about ADDRESS.
Returns 0 iff no shared object's segments contain that address. */
typedef struct
} Dl_info;
extern int dladdr __P ((const void *__address, Dl_info *__info));
-#ifdef __USE_GNU
/* To support profiling of shared objects it is a good idea to call
the function found using `dlsym' using the following macro since
these calls do not use the PLT. But this would mean the dynamic
if (args->handle == NULL)
/* Search the global scope. */
args->loadbase = _dl_lookup_symbol (args->name, &args->ref,
- &(_dl_global_scope
- ?: _dl_default_scope)[2],
- NULL, 0);
+ _dl_global_scope, NULL, 0);
else if (args->handle == RTLD_NEXT)
{
struct link_map *l, *match;
while (l->l_loader)
l = l->l_loader;
- {
- struct link_map *mapscope[2] = { l, NULL };
- args->loadbase = _dl_lookup_symbol_skip (args->name, &args->ref,
- mapscope, NULL, match);
- }
+ args->loadbase = _dl_lookup_symbol_skip (args->name, &args->ref,
+ l->l_local_scope, NULL, match);
}
else
{
/* Search the scope of the given object. */
struct link_map *map = args->handle;
- struct link_map *mapscope[2] = { map, NULL };
- args->loadbase = _dl_lookup_symbol (args->name, &args->ref, mapscope,
- map->l_name, 0);
+ args->loadbase = _dl_lookup_symbol (args->name, &args->ref,
+ map->l_local_scope, map->l_name, 0);
}
}
if (args->handle == NULL)
/* Search the global scope. */
args->loadbase = _dl_lookup_versioned_symbol (args->name, &args->ref,
- &(_dl_global_scope
- ?: _dl_default_scope)[2],
+ _dl_global_scope,
NULL, &args->version, 0);
else if (args->handle == RTLD_NEXT)
{
while (l->l_loader)
l = l->l_loader;
- {
- struct link_map *mapscope[2] = { l, NULL };
- args->loadbase = _dl_lookup_versioned_symbol_skip (args->name,
- &args->ref,
- mapscope,
- NULL,
- &args->version,
- match);
- }
+ args->loadbase = _dl_lookup_versioned_symbol_skip (args->name,
+ &args->ref,
+ l->l_local_scope,
+ NULL, &args->version,
+ match);
}
else
{
/* Search the scope of the given object. */
struct link_map *map = args->handle;
- struct link_map *mapscope[2] = { map, NULL };
args->loadbase = _dl_lookup_versioned_symbol (args->name, &args->ref,
- mapscope, map->l_name,
+ map->l_local_scope,
+ map->l_name,
&args->version, 0);
}
}
symbols can be chosen. */
extern ElfW(Addr) _dl_lookup_symbol (const char *undef,
const ElfW(Sym) **sym,
- struct link_map *symbol_scope[],
+ struct r_scope_elem *symbol_scope[],
const char *reference_name,
int reloc_type)
internal_function;
/* Lookup versioned symbol. */
extern ElfW(Addr) _dl_lookup_versioned_symbol (const char *undef,
const ElfW(Sym) **sym,
- struct link_map *symbol_scope[],
+ struct r_scope_elem *symbol_scope[],
const char *reference_name,
const struct r_found_version *version,
int reloc_type)
/* For handling RTLD_NEXT we must be able to skip shared objects. */
extern ElfW(Addr) _dl_lookup_symbol_skip (const char *undef,
const ElfW(Sym) **sym,
- struct link_map *symbol_scope[],
+ struct r_scope_elem *symbol_scope[],
const char *reference_name,
struct link_map *skip_this)
internal_function;
skip shared objects. */
extern ElfW(Addr) _dl_lookup_versioned_symbol_skip (const char *undef,
const ElfW(Sym) **sym,
- struct link_map *symbol_scope[],
+ struct r_scope_elem *symbol_scope[],
const char *reference_name,
const struct r_found_version *version,
struct link_map *skip_this)
/* Structure describing the dynamic linker itself. */
extern struct link_map _dl_rtld_map;
-
-/* The list of objects currently loaded is the third element of the
- `_dl_default_scope' array, and the fourth element is always null.
- This leaves two slots before it that are used when resolving
- DT_SYMBOLIC objects' references one after it for normal references
- (see below). */
-#define _dl_loaded (_dl_default_scope[2])
-extern struct link_map *_dl_default_scope[5];
-
-/* Null-terminated list of objects in the dynamic `global scope'. The
- list starts at [2]; i.e. &_dl_global_scope[2] is the argument
- passed to _dl_lookup_symbol to search the global scope. To search
- a specific object and its dependencies in preference to the global
- scope, fill in the [1] slot and pass its address; for two specific
- object scopes, fill [0] and [1]. The list is double-terminated; to
- search the global scope and then a specific object and its
- dependencies, set *_dl_global_scope_end. This variable initially
- points to _dl_default_scope, and _dl_loaded is always kept in [2]
- of this list. A new list is malloc'd when new objects are loaded
- with RTLD_GLOBAL. */
-extern struct link_map **_dl_global_scope, **_dl_global_scope_end;
-extern size_t _dl_global_scope_alloc; /* Number of slots malloc'd. */
-
-/* Hack _dl_global_scope[0] and [1] as necessary, and return a pointer into
- _dl_global_scope that should be passed to _dl_lookup_symbol for symbol
- references made in the object MAP's relocations. */
-extern struct link_map **_dl_object_relocation_scope (struct link_map *map)
- internal_function;
-
+/* And a pointer to the map for the main map. */
+extern struct link_map *_dl_loaded;
+/* Array representing global scope. */
+extern struct r_scope_elem *_dl_global_scope[2];
+/* Direct pointer to the searchlist of the main object. */
+extern struct r_scope_elem *_dl_main_searchlist;
/* Allocate a `struct link_map' for a new object being loaded,
- and enter it into the _dl_loaded list. */
+ and enter it into the _dl_main_map list. */
extern struct link_map *_dl_new_object (char *realname, const char *libname,
- int type) internal_function;
+ int type, struct link_map *loader)
+ internal_function;
/* Relocate the given object (if it hasn't already been).
SCOPE is passed to _dl_lookup_symbol in symbol lookups.
If LAZY is nonzero, don't relocate its PLT. */
extern void _dl_relocate_object (struct link_map *map,
- struct link_map *scope[],
+ struct r_scope_elem *scope[],
int lazy, int consider_profiling);
/* Check the version dependencies of all objects available through
extern int _dl_check_map_versions (struct link_map *map, int verbose)
internal_function;
-/* Return the address of the next initializer function for MAP or one of
+/* Return the address of the next initializer function for SCOPE or one of
its dependencies that has not yet been run. When there are no more
initializers to be run, this returns zero. The functions are returned
in the order they should be called. */
-extern ElfW(Addr) _dl_init_next (struct link_map *map) internal_function;
+extern ElfW(Addr) _dl_init_next (struct r_scope_elem *scope) internal_function;
/* Call the finalizer functions of all shared objects whose
initializer functions have completed. */
struct r_found_version;
struct r_search_path_elem;
+/* Forward declaration. */
+struct link_map;
+
+/* Structure to describe a single list of scope elements. The lookup
+ functions get passed an array of pointers to such structures. */
+struct r_scope_elem
+{
+ /* Array of maps for the scope. */
+ struct link_map **r_list;
+ /* Number of entries in the scope. */
+ unsigned int r_nlist;
+
+ /* Array of maps which also includes duplicates. */
+ struct link_map **r_duplist;
+ /* Number of elements in this list. */
+ unsigned int r_nduplist;
+};
+
/* Structure describing a loaded shared object. The `l_next' and `l_prev'
members form a chain of all the shared objects loaded at startup.
ElfW(Half) l_phnum; /* Number of program header entries. */
/* Array of DT_NEEDED dependencies and their dependencies, in
- dependency order for symbol lookup. This is null before the
- dependencies have been loaded. */
- struct link_map **l_searchlist;
- unsigned int l_nsearchlist;
+ dependency order for symbol lookup (with and without
+ duplicates). There is no entry before the dependencies have
+ been loaded. */
+ struct r_scope_elem l_searchlist;
- /* We keep another list in which we keep duplicates. This is
- needed in _dl_lookup_symbol_skip to implemented RTLD_NEXT. */
- struct link_map **l_dupsearchlist;
- unsigned int l_ndupsearchlist;
+ /* We need a special searchlist to process objects marked with
+ DT_SYMBOLIC. */
+ struct r_scope_elem l_symbolic_searchlist;
/* Dependent object that first caused this object to be loaded. */
struct link_map *l_loader;
/* Start and finish of memory map for this object. l_map_start
need not be the same as l_addr. */
ElfW(Addr) l_map_start, l_map_end;
+
+ /* This is an array defining the lookup scope for this link map.
+ There are at most three different scope lists. */
+ struct r_scope_elem *l_scope[4];
+
+ /* A similar array, this time only with the local scope. This is
+ used occasionally. */
+ struct r_scope_elem *l_local_scope[2];
};
#endif /* link.h */
ignored. */
const char *_dl_origin_path;
+/* This is a pointer to the map for the main object and through it to
+ all loaded objects. */
+struct link_map *_dl_loaded;
+/* Pointer to the l_searchlist element of the link map of the main object. */
+struct r_scope_elem *_dl_main_searchlist;
+/* Array which is used when looking up in the global scope. */
+struct r_scope_elem *_dl_global_scope[2];
+
/* Set nonzero during loading and initialization of executable and
libraries, cleared before the executable's entry point runs. This
must not be initialized to nonzero, because the unused dynamic
/* Arguments to version_check_doit. */
struct version_check_args
{
- struct link_map *main_map;
int doexit;
};
{
struct relocate_args *args = (struct relocate_args *) a;
- _dl_relocate_object (args->l, _dl_object_relocation_scope (args->l),
+ _dl_relocate_object (args->l, args->l->l_scope,
args->lazy, 0);
}
static void
map_doit (void *a)
{
- struct map_args *args = (struct map_args *)a;
+ struct map_args *args = (struct map_args *) a;
args->main_map = _dl_map_object (NULL, args->str, 0, lt_library, 0);
}
static void
version_check_doit (void *a)
{
- struct version_check_args *args = (struct version_check_args *)a;
- if (_dl_check_all_versions (args->main_map, 1) && args->doexit)
+ struct version_check_args *args = (struct version_check_args *) a;
+ if (_dl_check_all_versions (_dl_loaded, 1) && args->doexit)
/* We cannot start the application. Abort now. */
_exit (1);
}
static inline struct link_map *
find_needed (const char *name)
{
- unsigned int n;
+ unsigned int n = _dl_loaded->l_searchlist.r_nlist;
- for (n = 0; n < _dl_loaded->l_nsearchlist; ++n)
- if (_dl_name_match_p (name, _dl_loaded->l_searchlist[n]))
- return _dl_loaded->l_searchlist[n];
+ while (n-- > 0)
+ if (_dl_name_match_p (name, _dl_loaded->l_searchlist.r_list[n]))
+ return _dl_loaded->l_searchlist.r_list[n];
/* Should never happen. */
return NULL;
ElfW(Addr) *user_entry)
{
const ElfW(Phdr) *ph;
- struct link_map *main_map;
int lazy;
enum mode mode;
struct link_map **preloads;
args.str = _dl_argv[0];
(void) _dl_catch_error (&err_str, map_doit, &args);
- main_map = args.main_map;
+ _dl_loaded = args.main_map;
if (err_str != NULL)
{
free (err_str);
}
}
else
- main_map = _dl_map_object (NULL, _dl_argv[0], 0, lt_library, 0);
+ _dl_loaded = _dl_map_object (NULL, _dl_argv[0], 0, lt_library, 0);
- phdr = main_map->l_phdr;
- phent = main_map->l_phnum;
+ phdr = _dl_loaded->l_phdr;
+ phent = _dl_loaded->l_phnum;
/* We overwrite here a pointer to a malloc()ed string. But since
the malloc() implementation used at this point is the dummy
implementations which has no real free() function it does not
makes sense to free the old string first. */
- main_map->l_name = (char *) "";
- *user_entry = main_map->l_entry;
+ _dl_loaded->l_name = (char *) "";
+ *user_entry = _dl_loaded->l_entry;
}
else
{
/* Create a link_map for the executable itself.
This will be what dlopen on "" returns. */
- main_map = _dl_new_object ((char *) "", "", lt_executable);
- if (main_map == NULL)
+ _dl_loaded = _dl_new_object ((char *) "", "", lt_executable, NULL);
+ if (_dl_loaded == NULL)
_dl_sysdep_fatal ("cannot allocate memory for link map\n", NULL);
- main_map->l_phdr = phdr;
- main_map->l_phnum = phent;
- main_map->l_entry = *user_entry;
- main_map->l_opencount = 1;
+ _dl_loaded->l_phdr = phdr;
+ _dl_loaded->l_phnum = phent;
+ _dl_loaded->l_entry = *user_entry;
+ _dl_loaded->l_opencount = 1;
/* We delay initializing the path structure until we got the dynamic
information for the program. */
}
/* It is not safe to load stuff after the main program. */
- main_map->l_map_end = ~0;
+ _dl_loaded->l_map_end = ~0;
/* Perhaps the executable has no PT_LOAD header entries at all. */
- main_map->l_map_start = ~0;
+ _dl_loaded->l_map_start = ~0;
/* Scan the program header table for the dynamic section. */
for (ph = phdr; ph < &phdr[phent]; ++ph)
{
case PT_PHDR:
/* Find out the load address. */
- main_map->l_addr = (ElfW(Addr)) phdr - ph->p_vaddr;
+ _dl_loaded->l_addr = (ElfW(Addr)) phdr - ph->p_vaddr;
break;
case PT_DYNAMIC:
/* This tells us where to find the dynamic section,
which tells us everything we need to do. */
- main_map->l_ld = (void *) main_map->l_addr + ph->p_vaddr;
+ _dl_loaded->l_ld = (void *) _dl_loaded->l_addr + ph->p_vaddr;
break;
case PT_INTERP:
/* This "interpreter segment" was used by the program loader to
dlopen call or DT_NEEDED entry, for something that wants to link
against the dynamic linker as a shared library, will know that
the shared object is already loaded. */
- _dl_rtld_libname.name = (const char *) main_map->l_addr + ph->p_vaddr;
+ _dl_rtld_libname.name = ((const char *) _dl_loaded->l_addr
+ + ph->p_vaddr);
_dl_rtld_libname.next = NULL;
_dl_rtld_map.l_libname = &_dl_rtld_libname;
/* Remember where the main program starts in memory. */
{
ElfW(Addr) mapstart;
- mapstart = main_map->l_addr + (ph->p_vaddr & ~(ph->p_align - 1));
- if (main_map->l_map_start > mapstart)
- main_map->l_map_start = mapstart;
+ mapstart = _dl_loaded->l_addr + (ph->p_vaddr & ~(ph->p_align - 1));
+ if (_dl_loaded->l_map_start > mapstart)
+ _dl_loaded->l_map_start = mapstart;
}
break;
}
assert (_dl_rtld_map.l_libname); /* How else did we get here? */
/* Extract the contents of the dynamic section for easy access. */
- elf_get_dynamic_info (main_map->l_ld, main_map->l_info);
- if (main_map->l_info[DT_HASH])
+ elf_get_dynamic_info (_dl_loaded->l_ld, _dl_loaded->l_info);
+ if (_dl_loaded->l_info[DT_HASH])
/* Set up our cache of pointers into the hash table. */
- _dl_setup_hash (main_map);
+ _dl_setup_hash (_dl_loaded);
if (mode == verify)
{
executable using us as the program interpreter. Exit with an
error if we were not able to load the binary or no interpreter
is specified (i.e., this is no dynamically linked binary. */
- if (main_map->l_ld == NULL)
+ if (_dl_loaded->l_ld == NULL)
_exit (1);
/* We allow here some platform specific code. */
/* Put the link_map for ourselves on the chain so it can be found by
name. Note that at this point the global chain of link maps contains
- exactly one element, which is pointed to by main_map. */
+ exactly one element, which is pointed to by _dl_loaded. */
if (! _dl_rtld_map.l_name)
/* If not invoked directly, the dynamic linker shared object file was
found by the PT_INTERP name. */
_dl_rtld_map.l_name = (char *) _dl_rtld_map.l_libname->name;
_dl_rtld_map.l_type = lt_library;
- main_map->l_next = &_dl_rtld_map;
- _dl_rtld_map.l_prev = main_map;
+ _dl_loaded->l_next = &_dl_rtld_map;
+ _dl_rtld_map.l_prev = _dl_loaded;
/* We have two ways to specify objects to preload: via environment
variable and via the file /etc/ld.so.preload. The later can also
if (p[0] != '\0'
&& (! __libc_enable_secure || strchr (p, '/') == NULL))
{
- struct link_map *new_map = _dl_map_object (main_map, p, 1,
+ struct link_map *new_map = _dl_map_object (_dl_loaded, p, 1,
lt_library, 0);
if (new_map->l_opencount == 1)
/* It is no duplicate. */
while ((p = strsep (&runp, ": \t\n")) != NULL)
if (p[0] != '\0')
{
- struct link_map *new_map = _dl_map_object (main_map, p, 1,
+ struct link_map *new_map = _dl_map_object (_dl_loaded, p, 1,
lt_library, 0);
if (new_map->l_opencount == 1)
/* It is no duplicate. */
if (problem != NULL)
{
char *p = strndupa (problem, file_size - (problem - file));
- struct link_map *new_map = _dl_map_object (main_map, p, 1,
+ struct link_map *new_map = _dl_map_object (_dl_loaded, p, 1,
lt_library, 0);
if (new_map->l_opencount == 1)
/* It is no duplicate. */
/* Load all the libraries specified by DT_NEEDED entries. If LD_PRELOAD
specified some libraries to load, these are inserted before the actual
dependencies in the executable's searchlist for symbol resolution. */
- _dl_map_object_deps (main_map, preloads, npreloads, mode == trace);
+ _dl_map_object_deps (_dl_loaded, preloads, npreloads, mode == trace);
#ifndef MAP_ANON
/* We are done mapping things, so close the zero-fill descriptor. */
chain in symbol search order because gdb uses the chain's order as
its symbol search order. */
i = 1;
- while (main_map->l_searchlist[i] != &_dl_rtld_map)
+ while (_dl_loaded->l_searchlist.r_list[i] != &_dl_rtld_map)
++i;
- _dl_rtld_map.l_prev = main_map->l_searchlist[i - 1];
- _dl_rtld_map.l_next = (i + 1 < main_map->l_nsearchlist ?
- main_map->l_searchlist[i + 1] : NULL);
+ _dl_rtld_map.l_prev = _dl_loaded->l_searchlist.r_list[i - 1];
+ _dl_rtld_map.l_next = (i + 1 < _dl_loaded->l_searchlist.r_nlist
+ ? _dl_loaded->l_searchlist.r_list[i + 1]
+ : NULL);
assert (_dl_rtld_map.l_prev->l_next == _dl_rtld_map.l_next);
_dl_rtld_map.l_prev->l_next = &_dl_rtld_map;
if (_dl_rtld_map.l_next)
{
struct version_check_args args;
args.doexit = mode == normal;
- args.main_map = main_map;
_dl_receive_error (print_missing_version, version_check_doit, &args);
}
{
const ElfW(Sym) *ref = NULL;
ElfW(Addr) loadbase = _dl_lookup_symbol (_dl_argv[i], &ref,
- &_dl_default_scope[2],
+ _dl_loaded->l_scope,
"argument",
ELF_MACHINE_JMP_SLOT);
char buf[20], *bp;
args.l = l;
_dl_receive_error (print_unresolved, relocate_doit,
&args);
- *_dl_global_scope_end = NULL;
}
l = l->l_prev;
} while (l);
do
{
if (l != &_dl_rtld_map)
- {
- _dl_relocate_object (l, _dl_object_relocation_scope (l), lazy,
- consider_profiling);
- *_dl_global_scope_end = NULL;
- }
+ _dl_relocate_object (l, l->l_scope, lazy, consider_profiling);
+
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, &_dl_default_scope[2], 0, 0);
+ _dl_relocate_object (&_dl_rtld_map, _dl_loaded->l_scope, 0, 0);
}
+ /* Now set up the variable which helps the assembler startup code. */
+ _dl_main_searchlist = &_dl_loaded->l_searchlist;
+ _dl_global_scope[0] = &_dl_loaded->l_searchlist;
+
{
/* Initialize _r_debug. */
struct r_debug *r = _dl_debug_initialize (_dl_rtld_map.l_addr);
get_sym (void *a)
{
struct get_sym_args *args = (struct get_sym_args *) a;
- struct link_map *scope[2] = { args->map, NULL };
args->ref = NULL;
args->loadbase = _dl_lookup_symbol (args->name, &args->ref,
- scope, args->map->l_name, 0);
+ args->map->l_local_scope,
+ args->map->l_name, 0);
}
+1998-09-06 09:08 Ulrich Drepper <drepper@cygnus.com>
+
+ * sysdeps/pthread/bits/libc-lock.h (enum __libc_tsd_key_t): Add
+ _LIBC_TSD_KEY_DL_ERROR.
+
1998-08-31 Ulrich Drepper <drepper@cygnus.com>
* sysdeps/i386/i686/pt-machine.h (testandset): Add memory clobber.
#ifdef _LIBC
/* Fast thread-specific data internal to libc. */
-enum __libc_tsd_key_t { _LIBC_TSD_KEY_MALLOC = 0, _LIBC_TSD_KEY_N };
+enum __libc_tsd_key_t { _LIBC_TSD_KEY_MALLOC = 0,
+ _LIBC_TSD_KEY_DL_ERROR,
+ _LIBC_TSD_KEY_N };
extern void *__libc_internal_tsd_get __P ((enum __libc_tsd_key_t));
extern int __libc_internal_tsd_set __P ((enum __libc_tsd_key_t,
get_sym (void *a)
{
struct get_sym_args *args = (struct get_sym_args *) a;
- struct link_map *scope[2] = { args->map, NULL };
args->ref = NULL;
args->loadbase = _dl_lookup_symbol (args->name, &args->ref,
- scope, args->map->l_name, 0);
+ args->map->l_local_scope,
+ args->map->l_name, 0);
}
#endif
leal (%esp,%eax,4), %esp\n\
# Push back the modified argument count.\n\
pushl %ecx\n\
- # Push _dl_default_scope[2] as argument in _dl_init_next call below.\n\
- movl _dl_default_scope@GOT(%ebx), %eax\n\
- movl 8(%eax), %esi\n\
+ # Push the searchlist of the main object as argument in\n\
+ # _dl_init_next call below.\n\
+ movl _dl_main_searchlist@GOT(%ebx), %eax\n\
+ movl (%eax), %esi\n\
0: movl %esi,%eax\n\
# Call _dl_init_next to return the address of an initializer\n\
# function to run.\n\
/* We have to find out whether the binary is linked against \
libc 5 or glibc. We do this by looking at all the DT_NEEDED \
entries. If one is libc.so.5 this is a libc 5 linked binary. */ \
- if (main_map->l_info[DT_NEEDED]) \
+ if (_dl_loaded->l_info[DT_NEEDED]) \
{ \
/* We have dependencies. */ \
- const char *strtab = ((void *) main_map->l_addr \
- + main_map->l_info[DT_STRTAB]->d_un.d_ptr); \
const ElfW(Dyn) *d; \
+ const char *strtab; \
\
- for (d = main_map->l_ld; d->d_tag != DT_NULL; ++d) \
+ strtab = ((void *) _dl_loaded->l_addr \
+ + _dl_loaded->l_info[DT_STRTAB]->d_un.d_ptr); \
+ \
+ for (d = _dl_loaded->l_ld; d->d_tag != DT_NULL; ++d) \
if (d->d_tag == DT_NEEDED \
&& strcmp (strtab + d->d_un.d_val, "libc.so.5") == 0) \
break; \
projects / thirdparty / glibc.git / commitdiff
