elf/dl-open.c

   1 /* Load a shared object at runtime, relocate it, and run its initializer.
   2    Copyright (C) 1996, 1997 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 Library General Public License as
   7    published by the Free Software Foundation; either version 2 of the
   8    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    Library General Public License for more details.
  14
  15    You should have received a copy of the GNU Library General Public
  16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18    Boston, MA 02111-1307, USA.  */
  19
  20 #include <link.h>
  21 #include <dlfcn.h>
  22 #include <stdlib.h>
  23 #include <errno.h>
  24 #include <bits/libc-lock.h>
  25
  26
  27 extern ElfW(Addr) _dl_sysdep_start (void **start_argptr,
  28                                     void (*dl_main) (const ElfW(Phdr) *phdr,
  29                                                      ElfW(Word) phnum,
  30                                                      ElfW(Addr) *user_entry));
  31 weak_extern (_dl_sysdep_start)
  32
  33 extern int __libc_multiple_libcs;       /* Defined in init-first.c.  */
  34
  35 extern int __libc_argc;
  36 extern char **__libc_argv;
  37
  38 extern char **__environ;
  39
  40 size_t _dl_global_scope_alloc;
  41
  42
  43 /* During the program run we must not modify the global data of
  44    loaded shared object simultanously in two threads.  Therefore we
  45    protect `_dl_open' and `_dl_close' in dl-close.c.
  46
  47    This must be a recursive lock since the initializer function of
  48    the loaded object might as well require a call to this function.
  49    At this time it is not anymore a problem to modify the tables.  */
  50 __libc_lock_define_initialized_recursive (, _dl_load_lock)
  51
  52
  53 struct link_map *
  54 _dl_open (const char *file, int mode)
  55 {
  56   struct link_map *new, *l;
  57   ElfW(Addr) init;
  58   struct r_debug *r;
  59
  60   /* Make sure we are alone.  */
  61   __libc_lock_lock (_dl_load_lock);
  62
  63   /* Load the named object.  */
  64   new = _dl_map_object (NULL, file, lt_loaded, 0);
  65   if (new->l_searchlist)
  66     {
  67       /* It was already open.  */
  68       __libc_lock_unlock (_dl_load_lock);
  69       return new;
  70     }
  71
  72   /* Load that object's dependencies.  */
  73   _dl_map_object_deps (new, NULL, 0, 0);
  74
  75   /* So far, so good.  Now check the versions.  */
  76   (void) _dl_check_all_versions (new, 0);
  77
  78   /* Relocate the objects loaded.  We do this in reverse order so that copy
  79      relocs of earlier objects overwrite the data written by later objects.  */
  80
  81   l = new;
  82   while (l->l_next)
  83     l = l->l_next;
  84   while (1)
  85     {
  86       if (! l->l_relocated)
  87         {
  88           /* We use an indirect call call for _dl_relocate_object because
  89              we must avoid using the PLT in the call.  If our PLT entry for
  90              _dl_relocate_object hasn't been used yet, then the dynamic
  91              linker fixup routine will clobber _dl_global_scope during its
  92              work.  We must be sure that nothing will require a PLT fixup
  93              between when _dl_object_relocation_scope returns and when we
  94              enter the dynamic linker's code (_dl_relocate_object).  */
  95           __typeof (_dl_relocate_object) *reloc = &_dl_relocate_object;
  96           (*reloc) (l, _dl_object_relocation_scope (l),
  97                     (mode & RTLD_BINDING_MASK) == RTLD_LAZY);
  98           *_dl_global_scope_end = NULL;
  99         }
 100
 101       if (l == new)
 102         break;
 103       l = l->l_prev;
 104     }
 105
 106   new->l_global = (mode & RTLD_GLOBAL);
 107   if (new->l_global)
 108     {
 109       /* The symbols of the new object and its dependencies are to be
 110          introduced into the global scope that will be used to resolve
 111          references from other dynamically-loaded objects.  */
 112
 113       if (_dl_global_scope_alloc == 0)
 114         {
 115           /* This is the first dynamic object given global scope.  */
 116           _dl_global_scope_alloc = 8;
 117           _dl_global_scope = malloc (8 * sizeof (struct link_map *));
 118           if (! _dl_global_scope)
 119             {
 120               _dl_global_scope = _dl_default_scope;
 121             nomem:
 122               _dl_close (new);
 123               _dl_signal_error (ENOMEM, file, "cannot extend global scope");
 124             }
 125           _dl_global_scope[2] = _dl_default_scope[2];
 126           _dl_global_scope[3] = new;
 127           _dl_global_scope[4] = NULL;
 128           _dl_global_scope[5] = NULL;
 129         }
 130       else
 131         {
 132           if (_dl_global_scope_alloc <
 133               (size_t) (_dl_global_scope_end - _dl_global_scope + 2))
 134             {
 135               /* Must extend the list.  */
 136               struct link_map **new = realloc (_dl_global_scope,
 137                                                _dl_global_scope_alloc * 2);
 138               if (! new)
 139                 goto nomem;
 140               _dl_global_scope_end = new + (_dl_global_scope_end -
 141                                             _dl_global_scope);
 142               _dl_global_scope = new;
 143               _dl_global_scope_alloc *= 2;
 144             }
 145
 146           /* Append the new object and re-terminate the list.  */
 147           *_dl_global_scope_end++ = new;
 148           /* We keep the list double-terminated so the last element
 149              can be filled in for symbol lookups.  */
 150           _dl_global_scope_end[0] = NULL;
 151           _dl_global_scope_end[1] = NULL;
 152         }
 153     }
 154
 155
 156   /* Notify the debugger we have added some objects.  We need to call
 157      _dl_debug_initialize in a static program in case dynamic linking has
 158      not been used before.  */
 159   r = _dl_debug_initialize (0);
 160   r->r_state = RT_ADD;
 161   _dl_debug_state ();
 162
 163   /* Run the initializer functions of new objects.  */
 164   while (init = _dl_init_next (new))
 165     (*(void (*) (int, char **, char **)) init) (__libc_argc, __libc_argv,
 166                                                 __environ);
 167
 168   if (_dl_sysdep_start == NULL)
 169     /* We must be the static _dl_open in libc.a.  A static program that
 170        has loaded a dynamic object now has competition.  */
 171     __libc_multiple_libcs = 1;
 172
 173   /* Release the lock.  */
 174   __libc_lock_unlock (_dl_load_lock);
 175
 176   return new;
 177 }