/* Load a shared object at runtime, relocate it, and run its initializer.
- Copyright (C) 1996-2013 Free Software Foundation, Inc.
+ Copyright (C) 1996-2015 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
#include <dl-dst.h>
-extern ElfW(Addr) _dl_sysdep_start (void **start_argptr,
- void (*dl_main) (const ElfW(Phdr) *phdr,
- ElfW(Word) phnum,
- ElfW(Addr) *user_entry,
- ElfW(auxv_t) *auxv));
-weak_extern (_dl_sysdep_start)
-
extern int __libc_multiple_libcs; /* Defined in init-first.c. */
/* We must be careful not to leave us in an inconsistent state. Thus we
ns->_ns_main_searchlist->r_list[new_nlist++] = map;
/* We modify the global scope. Report this. */
- if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_SCOPES, 0))
+ if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_SCOPES))
_dl_debug_printf ("\nadd %s [%lu] to global scope\n",
map->l_name, map->l_ns);
}
return 0;
}
+/* Search link maps in all namespaces for the DSO that contains the object at
+ address ADDR. Returns the pointer to the link map of the matching DSO, or
+ NULL if a match is not found. */
+struct link_map *
+internal_function
+_dl_find_dso_for_object (const ElfW(Addr) addr)
+{
+ struct link_map *l;
+
+ /* Find the highest-addressed object that ADDR is not below. */
+ for (Lmid_t ns = 0; ns < GL(dl_nns); ++ns)
+ for (l = GL(dl_ns)[ns]._ns_loaded; l != NULL; l = l->l_next)
+ if (addr >= l->l_map_start && addr < l->l_map_end
+ && (l->l_contiguous
+ || _dl_addr_inside_object (l, (ElfW(Addr)) addr)))
+ {
+ assert (ns == l->l_ns);
+ return l;
+ }
+ return NULL;
+}
+rtld_hidden_def (_dl_find_dso_for_object);
+
static void
dl_open_worker (void *a)
{
{
const void *caller_dlopen = args->caller_dlopen;
-#ifdef SHARED
/* We have to find out from which object the caller is calling.
By default we assume this is the main application. */
call_map = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
-#endif
- struct link_map *l;
- for (Lmid_t ns = 0; ns < GL(dl_nns); ++ns)
- for (l = GL(dl_ns)[ns]._ns_loaded; l != NULL; l = l->l_next)
- if (caller_dlopen >= (const void *) l->l_map_start
- && caller_dlopen < (const void *) l->l_map_end
- && (l->l_contiguous
- || _dl_addr_inside_object (l, (ElfW(Addr)) caller_dlopen)))
- {
- assert (ns == l->l_ns);
- call_map = l;
- goto found_caller;
- }
+ struct link_map *l = _dl_find_dso_for_object ((ElfW(Addr)) caller_dlopen);
+
+ if (l)
+ call_map = l;
- found_caller:
if (args->nsid == __LM_ID_CALLER)
- {
-#ifndef SHARED
- /* In statically linked apps there might be no loaded object. */
- if (call_map == NULL)
- args->nsid = LM_ID_BASE;
- else
-#endif
- args->nsid = call_map->l_ns;
- }
+ args->nsid = call_map->l_ns;
}
- assert (_dl_debug_initialize (0, args->nsid)->r_state == RT_CONSISTENT);
+ /* One might be tempted to assert that we are RT_CONSISTENT at this point, but that
+ may not be true if this is a recursive call to dlopen. */
+ _dl_debug_initialize (0, args->nsid);
/* Load the named object. */
struct link_map *new;
return;
}
- if (__builtin_expect (mode & __RTLD_SPROF, 0))
+ if (__glibc_unlikely (mode & __RTLD_SPROF))
/* This happens only if we load a DSO for 'sprof'. */
return;
++new->l_direct_opencount;
/* It was already open. */
- if (__builtin_expect (new->l_searchlist.r_list != NULL, 0))
+ if (__glibc_unlikely (new->l_searchlist.r_list != NULL))
{
/* Let the user know about the opencount. */
- if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
+ if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_FILES))
_dl_debug_printf ("opening file=%s [%lu]; direct_opencount=%u\n\n",
new->l_name, new->l_ns, new->l_direct_opencount);
#ifdef SHARED
/* Auditing checkpoint: we have added all objects. */
- if (__builtin_expect (GLRO(dl_naudit) > 0, 0))
+ if (__glibc_unlikely (GLRO(dl_naudit) > 0))
{
struct link_map *head = GL(dl_ns)[new->l_ns]._ns_loaded;
/* Do not call the functions for any auditing object. */
LIBC_PROBE (map_complete, 3, args->nsid, r, new);
/* Print scope information. */
- if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_SCOPES, 0))
+ if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_SCOPES))
_dl_show_scope (new, 0);
/* Only do lazy relocation if `LD_BIND_NOW' is not set. */
if (nmaps > 1)
{
uint16_t seen[nmaps];
- memset (seen, '\0', nmaps);
+ memset (seen, '\0', sizeof (seen));
size_t i = 0;
while (1)
{
if (runp != NULL)
/* Look through the dependencies of the object. */
while (*runp != NULL)
- if (__builtin_expect (*runp++ == thisp, 0))
+ if (__glibc_unlikely (*runp++ == thisp))
{
/* Move the current object to the back past the last
object with it as the dependency. */
}
#ifdef SHARED
- if (__builtin_expect (GLRO(dl_profile) != NULL, 0))
+ if (__glibc_unlikely (GLRO(dl_profile) != NULL))
{
/* If this here is the shared object which we want to profile
make sure the profile is started. We can find out whether
this is necessary or not by observing the `_dl_profile_map'
- variable. If it was NULL but is not NULL afterwars we must
+ variable. If it was NULL but is not NULL afterwards we must
start the profiling. */
struct link_map *old_profile_map = GL(dl_profile_map);
/* Avoid duplicates. */
continue;
- if (__builtin_expect (cnt + 1 >= imap->l_scope_max, 0))
+ if (__glibc_unlikely (cnt + 1 >= imap->l_scope_max))
{
/* The 'r_scope' array is too small. Allocate a new one
dynamically. */
}
/* Print scope information. */
- if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_SCOPES, 0))
+ if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_SCOPES))
_dl_show_scope (imap, from_scope);
}
if (relocation_in_progress)
LIBC_PROBE (reloc_complete, 3, args->nsid, r, new);
+#ifndef SHARED
+ DL_STATIC_INIT (new);
+#endif
+
/* Run the initializer functions of new objects. */
_dl_init (new, args->argc, args->argv, args->env);
/* Mark the object as not deletable if the RTLD_NODELETE flags was
passed. */
- if (__builtin_expect (mode & RTLD_NODELETE, 0))
+ if (__glibc_unlikely (mode & RTLD_NODELETE))
new->l_flags_1 |= DF_1_NODELETE;
#ifndef SHARED
#endif
/* Let the user know about the opencount. */
- if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
+ if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_FILES))
_dl_debug_printf ("opening file=%s [%lu]; direct_opencount=%u\n\n",
new->l_name, new->l_ns, new->l_direct_opencount);
}
/* Make sure we are alone. */
__rtld_lock_lock_recursive (GL(dl_load_lock));
- if (__builtin_expect (nsid == LM_ID_NEWLM, 0))
+ if (__glibc_unlikely (nsid == LM_ID_NEWLM))
{
/* Find a new namespace. */
for (nsid = 1; DL_NNS > 1 && nsid < GL(dl_nns); ++nsid)
if (GL(dl_ns)[nsid]._ns_loaded == NULL)
break;
- if (__builtin_expect (nsid == DL_NNS, 0))
+ if (__glibc_unlikely (nsid == DL_NNS))
{
/* No more namespace available. */
__rtld_lock_unlock_recursive (GL(dl_load_lock));
|| GL(dl_ns)[nsid]._ns_loaded->l_auditing))
_dl_signal_error (EINVAL, file, NULL,
N_("invalid target namespace in dlmopen()"));
-#ifndef SHARED
- else if ((nsid == LM_ID_BASE || nsid == __LM_ID_CALLER)
- && GL(dl_ns)[LM_ID_BASE]._ns_loaded == NULL
- && GL(dl_nns) == 0)
- GL(dl_nns) = 1;
-#endif
struct dl_open_args args;
args.file = file;
#endif
/* See if an error occurred during loading. */
- if (__builtin_expect (errstring != NULL, 0))
+ if (__glibc_unlikely (errstring != NULL))
{
/* Remove the object from memory. It may be in an inconsistent
state if relocation failed, for example. */
/* Release the lock. */
__rtld_lock_unlock_recursive (GL(dl_load_lock));
-#ifndef SHARED
- DL_STATIC_INIT (args.map);
-#endif
-
return args.map;
}
_dl_show_scope (struct link_map *l, int from)
{
_dl_debug_printf ("object=%s [%lu]\n",
- *l->l_name ? l->l_name : rtld_progname, l->l_ns);
+ DSO_FILENAME (l->l_name), l->l_ns);
if (l->l_scope != NULL)
for (int scope_cnt = from; l->l_scope[scope_cnt] != NULL; ++scope_cnt)
{
_dl_debug_printf_c (" %s",
l->l_scope[scope_cnt]->r_list[cnt]->l_name);
else
- _dl_debug_printf_c (" %s", rtld_progname);
+ _dl_debug_printf_c (" %s", RTLD_PROGNAME);
_dl_debug_printf_c ("\n");
}
_dl_debug_printf ("\n");
}
-#ifdef IS_IN_rtld
+#if IS_IN (rtld)
/* Return non-zero if ADDR lies within one of L's segments. */
int
internal_function