elf/dl-libc.c

   1 /* Handle loading and unloading shared objects for internal libc purposes.
   2    Copyright (C) 1999-2017 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Zack Weinberg <zack@rabi.columbia.edu>, 1999.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, see
  18    <http://www.gnu.org/licenses/>.  */
  19
  20 #include <dlfcn.h>
  21 #include <stdlib.h>
  22 #include <ldsodefs.h>
  23
  24 extern int __libc_argc attribute_hidden;
  25 extern char **__libc_argv attribute_hidden;
  26
  27 extern char **__environ;
  28
  29 /* The purpose of this file is to provide wrappers around the dynamic
  30    linker error mechanism (similar to dlopen() et al in libdl) which
  31    are usable from within libc.  Generally we want to throw away the
  32    string that dlerror() would return and just pass back a null pointer
  33    for errors.  This also lets the rest of libc not know about the error
  34    handling mechanism.
  35
  36    Much of this code came from gconv_dl.c with slight modifications. */
  37
  38 static int
  39 dlerror_run (void (*operate) (void *), void *args)
  40 {
  41   const char *objname;
  42   const char *last_errstring = NULL;
  43   bool malloced;
  44
  45   int result = (_dl_catch_error (&objname, &last_errstring, &malloced,
  46                                 operate, args)
  47                 ?: last_errstring != NULL);
  48
  49   if (result && malloced)
  50     free ((char *) last_errstring);
  51
  52   return result;
  53 }
  54
  55 /* These functions are called by dlerror_run... */
  56
  57 struct do_dlopen_args
  58 {
  59   /* Argument to do_dlopen.  */
  60   const char *name;
  61   /* Opening mode.  */
  62   int mode;
  63   /* This is the caller of the dlopen() function.  */
  64   const void *caller_dlopen;
  65
  66   /* Return from do_dlopen.  */
  67   struct link_map *map;
  68 };
  69
  70 struct do_dlsym_args
  71 {
  72   /* Arguments to do_dlsym.  */
  73   struct link_map *map;
  74   const char *name;
  75
  76   /* Return values of do_dlsym.  */
  77   lookup_t loadbase;
  78   const ElfW(Sym) *ref;
  79 };
  80
  81 static void
  82 do_dlopen (void *ptr)
  83 {
  84   struct do_dlopen_args *args = (struct do_dlopen_args *) ptr;
  85   /* Open and relocate the shared object.  */
  86   args->map = GLRO(dl_open) (args->name, args->mode, args->caller_dlopen,
  87                              __LM_ID_CALLER, __libc_argc, __libc_argv,
  88                              __environ);
  89 }
  90
  91 static void
  92 do_dlsym (void *ptr)
  93 {
  94   struct do_dlsym_args *args = (struct do_dlsym_args *) ptr;
  95   args->ref = NULL;
  96   args->loadbase = GLRO(dl_lookup_symbol_x) (args->name, args->map, &args->ref,
  97                                              args->map->l_local_scope, NULL, 0,
  98                                              DL_LOOKUP_RETURN_NEWEST, NULL);
  99 }
 100
 101 static void
 102 do_dlclose (void *ptr)
 103 {
 104   GLRO(dl_close) ((struct link_map *) ptr);
 105 }
 106
 107 /* This code is to support __libc_dlopen from __libc_dlopen'ed shared
 108    libraries.  We need to ensure the statically linked __libc_dlopen
 109    etc. functions are used instead of the dynamically loaded.  */
 110 struct dl_open_hook
 111 {
 112   void *(*dlopen_mode) (const char *name, int mode);
 113   void *(*dlsym) (void *map, const char *name);
 114   int (*dlclose) (void *map);
 115 };
 116
 117 #ifdef SHARED
 118 extern struct dl_open_hook *_dl_open_hook;
 119 libc_hidden_proto (_dl_open_hook);
 120 struct dl_open_hook *_dl_open_hook __attribute__ ((nocommon));
 121 libc_hidden_data_def (_dl_open_hook);
 122 #else
 123 static void
 124 do_dlsym_private (void *ptr)
 125 {
 126   lookup_t l;
 127   struct r_found_version vers;
 128   vers.name = "GLIBC_PRIVATE";
 129   vers.hidden = 1;
 130   /* vers.hash = _dl_elf_hash (vers.name);  */
 131   vers.hash = 0x0963cf85;
 132   vers.filename = NULL;
 133
 134   struct do_dlsym_args *args = (struct do_dlsym_args *) ptr;
 135   args->ref = NULL;
 136   l = GLRO(dl_lookup_symbol_x) (args->name, args->map, &args->ref,
 137                                 args->map->l_scope, &vers, 0, 0, NULL);
 138   args->loadbase = l;
 139 }
 140
 141 static struct dl_open_hook _dl_open_hook =
 142   {
 143     .dlopen_mode = __libc_dlopen_mode,
 144     .dlsym = __libc_dlsym,
 145     .dlclose = __libc_dlclose
 146   };
 147 #endif
 148
 149 /* ... and these functions call dlerror_run. */
 150
 151 void *
 152 __libc_dlopen_mode (const char *name, int mode)
 153 {
 154   struct do_dlopen_args args;
 155   args.name = name;
 156   args.mode = mode;
 157   args.caller_dlopen = RETURN_ADDRESS (0);
 158
 159 #ifdef SHARED
 160   if (__glibc_unlikely (_dl_open_hook != NULL))
 161     return _dl_open_hook->dlopen_mode (name, mode);
 162   return (dlerror_run (do_dlopen, &args) ? NULL : (void *) args.map);
 163 #else
 164   if (dlerror_run (do_dlopen, &args))
 165     return NULL;
 166
 167   __libc_register_dl_open_hook (args.map);
 168   __libc_register_dlfcn_hook (args.map);
 169   return (void *) args.map;
 170 #endif
 171 }
 172 libc_hidden_def (__libc_dlopen_mode)
 173
 174 #ifndef SHARED
 175 void *
 176 __libc_dlsym_private (struct link_map *map, const char *name)
 177 {
 178   struct do_dlsym_args sargs;
 179   sargs.map = map;
 180   sargs.name = name;
 181
 182   if (! dlerror_run (do_dlsym_private, &sargs))
 183     return DL_SYMBOL_ADDRESS (sargs.loadbase, sargs.ref);
 184   return NULL;
 185 }
 186
 187 void
 188 __libc_register_dl_open_hook (struct link_map *map)
 189 {
 190   struct dl_open_hook **hook;
 191
 192   hook = (struct dl_open_hook **) __libc_dlsym_private (map, "_dl_open_hook");
 193   if (hook != NULL)
 194     *hook = &_dl_open_hook;
 195 }
 196 #endif
 197
 198 void *
 199 __libc_dlsym (void *map, const char *name)
 200 {
 201   struct do_dlsym_args args;
 202   args.map = map;
 203   args.name = name;
 204
 205 #ifdef SHARED
 206   if (__glibc_unlikely (_dl_open_hook != NULL))
 207     return _dl_open_hook->dlsym (map, name);
 208 #endif
 209   return (dlerror_run (do_dlsym, &args) ? NULL
 210           : (void *) (DL_SYMBOL_ADDRESS (args.loadbase, args.ref)));
 211 }
 212 libc_hidden_def (__libc_dlsym)
 213
 214 int
 215 __libc_dlclose (void *map)
 216 {
 217 #ifdef SHARED
 218   if (__glibc_unlikely (_dl_open_hook != NULL))
 219     return _dl_open_hook->dlclose (map);
 220 #endif
 221   return dlerror_run (do_dlclose, map);
 222 }
 223 libc_hidden_def (__libc_dlclose)
 224
 225
 226 static bool __libc_freeres_fn_section
 227 free_slotinfo (struct dtv_slotinfo_list **elemp)
 228 {
 229   size_t cnt;
 230
 231   if (*elemp == NULL)
 232     /* Nothing here, all is removed (or there never was anything).  */
 233     return true;
 234
 235   if (!free_slotinfo (&(*elemp)->next))
 236     /* We cannot free the entry.  */
 237     return false;
 238
 239   /* That cleared our next pointer for us.  */
 240
 241   for (cnt = 0; cnt < (*elemp)->len; ++cnt)
 242     if ((*elemp)->slotinfo[cnt].map != NULL)
 243       /* Still used.  */
 244       return false;
 245
 246   /* We can remove the list element.  */
 247   free (*elemp);
 248   *elemp = NULL;
 249
 250   return true;
 251 }
 252
 253
 254 libc_freeres_fn (free_mem)
 255 {
 256   struct link_map *l;
 257   struct r_search_path_elem *d;
 258
 259   /* Remove all search directories.  */
 260   d = GL(dl_all_dirs);
 261   while (d != GLRO(dl_init_all_dirs))
 262     {
 263       struct r_search_path_elem *old = d;
 264       d = d->next;
 265       free (old);
 266     }
 267
 268   for (Lmid_t ns = 0; ns < GL(dl_nns); ++ns)
 269     {
 270       for (l = GL(dl_ns)[ns]._ns_loaded; l != NULL; l = l->l_next)
 271         {
 272           struct libname_list *lnp = l->l_libname->next;
 273
 274           l->l_libname->next = NULL;
 275
 276           /* Remove all additional names added to the objects.  */
 277           while (lnp != NULL)
 278             {
 279               struct libname_list *old = lnp;
 280               lnp = lnp->next;
 281               if (! old->dont_free)
 282                 free (old);
 283             }
 284
 285           /* Free the initfini dependency list.  */
 286           if (l->l_free_initfini)
 287             free (l->l_initfini);
 288           l->l_initfini = NULL;
 289         }
 290
 291       if (__builtin_expect (GL(dl_ns)[ns]._ns_global_scope_alloc, 0) != 0
 292           && (GL(dl_ns)[ns]._ns_main_searchlist->r_nlist
 293               // XXX Check whether we need NS-specific initial_searchlist
 294               == GLRO(dl_initial_searchlist).r_nlist))
 295         {
 296           /* All object dynamically loaded by the program are unloaded.  Free
 297              the memory allocated for the global scope variable.  */
 298           struct link_map **old = GL(dl_ns)[ns]._ns_main_searchlist->r_list;
 299
 300           /* Put the old map in.  */
 301           GL(dl_ns)[ns]._ns_main_searchlist->r_list
 302             // XXX Check whether we need NS-specific initial_searchlist
 303             = GLRO(dl_initial_searchlist).r_list;
 304           /* Signal that the original map is used.  */
 305           GL(dl_ns)[ns]._ns_global_scope_alloc = 0;
 306
 307           /* Now free the old map.  */
 308           free (old);
 309         }
 310     }
 311
 312   /* Free the memory allocated for the dtv slotinfo array.  We can do
 313      this only if all modules which used this memory are unloaded.  */
 314 #ifdef SHARED
 315   if (GL(dl_initial_dtv) == NULL)
 316     /* There was no initial TLS setup, it was set up later when
 317        it used the normal malloc.  */
 318     free_slotinfo (&GL(dl_tls_dtv_slotinfo_list));
 319   else
 320 #endif
 321     /* The first element of the list does not have to be deallocated.
 322        It was allocated in the dynamic linker (i.e., with a different
 323        malloc), and in the static library it's in .bss space.  */
 324     free_slotinfo (&GL(dl_tls_dtv_slotinfo_list)->next);
 325
 326   void *scope_free_list = GL(dl_scope_free_list);
 327   GL(dl_scope_free_list) = NULL;
 328   free (scope_free_list);
 329 }