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   const char *dst;
 167   int lazy;
 168   unsigned int i;
 169 #ifdef USE_TLS
 170   bool any_tls;
 171 #endif
 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   /* Maybe we have to expand a DST.  */
 178   dst = strchr (file, '$');
 179   if (__builtin_expect (dst != NULL, 0))
 180     {
 181       const void *caller_dlopen = args->caller_dlopen;
 182       size_t len = strlen (file);
 183       size_t required;
 184       struct link_map *call_map;
 185       char *new_file;
 186
 187       /* DSTs must not appear in SUID/SGID programs.  */
 188       if (__libc_enable_secure)
 189         /* This is an error.  */
 190         GLRO(dl_signal_error) (0, "dlopen", NULL,
 191                                N_("DST not allowed in SUID/SGID programs"));
 192
 193       /* We have to find out from which object the caller is calling.  */
 194       call_map = NULL;
 195       for (l = GL(dl_loaded); l; l = l->l_next)
 196         if (caller_dlopen >= (const void *) l->l_map_start
 197             && caller_dlopen < (const void *) l->l_map_end)
 198           {
 199             /* There must be exactly one DSO for the range of the virtual
 200                memory.  Otherwise something is really broken.  */
 201             call_map = l;
 202             break;
 203           }
 204
 205       if (call_map == NULL)
 206         /* In this case we assume this is the main application.  */
 207         call_map = GL(dl_loaded);
 208
 209       /* Determine how much space we need.  We have to allocate the
 210          memory locally.  */
 211       required = DL_DST_REQUIRED (call_map, file, len, _dl_dst_count (dst, 0));
 212
 213       /* Get space for the new file name.  */
 214       new_file = (char *) alloca (required + 1);
 215
 216       /* Generate the new file name.  */
 217       _dl_dst_substitute (call_map, file, new_file, 0);
 218
 219       /* If the substitution failed don't try to load.  */
 220       if (*new_file == '\0')
 221         GLRO(dl_signal_error) (0, "dlopen", NULL,
 222                                N_("empty dynamic string token substitution"));
 223
 224       /* Now we have a new file name.  */
 225       file = new_file;
 226     }
 227
 228   /* Load the named object.  */
 229   args->map = new = GLRO(dl_map_object) (NULL, file, 0, lt_loaded, 0, mode);
 230
 231   /* If the pointer returned is NULL this means the RTLD_NOLOAD flag is
 232      set and the object is not already loaded.  */
 233   if (new == NULL)
 234     {
 235       assert (mode & RTLD_NOLOAD);
 236       return;
 237     }
 238
 239   if (__builtin_expect (mode & __RTLD_SPROF, 0))
 240     /* This happens only if we load a DSO for 'sprof'.  */
 241     return;
 242
 243   /* It was already open.  */
 244   if (__builtin_expect (new->l_searchlist.r_list != NULL, 0))
 245     {
 246       /* Let the user know about the opencount.  */
 247       if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
 248         GLRO(dl_debug_printf) ("opening file=%s; opencount == %u\n\n",
 249                                new->l_name, new->l_opencount);
 250
 251       /* If the user requested the object to be in the global namespace
 252          but it is not so far, add it now.  */
 253       if ((mode & RTLD_GLOBAL) && new->l_global == 0)
 254         (void) add_to_global (new);
 255
 256       /* Increment just the reference counter of the object.  */
 257       ++new->l_opencount;
 258
 259       return;
 260     }
 261
 262   /* Load that object's dependencies.  */
 263   GLRO(dl_map_object_deps) (new, NULL, 0, 0, mode & __RTLD_DLOPEN);
 264
 265   /* So far, so good.  Now check the versions.  */
 266   for (i = 0; i < new->l_searchlist.r_nlist; ++i)
 267     if (new->l_searchlist.r_list[i]->l_versions == NULL)
 268       (void) GLRO(dl_check_map_versions) (new->l_searchlist.r_list[i], 0, 0);
 269
 270 #ifdef SCOPE_DEBUG
 271   show_scope (new);
 272 #endif
 273
 274   /* Only do lazy relocation if `LD_BIND_NOW' is not set.  */
 275   lazy = (mode & RTLD_BINDING_MASK) == RTLD_LAZY && GLRO(dl_lazy);
 276
 277   /* Relocate the objects loaded.  We do this in reverse order so that copy
 278      relocs of earlier objects overwrite the data written by later objects.  */
 279
 280   l = new;
 281   while (l->l_next)
 282     l = l->l_next;
 283   while (1)
 284     {
 285       if (! l->l_relocated)
 286         {
 287 #ifdef SHARED
 288           if (GLRO(dl_profile) != NULL)
 289             {
 290               /* If this here is the shared object which we want to profile
 291                  make sure the profile is started.  We can find out whether
 292                  this is necessary or not by observing the `_dl_profile_map'
 293                  variable.  If was NULL but is not NULL afterwars we must
 294                  start the profiling.  */
 295               struct link_map *old_profile_map = GL(dl_profile_map);
 296
 297               GLRO(dl_relocate_object) (l, l->l_scope, 1, 1);
 298
 299               if (old_profile_map == NULL && GL(dl_profile_map) != NULL)
 300                 /* We must prepare the profiling.  */
 301                 GLRO(dl_start_profile) ();
 302             }
 303           else
 304 #endif
 305             GLRO(dl_relocate_object) (l, l->l_scope, lazy, 0);
 306         }
 307
 308       if (l == new)
 309         break;
 310       l = l->l_prev;
 311     }
 312
 313 #ifdef USE_TLS
 314   /* Do static TLS initialization now if it has been delayed because
 315      the TLS template might not be fully relocated at _dl_allocate_static_tls
 316      time.  */
 317   for (l = new; l; l = l->l_next)
 318     if (l->l_need_tls_init)
 319       {
 320         l->l_need_tls_init = 0;
 321         GL(dl_init_static_tls) (l);
 322       }
 323
 324   /* We normally don't bump the TLS generation counter.  There must be
 325      actually a need to do this.  */
 326   any_tls = false;
 327 #endif
 328
 329   /* Increment the open count for all dependencies.  If the file is
 330      not loaded as a dependency here add the search list of the newly
 331      loaded object to the scope.  */
 332   for (i = 0; i < new->l_searchlist.r_nlist; ++i)
 333     if (++new->l_searchlist.r_list[i]->l_opencount > 1
 334         && new->l_searchlist.r_list[i]->l_type == lt_loaded)
 335       {
 336         struct link_map *imap = new->l_searchlist.r_list[i];
 337         struct r_scope_elem **runp = imap->l_scope;
 338         size_t cnt = 0;
 339
 340         while (*runp != NULL)
 341           {
 342             /* This can happen if imap was just loaded, but during
 343                relocation had l_opencount bumped because of relocation
 344                dependency.  Avoid duplicates in l_scope.  */
 345             if (__builtin_expect (*runp == &new->l_searchlist, 0))
 346               break;
 347
 348             ++cnt;
 349             ++runp;
 350           }
 351
 352         if (*runp != NULL)
 353           /* Avoid duplicates.  */
 354           continue;
 355
 356         if (__builtin_expect (cnt + 1 >= imap->l_scope_max, 0))
 357           {
 358             /* The 'r_scope' array is too small.  Allocate a new one
 359                dynamically.  */
 360             struct r_scope_elem **newp;
 361             size_t new_size = imap->l_scope_max * 2;
 362
 363             if (imap->l_scope == imap->l_scope_mem)
 364               {
 365                 newp = (struct r_scope_elem **)
 366                   malloc (new_size * sizeof (struct r_scope_elem *));
 367                 if (newp == NULL)
 368                   GLRO(dl_signal_error) (ENOMEM, "dlopen", NULL,
 369                                          N_("cannot create scope list"));
 370                 imap->l_scope = memcpy (newp, imap->l_scope,
 371                                         cnt * sizeof (imap->l_scope[0]));
 372               }
 373             else
 374               {
 375                 newp = (struct r_scope_elem **)
 376                   realloc (imap->l_scope,
 377                            new_size * sizeof (struct r_scope_elem *));
 378                 if (newp == NULL)
 379                   GLRO(dl_signal_error) (ENOMEM, "dlopen", NULL,
 380                                          N_("cannot create scope list"));
 381                 imap->l_scope = newp;
 382               }
 383
 384             imap->l_scope_max = new_size;
 385           }
 386
 387         imap->l_scope[cnt++] = &new->l_searchlist;
 388         imap->l_scope[cnt] = NULL;
 389       }
 390 #if USE_TLS
 391     else if (new->l_searchlist.r_list[i]->l_opencount == 1
 392              /* Only if the module defines thread local data.  */
 393              && __builtin_expect (new->l_searchlist.r_list[i]->l_tls_blocksize
 394                                   > 0, 0))
 395       {
 396         /* Now that we know the object is loaded successfully add
 397            modules containing TLS data to the dtv info table.  We
 398            might have to increase its size.  */
 399         struct dtv_slotinfo_list *listp;
 400         struct dtv_slotinfo_list *prevp;
 401         size_t idx = new->l_searchlist.r_list[i]->l_tls_modid;
 402
 403         assert (new->l_searchlist.r_list[i]->l_type == lt_loaded);
 404
 405         /* Find the place in the dtv slotinfo list.  */
 406         listp = GL(dl_tls_dtv_slotinfo_list);
 407         prevp = NULL;           /* Needed to shut up gcc.  */
 408         do
 409           {
 410             /* Does it fit in the array of this list element?  */
 411             if (idx < listp->len)
 412               break;
 413             idx -= listp->len;
 414             prevp = listp;
 415             listp = listp->next;
 416           }
 417         while (listp != NULL);
 418
 419         if (listp == NULL)
 420           {
 421             /* When we come here it means we have to add a new element
 422                to the slotinfo list.  And the new module must be in
 423                the first slot.  */
 424             assert (idx == 0);
 425
 426             listp = prevp->next = (struct dtv_slotinfo_list *)
 427               malloc (sizeof (struct dtv_slotinfo_list)
 428                       + TLS_SLOTINFO_SURPLUS * sizeof (struct dtv_slotinfo));
 429             if (listp == NULL)
 430               {
 431                 /* We ran out of memory.  We will simply fail this
 432                    call but don't undo anything we did so far.  The
 433                    application will crash or be terminated anyway very
 434                    soon.  */
 435
 436                 /* We have to do this since some entries in the dtv
 437                    slotinfo array might already point to this
 438                    generation.  */
 439                 ++GL(dl_tls_generation);
 440
 441                 GLRO(dl_signal_error) (ENOMEM, "dlopen", NULL, N_("\
 442 cannot create TLS data structures"));
 443               }
 444
 445             listp->len = TLS_SLOTINFO_SURPLUS;
 446             listp->next = NULL;
 447             memset (listp->slotinfo, '\0',
 448                     TLS_SLOTINFO_SURPLUS * sizeof (struct dtv_slotinfo));
 449           }
 450
 451         /* Add the information into the slotinfo data structure.  */
 452         listp->slotinfo[idx].map = new->l_searchlist.r_list[i];
 453         listp->slotinfo[idx].gen = GL(dl_tls_generation) + 1;
 454
 455         /* We have to bump the generation counter.  */
 456         any_tls = true;
 457       }
 458
 459   /* Bump the generation number if necessary.  */
 460   if (any_tls)
 461     if (__builtin_expect (++GL(dl_tls_generation) == 0, 0))
 462       __libc_fatal (_("TLS generation counter wrapped!  Please send report with the 'glibcbug' script."));
 463 #endif
 464
 465   /* Run the initializer functions of new objects.  */
 466   GLRO(dl_init) (new, __libc_argc, __libc_argv, __environ);
 467
 468   /* Now we can make the new map available in the global scope.  */
 469   if (mode & RTLD_GLOBAL)
 470     /* Move the object in the global namespace.  */
 471     if (add_to_global (new) != 0)
 472       /* It failed.  */
 473       return;
 474
 475   /* Mark the object as not deletable if the RTLD_NODELETE flags was
 476      passed.  */
 477   if (__builtin_expect (mode & RTLD_NODELETE, 0))
 478     new->l_flags_1 |= DF_1_NODELETE;
 479
 480 #ifndef SHARED
 481   /* We must be the static _dl_open in libc.a.  A static program that
 482      has loaded a dynamic object now has competition.  */
 483   __libc_multiple_libcs = 1;
 484 #endif
 485
 486   /* Let the user know about the opencount.  */
 487   if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
 488     GLRO(dl_debug_printf) ("opening file=%s; opencount == %u\n\n",
 489                            new->l_name, new->l_opencount);
 490 }
 491
 492
 493 void *
 494 internal_function
 495 _dl_open (const char *file, int mode, const void *caller_dlopen)
 496 {
 497   struct dl_open_args args;
 498   const char *objname;
 499   const char *errstring;
 500   int errcode;
 501
 502   if ((mode & RTLD_BINDING_MASK) == 0)
 503     /* One of the flags must be set.  */
 504     GLRO(dl_signal_error) (EINVAL, file, NULL,
 505                            N_("invalid mode for dlopen()"));
 506
 507   /* Make sure we are alone.  */
 508   __rtld_lock_lock_recursive (GL(dl_load_lock));
 509
 510   args.file = file;
 511   args.mode = mode;
 512   args.caller_dlopen = caller_dlopen;
 513   args.caller_dl_open = RETURN_ADDRESS (0);
 514   args.map = NULL;
 515   errcode = GLRO(dl_catch_error) (&objname, &errstring, dl_open_worker, &args);
 516
 517 #ifndef MAP_COPY
 518   /* We must munmap() the cache file.  */
 519   GLRO(dl_unload_cache) ();
 520 #endif
 521
 522   /* Release the lock.  */
 523   __rtld_lock_unlock_recursive (GL(dl_load_lock));
 524
 525   if (__builtin_expect (errstring != NULL, 0))
 526     {
 527       /* Some error occurred during loading.  */
 528       char *local_errstring;
 529       size_t len_errstring;
 530
 531       /* Remove the object from memory.  It may be in an inconsistent
 532          state if relocation failed, for example.  */
 533       if (args.map)
 534         {
 535           unsigned int i;
 536
 537           /* Increment open counters for all objects since this
 538              sometimes has not happened yet.  */
 539           if (args.map->l_searchlist.r_list[0]->l_opencount == 0)
 540             for (i = 0; i < args.map->l_searchlist.r_nlist; ++i)
 541               ++args.map->l_searchlist.r_list[i]->l_opencount;
 542
 543 #ifdef USE_TLS
 544           /* Maybe some of the modules which were loaded uses TLS.
 545              Since it will be removed in the following _dl_close call
 546              we have to mark the dtv array as having gaps to fill
 547              the holes.  This is a pessimistic assumption which won't
 548              hurt if not true.  */
 549           GL(dl_tls_dtv_gaps) = true;
 550 #endif
 551
 552           _dl_close (args.map);
 553         }
 554
 555       /* Make a local copy of the error string so that we can release the
 556          memory allocated for it.  */
 557       len_errstring = strlen (errstring) + 1;
 558       if (objname == errstring + len_errstring)
 559         {
 560           size_t total_len = len_errstring + strlen (objname) + 1;
 561           local_errstring = alloca (total_len);
 562           memcpy (local_errstring, errstring, total_len);
 563           objname = local_errstring + len_errstring;
 564         }
 565       else
 566         {
 567           local_errstring = alloca (len_errstring);
 568           memcpy (local_errstring, errstring, len_errstring);
 569         }
 570
 571       if (errstring != _dl_out_of_memory)
 572         free ((char *) errstring);
 573
 574       /* Reraise the error.  */
 575       GLRO(dl_signal_error) (errcode, objname, NULL, local_errstring);
 576     }
 577
 578 #ifndef SHARED
 579   DL_STATIC_INIT (args.map);
 580 #endif
 581
 582   return args.map;
 583 }
 584 libc_hidden_def (_dl_open)
 585
 586
 587 #ifdef SCOPE_DEBUG
 588 #include <unistd.h>
 589
 590 static void
 591 show_scope (struct link_map *new)
 592 {
 593   int scope_cnt;
 594
 595   for (scope_cnt = 0; new->l_scope[scope_cnt] != NULL; ++scope_cnt)
 596     {
 597       char numbuf[2];
 598       unsigned int cnt;
 599
 600       numbuf[0] = '0' + scope_cnt;
 601       numbuf[1] = '\0';
 602       _dl_printf ("scope %s:", numbuf);
 603
 604       for (cnt = 0; cnt < new->l_scope[scope_cnt]->r_nlist; ++cnt)
 605         if (*new->l_scope[scope_cnt]->r_list[cnt]->l_name)
 606           _dl_printf (" %s", new->l_scope[scope_cnt]->r_list[cnt]->l_name);
 607         else
 608           _dl_printf (" <main>");
 609
 610       _dl_printf ("\n");
 611     }
 612 }
 613 #endif