elf/dl-support.c

   1 /* Support for dynamic linking code in static libc.
   2    Copyright (C) 1996-2020 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 /* This file defines some things that for the dynamic linker are defined in
  20    rtld.c and dl-sysdep.c in ways appropriate to bootstrap dynamic linking.  */
  21
  22 #include <errno.h>
  23 #include <libintl.h>
  24 #include <stdlib.h>
  25 #include <unistd.h>
  26 #include <sys/param.h>
  27 #include <stdint.h>
  28 #include <ldsodefs.h>
  29 #include <dl-machine.h>
  30 #include <libc-lock.h>
  31 #include <dl-cache.h>
  32 #include <dl-librecon.h>
  33 #include <dl-procinfo.h>
  34 #include <unsecvars.h>
  35 #include <hp-timing.h>
  36 #include <stackinfo.h>
  37 #include <dl-vdso.h>
  38 #include <dl-vdso-setup.h>
  39
  40 extern char *__progname;
  41 char **_dl_argv = &__progname;  /* This is checked for some error messages.  */
  42
  43 /* Name of the architecture.  */
  44 const char *_dl_platform;
  45 size_t _dl_platformlen;
  46
  47 int _dl_debug_mask;
  48 int _dl_lazy;
  49 ElfW(Addr) _dl_use_load_bias = -2;
  50 int _dl_dynamic_weak;
  51
  52 /* If nonzero print warnings about problematic situations.  */
  53 int _dl_verbose;
  54
  55 /* We never do profiling.  */
  56 const char *_dl_profile;
  57 const char *_dl_profile_output;
  58
  59 /* Names of shared object for which the RUNPATHs and RPATHs should be
  60    ignored.  */
  61 const char *_dl_inhibit_rpath;
  62
  63 /* The map for the object we will profile.  */
  64 struct link_map *_dl_profile_map;
  65
  66 /* This is the address of the last stack address ever used.  */
  67 void *__libc_stack_end;
  68
  69 /* Path where the binary is found.  */
  70 const char *_dl_origin_path;
  71
  72 /* Nonzero if runtime lookup should not update the .got/.plt.  */
  73 int _dl_bind_not;
  74
  75 /* A dummy link map for the executable, used by dlopen to access the global
  76    scope.  We don't export any symbols ourselves, so this can be minimal.  */
  77 static struct link_map _dl_main_map =
  78   {
  79     .l_name = (char *) "",
  80     .l_real = &_dl_main_map,
  81     .l_ns = LM_ID_BASE,
  82     .l_libname = &(struct libname_list) { .name = "", .dont_free = 1 },
  83     .l_searchlist =
  84       {
  85         .r_list = &(struct link_map *) { &_dl_main_map },
  86         .r_nlist = 1,
  87       },
  88     .l_symbolic_searchlist = { .r_list = &(struct link_map *) { NULL } },
  89     .l_type = lt_executable,
  90     .l_scope_mem = { &_dl_main_map.l_searchlist },
  91     .l_scope_max = (sizeof (_dl_main_map.l_scope_mem)
  92                     / sizeof (_dl_main_map.l_scope_mem[0])),
  93     .l_scope = _dl_main_map.l_scope_mem,
  94     .l_local_scope = { &_dl_main_map.l_searchlist },
  95     .l_used = 1,
  96     .l_tls_offset = NO_TLS_OFFSET,
  97     .l_serial = 1,
  98   };
  99
 100 /* Namespace information.  */
 101 struct link_namespaces _dl_ns[DL_NNS] =
 102   {
 103     [LM_ID_BASE] =
 104       {
 105         ._ns_loaded = &_dl_main_map,
 106         ._ns_nloaded = 1,
 107         ._ns_main_searchlist = &_dl_main_map.l_searchlist,
 108       }
 109   };
 110 size_t _dl_nns = 1;
 111
 112 /* Incremented whenever something may have been added to dl_loaded. */
 113 unsigned long long _dl_load_adds = 1;
 114
 115 /* Fake scope of the main application.  */
 116 struct r_scope_elem _dl_initial_searchlist =
 117   {
 118     .r_list = &(struct link_map *) { &_dl_main_map },
 119     .r_nlist = 1,
 120   };
 121
 122 #ifndef HAVE_INLINED_SYSCALLS
 123 /* Nonzero during startup.  */
 124 int _dl_starting_up = 1;
 125 #endif
 126
 127 /* Random data provided by the kernel.  */
 128 void *_dl_random;
 129
 130 /* Get architecture specific initializer.  */
 131 #include <dl-procruntime.c>
 132 #include <dl-procinfo.c>
 133
 134 void (*_dl_init_static_tls) (struct link_map *) = &_dl_nothread_init_static_tls;
 135
 136 size_t _dl_pagesize = EXEC_PAGESIZE;
 137
 138 int _dl_inhibit_cache;
 139
 140 unsigned int _dl_osversion;
 141
 142 /* All known directories in sorted order.  */
 143 struct r_search_path_elem *_dl_all_dirs;
 144
 145 /* All directories after startup.  */
 146 struct r_search_path_elem *_dl_init_all_dirs;
 147
 148 /* The object to be initialized first.  */
 149 struct link_map *_dl_initfirst;
 150
 151 /* Descriptor to write debug messages to.  */
 152 int _dl_debug_fd = STDERR_FILENO;
 153
 154 int _dl_correct_cache_id = _DL_CACHE_DEFAULT_ID;
 155
 156 ElfW(auxv_t) *_dl_auxv;
 157 const ElfW(Phdr) *_dl_phdr;
 158 size_t _dl_phnum;
 159 uint64_t _dl_hwcap __attribute__ ((nocommon));
 160 uint64_t _dl_hwcap2 __attribute__ ((nocommon));
 161
 162 /* The value of the FPU control word the kernel will preset in hardware.  */
 163 fpu_control_t _dl_fpu_control = _FPU_DEFAULT;
 164
 165 #if !HAVE_TUNABLES
 166 /* This is not initialized to HWCAP_IMPORTANT, matching the definition
 167    of _dl_important_hwcaps, below, where no hwcap strings are ever
 168    used.  This mask is still used to mediate the lookups in the cache
 169    file.  Since there is no way to set this nonzero (we don't grok the
 170    LD_HWCAP_MASK environment variable here), there is no real point in
 171    setting _dl_hwcap nonzero below, but we do anyway.  */
 172 uint64_t _dl_hwcap_mask __attribute__ ((nocommon));
 173 #endif
 174
 175 /* Prevailing state of the stack.  Generally this includes PF_X, indicating it's
 176  * executable but this isn't true for all platforms.  */
 177 ElfW(Word) _dl_stack_flags = DEFAULT_STACK_PERMS;
 178
 179 /* If loading a shared object requires that we make the stack executable
 180    when it was not, we do it by calling this function.
 181    It returns an errno code or zero on success.  */
 182 int (*_dl_make_stack_executable_hook) (void **) = _dl_make_stack_executable;
 183
 184
 185 /* Function in libpthread to wait for termination of lookups.  */
 186 void (*_dl_wait_lookup_done) (void);
 187
 188 #if !THREAD_GSCOPE_IN_TCB
 189 int _dl_thread_gscope_count;
 190 #endif
 191 struct dl_scope_free_list *_dl_scope_free_list;
 192
 193 #ifdef NEED_DL_SYSINFO
 194 /* Needed for improved syscall handling on at least x86/Linux.  */
 195 uintptr_t _dl_sysinfo = DL_SYSINFO_DEFAULT;
 196 #endif
 197 #ifdef NEED_DL_SYSINFO_DSO
 198 /* Address of the ELF headers in the vsyscall page.  */
 199 const ElfW(Ehdr) *_dl_sysinfo_dso;
 200
 201 struct link_map *_dl_sysinfo_map;
 202
 203 # include "get-dynamic-info.h"
 204 #endif
 205 #include "setup-vdso.h"
 206 /* Define the vDSO function pointers.  */
 207 #include <dl-vdso-setup.c>
 208
 209 /* During the program run we must not modify the global data of
 210    loaded shared object simultanously in two threads.  Therefore we
 211    protect `_dl_open' and `_dl_close' in dl-close.c.
 212
 213    This must be a recursive lock since the initializer function of
 214    the loaded object might as well require a call to this function.
 215    At this time it is not anymore a problem to modify the tables.  */
 216 __rtld_lock_define_initialized_recursive (, _dl_load_lock)
 217 /* This lock is used to keep __dl_iterate_phdr from inspecting the
 218    list of loaded objects while an object is added to or removed from
 219    that list.  */
 220 __rtld_lock_define_initialized_recursive (, _dl_load_write_lock)
 221
 222
 223 #ifdef HAVE_AUX_VECTOR
 224 int _dl_clktck;
 225
 226 void
 227 _dl_aux_init (ElfW(auxv_t) *av)
 228 {
 229   int seen = 0;
 230   uid_t uid = 0;
 231   gid_t gid = 0;
 232
 233   _dl_auxv = av;
 234   for (; av->a_type != AT_NULL; ++av)
 235     switch (av->a_type)
 236       {
 237       case AT_PAGESZ:
 238         if (av->a_un.a_val != 0)
 239           GLRO(dl_pagesize) = av->a_un.a_val;
 240         break;
 241       case AT_CLKTCK:
 242         GLRO(dl_clktck) = av->a_un.a_val;
 243         break;
 244       case AT_PHDR:
 245         GL(dl_phdr) = (const void *) av->a_un.a_val;
 246         break;
 247       case AT_PHNUM:
 248         GL(dl_phnum) = av->a_un.a_val;
 249         break;
 250       case AT_PLATFORM:
 251         GLRO(dl_platform) = (void *) av->a_un.a_val;
 252         break;
 253       case AT_HWCAP:
 254         GLRO(dl_hwcap) = (unsigned long int) av->a_un.a_val;
 255         break;
 256       case AT_HWCAP2:
 257         GLRO(dl_hwcap2) = (unsigned long int) av->a_un.a_val;
 258         break;
 259       case AT_FPUCW:
 260         GLRO(dl_fpu_control) = av->a_un.a_val;
 261         break;
 262 #ifdef NEED_DL_SYSINFO
 263       case AT_SYSINFO:
 264         GL(dl_sysinfo) = av->a_un.a_val;
 265         break;
 266 #endif
 267 #ifdef NEED_DL_SYSINFO_DSO
 268       case AT_SYSINFO_EHDR:
 269         GL(dl_sysinfo_dso) = (void *) av->a_un.a_val;
 270         break;
 271 #endif
 272       case AT_UID:
 273         uid ^= av->a_un.a_val;
 274         seen |= 1;
 275         break;
 276       case AT_EUID:
 277         uid ^= av->a_un.a_val;
 278         seen |= 2;
 279         break;
 280       case AT_GID:
 281         gid ^= av->a_un.a_val;
 282         seen |= 4;
 283         break;
 284       case AT_EGID:
 285         gid ^= av->a_un.a_val;
 286         seen |= 8;
 287         break;
 288       case AT_SECURE:
 289         seen = -1;
 290         __libc_enable_secure = av->a_un.a_val;
 291         __libc_enable_secure_decided = 1;
 292         break;
 293       case AT_RANDOM:
 294         _dl_random = (void *) av->a_un.a_val;
 295         break;
 296 # ifdef DL_PLATFORM_AUXV
 297       DL_PLATFORM_AUXV
 298 # endif
 299       }
 300   if (seen == 0xf)
 301     {
 302       __libc_enable_secure = uid != 0 || gid != 0;
 303       __libc_enable_secure_decided = 1;
 304     }
 305 }
 306 #endif
 307
 308
 309 void
 310 _dl_non_dynamic_init (void)
 311 {
 312   _dl_main_map.l_origin = _dl_get_origin ();
 313   _dl_main_map.l_phdr = GL(dl_phdr);
 314   _dl_main_map.l_phnum = GL(dl_phnum);
 315
 316   _dl_verbose = *(getenv ("LD_WARN") ?: "") == '\0' ? 0 : 1;
 317
 318   /* Set up the data structures for the system-supplied DSO early,
 319      so they can influence _dl_init_paths.  */
 320   setup_vdso (NULL, NULL);
 321
 322   /* With vDSO setup we can initialize the function pointers.  */
 323   setup_vdso_pointers ();
 324
 325   /* Initialize the data structures for the search paths for shared
 326      objects.  */
 327   _dl_init_paths (getenv ("LD_LIBRARY_PATH"));
 328
 329   /* Remember the last search directory added at startup.  */
 330   _dl_init_all_dirs = GL(dl_all_dirs);
 331
 332   _dl_lazy = *(getenv ("LD_BIND_NOW") ?: "") == '\0';
 333
 334   _dl_bind_not = *(getenv ("LD_BIND_NOT") ?: "") != '\0';
 335
 336   _dl_dynamic_weak = *(getenv ("LD_DYNAMIC_WEAK") ?: "") == '\0';
 337
 338   _dl_profile_output = getenv ("LD_PROFILE_OUTPUT");
 339   if (_dl_profile_output == NULL || _dl_profile_output[0] == '\0')
 340     _dl_profile_output
 341       = &"/var/tmp\0/var/profile"[__libc_enable_secure ? 9 : 0];
 342
 343   if (__libc_enable_secure)
 344     {
 345       static const char unsecure_envvars[] =
 346         UNSECURE_ENVVARS
 347 #ifdef EXTRA_UNSECURE_ENVVARS
 348         EXTRA_UNSECURE_ENVVARS
 349 #endif
 350         ;
 351       const char *cp = unsecure_envvars;
 352
 353       while (cp < unsecure_envvars + sizeof (unsecure_envvars))
 354         {
 355           __unsetenv (cp);
 356           cp = (const char *) __rawmemchr (cp, '\0') + 1;
 357         }
 358
 359 #if !HAVE_TUNABLES
 360       if (__access ("/etc/suid-debug", F_OK) != 0)
 361         __unsetenv ("MALLOC_CHECK_");
 362 #endif
 363     }
 364
 365 #ifdef DL_PLATFORM_INIT
 366   DL_PLATFORM_INIT;
 367 #endif
 368
 369 #ifdef DL_OSVERSION_INIT
 370   DL_OSVERSION_INIT;
 371 #endif
 372
 373   /* Now determine the length of the platform string.  */
 374   if (_dl_platform != NULL)
 375     _dl_platformlen = strlen (_dl_platform);
 376
 377   if (_dl_phdr != NULL)
 378     for (const ElfW(Phdr) *ph = _dl_phdr; ph < &_dl_phdr[_dl_phnum]; ++ph)
 379       switch (ph->p_type)
 380         {
 381         /* Check if the stack is nonexecutable.  */
 382         case PT_GNU_STACK:
 383           _dl_stack_flags = ph->p_flags;
 384           break;
 385
 386         case PT_GNU_RELRO:
 387           _dl_main_map.l_relro_addr = ph->p_vaddr;
 388           _dl_main_map.l_relro_size = ph->p_memsz;
 389           break;
 390         }
 391
 392   /* Setup relro on the binary itself.  */
 393   if (_dl_main_map.l_relro_size != 0)
 394     _dl_protect_relro (&_dl_main_map);
 395 }
 396
 397 #ifdef DL_SYSINFO_IMPLEMENTATION
 398 DL_SYSINFO_IMPLEMENTATION
 399 #endif
 400
 401 #if ENABLE_STATIC_PIE
 402 /* Since relocation to hidden _dl_main_map causes relocation overflow on
 403    aarch64, a function is used to get the address of _dl_main_map.  */
 404
 405 struct link_map *
 406 _dl_get_dl_main_map (void)
 407 {
 408   return &_dl_main_map;
 409 }
 410 #endif