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