elf/dl-libc.c

   1 /* Handle loading and unloading shared objects for internal libc purposes.
   2    Copyright (C) 1999-2018 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 #include <dl-hash.h>
  24
  25 extern int __libc_argc attribute_hidden;
  26 extern char **__libc_argv attribute_hidden;
  27
  28 extern char **__environ;
  29
  30 /* The purpose of this file is to provide wrappers around the dynamic
  31    linker error mechanism (similar to dlopen() et al in libdl) which
  32    are usable from within libc.  Generally we want to throw away the
  33    string that dlerror() would return and just pass back a null pointer
  34    for errors.  This also lets the rest of libc not know about the error
  35    handling mechanism.
  36
  37    Much of this code came from gconv_dl.c with slight modifications. */
  38
  39 static int
  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 = (_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 struct do_dlvsym_args
  83 {
  84   /* dlvsym is like dlsym.  */
  85   struct do_dlsym_args dlsym;
  86
  87   /* But dlvsym needs a version  as well.  */
  88   struct r_found_version version;
  89 };
  90
  91 static void
  92 do_dlopen (void *ptr)
  93 {
  94   struct do_dlopen_args *args = (struct do_dlopen_args *) ptr;
  95   /* Open and relocate the shared object.  */
  96   args->map = GLRO(dl_open) (args->name, args->mode, args->caller_dlopen,
  97                              __LM_ID_CALLER, __libc_argc, __libc_argv,
  98                              __environ);
  99 }
 100
 101 static void
 102 do_dlsym (void *ptr)
 103 {
 104   struct do_dlsym_args *args = (struct do_dlsym_args *) ptr;
 105   args->ref = NULL;
 106   args->loadbase = GLRO(dl_lookup_symbol_x) (args->name, args->map, &args->ref,
 107                                              args->map->l_local_scope, NULL, 0,
 108                                              DL_LOOKUP_RETURN_NEWEST, NULL);
 109 }
 110
 111 static void
 112 do_dlvsym (void *ptr)
 113 {
 114   struct do_dlvsym_args *args = ptr;
 115   args->dlsym.ref = NULL;
 116   args->dlsym.loadbase
 117     = GLRO(dl_lookup_symbol_x) (args->dlsym.name, args->dlsym.map,
 118                                 &args->dlsym.ref,
 119                                 args->dlsym.map->l_local_scope,
 120                                 &args->version, 0, 0, NULL);
 121 }
 122
 123 static void
 124 do_dlclose (void *ptr)
 125 {
 126   GLRO(dl_close) ((struct link_map *) ptr);
 127 }
 128
 129 /* This code is to support __libc_dlopen from __libc_dlopen'ed shared
 130    libraries.  We need to ensure the statically linked __libc_dlopen
 131    etc. functions are used instead of the dynamically loaded.  */
 132 struct dl_open_hook
 133 {
 134   void *(*dlopen_mode) (const char *name, int mode);
 135   void *(*dlsym) (void *map, const char *name);
 136   int (*dlclose) (void *map);
 137   void *(*dlvsym) (void *map, const char *name, const char *version);
 138 };
 139
 140 #ifdef SHARED
 141 extern struct dl_open_hook *_dl_open_hook;
 142 libc_hidden_proto (_dl_open_hook);
 143 struct dl_open_hook *_dl_open_hook __attribute__ ((nocommon));
 144 libc_hidden_data_def (_dl_open_hook);
 145
 146 /* The dlvsym member was added retroactively to struct dl_open_hook.
 147    Static applications which have it will set _dl_open_hook2 in
 148    addition to _dl_open_hook.  */
 149 extern struct dl_open_hook *_dl_open_hook2;
 150 libc_hidden_proto (_dl_open_hook2);
 151 struct dl_open_hook *_dl_open_hook2 __attribute__ ((nocommon));
 152 libc_hidden_data_def (_dl_open_hook2);
 153
 154 #else
 155 static void
 156 do_dlsym_private (void *ptr)
 157 {
 158   lookup_t l;
 159   struct r_found_version vers;
 160   vers.name = "GLIBC_PRIVATE";
 161   vers.hidden = 1;
 162   /* vers.hash = _dl_elf_hash (vers.name);  */
 163   vers.hash = 0x0963cf85;
 164   vers.filename = NULL;
 165
 166   struct do_dlsym_args *args = (struct do_dlsym_args *) ptr;
 167   args->ref = NULL;
 168   l = GLRO(dl_lookup_symbol_x) (args->name, args->map, &args->ref,
 169                                 args->map->l_scope, &vers, 0, 0, NULL);
 170   args->loadbase = l;
 171 }
 172
 173 static struct dl_open_hook _dl_open_hook =
 174   {
 175     .dlopen_mode = __libc_dlopen_mode,
 176     .dlsym = __libc_dlsym,
 177     .dlclose = __libc_dlclose,
 178     .dlvsym = __libc_dlvsym,
 179   };
 180 #endif
 181
 182 /* ... and these functions call dlerror_run. */
 183
 184 void *
 185 __libc_dlopen_mode (const char *name, int mode)
 186 {
 187   struct do_dlopen_args args;
 188   args.name = name;
 189   args.mode = mode;
 190   args.caller_dlopen = RETURN_ADDRESS (0);
 191
 192 #ifdef SHARED
 193   if (!rtld_active ())
 194     return _dl_open_hook->dlopen_mode (name, mode);
 195   return (dlerror_run (do_dlopen, &args) ? NULL : (void *) args.map);
 196 #else
 197   if (dlerror_run (do_dlopen, &args))
 198     return NULL;
 199
 200   __libc_register_dl_open_hook (args.map);
 201   __libc_register_dlfcn_hook (args.map);
 202   return (void *) args.map;
 203 #endif
 204 }
 205 libc_hidden_def (__libc_dlopen_mode)
 206
 207 #ifndef SHARED
 208 void *
 209 __libc_dlsym_private (struct link_map *map, const char *name)
 210 {
 211   struct do_dlsym_args sargs;
 212   sargs.map = map;
 213   sargs.name = name;
 214
 215   if (! dlerror_run (do_dlsym_private, &sargs))
 216     return DL_SYMBOL_ADDRESS (sargs.loadbase, sargs.ref);
 217   return NULL;
 218 }
 219
 220 void
 221 __libc_register_dl_open_hook (struct link_map *map)
 222 {
 223   struct dl_open_hook **hook;
 224
 225   hook = (struct dl_open_hook **) __libc_dlsym_private (map, "_dl_open_hook");
 226   if (hook != NULL)
 227     *hook = &_dl_open_hook;
 228
 229   /* For dlvsym support.  */
 230   hook = (struct dl_open_hook **) __libc_dlsym_private (map, "_dl_open_hook2");
 231   if (hook != NULL)
 232     *hook = &_dl_open_hook;
 233 }
 234 #endif
 235
 236 void *
 237 __libc_dlsym (void *map, const char *name)
 238 {
 239   struct do_dlsym_args args;
 240   args.map = map;
 241   args.name = name;
 242
 243 #ifdef SHARED
 244   if (!rtld_active ())
 245     return _dl_open_hook->dlsym (map, name);
 246 #endif
 247   return (dlerror_run (do_dlsym, &args) ? NULL
 248           : (void *) (DL_SYMBOL_ADDRESS (args.loadbase, args.ref)));
 249 }
 250 libc_hidden_def (__libc_dlsym)
 251
 252 /* Replacement for dlvsym.  MAP must be a real map.  This function
 253    returns NULL without setting the dlerror value in case of static
 254    dlopen from an old binary.  */
 255 void *
 256 __libc_dlvsym (void *map, const char *name, const char *version)
 257 {
 258 #ifdef SHARED
 259   if (!rtld_active ())
 260     {
 261       /* The static application is too old and does not provide the
 262          dlvsym hook.  */
 263       if (_dl_open_hook2 == NULL)
 264         return NULL;
 265       return _dl_open_hook2->dlvsym (map, name, version);
 266     }
 267 #endif
 268
 269   struct do_dlvsym_args args;
 270   args.dlsym.map = map;
 271   args.dlsym.name = name;
 272
 273   /* See _dl_vsym in dl-sym.c.  */
 274   args.version.name = version;
 275   args.version.hidden = 1;
 276   args.version.hash = _dl_elf_hash (version);
 277   args.version.filename = NULL;
 278
 279   return (dlerror_run (do_dlvsym, &args) ? NULL
 280           : (void *) (DL_SYMBOL_ADDRESS (args.dlsym.loadbase,
 281                                          args.dlsym.ref)));
 282 }
 283 libc_hidden_def (__libc_dlvsym)
 284
 285 int
 286 __libc_dlclose (void *map)
 287 {
 288 #ifdef SHARED
 289   if (!rtld_active ())
 290     return _dl_open_hook->dlclose (map);
 291 #endif
 292   return dlerror_run (do_dlclose, map);
 293 }
 294 libc_hidden_def (__libc_dlclose)
 295
 296
 297 static bool __libc_freeres_fn_section
 298 free_slotinfo (struct dtv_slotinfo_list **elemp)
 299 {
 300   size_t cnt;
 301
 302   if (*elemp == NULL)
 303     /* Nothing here, all is removed (or there never was anything).  */
 304     return true;
 305
 306   if (!free_slotinfo (&(*elemp)->next))
 307     /* We cannot free the entry.  */
 308     return false;
 309
 310   /* That cleared our next pointer for us.  */
 311
 312   for (cnt = 0; cnt < (*elemp)->len; ++cnt)
 313     if ((*elemp)->slotinfo[cnt].map != NULL)
 314       /* Still used.  */
 315       return false;
 316
 317   /* We can remove the list element.  */
 318   free (*elemp);
 319   *elemp = NULL;
 320
 321   return true;
 322 }
 323
 324
 325 libc_freeres_fn (free_mem)
 326 {
 327   struct link_map *l;
 328   struct r_search_path_elem *d;
 329
 330   /* Remove all search directories.  */
 331   d = GL(dl_all_dirs);
 332   while (d != GLRO(dl_init_all_dirs))
 333     {
 334       struct r_search_path_elem *old = d;
 335       d = d->next;
 336       free (old);
 337     }
 338
 339   for (Lmid_t ns = 0; ns < GL(dl_nns); ++ns)
 340     {
 341       for (l = GL(dl_ns)[ns]._ns_loaded; l != NULL; l = l->l_next)
 342         {
 343           struct libname_list *lnp = l->l_libname->next;
 344
 345           l->l_libname->next = NULL;
 346
 347           /* Remove all additional names added to the objects.  */
 348           while (lnp != NULL)
 349             {
 350               struct libname_list *old = lnp;
 351               lnp = lnp->next;
 352               if (! old->dont_free)
 353                 free (old);
 354             }
 355
 356           /* Free the initfini dependency list.  */
 357           if (l->l_free_initfini)
 358             free (l->l_initfini);
 359           l->l_initfini = NULL;
 360         }
 361
 362       if (__builtin_expect (GL(dl_ns)[ns]._ns_global_scope_alloc, 0) != 0
 363           && (GL(dl_ns)[ns]._ns_main_searchlist->r_nlist
 364               // XXX Check whether we need NS-specific initial_searchlist
 365               == GLRO(dl_initial_searchlist).r_nlist))
 366         {
 367           /* All object dynamically loaded by the program are unloaded.  Free
 368              the memory allocated for the global scope variable.  */
 369           struct link_map **old = GL(dl_ns)[ns]._ns_main_searchlist->r_list;
 370
 371           /* Put the old map in.  */
 372           GL(dl_ns)[ns]._ns_main_searchlist->r_list
 373             // XXX Check whether we need NS-specific initial_searchlist
 374             = GLRO(dl_initial_searchlist).r_list;
 375           /* Signal that the original map is used.  */
 376           GL(dl_ns)[ns]._ns_global_scope_alloc = 0;
 377
 378           /* Now free the old map.  */
 379           free (old);
 380         }
 381     }
 382
 383   /* Free the memory allocated for the dtv slotinfo array.  We can do
 384      this only if all modules which used this memory are unloaded.  */
 385 #ifdef SHARED
 386   if (GL(dl_initial_dtv) == NULL)
 387     /* There was no initial TLS setup, it was set up later when
 388        it used the normal malloc.  */
 389     free_slotinfo (&GL(dl_tls_dtv_slotinfo_list));
 390   else
 391 #endif
 392     /* The first element of the list does not have to be deallocated.
 393        It was allocated in the dynamic linker (i.e., with a different
 394        malloc), and in the static library it's in .bss space.  */
 395     free_slotinfo (&GL(dl_tls_dtv_slotinfo_list)->next);
 396
 397   void *scope_free_list = GL(dl_scope_free_list);
 398   GL(dl_scope_free_list) = NULL;
 399   free (scope_free_list);
 400 }