elf/dl-libc.c

   1 /* Handle loading and unloading shared objects for internal libc purposes.
   2    Copyright (C) 1999-2022 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 Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the 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    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <dlfcn.h>
  20 #include <stdlib.h>
  21 #include <ldsodefs.h>
  22 #include <dl-hash.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 = (GLRO (dl_catch_error) (&objname, &last_errstring, &malloced,
  46                                        operate, args)
  47                 ?: last_errstring != NULL);
  48
  49   if (result && malloced)
  50     GLRO (dl_error_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 struct do_dlvsym_args
  82 {
  83   /* dlvsym is like dlsym.  */
  84   struct do_dlsym_args dlsym;
  85
  86   /* But dlvsym needs a version  as well.  */
  87   struct r_found_version version;
  88 };
  89
  90 static void
  91 do_dlopen (void *ptr)
  92 {
  93   struct do_dlopen_args *args = (struct do_dlopen_args *) ptr;
  94   /* Open and relocate the shared object.  */
  95   args->map = GLRO(dl_open) (args->name, args->mode, args->caller_dlopen,
  96                              __LM_ID_CALLER, __libc_argc, __libc_argv,
  97                              __environ);
  98 }
  99
 100 static void
 101 do_dlsym (void *ptr)
 102 {
 103   struct do_dlsym_args *args = (struct do_dlsym_args *) ptr;
 104   args->ref = NULL;
 105   args->loadbase = GLRO(dl_lookup_symbol_x) (args->name, args->map, &args->ref,
 106                                              args->map->l_local_scope, NULL, 0,
 107                                              DL_LOOKUP_RETURN_NEWEST, NULL);
 108 }
 109
 110 static void
 111 do_dlvsym (void *ptr)
 112 {
 113   struct do_dlvsym_args *args = ptr;
 114   args->dlsym.ref = NULL;
 115   args->dlsym.loadbase
 116     = GLRO(dl_lookup_symbol_x) (args->dlsym.name, args->dlsym.map,
 117                                 &args->dlsym.ref,
 118                                 args->dlsym.map->l_local_scope,
 119                                 &args->version, 0, 0, NULL);
 120 }
 121
 122 static void
 123 do_dlclose (void *ptr)
 124 {
 125   GLRO(dl_close) ((struct link_map *) ptr);
 126 }
 127
 128 #ifndef SHARED
 129 static void
 130 do_dlsym_private (void *ptr)
 131 {
 132   lookup_t l;
 133   struct r_found_version vers;
 134   vers.name = "GLIBC_PRIVATE";
 135   vers.hidden = 1;
 136   /* vers.hash = _dl_elf_hash (vers.name);  */
 137   vers.hash = 0x0963cf85;
 138   vers.filename = NULL;
 139
 140   struct do_dlsym_args *args = (struct do_dlsym_args *) ptr;
 141   args->ref = NULL;
 142   l = GLRO(dl_lookup_symbol_x) (args->name, args->map, &args->ref,
 143                                 args->map->l_scope, &vers, 0, 0, NULL);
 144   args->loadbase = l;
 145 }
 146 #endif
 147
 148 /* ... and these functions call dlerror_run. */
 149
 150 void *
 151 __libc_dlopen_mode (const char *name, int mode)
 152 {
 153   struct do_dlopen_args args;
 154   args.name = name;
 155   args.mode = mode;
 156   args.caller_dlopen = RETURN_ADDRESS (0);
 157
 158 #ifdef SHARED
 159   if (GLRO (dl_dlfcn_hook) != NULL)
 160     return GLRO (dl_dlfcn_hook)->libc_dlopen_mode (name, mode);
 161 #endif
 162   return dlerror_run (do_dlopen, &args) ? NULL : (void *) args.map;
 163 }
 164
 165 #ifndef SHARED
 166 void *
 167 __libc_dlsym_private (struct link_map *map, const char *name)
 168 {
 169   struct do_dlsym_args sargs;
 170   sargs.map = map;
 171   sargs.name = name;
 172
 173   if (! dlerror_run (do_dlsym_private, &sargs))
 174     return DL_SYMBOL_ADDRESS (sargs.loadbase, sargs.ref);
 175   return NULL;
 176 }
 177 #endif
 178
 179 void *
 180 __libc_dlsym (void *map, const char *name)
 181 {
 182   struct do_dlsym_args args;
 183   args.map = map;
 184   args.name = name;
 185
 186 #ifdef SHARED
 187   if (GLRO (dl_dlfcn_hook) != NULL)
 188     return GLRO (dl_dlfcn_hook)->libc_dlsym (map, name);
 189 #endif
 190   return (dlerror_run (do_dlsym, &args) ? NULL
 191           : (void *) (DL_SYMBOL_ADDRESS (args.loadbase, args.ref)));
 192 }
 193
 194 /* Replacement for dlvsym.  MAP must be a real map.  This function
 195    returns NULL without setting the dlerror value in case of static
 196    dlopen from an old binary.  */
 197 void *
 198 __libc_dlvsym (void *map, const char *name, const char *version)
 199 {
 200 #ifdef SHARED
 201   if (GLRO (dl_dlfcn_hook) != NULL)
 202     return GLRO (dl_dlfcn_hook)->libc_dlvsym (map, name, version);
 203 #endif
 204
 205   struct do_dlvsym_args args;
 206   args.dlsym.map = map;
 207   args.dlsym.name = name;
 208
 209   /* See _dl_vsym in dl-sym.c.  */
 210   args.version.name = version;
 211   args.version.hidden = 1;
 212   args.version.hash = _dl_elf_hash (version);
 213   args.version.filename = NULL;
 214
 215   return (dlerror_run (do_dlvsym, &args) ? NULL
 216           : (void *) (DL_SYMBOL_ADDRESS (args.dlsym.loadbase,
 217                                          args.dlsym.ref)));
 218 }
 219
 220 int
 221 __libc_dlclose (void *map)
 222 {
 223 #ifdef SHARED
 224   if (GLRO (dl_dlfcn_hook) != NULL)
 225     return GLRO (dl_dlfcn_hook)->libc_dlclose (map);
 226 #endif
 227   return dlerror_run (do_dlclose, map);
 228 }
 229
 230
 231 static bool __libc_freeres_fn_section
 232 free_slotinfo (struct dtv_slotinfo_list **elemp)
 233 {
 234   size_t cnt;
 235
 236   if (*elemp == NULL)
 237     /* Nothing here, all is removed (or there never was anything).  */
 238     return true;
 239
 240   if (!free_slotinfo (&(*elemp)->next))
 241     /* We cannot free the entry.  */
 242     return false;
 243
 244   /* That cleared our next pointer for us.  */
 245
 246   for (cnt = 0; cnt < (*elemp)->len; ++cnt)
 247     if ((*elemp)->slotinfo[cnt].map != NULL)
 248       /* Still used.  */
 249       return false;
 250
 251   /* We can remove the list element.  */
 252   free (*elemp);
 253   *elemp = NULL;
 254
 255   return true;
 256 }
 257
 258
 259 libc_freeres_fn (free_mem)
 260 {
 261   struct link_map *l;
 262   struct r_search_path_elem *d;
 263
 264   /* Remove all search directories.  */
 265   d = GL(dl_all_dirs);
 266   while (d != GLRO(dl_init_all_dirs))
 267     {
 268       struct r_search_path_elem *old = d;
 269       d = d->next;
 270       free (old);
 271     }
 272
 273   for (Lmid_t ns = 0; ns < GL(dl_nns); ++ns)
 274     {
 275       for (l = GL(dl_ns)[ns]._ns_loaded; l != NULL; l = l->l_next)
 276         {
 277           struct libname_list *lnp = l->l_libname->next;
 278
 279           l->l_libname->next = NULL;
 280
 281           /* Remove all additional names added to the objects.  */
 282           while (lnp != NULL)
 283             {
 284               struct libname_list *old = lnp;
 285               lnp = lnp->next;
 286               if (! old->dont_free)
 287                 free (old);
 288             }
 289
 290           /* Free the initfini dependency list.  */
 291           if (l->l_free_initfini)
 292             free (l->l_initfini);
 293           l->l_initfini = NULL;
 294         }
 295
 296       if (__builtin_expect (GL(dl_ns)[ns]._ns_global_scope_alloc, 0) != 0
 297           && (GL(dl_ns)[ns]._ns_main_searchlist->r_nlist
 298               // XXX Check whether we need NS-specific initial_searchlist
 299               == GLRO(dl_initial_searchlist).r_nlist))
 300         {
 301           /* All object dynamically loaded by the program are unloaded.  Free
 302              the memory allocated for the global scope variable.  */
 303           struct link_map **old = GL(dl_ns)[ns]._ns_main_searchlist->r_list;
 304
 305           /* Put the old map in.  */
 306           GL(dl_ns)[ns]._ns_main_searchlist->r_list
 307             // XXX Check whether we need NS-specific initial_searchlist
 308             = GLRO(dl_initial_searchlist).r_list;
 309           /* Signal that the original map is used.  */
 310           GL(dl_ns)[ns]._ns_global_scope_alloc = 0;
 311
 312           /* Now free the old map.  */
 313           free (old);
 314         }
 315     }
 316
 317   /* Free the memory allocated for the dtv slotinfo array.  We can do
 318      this only if all modules which used this memory are unloaded.  */
 319 #ifdef SHARED
 320   if (GL(dl_initial_dtv) == NULL)
 321     /* There was no initial TLS setup, it was set up later when
 322        it used the normal malloc.  */
 323     free_slotinfo (&GL(dl_tls_dtv_slotinfo_list));
 324   else
 325 #endif
 326     /* The first element of the list does not have to be deallocated.
 327        It was allocated in the dynamic linker (i.e., with a different
 328        malloc), and in the static library it's in .bss space.  */
 329     free_slotinfo (&GL(dl_tls_dtv_slotinfo_list)->next);
 330
 331   void *scope_free_list = GL(dl_scope_free_list);
 332   GL(dl_scope_free_list) = NULL;
 333   free (scope_free_list);
 334 }