elf/dl-open.c

   1 /* Load a shared object at runtime, relocate it, and run its initializer.
   2    Copyright (C) 1996, 1997, 1998 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
  97           /* GCC is very clever.  If we wouldn't add some magic it would
  98              simply optimize away our nice little variable `reloc' and we
  99              would result in a not working binary.  So let's swing the
 100              magic ward.  */
 101           asm ("" : "=r" (reloc) : "0" (reloc));
 102
 103           (*reloc) (l, _dl_object_relocation_scope (l),
 104                     (mode & RTLD_BINDING_MASK) == RTLD_LAZY);
 105           *_dl_global_scope_end = NULL;
 106         }
 107
 108       if (l == new)
 109         break;
 110       l = l->l_prev;
 111     }
 112
 113   new->l_global = (mode & RTLD_GLOBAL);
 114   if (new->l_global)
 115     {
 116       /* The symbols of the new object and its dependencies are to be
 117          introduced into the global scope that will be used to resolve
 118          references from other dynamically-loaded objects.  */
 119
 120       if (_dl_global_scope_alloc == 0)
 121         {
 122           /* This is the first dynamic object given global scope.  */
 123           _dl_global_scope_alloc = 8;
 124           _dl_global_scope = malloc (8 * sizeof (struct link_map *));
 125           if (! _dl_global_scope)
 126             {
 127               _dl_global_scope = _dl_default_scope;
 128             nomem:
 129               _dl_close (new);
 130               _dl_signal_error (ENOMEM, file, "cannot extend global scope");
 131             }
 132           _dl_global_scope[2] = _dl_default_scope[2];
 133           _dl_global_scope[3] = new;
 134           _dl_global_scope[4] = NULL;
 135           _dl_global_scope[5] = NULL;
 136         }
 137       else
 138         {
 139           if (_dl_global_scope_alloc <
 140               (size_t) (_dl_global_scope_end - _dl_global_scope + 2))
 141             {
 142               /* Must extend the list.  */
 143               struct link_map **new = realloc (_dl_global_scope,
 144                                                _dl_global_scope_alloc * 2);
 145               if (! new)
 146                 goto nomem;
 147               _dl_global_scope_end = new + (_dl_global_scope_end -
 148                                             _dl_global_scope);
 149               _dl_global_scope = new;
 150               _dl_global_scope_alloc *= 2;
 151             }
 152
 153           /* Append the new object and re-terminate the list.  */
 154           *_dl_global_scope_end++ = new;
 155           /* We keep the list double-terminated so the last element
 156              can be filled in for symbol lookups.  */
 157           _dl_global_scope_end[0] = NULL;
 158           _dl_global_scope_end[1] = NULL;
 159         }
 160     }
 161
 162
 163   /* Notify the debugger we have added some objects.  We need to call
 164      _dl_debug_initialize in a static program in case dynamic linking has
 165      not been used before.  */
 166   r = _dl_debug_initialize (0);
 167   r->r_state = RT_ADD;
 168   _dl_debug_state ();
 169
 170   /* Run the initializer functions of new objects.  */
 171   while (init = _dl_init_next (new))
 172     (*(void (*) (int, char **, char **)) init) (__libc_argc, __libc_argv,
 173                                                 __environ);
 174
 175   if (_dl_sysdep_start == NULL)
 176     /* We must be the static _dl_open in libc.a.  A static program that
 177        has loaded a dynamic object now has competition.  */
 178     __libc_multiple_libcs = 1;
 179
 180   /* Release the lock.  */
 181   __libc_lock_unlock (_dl_load_lock);
 182
 183   return new;
 184 }