elf/dl-open.c

   1 /* Load a shared object at runtime, relocate it, and run its initializer.
   2    Copyright (C) 1996-2001, 2002, 2003, 2004 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, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 #include <assert.h>
  21 #include <dlfcn.h>
  22 #include <errno.h>
  23 #include <libintl.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <unistd.h>
  28 #include <sys/mman.h>           /* Check whether MAP_COPY is defined.  */
  29 #include <sys/param.h>
  30 #include <bits/libc-lock.h>
  31 #include <ldsodefs.h>
  32 #include <bp-sym.h>
  33 #include <caller.h>
  34
  35 #include <dl-dst.h>
  36
  37
  38 #ifndef SHARED
  39 /* Giving this initialized value preallocates some surplus bytes in the
  40    static TLS area, see __libc_setup_tls (libc-tls.c).  */
  41 size_t _dl_tls_static_size = 2048;
  42 #endif
  43
  44 extern ElfW(Addr) _dl_sysdep_start (void **start_argptr,
  45                                     void (*dl_main) (const ElfW(Phdr) *phdr,
  46                                                      ElfW(Word) phnum,
  47                                                      ElfW(Addr) *user_entry));
  48 weak_extern (BP_SYM (_dl_sysdep_start))
  49
  50 extern int __libc_multiple_libcs;       /* Defined in init-first.c.  */
  51
  52 extern int __libc_argc attribute_hidden;
  53 extern char **__libc_argv attribute_hidden;
  54
  55 extern char **__environ;
  56
  57 /* Undefine the following for debugging.  */
  58 /* #define SCOPE_DEBUG 1 */
  59 #ifdef SCOPE_DEBUG
  60 static void show_scope (struct link_map *new);
  61 #endif
  62
  63 /* We must be carefull not to leave us in an inconsistent state.  Thus we
  64    catch any error and re-raise it after cleaning up.  */
  65
  66 struct dl_open_args
  67 {
  68   const char *file;
  69   int mode;
  70   /* This is the caller of the dlopen() function.  */
  71   const void *caller_dlopen;
  72   /* This is the caller if _dl_open().  */
  73   const void *caller_dl_open;
  74   struct link_map *map;
  75 };
  76
  77
  78 static int
  79 add_to_global (struct link_map *new)
  80 {
  81   struct link_map **new_global;
  82   unsigned int to_add = 0;
  83   unsigned int cnt;
  84
  85   /* Count the objects we have to put in the global scope.  */
  86   for (cnt = 0; cnt < new->l_searchlist.r_nlist; ++cnt)
  87     if (new->l_searchlist.r_list[cnt]->l_global == 0)
  88       ++to_add;
  89
  90   /* The symbols of the new objects and its dependencies are to be
  91      introduced into the global scope that will be used to resolve
  92      references from other dynamically-loaded objects.
  93
  94      The global scope is the searchlist in the main link map.  We
  95      extend this list if necessary.  There is one problem though:
  96      since this structure was allocated very early (before the libc
  97      is loaded) the memory it uses is allocated by the malloc()-stub
  98      in the ld.so.  When we come here these functions are not used
  99      anymore.  Instead the malloc() implementation of the libc is
 100      used.  But this means the block from the main map cannot be used
 101      in an realloc() call.  Therefore we allocate a completely new
 102      array the first time we have to add something to the locale scope.  */
 103
 104   if (GL(dl_global_scope_alloc) == 0)
 105     {
 106       /* This is the first dynamic object given global scope.  */
 107       GL(dl_global_scope_alloc) = GL(dl_main_searchlist)->r_nlist + to_add + 8;
 108       new_global = (struct link_map **)
 109         malloc (GL(dl_global_scope_alloc) * sizeof (struct link_map *));
 110       if (new_global == NULL)
 111         {
 112           GL(dl_global_scope_alloc) = 0;
 113         nomem:
 114           GLRO(dl_signal_error) (ENOMEM, new->l_libname->name, NULL,
 115                                  N_("cannot extend global scope"));
 116           return 1;
 117         }
 118
 119       /* Copy over the old entries.  */
 120       memcpy (new_global, GL(dl_main_searchlist)->r_list,
 121               (GL(dl_main_searchlist)->r_nlist * sizeof (struct link_map *)));
 122
 123       GL(dl_main_searchlist)->r_list = new_global;
 124     }
 125   else if (GL(dl_main_searchlist)->r_nlist + to_add
 126            > GL(dl_global_scope_alloc))
 127     {
 128       /* We have to extend the existing array of link maps in the
 129          main map.  */
 130       new_global = (struct link_map **)
 131         realloc (GL(dl_main_searchlist)->r_list,
 132                  ((GL(dl_global_scope_alloc) + to_add + 8)
 133                   * sizeof (struct link_map *)));
 134       if (new_global == NULL)
 135         goto nomem;
 136
 137       GL(dl_global_scope_alloc) += to_add + 8;
 138       GL(dl_main_searchlist)->r_list = new_global;
 139     }
 140
 141   /* Now add the new entries.  */
 142   for (cnt = 0; cnt < new->l_searchlist.r_nlist; ++cnt)
 143     {
 144       struct link_map *map = new->l_searchlist.r_list[cnt];
 145
 146       if (map->l_global == 0)
 147         {
 148           map->l_global = 1;
 149           GL(dl_main_searchlist)->r_list[GL(dl_main_searchlist)->r_nlist]
 150             = map;
 151           ++GL(dl_main_searchlist)->r_nlist;
 152         }
 153     }
 154
 155   return 0;
 156 }
 157
 158
 159 static void
 160 dl_open_worker (void *a)
 161 {
 162   struct dl_open_args *args = a;
 163   const char *file = args->file;
 164   int mode = args->mode;
 165   struct link_map *new, *l;
 166   int lazy;
 167   unsigned int i;
 168 #ifdef USE_TLS
 169   bool any_tls;
 170 #endif
 171   struct link_map *call_map = NULL;
 172
 173   /* Check whether _dl_open() has been called from a valid DSO.  */
 174   if (__check_caller (args->caller_dl_open, allow_libc|allow_libdl) != 0)
 175     GLRO(dl_signal_error) (0, "dlopen", NULL, N_("invalid caller"));
 176
 177   /* Determine the caller's map if necessary.  This is needed in case
 178      we have a DST or when the file name has no path in which case we
 179      need to look along the RUNPATH/RPATH of the caller.  */
 180   const char *dst = strchr (file, '$');
 181   if (dst != NULL || strchr (file, '/') == NULL)
 182     {
 183       const void *caller_dlopen = args->caller_dlopen;
 184
 185       /* We have to find out from which object the caller is calling.  */
 186       call_map = NULL;
 187       for (l = GL(dl_loaded); l; l = l->l_next)
 188         if (caller_dlopen >= (const void *) l->l_map_start
 189             && caller_dlopen < (const void *) l->l_map_end)
 190           {
 191             /* There must be exactly one DSO for the range of the virtual
 192                memory.  Otherwise something is really broken.  */
 193             call_map = l;
 194             break;
 195           }
 196
 197       if (call_map == NULL)
 198         /* In this case we assume this is the main application.  */
 199         call_map = GL(dl_loaded);
 200     }
 201
 202   /* Maybe we have to expand a DST.  */
 203   if (__builtin_expect (dst != NULL, 0))
 204     {
 205       size_t len = strlen (file);
 206       size_t required;
 207       char *new_file;
 208
 209       /* DSTs must not appear in SUID/SGID programs.  */
 210       if (__libc_enable_secure)
 211         /* This is an error.  */
 212         GLRO(dl_signal_error) (0, "dlopen", NULL,
 213                                N_("DST not allowed in SUID/SGID programs"));
 214
 215
 216       /* Determine how much space we need.  We have to allocate the
 217          memory locally.  */
 218       required = DL_DST_REQUIRED (call_map, file, len, _dl_dst_count (dst, 0));
 219
 220       /* Get space for the new file name.  */
 221       new_file = (char *) alloca (required + 1);
 222
 223       /* Generate the new file name.  */
 224       _dl_dst_substitute (call_map, file, new_file, 0);
 225
 226       /* If the substitution failed don't try to load.  */
 227       if (*new_file == '\0')
 228         GLRO(dl_signal_error) (0, "dlopen", NULL,
 229                                N_("empty dynamic string token substitution"));
 230
 231       /* Now we have a new file name.  */
 232       file = new_file;
 233
 234       /* It does not matter whether call_map is set even if we
 235          computed it only because of the DST.  Since the path contains
 236          a slash the value is not used.  See dl-load.c.  */
 237     }
 238
 239   /* Load the named object.  */
 240   args->map = new = GLRO(dl_map_object) (call_map, file, 0, lt_loaded, 0,
 241                                          mode | __RTLD_CALLMAP);
 242
 243   /* If the pointer returned is NULL this means the RTLD_NOLOAD flag is
 244      set and the object is not already loaded.  */
 245   if (new == NULL)
 246     {
 247       assert (mode & RTLD_NOLOAD);
 248       return;
 249     }
 250
 251   if (__builtin_expect (mode & __RTLD_SPROF, 0))
 252     /* This happens only if we load a DSO for 'sprof'.  */
 253     return;
 254
 255   /* It was already open.  */
 256   if (__builtin_expect (new->l_searchlist.r_list != NULL, 0))
 257     {
 258       /* Let the user know about the opencount.  */
 259       if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
 260         GLRO(dl_debug_printf) ("opening file=%s; opencount == %u\n\n",
 261                                new->l_name, new->l_opencount);
 262
 263       /* If the user requested the object to be in the global namespace
 264          but it is not so far, add it now.  */
 265       if ((mode & RTLD_GLOBAL) && new->l_global == 0)
 266         (void) add_to_global (new);
 267
 268       /* Increment just the reference counter of the object.  */
 269       ++new->l_opencount;
 270
 271       return;
 272     }
 273
 274   /* Load that object's dependencies.  */
 275   GLRO(dl_map_object_deps) (new, NULL, 0, 0,
 276                             mode & (__RTLD_DLOPEN | RTLD_DEEPBIND));
 277
 278   /* So far, so good.  Now check the versions.  */
 279   for (i = 0; i < new->l_searchlist.r_nlist; ++i)
 280     if (new->l_searchlist.r_list[i]->l_versions == NULL)
 281       (void) GLRO(dl_check_map_versions) (new->l_searchlist.r_list[i], 0, 0);
 282
 283 #ifdef SCOPE_DEBUG
 284   show_scope (new);
 285 #endif
 286
 287   /* Only do lazy relocation if `LD_BIND_NOW' is not set.  */
 288   lazy = (mode & RTLD_BINDING_MASK) == RTLD_LAZY && GLRO(dl_lazy);
 289
 290   /* Relocate the objects loaded.  We do this in reverse order so that copy
 291      relocs of earlier objects overwrite the data written by later objects.  */
 292
 293   l = new;
 294   while (l->l_next)
 295     l = l->l_next;
 296   while (1)
 297     {
 298       if (! l->l_relocated)
 299         {
 300 #ifdef SHARED
 301           if (GLRO(dl_profile) != NULL)
 302             {
 303               /* If this here is the shared object which we want to profile
 304                  make sure the profile is started.  We can find out whether
 305                  this is necessary or not by observing the `_dl_profile_map'
 306                  variable.  If was NULL but is not NULL afterwars we must
 307                  start the profiling.  */
 308               struct link_map *old_profile_map = GL(dl_profile_map);
 309
 310               GLRO(dl_relocate_object) (l, l->l_scope, 1, 1);
 311
 312               if (old_profile_map == NULL && GL(dl_profile_map) != NULL)
 313                 {
 314                   /* We must prepare the profiling.  */
 315                   GLRO(dl_start_profile) ();
 316
 317                   /* Prevent unloading the object.  */
 318                   GL(dl_profile_map)->l_flags_1 |= DF_1_NODELETE;
 319                 }
 320             }
 321           else
 322 #endif
 323             GLRO(dl_relocate_object) (l, l->l_scope, lazy, 0);
 324         }
 325
 326       if (l == new)
 327         break;
 328       l = l->l_prev;
 329     }
 330
 331 #ifdef USE_TLS
 332   /* Do static TLS initialization now if it has been delayed because
 333      the TLS template might not be fully relocated at _dl_allocate_static_tls
 334      time.  */
 335   for (l = new; l; l = l->l_next)
 336     if (l->l_need_tls_init)
 337       {
 338         l->l_need_tls_init = 0;
 339         GL(dl_init_static_tls) (l);
 340       }
 341
 342   /* We normally don't bump the TLS generation counter.  There must be
 343      actually a need to do this.  */
 344   any_tls = false;
 345 #endif
 346
 347   /* Increment the open count for all dependencies.  If the file is
 348      not loaded as a dependency here add the search list of the newly
 349      loaded object to the scope.  */
 350   for (i = 0; i < new->l_searchlist.r_nlist; ++i)
 351     if (++new->l_searchlist.r_list[i]->l_opencount > 1
 352         && new->l_searchlist.r_list[i]->l_type == lt_loaded)
 353       {
 354         struct link_map *imap = new->l_searchlist.r_list[i];
 355         struct r_scope_elem **runp = imap->l_scope;
 356         size_t cnt = 0;
 357
 358         while (*runp != NULL)
 359           {
 360             /* This can happen if imap was just loaded, but during
 361                relocation had l_opencount bumped because of relocation
 362                dependency.  Avoid duplicates in l_scope.  */
 363             if (__builtin_expect (*runp == &new->l_searchlist, 0))
 364               break;
 365
 366             ++cnt;
 367             ++runp;
 368           }
 369
 370         if (*runp != NULL)
 371           /* Avoid duplicates.  */
 372           continue;
 373
 374         if (__builtin_expect (cnt + 1 >= imap->l_scope_max, 0))
 375           {
 376             /* The 'r_scope' array is too small.  Allocate a new one
 377                dynamically.  */
 378             struct r_scope_elem **newp;
 379             size_t new_size = imap->l_scope_max * 2;
 380
 381             if (imap->l_scope == imap->l_scope_mem)
 382               {
 383                 newp = (struct r_scope_elem **)
 384                   malloc (new_size * sizeof (struct r_scope_elem *));
 385                 if (newp == NULL)
 386                   GLRO(dl_signal_error) (ENOMEM, "dlopen", NULL,
 387                                          N_("cannot create scope list"));
 388                 imap->l_scope = memcpy (newp, imap->l_scope,
 389                                         cnt * sizeof (imap->l_scope[0]));
 390               }
 391             else
 392               {
 393                 newp = (struct r_scope_elem **)
 394                   realloc (imap->l_scope,
 395                            new_size * sizeof (struct r_scope_elem *));
 396                 if (newp == NULL)
 397                   GLRO(dl_signal_error) (ENOMEM, "dlopen", NULL,
 398                                          N_("cannot create scope list"));
 399                 imap->l_scope = newp;
 400               }
 401
 402             imap->l_scope_max = new_size;
 403           }
 404
 405         imap->l_scope[cnt++] = &new->l_searchlist;
 406         imap->l_scope[cnt] = NULL;
 407       }
 408 #if USE_TLS
 409     else if (new->l_searchlist.r_list[i]->l_opencount == 1
 410              /* Only if the module defines thread local data.  */
 411              && __builtin_expect (new->l_searchlist.r_list[i]->l_tls_blocksize
 412                                   > 0, 0))
 413       {
 414         /* Now that we know the object is loaded successfully add
 415            modules containing TLS data to the dtv info table.  We
 416            might have to increase its size.  */
 417         struct dtv_slotinfo_list *listp;
 418         struct dtv_slotinfo_list *prevp;
 419         size_t idx = new->l_searchlist.r_list[i]->l_tls_modid;
 420
 421         assert (new->l_searchlist.r_list[i]->l_type == lt_loaded);
 422
 423         /* Find the place in the dtv slotinfo list.  */
 424         listp = GL(dl_tls_dtv_slotinfo_list);
 425         prevp = NULL;           /* Needed to shut up gcc.  */
 426         do
 427           {
 428             /* Does it fit in the array of this list element?  */
 429             if (idx < listp->len)
 430               break;
 431             idx -= listp->len;
 432             prevp = listp;
 433             listp = listp->next;
 434           }
 435         while (listp != NULL);
 436
 437         if (listp == NULL)
 438           {
 439             /* When we come here it means we have to add a new element
 440                to the slotinfo list.  And the new module must be in
 441                the first slot.  */
 442             assert (idx == 0);
 443
 444             listp = prevp->next = (struct dtv_slotinfo_list *)
 445               malloc (sizeof (struct dtv_slotinfo_list)
 446                       + TLS_SLOTINFO_SURPLUS * sizeof (struct dtv_slotinfo));
 447             if (listp == NULL)
 448               {
 449                 /* We ran out of memory.  We will simply fail this
 450                    call but don't undo anything we did so far.  The
 451                    application will crash or be terminated anyway very
 452                    soon.  */
 453
 454                 /* We have to do this since some entries in the dtv
 455                    slotinfo array might already point to this
 456                    generation.  */
 457                 ++GL(dl_tls_generation);
 458
 459                 GLRO(dl_signal_error) (ENOMEM, "dlopen", NULL, N_("\
 460 cannot create TLS data structures"));
 461               }
 462
 463             listp->len = TLS_SLOTINFO_SURPLUS;
 464             listp->next = NULL;
 465             memset (listp->slotinfo, '\0',
 466                     TLS_SLOTINFO_SURPLUS * sizeof (struct dtv_slotinfo));
 467           }
 468
 469         /* Add the information into the slotinfo data structure.  */
 470         listp->slotinfo[idx].map = new->l_searchlist.r_list[i];
 471         listp->slotinfo[idx].gen = GL(dl_tls_generation) + 1;
 472
 473         /* We have to bump the generation counter.  */
 474         any_tls = true;
 475       }
 476
 477   /* Bump the generation number if necessary.  */
 478   if (any_tls)
 479     if (__builtin_expect (++GL(dl_tls_generation) == 0, 0))
 480       __libc_fatal (_("TLS generation counter wrapped!  Please send report with the 'glibcbug' script."));
 481 #endif
 482
 483   /* Run the initializer functions of new objects.  */
 484   GLRO(dl_init) (new, __libc_argc, __libc_argv, __environ);
 485
 486   /* Now we can make the new map available in the global scope.  */
 487   if (mode & RTLD_GLOBAL)
 488     /* Move the object in the global namespace.  */
 489     if (add_to_global (new) != 0)
 490       /* It failed.  */
 491       return;
 492
 493   /* Mark the object as not deletable if the RTLD_NODELETE flags was
 494      passed.  */
 495   if (__builtin_expect (mode & RTLD_NODELETE, 0))
 496     new->l_flags_1 |= DF_1_NODELETE;
 497
 498 #ifndef SHARED
 499   /* We must be the static _dl_open in libc.a.  A static program that
 500      has loaded a dynamic object now has competition.  */
 501   __libc_multiple_libcs = 1;
 502 #endif
 503
 504   /* Let the user know about the opencount.  */
 505   if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
 506     GLRO(dl_debug_printf) ("opening file=%s; opencount == %u\n\n",
 507                            new->l_name, new->l_opencount);
 508 }
 509
 510
 511 void *
 512 internal_function
 513 _dl_open (const char *file, int mode, const void *caller_dlopen)
 514 {
 515   struct dl_open_args args;
 516   const char *objname;
 517   const char *errstring;
 518   int errcode;
 519
 520   if ((mode & RTLD_BINDING_MASK) == 0)
 521     /* One of the flags must be set.  */
 522     GLRO(dl_signal_error) (EINVAL, file, NULL,
 523                            N_("invalid mode for dlopen()"));
 524
 525   /* Make sure we are alone.  */
 526   __rtld_lock_lock_recursive (GL(dl_load_lock));
 527
 528   args.file = file;
 529   args.mode = mode;
 530   args.caller_dlopen = caller_dlopen;
 531   args.caller_dl_open = RETURN_ADDRESS (0);
 532   args.map = NULL;
 533   errcode = GLRO(dl_catch_error) (&objname, &errstring, dl_open_worker, &args);
 534
 535 #ifndef MAP_COPY
 536   /* We must munmap() the cache file.  */
 537   GLRO(dl_unload_cache) ();
 538 #endif
 539
 540   /* Release the lock.  */
 541   __rtld_lock_unlock_recursive (GL(dl_load_lock));
 542
 543   if (__builtin_expect (errstring != NULL, 0))
 544     {
 545       /* Some error occurred during loading.  */
 546       char *local_errstring;
 547       size_t len_errstring;
 548
 549       /* Remove the object from memory.  It may be in an inconsistent
 550          state if relocation failed, for example.  */
 551       if (args.map)
 552         {
 553           unsigned int i;
 554
 555           /* Increment open counters for all objects since this
 556              sometimes has not happened yet.  */
 557           if (args.map->l_searchlist.r_list[0]->l_opencount == 0)
 558             for (i = 0; i < args.map->l_searchlist.r_nlist; ++i)
 559               ++args.map->l_searchlist.r_list[i]->l_opencount;
 560
 561 #ifdef USE_TLS
 562           /* Maybe some of the modules which were loaded uses TLS.
 563              Since it will be removed in the following _dl_close call
 564              we have to mark the dtv array as having gaps to fill
 565              the holes.  This is a pessimistic assumption which won't
 566              hurt if not true.  */
 567           GL(dl_tls_dtv_gaps) = true;
 568 #endif
 569
 570           _dl_close (args.map);
 571         }
 572
 573       /* Make a local copy of the error string so that we can release the
 574          memory allocated for it.  */
 575       len_errstring = strlen (errstring) + 1;
 576       if (objname == errstring + len_errstring)
 577         {
 578           size_t total_len = len_errstring + strlen (objname) + 1;
 579           local_errstring = alloca (total_len);
 580           memcpy (local_errstring, errstring, total_len);
 581           objname = local_errstring + len_errstring;
 582         }
 583       else
 584         {
 585           local_errstring = alloca (len_errstring);
 586           memcpy (local_errstring, errstring, len_errstring);
 587         }
 588
 589       if (errstring != _dl_out_of_memory)
 590         free ((char *) errstring);
 591
 592       /* Reraise the error.  */
 593       GLRO(dl_signal_error) (errcode, objname, NULL, local_errstring);
 594     }
 595
 596 #ifndef SHARED
 597   DL_STATIC_INIT (args.map);
 598 #endif
 599
 600   return args.map;
 601 }
 602 libc_hidden_def (_dl_open)
 603
 604
 605 #ifdef SCOPE_DEBUG
 606 #include <unistd.h>
 607
 608 static void
 609 show_scope (struct link_map *new)
 610 {
 611   int scope_cnt;
 612
 613   for (scope_cnt = 0; new->l_scope[scope_cnt] != NULL; ++scope_cnt)
 614     {
 615       char numbuf[2];
 616       unsigned int cnt;
 617
 618       numbuf[0] = '0' + scope_cnt;
 619       numbuf[1] = '\0';
 620       _dl_printf ("scope %s:", numbuf);
 621
 622       for (cnt = 0; cnt < new->l_scope[scope_cnt]->r_nlist; ++cnt)
 623         if (*new->l_scope[scope_cnt]->r_list[cnt]->l_name)
 624           _dl_printf (" %s", new->l_scope[scope_cnt]->r_list[cnt]->l_name);
 625         else
 626           _dl_printf (" <main>");
 627
 628       _dl_printf ("\n");
 629     }
 630 }
 631 #endif