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.  This includes allocating memory in the DTV.  But we
 537              cannot change any DTV other than our own.  So, if we
 538              cannot guarantee that there is room in the DTV we don't
 539              even try it and fail the load.
 540
 541              XXX We could track the minimum DTV slots allocated in
 542              all threads.  */
 543           if (! RTLD_SINGLE_THREAD_P && imap->l_tls_modid > DTV_SURPLUS)
 544             _dl_signal_error (0, "dlopen", NULL, N_("\
 545 cannot load any more object with static TLS"));
 546
 547           imap->l_need_tls_init = 0;
 548 #ifdef SHARED
 549           /* Update the slot information data for at least the
 550              generation of the DSO we are allocating data for.  */
 551           _dl_update_slotinfo (imap->l_tls_modid);
 552 #endif
 553
 554           GL(dl_init_static_tls) (imap);
 555           assert (imap->l_need_tls_init == 0);
 556         }
 557     }
 558
 559   /* Notify the debugger all new objects have been relocated.  */
 560   if (relocation_in_progress)
 561     LIBC_PROBE (reloc_complete, 3, args->nsid, r, new);
 562
 563 #ifndef SHARED
 564   DL_STATIC_INIT (new);
 565 #endif
 566
 567   /* Run the initializer functions of new objects.  */
 568   _dl_init (new, args->argc, args->argv, args->env);
 569
 570   /* Now we can make the new map available in the global scope.  */
 571   if (mode & RTLD_GLOBAL)
 572     /* Move the object in the global namespace.  */
 573     if (add_to_global (new) != 0)
 574       /* It failed.  */
 575       return;
 576
 577   /* Mark the object as not deletable if the RTLD_NODELETE flags was
 578      passed.  */
 579   if (__glibc_unlikely (mode & RTLD_NODELETE))
 580     new->l_flags_1 |= DF_1_NODELETE;
 581
 582 #ifndef SHARED
 583   /* We must be the static _dl_open in libc.a.  A static program that
 584      has loaded a dynamic object now has competition.  */
 585   __libc_multiple_libcs = 1;
 586 #endif
 587
 588   /* Let the user know about the opencount.  */
 589   if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_FILES))
 590     _dl_debug_printf ("opening file=%s [%lu]; direct_opencount=%u\n\n",
 591                       new->l_name, new->l_ns, new->l_direct_opencount);
 592 }
 593
 594
 595 void *
 596 _dl_open (const char *file, int mode, const void *caller_dlopen, Lmid_t nsid,
 597           int argc, char *argv[], char *env[])
 598 {
 599   if ((mode & RTLD_BINDING_MASK) == 0)
 600     /* One of the flags must be set.  */
 601     _dl_signal_error (EINVAL, file, NULL, N_("invalid mode for dlopen()"));
 602
 603   /* Make sure we are alone.  */
 604   __rtld_lock_lock_recursive (GL(dl_load_lock));
 605
 606   if (__glibc_unlikely (nsid == LM_ID_NEWLM))
 607     {
 608       /* Find a new namespace.  */
 609       for (nsid = 1; DL_NNS > 1 && nsid < GL(dl_nns); ++nsid)
 610         if (GL(dl_ns)[nsid]._ns_loaded == NULL)
 611           break;
 612
 613       if (__glibc_unlikely (nsid == DL_NNS))
 614         {
 615           /* No more namespace available.  */
 616           __rtld_lock_unlock_recursive (GL(dl_load_lock));
 617
 618           _dl_signal_error (EINVAL, file, NULL, N_("\
 619 no more namespaces available for dlmopen()"));
 620         }
 621       else if (nsid == GL(dl_nns))
 622         {
 623           __rtld_lock_initialize (GL(dl_ns)[nsid]._ns_unique_sym_table.lock);
 624           ++GL(dl_nns);
 625         }
 626
 627       _dl_debug_initialize (0, nsid)->r_state = RT_CONSISTENT;
 628     }
 629   /* Never allow loading a DSO in a namespace which is empty.  Such
 630      direct placements is only causing problems.  Also don't allow
 631      loading into a namespace used for auditing.  */
 632   else if (__builtin_expect (nsid != LM_ID_BASE && nsid != __LM_ID_CALLER, 0)
 633            && (GL(dl_ns)[nsid]._ns_nloaded == 0
 634                || GL(dl_ns)[nsid]._ns_loaded->l_auditing))
 635     _dl_signal_error (EINVAL, file, NULL,
 636                       N_("invalid target namespace in dlmopen()"));
 637
 638   struct dl_open_args args;
 639   args.file = file;
 640   args.mode = mode;
 641   args.caller_dlopen = caller_dlopen;
 642   args.caller_dl_open = RETURN_ADDRESS (0);
 643   args.map = NULL;
 644   args.nsid = nsid;
 645   args.argc = argc;
 646   args.argv = argv;
 647   args.env = env;
 648
 649   const char *objname;
 650   const char *errstring;
 651   bool malloced;
 652   int errcode = _dl_catch_error (&objname, &errstring, &malloced,
 653                                  dl_open_worker, &args);
 654
 655 #if defined USE_LDCONFIG && !defined MAP_COPY
 656   /* We must unmap the cache file.  */
 657   _dl_unload_cache ();
 658 #endif
 659
 660   /* See if an error occurred during loading.  */
 661   if (__glibc_unlikely (errstring != NULL))
 662     {
 663       /* Remove the object from memory.  It may be in an inconsistent
 664          state if relocation failed, for example.  */
 665       if (args.map)
 666         {
 667           /* Maybe some of the modules which were loaded use TLS.
 668              Since it will be removed in the following _dl_close call
 669              we have to mark the dtv array as having gaps to fill the
 670              holes.  This is a pessimistic assumption which won't hurt
 671              if not true.  There is no need to do this when we are
 672              loading the auditing DSOs since TLS has not yet been set
 673              up.  */
 674           if ((mode & __RTLD_AUDIT) == 0)
 675             GL(dl_tls_dtv_gaps) = true;
 676
 677           _dl_close_worker (args.map);
 678         }
 679
 680       assert (_dl_debug_initialize (0, args.nsid)->r_state == RT_CONSISTENT);
 681
 682       /* Release the lock.  */
 683       __rtld_lock_unlock_recursive (GL(dl_load_lock));
 684
 685       /* Make a local copy of the error string so that we can release the
 686          memory allocated for it.  */
 687       size_t len_errstring = strlen (errstring) + 1;
 688       char *local_errstring;
 689       if (objname == errstring + len_errstring)
 690         {
 691           size_t total_len = len_errstring + strlen (objname) + 1;
 692           local_errstring = alloca (total_len);
 693           memcpy (local_errstring, errstring, total_len);
 694           objname = local_errstring + len_errstring;
 695         }
 696       else
 697         {
 698           local_errstring = alloca (len_errstring);
 699           memcpy (local_errstring, errstring, len_errstring);
 700         }
 701
 702       if (malloced)
 703         free ((char *) errstring);
 704
 705       /* Reraise the error.  */
 706       _dl_signal_error (errcode, objname, NULL, local_errstring);
 707     }
 708
 709   assert (_dl_debug_initialize (0, args.nsid)->r_state == RT_CONSISTENT);
 710
 711   /* Release the lock.  */
 712   __rtld_lock_unlock_recursive (GL(dl_load_lock));
 713
 714   return args.map;
 715 }
 716
 717
 718 void
 719 _dl_show_scope (struct link_map *l, int from)
 720 {
 721   _dl_debug_printf ("object=%s [%lu]\n",
 722                     DSO_FILENAME (l->l_name), l->l_ns);
 723   if (l->l_scope != NULL)
 724     for (int scope_cnt = from; l->l_scope[scope_cnt] != NULL; ++scope_cnt)
 725       {
 726         _dl_debug_printf (" scope %u:", scope_cnt);
 727
 728         for (unsigned int cnt = 0; cnt < l->l_scope[scope_cnt]->r_nlist; ++cnt)
 729           if (*l->l_scope[scope_cnt]->r_list[cnt]->l_name)
 730             _dl_debug_printf_c (" %s",
 731                                 l->l_scope[scope_cnt]->r_list[cnt]->l_name);
 732           else
 733             _dl_debug_printf_c (" %s", RTLD_PROGNAME);
 734
 735         _dl_debug_printf_c ("\n");
 736       }
 737   else
 738     _dl_debug_printf (" no scope\n");
 739   _dl_debug_printf ("\n");
 740 }
 741
 742 #if IS_IN (rtld)
 743 /* Return non-zero if ADDR lies within one of L's segments.  */
 744 int
 745 internal_function
 746 _dl_addr_inside_object (struct link_map *l, const ElfW(Addr) addr)
 747 {
 748   int n = l->l_phnum;
 749   const ElfW(Addr) reladdr = addr - l->l_addr;
 750
 751   while (--n >= 0)
 752     if (l->l_phdr[n].p_type == PT_LOAD
 753         && reladdr - l->l_phdr[n].p_vaddr >= 0
 754         && reladdr - l->l_phdr[n].p_vaddr < l->l_phdr[n].p_memsz)
 755       return 1;
 756   return 0;
 757 }
 758 #endif