elf/dl-libc.c

   1 /* Handle loading and unloading shared objects for internal libc purposes.
   2    Copyright (C) 1999-2016 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 internal_function
  40 dlerror_run (void (*operate) (void *), void *args)
  41 {
  42   const char *objname;
  43   const char *last_errstring = NULL;
  44   bool malloced;
  45
  46   int result = (GLRO(dl_catch_error) (&objname, &last_errstring, &malloced,
  47                                       operate, args)
  48                 ?: last_errstring != NULL);
  49
  50   if (result && malloced)
  51     free ((char *) last_errstring);
  52
  53   return result;
  54 }
  55
  56 /* These functions are called by dlerror_run... */
  57
  58 struct do_dlopen_args
  59 {
  60   /* Argument to do_dlopen.  */
  61   const char *name;
  62   /* Opening mode.  */
  63   int mode;
  64   /* This is the caller of the dlopen() function.  */
  65   const void *caller_dlopen;
  66
  67   /* Return from do_dlopen.  */
  68   struct link_map *map;
  69 };
  70
  71 struct do_dlsym_args
  72 {
  73   /* Arguments to do_dlsym.  */
  74   struct link_map *map;
  75   const char *name;
  76
  77   /* Return values of do_dlsym.  */
  78   lookup_t loadbase;
  79   const ElfW(Sym) *ref;
  80 };
  81
  82 static void
  83 do_dlopen (void *ptr)
  84 {
  85   struct do_dlopen_args *args = (struct do_dlopen_args *) ptr;
  86   /* Open and relocate the shared object.  */
  87   args->map = GLRO(dl_open) (args->name, args->mode, args->caller_dlopen,
  88                              __LM_ID_CALLER, __libc_argc, __libc_argv,
  89                              __environ);
  90 }
  91
  92 static void
  93 do_dlsym (void *ptr)
  94 {
  95   struct do_dlsym_args *args = (struct do_dlsym_args *) ptr;
  96   args->ref = NULL;
  97   args->loadbase = GLRO(dl_lookup_symbol_x) (args->name, args->map, &args->ref,
  98                                              args->map->l_local_scope, NULL, 0,
  99                                              DL_LOOKUP_RETURN_NEWEST, NULL);
 100 }
 101
 102 static void
 103 do_dlclose (void *ptr)
 104 {
 105   GLRO(dl_close) ((struct link_map *) ptr);
 106 }
 107
 108 /* This code is to support __libc_dlopen from __libc_dlopen'ed shared
 109    libraries.  We need to ensure the statically linked __libc_dlopen
 110    etc. functions are used instead of the dynamically loaded.  */
 111 struct dl_open_hook
 112 {
 113   void *(*dlopen_mode) (const char *name, int mode);
 114   void *(*dlsym) (void *map, const char *name);
 115   int (*dlclose) (void *map);
 116 };
 117
 118 #ifdef SHARED
 119 extern struct dl_open_hook *_dl_open_hook;
 120 libc_hidden_proto (_dl_open_hook);
 121 struct dl_open_hook *_dl_open_hook __attribute__ ((nocommon));
 122 libc_hidden_data_def (_dl_open_hook);
 123 #else
 124 static void
 125 do_dlsym_private (void *ptr)
 126 {
 127   lookup_t l;
 128   struct r_found_version vers;
 129   vers.name = "GLIBC_PRIVATE";
 130   vers.hidden = 1;
 131   /* vers.hash = _dl_elf_hash (vers.name);  */
 132   vers.hash = 0x0963cf85;
 133   vers.filename = NULL;
 134
 135   struct do_dlsym_args *args = (struct do_dlsym_args *) ptr;
 136   args->ref = NULL;
 137   l = GLRO(dl_lookup_symbol_x) (args->name, args->map, &args->ref,
 138                                 args->map->l_scope, &vers, 0, 0, NULL);
 139   args->loadbase = l;
 140 }
 141
 142 static struct dl_open_hook _dl_open_hook =
 143   {
 144     .dlopen_mode = __libc_dlopen_mode,
 145     .dlsym = __libc_dlsym,
 146     .dlclose = __libc_dlclose
 147   };
 148 #endif
 149
 150 /* ... and these functions call dlerror_run. */
 151
 152 void *
 153 __libc_dlopen_mode (const char *name, int mode)
 154 {
 155   struct do_dlopen_args args;
 156   args.name = name;
 157   args.mode = mode;
 158   args.caller_dlopen = RETURN_ADDRESS (0);
 159
 160 #ifdef SHARED
 161   if (__glibc_unlikely (_dl_open_hook != NULL))
 162     return _dl_open_hook->dlopen_mode (name, mode);
 163   return (dlerror_run (do_dlopen, &args) ? NULL : (void *) args.map);
 164 #else
 165   if (dlerror_run (do_dlopen, &args))
 166     return NULL;
 167
 168   __libc_register_dl_open_hook (args.map);
 169   __libc_register_dlfcn_hook (args.map);
 170   return (void *) args.map;
 171 #endif
 172 }
 173 libc_hidden_def (__libc_dlopen_mode)
 174
 175 #ifndef SHARED
 176 void *
 177 __libc_dlsym_private (struct link_map *map, const char *name)
 178 {
 179   struct do_dlsym_args sargs;
 180   sargs.map = map;
 181   sargs.name = name;
 182
 183   if (! dlerror_run (do_dlsym_private, &sargs))
 184     return DL_SYMBOL_ADDRESS (sargs.loadbase, sargs.ref);
 185   return NULL;
 186 }
 187
 188 void
 189 __libc_register_dl_open_hook (struct link_map *map)
 190 {
 191   struct dl_open_hook **hook;
 192
 193   hook = (struct dl_open_hook **) __libc_dlsym_private (map, "_dl_open_hook");
 194   if (hook != NULL)
 195     *hook = &_dl_open_hook;
 196 }
 197 #endif
 198
 199 void *
 200 __libc_dlsym (void *map, const char *name)
 201 {
 202   struct do_dlsym_args args;
 203   args.map = map;
 204   args.name = name;
 205
 206 #ifdef SHARED
 207   if (__glibc_unlikely (_dl_open_hook != NULL))
 208     return _dl_open_hook->dlsym (map, name);
 209 #endif
 210   return (dlerror_run (do_dlsym, &args) ? NULL
 211           : (void *) (DL_SYMBOL_ADDRESS (args.loadbase, args.ref)));
 212 }
 213 libc_hidden_def (__libc_dlsym)
 214
 215 int
 216 __libc_dlclose (void *map)
 217 {
 218 #ifdef SHARED
 219   if (__glibc_unlikely (_dl_open_hook != NULL))
 220     return _dl_open_hook->dlclose (map);
 221 #endif
 222   return dlerror_run (do_dlclose, map);
 223 }
 224 libc_hidden_def (__libc_dlclose)
 225
 226
 227 static bool __libc_freeres_fn_section
 228 free_slotinfo (struct dtv_slotinfo_list **elemp)
 229 {
 230   size_t cnt;
 231
 232   if (*elemp == NULL)
 233     /* Nothing here, all is removed (or there never was anything).  */
 234     return true;
 235
 236   if (!free_slotinfo (&(*elemp)->next))
 237     /* We cannot free the entry.  */
 238     return false;
 239
 240   /* That cleared our next pointer for us.  */
 241
 242   for (cnt = 0; cnt < (*elemp)->len; ++cnt)
 243     if ((*elemp)->slotinfo[cnt].map != NULL)
 244       /* Still used.  */
 245       return false;
 246
 247   /* We can remove the list element.  */
 248   free (*elemp);
 249   *elemp = NULL;
 250
 251   return true;
 252 }
 253
 254
 255 libc_freeres_fn (free_mem)
 256 {
 257   struct link_map *l;
 258   struct r_search_path_elem *d;
 259
 260   /* Remove all search directories.  */
 261   d = GL(dl_all_dirs);
 262   while (d != GLRO(dl_init_all_dirs))
 263     {
 264       struct r_search_path_elem *old = d;
 265       d = d->next;
 266       free (old);
 267     }
 268
 269   for (Lmid_t ns = 0; ns < GL(dl_nns); ++ns)
 270     {
 271       for (l = GL(dl_ns)[ns]._ns_loaded; l != NULL; l = l->l_next)
 272         {
 273           struct libname_list *lnp = l->l_libname->next;
 274
 275           l->l_libname->next = NULL;
 276
 277           /* Remove all additional names added to the objects.  */
 278           while (lnp != NULL)
 279             {
 280               struct libname_list *old = lnp;
 281               lnp = lnp->next;
 282               if (! old->dont_free)
 283                 free (old);
 284             }
 285
 286           /* Free the initfini dependency list.  */
 287           if (l->l_free_initfini)
 288             free (l->l_initfini);
 289           l->l_initfini = NULL;
 290         }
 291
 292       if (__builtin_expect (GL(dl_ns)[ns]._ns_global_scope_alloc, 0) != 0
 293           && (GL(dl_ns)[ns]._ns_main_searchlist->r_nlist
 294               // XXX Check whether we need NS-specific initial_searchlist
 295               == GLRO(dl_initial_searchlist).r_nlist))
 296         {
 297           /* All object dynamically loaded by the program are unloaded.  Free
 298              the memory allocated for the global scope variable.  */
 299           struct link_map **old = GL(dl_ns)[ns]._ns_main_searchlist->r_list;
 300
 301           /* Put the old map in.  */
 302           GL(dl_ns)[ns]._ns_main_searchlist->r_list
 303             // XXX Check whether we need NS-specific initial_searchlist
 304             = GLRO(dl_initial_searchlist).r_list;
 305           /* Signal that the original map is used.  */
 306           GL(dl_ns)[ns]._ns_global_scope_alloc = 0;
 307
 308           /* Now free the old map.  */
 309           free (old);
 310         }
 311     }
 312
 313   /* Free the memory allocated for the dtv slotinfo array.  We can do
 314      this only if all modules which used this memory are unloaded.  */
 315 #ifdef SHARED
 316   if (GL(dl_initial_dtv) == NULL)
 317     /* There was no initial TLS setup, it was set up later when
 318        it used the normal malloc.  */
 319     free_slotinfo (&GL(dl_tls_dtv_slotinfo_list));
 320   else
 321 #endif
 322     /* The first element of the list does not have to be deallocated.
 323        It was allocated in the dynamic linker (i.e., with a different
 324        malloc), and in the static library it's in .bss space.  */
 325     free_slotinfo (&GL(dl_tls_dtv_slotinfo_list)->next);
 326
 327   void *scope_free_list = GL(dl_scope_free_list);
 328   GL(dl_scope_free_list) = NULL;
 329   free (scope_free_list);
 330 }