elf/dl-open.c

   1 /* Load a shared object at runtime, relocate it, and run its initializer.
   2    Copyright (C) 1996-2015 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <http://www.gnu.org/licenses/>.  */
  18
  19 #include <assert.h>
  20 #include <dlfcn.h>
  21 #include <errno.h>
  22 #include <libintl.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <unistd.h>
  27 #include <sys/mman.h>           /* Check whether MAP_COPY is defined.  */
  28 #include <sys/param.h>
  29 #include <bits/libc-lock.h>
  30 #include <ldsodefs.h>
  31 #include <caller.h>
  32 #include <sysdep-cancel.h>
  33 #include <tls.h>
  34 #include <stap-probe.h>
  35 #include <atomic.h>
  36
  37 #include <dl-dst.h>
  38
  39
  40 extern int __libc_multiple_libcs;       /* Defined in init-first.c.  */
  41
  42 /* We must be careful not to leave us in an inconsistent state.  Thus we
  43    catch any error and re-raise it after cleaning up.  */
  44
  45 struct dl_open_args
  46 {
  47   const char *file;
  48   int mode;
  49   /* This is the caller of the dlopen() function.  */
  50   const void *caller_dlopen;
  51   /* This is the caller of _dl_open().  */
  52   const void *caller_dl_open;
  53   struct link_map *map;
  54   /* Namespace ID.  */
  55   Lmid_t nsid;
  56   /* Original parameters to the program and the current environment.  */
  57   int argc;
  58   char **argv;
  59   char **env;
  60 };
  61
  62
  63 static int
  64 add_to_global (struct link_map *new)
  65 {
  66   struct link_map **new_global;
  67   unsigned int to_add = 0;
  68   unsigned int cnt;
  69
  70   /* Count the objects we have to put in the global scope.  */
  71   for (cnt = 0; cnt < new->l_searchlist.r_nlist; ++cnt)
  72     if (new->l_searchlist.r_list[cnt]->l_global == 0)
  73       ++to_add;
  74
  75   /* The symbols of the new objects and its dependencies are to be
  76      introduced into the global scope that will be used to resolve
  77      references from other dynamically-loaded objects.
  78
  79      The global scope is the searchlist in the main link map.  We
  80      extend this list if necessary.  There is one problem though:
  81      since this structure was allocated very early (before the libc
  82      is loaded) the memory it uses is allocated by the malloc()-stub
  83      in the ld.so.  When we come here these functions are not used
  84      anymore.  Instead the malloc() implementation of the libc is
  85      used.  But this means the block from the main map cannot be used
  86      in an realloc() call.  Therefore we allocate a completely new
  87      array the first time we have to add something to the locale scope.  */
  88
  89   struct link_namespaces *ns = &GL(dl_ns)[new->l_ns];
  90   if (ns->_ns_global_scope_alloc == 0)
  91     {
  92       /* This is the first dynamic object given global scope.  */
  93       ns->_ns_global_scope_alloc
  94         = ns->_ns_main_searchlist->r_nlist + to_add + 8;
  95       new_global = (struct link_map **)
  96         malloc (ns->_ns_global_scope_alloc * sizeof (struct link_map *));
  97       if (new_global == NULL)
  98         {
  99           ns->_ns_global_scope_alloc = 0;
 100         nomem:
 101           _dl_signal_error (ENOMEM, new->l_libname->name, NULL,
 102                             N_("cannot extend global scope"));
 103           return 1;
 104         }
 105
 106       /* Copy over the old entries.  */
 107       ns->_ns_main_searchlist->r_list
 108         = memcpy (new_global, ns->_ns_main_searchlist->r_list,
 109                   (ns->_ns_main_searchlist->r_nlist
 110                    * sizeof (struct link_map *)));
 111     }
 112   else if (ns->_ns_main_searchlist->r_nlist + to_add
 113            > ns->_ns_global_scope_alloc)
 114     {
 115       /* We have to extend the existing array of link maps in the
 116          main map.  */
 117       struct link_map **old_global
 118         = GL(dl_ns)[new->l_ns]._ns_main_searchlist->r_list;
 119       size_t new_nalloc = ((ns->_ns_global_scope_alloc + to_add) * 2);
 120
 121       new_global = (struct link_map **)
 122         malloc (new_nalloc * sizeof (struct link_map *));
 123       if (new_global == NULL)
 124         goto nomem;
 125
 126       memcpy (new_global, old_global,
 127               ns->_ns_global_scope_alloc * sizeof (struct link_map *));
 128
 129       ns->_ns_global_scope_alloc = new_nalloc;
 130       ns->_ns_main_searchlist->r_list = new_global;
 131
 132       if (!RTLD_SINGLE_THREAD_P)
 133         THREAD_GSCOPE_WAIT ();
 134
 135       free (old_global);
 136     }
 137
 138   /* Now add the new entries.  */
 139   unsigned int new_nlist = ns->_ns_main_searchlist->r_nlist;
 140   for (cnt = 0; cnt < new->l_searchlist.r_nlist; ++cnt)
 141     {
 142       struct link_map *map = new->l_searchlist.r_list[cnt];
 143
 144       if (map->l_global == 0)
 145         {
 146           map->l_global = 1;
 147           ns->_ns_main_searchlist->r_list[new_nlist++] = map;
 148
 149           /* We modify the global scope.  Report this.  */
 150           if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_SCOPES))
 151             _dl_debug_printf ("\nadd %s [%lu] to global scope\n",
 152                               map->l_name, map->l_ns);
 153         }
 154     }
 155   atomic_write_barrier ();
 156   ns->_ns_main_searchlist->r_nlist = new_nlist;
 157
 158   return 0;
 159 }
 160
 161 /* Search link maps in all namespaces for the DSO that contains the object at
 162    address ADDR.  Returns the pointer to the link map of the matching DSO, or
 163    NULL if a match is not found.  */
 164 struct link_map *
 165 internal_function
 166 _dl_find_dso_for_object (const ElfW(Addr) addr)
 167 {
 168   struct link_map *l;
 169
 170   /* Find the highest-addressed object that ADDR is not below.  */
 171   for (Lmid_t ns = 0; ns < GL(dl_nns); ++ns)
 172     for (l = GL(dl_ns)[ns]._ns_loaded; l != NULL; l = l->l_next)
 173       if (addr >= l->l_map_start && addr < l->l_map_end
 174           && (l->l_contiguous
 175               || _dl_addr_inside_object (l, (ElfW(Addr)) addr)))
 176         {
 177           assert (ns == l->l_ns);
 178           return l;
 179         }
 180   return NULL;
 181 }
 182 rtld_hidden_def (_dl_find_dso_for_object);
 183
 184 static void
 185 dl_open_worker (void *a)
 186 {
 187   struct dl_open_args *args = a;
 188   const char *file = args->file;
 189   int mode = args->mode;
 190   struct link_map *call_map = NULL;
 191
 192   /* Check whether _dl_open() has been called from a valid DSO.  */
 193   if (__check_caller (args->caller_dl_open,
 194                       allow_libc|allow_libdl|allow_ldso) != 0)
 195     _dl_signal_error (0, "dlopen", NULL, N_("invalid caller"));
 196
 197   /* Determine the caller's map if necessary.  This is needed in case
 198      we have a DST, when we don't know the namespace ID we have to put
 199      the new object in, or when the file name has no path in which
 200      case we need to look along the RUNPATH/RPATH of the caller.  */
 201   const char *dst = strchr (file, '$');
 202   if (dst != NULL || args->nsid == __LM_ID_CALLER
 203       || strchr (file, '/') == NULL)
 204     {
 205       const void *caller_dlopen = args->caller_dlopen;
 206
 207       /* We have to find out from which object the caller is calling.
 208          By default we assume this is the main application.  */
 209       call_map = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
 210
 211       struct link_map *l = _dl_find_dso_for_object ((ElfW(Addr)) caller_dlopen);
 212
 213       if (l)
 214         call_map = l;
 215
 216       if (args->nsid == __LM_ID_CALLER)
 217         args->nsid = call_map->l_ns;
 218     }
 219
 220   /* One might be tempted to assert that we are RT_CONSISTENT at this point, but that
 221      may not be true if this is a recursive call to dlopen.  */
 222   _dl_debug_initialize (0, args->nsid);
 223
 224   /* Load the named object.  */
 225   struct link_map *new;
 226   args->map = new = _dl_map_object (call_map, file, lt_loaded, 0,
 227                                     mode | __RTLD_CALLMAP, args->nsid);
 228
 229   /* If the pointer returned is NULL this means the RTLD_NOLOAD flag is
 230      set and the object is not already loaded.  */
 231   if (new == NULL)
 232     {
 233       assert (mode & RTLD_NOLOAD);
 234       return;
 235     }
 236
 237   if (__glibc_unlikely (mode & __RTLD_SPROF))
 238     /* This happens only if we load a DSO for 'sprof'.  */
 239     return;
 240
 241   /* This object is directly loaded.  */
 242   ++new->l_direct_opencount;
 243
 244   /* It was already open.  */
 245   if (__glibc_unlikely (new->l_searchlist.r_list != NULL))
 246     {
 247       /* Let the user know about the opencount.  */
 248       if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_FILES))
 249         _dl_debug_printf ("opening file=%s [%lu]; direct_opencount=%u\n\n",
 250                           new->l_name, new->l_ns, new->l_direct_opencount);
 251
 252       /* If the user requested the object to be in the global namespace
 253          but it is not so far, add it now.  */
 254       if ((mode & RTLD_GLOBAL) && new->l_global == 0)
 255         (void) add_to_global (new);
 256
 257       assert (_dl_debug_initialize (0, args->nsid)->r_state == RT_CONSISTENT);
 258
 259       return;
 260     }
 261
 262   /* Load that object's dependencies.  */
 263   _dl_map_object_deps (new, NULL, 0, 0,
 264                        mode & (__RTLD_DLOPEN | RTLD_DEEPBIND | __RTLD_AUDIT));
 265
 266   /* So far, so good.  Now check the versions.  */
 267   for (unsigned int i = 0; i < new->l_searchlist.r_nlist; ++i)
 268     if (new->l_searchlist.r_list[i]->l_real->l_versions == NULL)
 269       (void) _dl_check_map_versions (new->l_searchlist.r_list[i]->l_real,
 270                                      0, 0);
 271
 272 #ifdef SHARED
 273   /* Auditing checkpoint: we have added all objects.  */
 274   if (__glibc_unlikely (GLRO(dl_naudit) > 0))
 275     {
 276       struct link_map *head = GL(dl_ns)[new->l_ns]._ns_loaded;
 277       /* Do not call the functions for any auditing object.  */
 278       if (head->l_auditing == 0)
 279         {
 280           struct audit_ifaces *afct = GLRO(dl_audit);
 281           for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
 282             {
 283               if (afct->activity != NULL)
 284                 afct->activity (&head->l_audit[cnt].cookie, LA_ACT_CONSISTENT);
 285
 286               afct = afct->next;
 287             }
 288         }
 289     }
 290 #endif
 291
 292   /* Notify the debugger all new objects are now ready to go.  */
 293   struct r_debug *r = _dl_debug_initialize (0, args->nsid);
 294   r->r_state = RT_CONSISTENT;
 295   _dl_debug_state ();
 296   LIBC_PROBE (map_complete, 3, args->nsid, r, new);
 297
 298   /* Print scope information.  */
 299   if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_SCOPES))
 300     _dl_show_scope (new, 0);
 301
 302   /* Only do lazy relocation if `LD_BIND_NOW' is not set.  */
 303   int reloc_mode = mode & __RTLD_AUDIT;
 304   if (GLRO(dl_lazy))
 305     reloc_mode |= mode & RTLD_LAZY;
 306
 307   /* Sort the objects by dependency for the relocation process.  This
 308      allows IFUNC relocations to work and it also means copy
 309      relocation of dependencies are if necessary overwritten.  */
 310   size_t nmaps = 0;
 311   struct link_map *l = new;
 312   do
 313     {
 314       if (! l->l_real->l_relocated)
 315         ++nmaps;
 316       l = l->l_next;
 317     }
 318   while (l != NULL);
 319   struct link_map *maps[nmaps];
 320   nmaps = 0;
 321   l = new;
 322   do
 323     {
 324       if (! l->l_real->l_relocated)
 325         maps[nmaps++] = l;
 326       l = l->l_next;
 327     }
 328   while (l != NULL);
 329   if (nmaps > 1)
 330     {
 331       uint16_t seen[nmaps];
 332       memset (seen, '\0', sizeof (seen));
 333       size_t i = 0;
 334       while (1)
 335         {
 336           ++seen[i];
 337           struct link_map *thisp = maps[i];
 338
 339           /* Find the last object in the list for which the current one is
 340              a dependency and move the current object behind the object
 341              with the dependency.  */
 342           size_t k = nmaps - 1;
 343           while (k > i)
 344             {
 345               struct link_map **runp = maps[k]->l_initfini;
 346               if (runp != NULL)
 347                 /* Look through the dependencies of the object.  */
 348                 while (*runp != NULL)
 349                   if (__glibc_unlikely (*runp++ == thisp))
 350                     {
 351                       /* Move the current object to the back past the last
 352                          object with it as the dependency.  */
 353                       memmove (&maps[i], &maps[i + 1],
 354                                (k - i) * sizeof (maps[0]));
 355                       maps[k] = thisp;
 356
 357                       if (seen[i + 1] > nmaps - i)
 358                         {
 359                           ++i;
 360                           goto next_clear;
 361                         }
 362
 363                       uint16_t this_seen = seen[i];
 364                       memmove (&seen[i], &seen[i + 1],
 365                                (k - i) * sizeof (seen[0]));
 366                       seen[k] = this_seen;
 367
 368                       goto next;
 369                     }
 370
 371               --k;
 372             }
 373
 374           if (++i == nmaps)
 375             break;
 376         next_clear:
 377           memset (&seen[i], 0, (nmaps - i) * sizeof (seen[0]));
 378         next:;
 379         }
 380     }
 381
 382   int relocation_in_progress = 0;
 383
 384   for (size_t i = nmaps; i-- > 0; )
 385     {
 386       l = maps[i];
 387
 388       if (! relocation_in_progress)
 389         {
 390           /* Notify the debugger that relocations are about to happen.  */
 391           LIBC_PROBE (reloc_start, 2, args->nsid, r);
 392           relocation_in_progress = 1;
 393         }
 394
 395 #ifdef SHARED
 396       if (__glibc_unlikely (GLRO(dl_profile) != NULL))
 397         {
 398           /* If this here is the shared object which we want to profile
 399              make sure the profile is started.  We can find out whether
 400              this is necessary or not by observing the `_dl_profile_map'
 401              variable.  If it was NULL but is not NULL afterwards we must
 402              start the profiling.  */
 403           struct link_map *old_profile_map = GL(dl_profile_map);
 404
 405           _dl_relocate_object (l, l->l_scope, reloc_mode | RTLD_LAZY, 1);
 406
 407           if (old_profile_map == NULL && GL(dl_profile_map) != NULL)
 408             {
 409               /* We must prepare the profiling.  */
 410               _dl_start_profile ();
 411
 412               /* Prevent unloading the object.  */
 413               GL(dl_profile_map)->l_flags_1 |= DF_1_NODELETE;
 414             }
 415         }
 416       else
 417 #endif
 418         _dl_relocate_object (l, l->l_scope, reloc_mode, 0);
 419     }
 420
 421   /* If the file is not loaded now as a dependency, add the search
 422      list of the newly loaded object to the scope.  */
 423   bool any_tls = false;
 424   unsigned int first_static_tls = new->l_searchlist.r_nlist;
 425   for (unsigned int i = 0; i < new->l_searchlist.r_nlist; ++i)
 426     {
 427       struct link_map *imap = new->l_searchlist.r_list[i];
 428       int from_scope = 0;
 429
 430       /* If the initializer has been called already, the object has
 431          not been loaded here and now.  */
 432       if (imap->l_init_called && imap->l_type == lt_loaded)
 433         {
 434           struct r_scope_elem **runp = imap->l_scope;
 435           size_t cnt = 0;
 436
 437           while (*runp != NULL)
 438             {
 439               if (*runp == &new->l_searchlist)
 440                 break;
 441               ++cnt;
 442               ++runp;
 443             }
 444
 445           if (*runp != NULL)
 446             /* Avoid duplicates.  */
 447             continue;
 448
 449           if (__glibc_unlikely (cnt + 1 >= imap->l_scope_max))
 450             {
 451               /* The 'r_scope' array is too small.  Allocate a new one
 452                  dynamically.  */
 453               size_t new_size;
 454               struct r_scope_elem **newp;
 455
 456 #define SCOPE_ELEMS(imap) \
 457   (sizeof (imap->l_scope_mem) / sizeof (imap->l_scope_mem[0]))
 458
 459               if (imap->l_scope != imap->l_scope_mem
 460                   && imap->l_scope_max < SCOPE_ELEMS (imap))
 461                 {
 462                   new_size = SCOPE_ELEMS (imap);
 463                   newp = imap->l_scope_mem;
 464                 }
 465               else
 466                 {
 467                   new_size = imap->l_scope_max * 2;
 468                   newp = (struct r_scope_elem **)
 469                     malloc (new_size * sizeof (struct r_scope_elem *));
 470                   if (newp == NULL)
 471                     _dl_signal_error (ENOMEM, "dlopen", NULL,
 472                                       N_("cannot create scope list"));
 473                 }
 474
 475               memcpy (newp, imap->l_scope, cnt * sizeof (imap->l_scope[0]));
 476               struct r_scope_elem **old = imap->l_scope;
 477
 478               imap->l_scope = newp;
 479
 480               if (old != imap->l_scope_mem)
 481                 _dl_scope_free (old);
 482
 483               imap->l_scope_max = new_size;
 484             }
 485
 486           /* First terminate the extended list.  Otherwise a thread
 487              might use the new last element and then use the garbage
 488              at offset IDX+1.  */
 489           imap->l_scope[cnt + 1] = NULL;
 490           atomic_write_barrier ();
 491           imap->l_scope[cnt] = &new->l_searchlist;
 492
 493           /* Print only new scope information.  */
 494           from_scope = cnt;
 495         }
 496       /* Only add TLS memory if this object is loaded now and
 497          therefore is not yet initialized.  */
 498       else if (! imap->l_init_called
 499                /* Only if the module defines thread local data.  */
 500                && __builtin_expect (imap->l_tls_blocksize > 0, 0))
 501         {
 502           /* Now that we know the object is loaded successfully add
 503              modules containing TLS data to the slot info table.  We
 504              might have to increase its size.  */
 505           _dl_add_to_slotinfo (imap);
 506
 507           if (imap->l_need_tls_init
 508               && first_static_tls == new->l_searchlist.r_nlist)
 509             first_static_tls = i;
 510
 511           /* We have to bump the generation counter.  */
 512           any_tls = true;
 513         }
 514
 515       /* Print scope information.  */
 516       if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_SCOPES))
 517         _dl_show_scope (imap, from_scope);
 518     }
 519
 520   /* Bump the generation number if necessary.  */
 521   if (any_tls && __builtin_expect (++GL(dl_tls_generation) == 0, 0))
 522     _dl_fatal_printf (N_("\
 523 TLS generation counter wrapped!  Please report this."));
 524
 525   /* We need a second pass for static tls data, because _dl_update_slotinfo
 526      must not be run while calls to _dl_add_to_slotinfo are still pending.  */
 527   for (unsigned int i = first_static_tls; i < new->l_searchlist.r_nlist; ++i)
 528     {
 529       struct link_map *imap = new->l_searchlist.r_list[i];
 530
 531       if (imap->l_need_tls_init
 532           && ! imap->l_init_called
 533           && imap->l_tls_blocksize > 0)
 534         {
 535           /* For static TLS we have to allocate the memory here and
 536              now, but we can delay updating the DTV.  */
 537           imap->l_need_tls_init = 0;
 538 #ifdef SHARED
 539           /* Update the slot information data for at least the
 540              generation of the DSO we are allocating data for.  */
 541           _dl_update_slotinfo (imap->l_tls_modid);
 542 #endif
 543
 544           GL(dl_init_static_tls) (imap);
 545           assert (imap->l_need_tls_init == 0);
 546         }
 547     }
 548
 549   /* Notify the debugger all new objects have been relocated.  */
 550   if (relocation_in_progress)
 551     LIBC_PROBE (reloc_complete, 3, args->nsid, r, new);
 552
 553 #ifndef SHARED
 554   DL_STATIC_INIT (new);
 555 #endif
 556
 557   /* Run the initializer functions of new objects.  */
 558   _dl_init (new, args->argc, args->argv, args->env);
 559
 560   /* Now we can make the new map available in the global scope.  */
 561   if (mode & RTLD_GLOBAL)
 562     /* Move the object in the global namespace.  */
 563     if (add_to_global (new) != 0)
 564       /* It failed.  */
 565       return;
 566
 567   /* Mark the object as not deletable if the RTLD_NODELETE flags was
 568      passed.  */
 569   if (__glibc_unlikely (mode & RTLD_NODELETE))
 570     new->l_flags_1 |= DF_1_NODELETE;
 571
 572 #ifndef SHARED
 573   /* We must be the static _dl_open in libc.a.  A static program that
 574      has loaded a dynamic object now has competition.  */
 575   __libc_multiple_libcs = 1;
 576 #endif
 577
 578   /* Let the user know about the opencount.  */
 579   if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_FILES))
 580     _dl_debug_printf ("opening file=%s [%lu]; direct_opencount=%u\n\n",
 581                       new->l_name, new->l_ns, new->l_direct_opencount);
 582 }
 583
 584
 585 void *
 586 _dl_open (const char *file, int mode, const void *caller_dlopen, Lmid_t nsid,
 587           int argc, char *argv[], char *env[])
 588 {
 589   if ((mode & RTLD_BINDING_MASK) == 0)
 590     /* One of the flags must be set.  */
 591     _dl_signal_error (EINVAL, file, NULL, N_("invalid mode for dlopen()"));
 592
 593   /* Make sure we are alone.  */
 594   __rtld_lock_lock_recursive (GL(dl_load_lock));
 595
 596   if (__glibc_unlikely (nsid == LM_ID_NEWLM))
 597     {
 598       /* Find a new namespace.  */
 599       for (nsid = 1; DL_NNS > 1 && nsid < GL(dl_nns); ++nsid)
 600         if (GL(dl_ns)[nsid]._ns_loaded == NULL)
 601           break;
 602
 603       if (__glibc_unlikely (nsid == DL_NNS))
 604         {
 605           /* No more namespace available.  */
 606           __rtld_lock_unlock_recursive (GL(dl_load_lock));
 607
 608           _dl_signal_error (EINVAL, file, NULL, N_("\
 609 no more namespaces available for dlmopen()"));
 610         }
 611       else if (nsid == GL(dl_nns))
 612         {
 613           __rtld_lock_initialize (GL(dl_ns)[nsid]._ns_unique_sym_table.lock);
 614           ++GL(dl_nns);
 615         }
 616
 617       _dl_debug_initialize (0, nsid)->r_state = RT_CONSISTENT;
 618     }
 619   /* Never allow loading a DSO in a namespace which is empty.  Such
 620      direct placements is only causing problems.  Also don't allow
 621      loading into a namespace used for auditing.  */
 622   else if (__glibc_unlikely (nsid != LM_ID_BASE && nsid != __LM_ID_CALLER)
 623            && (__glibc_unlikely (nsid < 0 || nsid >= GL(dl_nns))
 624                /* This prevents the [NSID] index expressions from being
 625                   evaluated, so the compiler won't think that we are
 626                   accessing an invalid index here in the !SHARED case where
 627                   DL_NNS is 1 and so any NSID != 0 is invalid.  */
 628                || DL_NNS == 1
 629                || GL(dl_ns)[nsid]._ns_nloaded == 0
 630                || GL(dl_ns)[nsid]._ns_loaded->l_auditing))
 631     _dl_signal_error (EINVAL, file, NULL,
 632                       N_("invalid target namespace in dlmopen()"));
 633
 634   struct dl_open_args args;
 635   args.file = file;
 636   args.mode = mode;
 637   args.caller_dlopen = caller_dlopen;
 638   args.caller_dl_open = RETURN_ADDRESS (0);
 639   args.map = NULL;
 640   args.nsid = nsid;
 641   args.argc = argc;
 642   args.argv = argv;
 643   args.env = env;
 644
 645   const char *objname;
 646   const char *errstring;
 647   bool malloced;
 648   int errcode = _dl_catch_error (&objname, &errstring, &malloced,
 649                                  dl_open_worker, &args);
 650
 651 #if defined USE_LDCONFIG && !defined MAP_COPY
 652   /* We must unmap the cache file.  */
 653   _dl_unload_cache ();
 654 #endif
 655
 656   /* See if an error occurred during loading.  */
 657   if (__glibc_unlikely (errstring != NULL))
 658     {
 659       /* Remove the object from memory.  It may be in an inconsistent
 660          state if relocation failed, for example.  */
 661       if (args.map)
 662         {
 663           /* Maybe some of the modules which were loaded use TLS.
 664              Since it will be removed in the following _dl_close call
 665              we have to mark the dtv array as having gaps to fill the
 666              holes.  This is a pessimistic assumption which won't hurt
 667              if not true.  There is no need to do this when we are
 668              loading the auditing DSOs since TLS has not yet been set
 669              up.  */
 670           if ((mode & __RTLD_AUDIT) == 0)
 671             GL(dl_tls_dtv_gaps) = true;
 672
 673           _dl_close_worker (args.map);
 674         }
 675
 676       assert (_dl_debug_initialize (0, args.nsid)->r_state == RT_CONSISTENT);
 677
 678       /* Release the lock.  */
 679       __rtld_lock_unlock_recursive (GL(dl_load_lock));
 680
 681       /* Make a local copy of the error string so that we can release the
 682          memory allocated for it.  */
 683       size_t len_errstring = strlen (errstring) + 1;
 684       char *local_errstring;
 685       if (objname == errstring + len_errstring)
 686         {
 687           size_t total_len = len_errstring + strlen (objname) + 1;
 688           local_errstring = alloca (total_len);
 689           memcpy (local_errstring, errstring, total_len);
 690           objname = local_errstring + len_errstring;
 691         }
 692       else
 693         {
 694           local_errstring = alloca (len_errstring);
 695           memcpy (local_errstring, errstring, len_errstring);
 696         }
 697
 698       if (malloced)
 699         free ((char *) errstring);
 700
 701       /* Reraise the error.  */
 702       _dl_signal_error (errcode, objname, NULL, local_errstring);
 703     }
 704
 705   assert (_dl_debug_initialize (0, args.nsid)->r_state == RT_CONSISTENT);
 706
 707   /* Release the lock.  */
 708   __rtld_lock_unlock_recursive (GL(dl_load_lock));
 709
 710   return args.map;
 711 }
 712
 713
 714 void
 715 _dl_show_scope (struct link_map *l, int from)
 716 {
 717   _dl_debug_printf ("object=%s [%lu]\n",
 718                     DSO_FILENAME (l->l_name), l->l_ns);
 719   if (l->l_scope != NULL)
 720     for (int scope_cnt = from; l->l_scope[scope_cnt] != NULL; ++scope_cnt)
 721       {
 722         _dl_debug_printf (" scope %u:", scope_cnt);
 723
 724         for (unsigned int cnt = 0; cnt < l->l_scope[scope_cnt]->r_nlist; ++cnt)
 725           if (*l->l_scope[scope_cnt]->r_list[cnt]->l_name)
 726             _dl_debug_printf_c (" %s",
 727                                 l->l_scope[scope_cnt]->r_list[cnt]->l_name);
 728           else
 729             _dl_debug_printf_c (" %s", RTLD_PROGNAME);
 730
 731         _dl_debug_printf_c ("\n");
 732       }
 733   else
 734     _dl_debug_printf (" no scope\n");
 735   _dl_debug_printf ("\n");
 736 }
 737
 738 #if IS_IN (rtld)
 739 /* Return non-zero if ADDR lies within one of L's segments.  */
 740 int
 741 internal_function
 742 _dl_addr_inside_object (struct link_map *l, const ElfW(Addr) addr)
 743 {
 744   int n = l->l_phnum;
 745   const ElfW(Addr) reladdr = addr - l->l_addr;
 746
 747   while (--n >= 0)
 748     if (l->l_phdr[n].p_type == PT_LOAD
 749         && reladdr - l->l_phdr[n].p_vaddr >= 0
 750         && reladdr - l->l_phdr[n].p_vaddr < l->l_phdr[n].p_memsz)
 751       return 1;
 752   return 0;
 753 }
 754 #endif