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 <dlfcn.h>
  21 #include <errno.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <sys/mman.h>           /* Check whether MAP_COPY is defined.  */
  25 #include <bits/libc-lock.h>
  26 #include <elf/ldsodefs.h>
  27
  28
  29 extern ElfW(Addr) _dl_sysdep_start (void **start_argptr,
  30                                     void (*dl_main) (const ElfW(Phdr) *phdr,
  31                                                      ElfW(Word) phnum,
  32                                                      ElfW(Addr) *user_entry));
  33 weak_extern (_dl_sysdep_start)
  34
  35 /* This function is used to unload the cache file if necessary.  */
  36 extern void _dl_unload_cache (void);
  37
  38 extern int __libc_multiple_libcs;       /* Defined in init-first.c.  */
  39
  40 extern int __libc_argc;
  41 extern char **__libc_argv;
  42
  43 extern char **__environ;
  44
  45 static size_t _dl_global_scope_alloc;
  46
  47
  48 /* During the program run we must not modify the global data of
  49    loaded shared object simultanously in two threads.  Therefore we
  50    protect `_dl_open' and `_dl_close' in dl-close.c.
  51
  52    This must be a recursive lock since the initializer function of
  53    the loaded object might as well require a call to this function.
  54    At this time it is not anymore a problem to modify the tables.  */
  55 __libc_lock_define_initialized_recursive (, _dl_load_lock)
  56
  57
  58 /* We must be carefull not to leave us in an inconsistent state.  Thus we
  59    catch any error and re-raise it after cleaning up.  */
  60
  61 struct dl_open_args
  62 {
  63   const char *file;
  64   int mode;
  65   struct link_map *map;
  66 };
  67
  68 static void
  69 dl_open_worker (void *a)
  70 {
  71   struct dl_open_args *args = a;
  72   const char *file = args->file;
  73   int mode = args->mode;
  74   struct link_map *new, *l;
  75   ElfW(Addr) init;
  76   struct r_debug *r;
  77
  78   /* Load the named object.  */
  79   args->map = new = _dl_map_object (NULL, file, 0, lt_loaded, 0);
  80   if (new->l_searchlist.r_list)
  81     /* It was already open.  */
  82     return;
  83
  84   /* Load that object's dependencies.  */
  85   _dl_map_object_deps (new, NULL, 0, 0);
  86
  87   /* So far, so good.  Now check the versions.  */
  88   (void) _dl_check_all_versions (new, 0);
  89
  90   /* Relocate the objects loaded.  We do this in reverse order so that copy
  91      relocs of earlier objects overwrite the data written by later objects.  */
  92
  93   l = new;
  94   while (l->l_next)
  95     l = l->l_next;
  96   while (1)
  97     {
  98       if (! l->l_relocated)
  99         {
 100 #ifdef PIC
 101           if (_dl_profile != NULL)
 102             {
 103               /* If this here is the shared object which we want to profile
 104                  make sure the profile is started.  We can find out whether
 105                  this is necessary or not by observing the `_dl_profile_map'
 106                  variable.  If was NULL but is not NULL afterwars we must
 107                  start the profiling.  */
 108               struct link_map *old_profile_map = _dl_profile_map;
 109
 110               _dl_relocate_object (l, l->l_scope, 1, 1);
 111
 112               if (old_profile_map == NULL && _dl_profile_map != NULL)
 113                 /* We must prepare the profiling.  */
 114                 _dl_start_profile (_dl_profile_map, _dl_profile_output);
 115             }
 116           else
 117 #endif
 118             _dl_relocate_object (l, l->l_scope,
 119                                  (mode & RTLD_BINDING_MASK) == RTLD_LAZY, 0);
 120         }
 121
 122       if (l == new)
 123         break;
 124       l = l->l_prev;
 125     }
 126
 127   new->l_global = (mode & RTLD_GLOBAL) ? 1 : 0;
 128   if (new->l_global)
 129     {
 130       struct link_map **new_global;
 131
 132       /* The symbols of the new object and its dependencies are to be
 133          introduced into the global scope that will be used to resolve
 134          references from other dynamically-loaded objects.
 135
 136          The global scope is the searchlist in the main link map.  We
 137          extend this list if necessary.  There is one problem though:
 138          since this structure was allocated very early (before the libc
 139          is loaded) the memory it uses is allocated by the malloc()-stub
 140          in the ld.so.  When we come here these functions are not used
 141          anymore.  Instead the malloc() implementation of the libc is
 142          used.  But this means the block from the main map cannot be used
 143          in an realloc() call.  Therefore we allocate a completely new
 144          array the first time we have to add something to the locale scope.  */
 145       if (_dl_global_scope_alloc == 0)
 146         {
 147           /* This is the first dynamic object given global scope.  */
 148           _dl_global_scope_alloc = _dl_main_searchlist->r_nlist + 8;
 149           new_global = (struct link_map **)
 150             malloc (_dl_global_scope_alloc * sizeof (struct link_map *));
 151           if (new_global == NULL)
 152             {
 153               _dl_global_scope_alloc = 0;
 154             nomem:
 155               new->l_global = 0;
 156               _dl_signal_error (ENOMEM, file, "cannot extend global scope");
 157             }
 158
 159           /* Copy over the old entries.  */
 160           memcpy (new_global, _dl_main_searchlist->r_list,
 161                   (_dl_main_searchlist->r_nlist * sizeof (struct link_map *)));
 162
 163           _dl_main_searchlist->r_list = new_global;
 164         }
 165       else if (_dl_main_searchlist->r_nlist == _dl_global_scope_alloc)
 166         {
 167           /* We have to extend the existing array of link maps in the
 168              main map.  */
 169           new_global = (struct link_map **)
 170             malloc ((_dl_global_scope_alloc + 8) * sizeof (struct link_map *));
 171           if (new_global == NULL)
 172             goto nomem;
 173
 174           _dl_global_scope_alloc += 8;
 175           _dl_main_searchlist->r_list = new_global;
 176         }
 177
 178       /* Now add the new entry.  */
 179       _dl_main_searchlist->r_list[_dl_main_searchlist->r_nlist] = new;
 180
 181       /* XXX Do we have to add something to r_dupsearchlist???  --drepper */
 182     }
 183
 184
 185   /* Notify the debugger we have added some objects.  We need to call
 186      _dl_debug_initialize in a static program in case dynamic linking has
 187      not been used before.  */
 188   r = _dl_debug_initialize (0);
 189   r->r_state = RT_ADD;
 190   _dl_debug_state ();
 191
 192   /* Run the initializer functions of new objects.  */
 193   while ((init = _dl_init_next (&new->l_searchlist)))
 194     (*(void (*) (int, char **, char **)) init) (__libc_argc, __libc_argv,
 195                                                 __environ);
 196
 197   if (new->l_global)
 198     /* Now we can make the new map available in the global scope.  */
 199     ++_dl_main_searchlist->r_nlist;
 200
 201   if (_dl_sysdep_start == NULL)
 202     /* We must be the static _dl_open in libc.a.  A static program that
 203        has loaded a dynamic object now has competition.  */
 204     __libc_multiple_libcs = 1;
 205 }
 206
 207
 208 struct link_map *
 209 internal_function
 210 _dl_open (const char *file, int mode)
 211 {
 212   struct dl_open_args args;
 213   char *errstring;
 214   int errcode;
 215
 216   /* Make sure we are alone.  */
 217   __libc_lock_lock (_dl_load_lock);
 218
 219   args.file = file;
 220   args.mode = mode;
 221   args.map = NULL;
 222   errcode = _dl_catch_error (&errstring, dl_open_worker, &args);
 223
 224 #ifndef MAP_COPY
 225   /* We must munmap() the cache file.  */
 226   _dl_unload_cache ();
 227 #endif
 228
 229   /* Release the lock.  */
 230   __libc_lock_unlock (_dl_load_lock);
 231
 232   if (errstring)
 233     {
 234       /* Some error occured during loading.  */
 235       char *local_errstring;
 236
 237       /* Remove the object from memory.  It may be in an inconsistent
 238          state if relocation failed, for example.  */
 239       if (args.map)
 240         _dl_close (args.map);
 241
 242       /* Make a local copy of the error string so that we can release the
 243          memory allocated for it.  */
 244       local_errstring = strdupa (errstring);
 245       free (errstring);
 246
 247       /* Reraise the error.  */
 248       _dl_signal_error (errcode, NULL, local_errstring);
 249     }
 250
 251   return args.map;
 252 }