elf/dl-support.c

   1 /* Support for dynamic linking code in static libc.
   2    Copyright (C) 1996-2008,2009,2010 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, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 /* This file defines some things that for the dynamic linker are defined in
  21    rtld.c and dl-sysdep.c in ways appropriate to bootstrap dynamic linking.  */
  22
  23 #include <errno.h>
  24 #include <libintl.h>
  25 #include <stdlib.h>
  26 #include <unistd.h>
  27 #include <ldsodefs.h>
  28 #include <dl-machine.h>
  29 #include <bits/libc-lock.h>
  30 #include <dl-cache.h>
  31 #include <dl-librecon.h>
  32 #include <dl-procinfo.h>
  33 #include <unsecvars.h>
  34 #include <hp-timing.h>
  35
  36 extern char *__progname;
  37 char **_dl_argv = &__progname;  /* This is checked for some error messages.  */
  38
  39 /* Name of the architecture.  */
  40 const char *_dl_platform;
  41 size_t _dl_platformlen;
  42
  43 int _dl_debug_mask;
  44 int _dl_lazy;
  45 ElfW(Addr) _dl_use_load_bias = -2;
  46 int _dl_dynamic_weak;
  47
  48 /* If nonzero print warnings about problematic situations.  */
  49 int _dl_verbose;
  50
  51 /* We never do profiling.  */
  52 const char *_dl_profile;
  53 const char *_dl_profile_output;
  54
  55 /* Names of shared object for which the RUNPATHs and RPATHs should be
  56    ignored.  */
  57 const char *_dl_inhibit_rpath;
  58
  59 /* The map for the object we will profile.  */
  60 struct link_map *_dl_profile_map;
  61
  62 /* This is the address of the last stack address ever used.  */
  63 void *__libc_stack_end;
  64
  65 /* Path where the binary is found.  */
  66 const char *_dl_origin_path;
  67
  68 /* Nonzero if runtime lookup should not update the .got/.plt.  */
  69 int _dl_bind_not;
  70
  71 /* Namespace information.  */
  72 struct link_namespaces _dl_ns[DL_NNS];
  73 size_t _dl_nns;
  74
  75 /* Incremented whenever something may have been added to dl_loaded. */
  76 unsigned long long _dl_load_adds;
  77
  78 /* Fake scope.  In dynamically linked binaries this is the scope of the
  79    main application but here we don't have something like this.  So
  80    create a fake scope containing nothing.  */
  81 struct r_scope_elem _dl_initial_searchlist;
  82
  83 #ifndef HAVE_INLINED_SYSCALLS
  84 /* Nonzero during startup.  */
  85 int _dl_starting_up = 1;
  86 #endif
  87
  88 /* Random data provided by the kernel.  */
  89 void *_dl_random;
  90
  91 /* Get architecture specific initializer.  */
  92 #include <dl-procinfo.c>
  93
  94 /* We expect less than a second for relocation.  */
  95 #ifdef HP_SMALL_TIMING_AVAIL
  96 # undef HP_TIMING_AVAIL
  97 # define HP_TIMING_AVAIL HP_SMALL_TIMING_AVAIL
  98 #endif
  99
 100 /* Initial value of the CPU clock.  */
 101 #ifndef HP_TIMING_NONAVAIL
 102 hp_timing_t _dl_cpuclock_offset;
 103 #endif
 104
 105 void (*_dl_init_static_tls) (struct link_map *) = &_dl_nothread_init_static_tls;
 106
 107 size_t _dl_pagesize;
 108
 109 unsigned int _dl_osversion;
 110
 111 /* All known directories in sorted order.  */
 112 struct r_search_path_elem *_dl_all_dirs;
 113
 114 /* All directories after startup.  */
 115 struct r_search_path_elem *_dl_init_all_dirs;
 116
 117 /* The object to be initialized first.  */
 118 struct link_map *_dl_initfirst;
 119
 120 /* Descriptor to write debug messages to.  */
 121 int _dl_debug_fd = STDERR_FILENO;
 122
 123 int _dl_correct_cache_id = _DL_CACHE_DEFAULT_ID;
 124
 125 ElfW(Phdr) *_dl_phdr;
 126 size_t _dl_phnum;
 127 uint64_t _dl_hwcap __attribute__ ((nocommon));
 128
 129 /* This is not initialized to HWCAP_IMPORTANT, matching the definition
 130    of _dl_important_hwcaps, below, where no hwcap strings are ever
 131    used.  This mask is still used to mediate the lookups in the cache
 132    file.  Since there is no way to set this nonzero (we don't grok the
 133    LD_HWCAP_MASK environment variable here), there is no real point in
 134    setting _dl_hwcap nonzero below, but we do anyway.  */
 135 uint64_t _dl_hwcap_mask __attribute__ ((nocommon));
 136
 137 /* Prevailing state of the stack, PF_X indicating it's executable.  */
 138 ElfW(Word) _dl_stack_flags = PF_R|PF_W|PF_X;
 139
 140 /* If loading a shared object requires that we make the stack executable
 141    when it was not, we do it by calling this function.
 142    It returns an errno code or zero on success.  */
 143 int (*_dl_make_stack_executable_hook) (void **) internal_function
 144   = _dl_make_stack_executable;
 145
 146
 147 /* Function in libpthread to wait for termination of lookups.  */
 148 void (*_dl_wait_lookup_done) (void);
 149
 150 struct dl_scope_free_list *_dl_scope_free_list;
 151
 152 #ifdef NEED_DL_SYSINFO
 153 /* Needed for improved syscall handling on at least x86/Linux.  */
 154 uintptr_t _dl_sysinfo = DL_SYSINFO_DEFAULT;
 155 #endif
 156 #if defined NEED_DL_SYSINFO || defined NEED_DL_SYSINFO_DSO
 157 /* Address of the ELF headers in the vsyscall page.  */
 158 const ElfW(Ehdr) *_dl_sysinfo_dso;
 159 #endif
 160
 161 /* During the program run we must not modify the global data of
 162    loaded shared object simultanously in two threads.  Therefore we
 163    protect `_dl_open' and `_dl_close' in dl-close.c.
 164
 165    This must be a recursive lock since the initializer function of
 166    the loaded object might as well require a call to this function.
 167    At this time it is not anymore a problem to modify the tables.  */
 168 __rtld_lock_define_initialized_recursive (, _dl_load_lock)
 169 /* This lock is used to keep __dl_iterate_phdr from inspecting the
 170    list of loaded objects while an object is added to or removed from
 171    that list.  */
 172 __rtld_lock_define_initialized_recursive (, _dl_load_write_lock)
 173
 174
 175 #ifdef HAVE_AUX_VECTOR
 176 int _dl_clktck;
 177
 178 void
 179 internal_function
 180 _dl_aux_init (ElfW(auxv_t) *av)
 181 {
 182   int seen = 0;
 183   uid_t uid = 0;
 184   gid_t gid = 0;
 185
 186   for (; av->a_type != AT_NULL; ++av)
 187     switch (av->a_type)
 188       {
 189       case AT_PAGESZ:
 190         GLRO(dl_pagesize) = av->a_un.a_val;
 191         break;
 192       case AT_CLKTCK:
 193         GLRO(dl_clktck) = av->a_un.a_val;
 194         break;
 195       case AT_PHDR:
 196         GL(dl_phdr) = (void *) av->a_un.a_val;
 197         break;
 198       case AT_PHNUM:
 199         GL(dl_phnum) = av->a_un.a_val;
 200         break;
 201       case AT_HWCAP:
 202         GLRO(dl_hwcap) = (unsigned long int) av->a_un.a_val;
 203         break;
 204 #ifdef NEED_DL_SYSINFO
 205       case AT_SYSINFO:
 206         GL(dl_sysinfo) = av->a_un.a_val;
 207         break;
 208 #endif
 209 #if defined NEED_DL_SYSINFO || defined NEED_DL_SYSINFO_DSO
 210       case AT_SYSINFO_EHDR:
 211         GL(dl_sysinfo_dso) = (void *) av->a_un.a_val;
 212         break;
 213 #endif
 214       case AT_UID:
 215         uid ^= av->a_un.a_val;
 216         seen |= 1;
 217         break;
 218       case AT_EUID:
 219         uid ^= av->a_un.a_val;
 220         seen |= 2;
 221         break;
 222       case AT_GID:
 223         gid ^= av->a_un.a_val;
 224         seen |= 4;
 225         break;
 226       case AT_EGID:
 227         gid ^= av->a_un.a_val;
 228         seen |= 8;
 229         break;
 230       case AT_SECURE:
 231         seen = -1;
 232         __libc_enable_secure = av->a_un.a_val;
 233         __libc_enable_secure_decided = 1;
 234         break;
 235       case AT_RANDOM:
 236         _dl_random = (void *) av->a_un.a_val;
 237         break;
 238 # ifdef DL_PLATFORM_AUXV
 239       DL_PLATFORM_AUXV
 240 # endif
 241       }
 242   if (seen == 0xf)
 243     {
 244       __libc_enable_secure = uid != 0 || gid != 0;
 245       __libc_enable_secure_decided = 1;
 246     }
 247 }
 248 #endif
 249
 250
 251 void
 252 internal_function
 253 _dl_non_dynamic_init (void)
 254 {
 255   if (HP_TIMING_AVAIL)
 256     HP_TIMING_NOW (_dl_cpuclock_offset);
 257
 258   if (!_dl_pagesize)
 259     _dl_pagesize = __getpagesize ();
 260
 261   _dl_verbose = *(getenv ("LD_WARN") ?: "") == '\0' ? 0 : 1;
 262
 263   /* Initialize the data structures for the search paths for shared
 264      objects.  */
 265   _dl_init_paths (getenv ("LD_LIBRARY_PATH"));
 266
 267   _dl_lazy = *(getenv ("LD_BIND_NOW") ?: "") == '\0';
 268
 269   _dl_bind_not = *(getenv ("LD_BIND_NOT") ?: "") != '\0';
 270
 271   _dl_dynamic_weak = *(getenv ("LD_DYNAMIC_WEAK") ?: "") == '\0';
 272
 273   _dl_profile_output = getenv ("LD_PROFILE_OUTPUT");
 274   if (_dl_profile_output == NULL || _dl_profile_output[0] == '\0')
 275     _dl_profile_output
 276       = &"/var/tmp\0/var/profile"[__libc_enable_secure ? 9 : 0];
 277
 278   if (__libc_enable_secure)
 279     {
 280       static const char unsecure_envvars[] =
 281         UNSECURE_ENVVARS
 282 #ifdef EXTRA_UNSECURE_ENVVARS
 283         EXTRA_UNSECURE_ENVVARS
 284 #endif
 285         ;
 286       const char *cp = unsecure_envvars;
 287
 288       while (cp < unsecure_envvars + sizeof (unsecure_envvars))
 289         {
 290           __unsetenv (cp);
 291           cp = (const char *) __rawmemchr (cp, '\0') + 1;
 292         }
 293
 294       if (__access ("/etc/suid-debug", F_OK) != 0)
 295         __unsetenv ("MALLOC_CHECK_");
 296     }
 297
 298 #ifdef DL_PLATFORM_INIT
 299   DL_PLATFORM_INIT;
 300 #endif
 301
 302 #ifdef DL_OSVERSION_INIT
 303   DL_OSVERSION_INIT;
 304 #endif
 305
 306   /* Now determine the length of the platform string.  */
 307   if (_dl_platform != NULL)
 308     _dl_platformlen = strlen (_dl_platform);
 309
 310   /* Scan for a program header telling us the stack is nonexecutable.  */
 311   if (_dl_phdr != NULL)
 312     for (uint_fast16_t i = 0; i < _dl_phnum; ++i)
 313       if (_dl_phdr[i].p_type == PT_GNU_STACK)
 314         {
 315           _dl_stack_flags = _dl_phdr[i].p_flags;
 316           break;
 317         }
 318 }
 319
 320
 321 const struct r_strlenpair *
 322 internal_function
 323 _dl_important_hwcaps (const char *platform, size_t platform_len, size_t *sz,
 324                       size_t *max_capstrlen)
 325 {
 326   static struct r_strlenpair result;
 327   static char buf[1];
 328
 329   result.str = buf;     /* Does not really matter.  */
 330   result.len = 0;
 331
 332   *sz = 1;
 333   return &result;
 334 }
 335
 336
 337 #ifdef DL_SYSINFO_IMPLEMENTATION
 338 DL_SYSINFO_IMPLEMENTATION
 339 #endif