1 /* Run time dynamic linker.
2 Copyright (C) 1995-2014 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
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.
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.
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 <http://www.gnu.org/licenses/>. */
27 #include <sys/param.h>
32 #include <fpu_control.h>
33 #include <hp-timing.h>
34 #include <bits/libc-lock.h>
35 #include "dynamic-link.h"
36 #include <dl-librecon.h>
37 #include <unsecvars.h>
39 #include <dl-osinfo.h>
40 #include <dl-procinfo.h>
42 #include <stap-probe.h>
43 #include <stackinfo.h>
47 /* Avoid PLT use for our local calls at startup. */
48 extern __typeof (__mempcpy) __mempcpy attribute_hidden;
50 /* GCC has mental blocks about _exit. */
51 extern __typeof (_exit) exit_internal asm ("_exit") attribute_hidden;
52 #define _exit exit_internal
54 /* Helper function to handle errors while resolving symbols. */
55 static void print_unresolved (int errcode, const char *objname,
56 const char *errsting);
58 /* Helper function to handle errors when a version is missing. */
59 static void print_missing_version (int errcode, const char *objname,
60 const char *errsting);
62 /* Print the various times we collected. */
63 static void print_statistics (hp_timing_t *total_timep);
65 /* Add audit objects. */
66 static void process_dl_audit (char *str);
68 /* This is a list of all the modes the dynamic loader can be in. */
69 enum mode { normal, list, verify, trace };
71 /* Process all environments variables the dynamic linker must recognize.
72 Since all of them start with `LD_' we are a bit smarter while finding
74 static void process_envvars (enum mode *modep);
76 #ifdef DL_ARGV_NOT_RELRO
77 int _dl_argc attribute_hidden;
78 char **_dl_argv = NULL;
79 /* Nonzero if we were run directly. */
80 unsigned int _dl_skip_args attribute_hidden;
82 int _dl_argc attribute_relro attribute_hidden;
83 char **_dl_argv attribute_relro = NULL;
84 unsigned int _dl_skip_args attribute_relro attribute_hidden;
88 #ifndef THREAD_SET_STACK_GUARD
89 /* Only exported for architectures that don't store the stack guard canary
90 in thread local area. */
91 uintptr_t __stack_chk_guard attribute_relro;
94 /* Only exported for architectures that don't store the pointer guard
95 value in thread local area. */
96 uintptr_t __pointer_chk_guard_local
97 attribute_relro attribute_hidden __attribute__ ((nocommon));
98 #ifndef THREAD_SET_POINTER_GUARD
99 strong_alias (__pointer_chk_guard_local, __pointer_chk_guard)
103 /* List of auditing DSOs. */
104 static struct audit_list
107 struct audit_list *next;
110 #ifndef HAVE_INLINED_SYSCALLS
111 /* Set nonzero during loading and initialization of executable and
112 libraries, cleared before the executable's entry point runs. This
113 must not be initialized to nonzero, because the unused dynamic
114 linker loaded in for libc.so's "ld.so.1" dep will provide the
115 definition seen by libc.so's initializer; that value must be zero,
116 and will be since that dynamic linker's _dl_start and dl_main will
118 int _dl_starting_up = 0;
119 INTVARDEF(_dl_starting_up)
122 /* This is the structure which defines all variables global to ld.so
123 (except those which cannot be added for some reason). */
124 struct rtld_global _rtld_global =
126 /* Generally the default presumption without further information is an
127 * executable stack but this is not true for all platforms. */
128 ._dl_stack_flags = DEFAULT_STACK_PERMS,
129 #ifdef _LIBC_REENTRANT
130 ._dl_load_lock = _RTLD_LOCK_RECURSIVE_INITIALIZER,
131 ._dl_load_write_lock = _RTLD_LOCK_RECURSIVE_INITIALIZER,
136 #ifdef _LIBC_REENTRANT
137 [LM_ID_BASE] = { ._ns_unique_sym_table
138 = { .lock = _RTLD_LOCK_RECURSIVE_INITIALIZER } }
142 /* If we would use strong_alias here the compiler would see a
143 non-hidden definition. This would undo the effect of the previous
144 declaration. So spell out was strong_alias does plus add the
145 visibility attribute. */
146 extern struct rtld_global _rtld_local
147 __attribute__ ((alias ("_rtld_global"), visibility ("hidden")));
150 /* This variable is similar to _rtld_local, but all values are
151 read-only after relocation. */
152 struct rtld_global_ro _rtld_global_ro attribute_relro =
154 /* Get architecture specific initializer. */
155 #include <dl-procinfo.c>
156 #ifdef NEED_DL_SYSINFO
157 ._dl_sysinfo = DL_SYSINFO_DEFAULT,
159 ._dl_debug_fd = STDERR_FILENO,
160 ._dl_use_load_bias = -2,
161 ._dl_correct_cache_id = _DL_CACHE_DEFAULT_ID,
162 ._dl_hwcap_mask = HWCAP_IMPORTANT,
164 ._dl_fpu_control = _FPU_DEFAULT,
165 ._dl_pointer_guard = 1,
166 ._dl_pagesize = EXEC_PAGESIZE,
167 ._dl_inhibit_cache = 0,
169 /* Function pointers. */
170 ._dl_debug_printf = _dl_debug_printf,
171 ._dl_catch_error = _dl_catch_error,
172 ._dl_signal_error = _dl_signal_error,
173 ._dl_mcount = _dl_mcount_internal,
174 ._dl_lookup_symbol_x = _dl_lookup_symbol_x,
175 ._dl_check_caller = _dl_check_caller,
176 ._dl_open = _dl_open,
177 ._dl_close = _dl_close,
178 ._dl_tls_get_addr_soft = _dl_tls_get_addr_soft,
179 #ifdef HAVE_DL_DISCOVER_OSVERSION
180 ._dl_discover_osversion = _dl_discover_osversion
183 /* If we would use strong_alias here the compiler would see a
184 non-hidden definition. This would undo the effect of the previous
185 declaration. So spell out was strong_alias does plus add the
186 visibility attribute. */
187 extern struct rtld_global_ro _rtld_local_ro
188 __attribute__ ((alias ("_rtld_global_ro"), visibility ("hidden")));
191 static void dl_main (const ElfW(Phdr) *phdr, ElfW(Word) phnum,
192 ElfW(Addr) *user_entry, ElfW(auxv_t) *auxv);
194 /* These two variables cannot be moved into .data.rel.ro. */
195 static struct libname_list _dl_rtld_libname;
196 static struct libname_list _dl_rtld_libname2;
198 /* We expect less than a second for relocation. */
199 #ifdef HP_SMALL_TIMING_AVAIL
200 # undef HP_TIMING_AVAIL
201 # define HP_TIMING_AVAIL HP_SMALL_TIMING_AVAIL
204 /* Variable for statistics. */
205 #ifndef HP_TIMING_NONAVAIL
206 static hp_timing_t relocate_time;
207 static hp_timing_t load_time attribute_relro;
208 static hp_timing_t start_time attribute_relro;
211 /* Additional definitions needed by TLS initialization. */
212 #ifdef TLS_INIT_HELPER
216 /* Helper function for syscall implementation. */
217 #ifdef DL_SYSINFO_IMPLEMENTATION
218 DL_SYSINFO_IMPLEMENTATION
221 /* Before ld.so is relocated we must not access variables which need
222 relocations. This means variables which are exported. Variables
223 declared as static are fine. If we can mark a variable hidden this
224 is fine, too. The latter is important here. We can avoid setting
225 up a temporary link map for ld.so if we can mark _rtld_global as
227 #ifdef PI_STATIC_AND_HIDDEN
228 # define DONT_USE_BOOTSTRAP_MAP 1
231 #ifdef DONT_USE_BOOTSTRAP_MAP
232 static ElfW(Addr) _dl_start_final (void *arg);
234 struct dl_start_final_info
237 #if !defined HP_TIMING_NONAVAIL && HP_TIMING_INLINE
238 hp_timing_t start_time;
241 static ElfW(Addr) _dl_start_final (void *arg,
242 struct dl_start_final_info *info);
245 /* These defined magically in the linker script. */
246 extern char _begin[] attribute_hidden;
247 extern char _etext[] attribute_hidden;
248 extern char _end[] attribute_hidden;
254 # error "sysdeps/MACHINE/dl-machine.h fails to define RTLD_START"
257 /* This is the second half of _dl_start (below). It can be inlined safely
258 under DONT_USE_BOOTSTRAP_MAP, where it is careful not to make any GOT
259 references. When the tools don't permit us to avoid using a GOT entry
260 for _dl_rtld_global (no attribute_hidden support), we must make sure
261 this function is not inlined (see below). */
263 #ifdef DONT_USE_BOOTSTRAP_MAP
264 static inline ElfW(Addr) __attribute__ ((always_inline))
265 _dl_start_final (void *arg)
267 static ElfW(Addr) __attribute__ ((noinline))
268 _dl_start_final (void *arg, struct dl_start_final_info *info)
271 ElfW(Addr) start_addr;
275 /* If it hasn't happen yet record the startup time. */
276 if (! HP_TIMING_INLINE)
277 HP_TIMING_NOW (start_time);
278 #if !defined DONT_USE_BOOTSTRAP_MAP && !defined HP_TIMING_NONAVAIL
280 start_time = info->start_time;
283 /* Initialize the timing functions. */
284 HP_TIMING_DIFF_INIT ();
287 /* Transfer data about ourselves to the permanent link_map structure. */
288 #ifndef DONT_USE_BOOTSTRAP_MAP
289 GL(dl_rtld_map).l_addr = info->l.l_addr;
290 GL(dl_rtld_map).l_ld = info->l.l_ld;
291 memcpy (GL(dl_rtld_map).l_info, info->l.l_info,
292 sizeof GL(dl_rtld_map).l_info);
293 GL(dl_rtld_map).l_mach = info->l.l_mach;
294 GL(dl_rtld_map).l_relocated = 1;
296 _dl_setup_hash (&GL(dl_rtld_map));
297 GL(dl_rtld_map).l_real = &GL(dl_rtld_map);
298 GL(dl_rtld_map).l_map_start = (ElfW(Addr)) _begin;
299 GL(dl_rtld_map).l_map_end = (ElfW(Addr)) _end;
300 GL(dl_rtld_map).l_text_end = (ElfW(Addr)) _etext;
301 /* Copy the TLS related data if necessary. */
302 #ifndef DONT_USE_BOOTSTRAP_MAP
304 assert (info->l.l_tls_modid != 0);
305 GL(dl_rtld_map).l_tls_blocksize = info->l.l_tls_blocksize;
306 GL(dl_rtld_map).l_tls_align = info->l.l_tls_align;
307 GL(dl_rtld_map).l_tls_firstbyte_offset = info->l.l_tls_firstbyte_offset;
308 GL(dl_rtld_map).l_tls_initimage_size = info->l.l_tls_initimage_size;
309 GL(dl_rtld_map).l_tls_initimage = info->l.l_tls_initimage;
310 GL(dl_rtld_map).l_tls_offset = info->l.l_tls_offset;
311 GL(dl_rtld_map).l_tls_modid = 1;
313 # if NO_TLS_OFFSET != 0
314 GL(dl_rtld_map).l_tls_offset = NO_TLS_OFFSET;
321 HP_TIMING_NOW (GL(dl_cpuclock_offset));
324 /* Initialize the stack end variable. */
325 __libc_stack_end = __builtin_frame_address (0);
327 /* Call the OS-dependent function to set up life so we can do things like
328 file access. It will call `dl_main' (below) to do all the real work
329 of the dynamic linker, and then unwind our frame and run the user
330 entry point on the same stack we entered on. */
331 start_addr = _dl_sysdep_start (arg, &dl_main);
333 #ifndef HP_TIMING_NONAVAIL
334 hp_timing_t rtld_total_time;
337 hp_timing_t end_time;
339 /* Get the current time. */
340 HP_TIMING_NOW (end_time);
342 /* Compute the difference. */
343 HP_TIMING_DIFF (rtld_total_time, start_time, end_time);
347 if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_STATISTICS))
349 #ifndef HP_TIMING_NONAVAIL
350 print_statistics (&rtld_total_time);
352 print_statistics (NULL);
359 static ElfW(Addr) __attribute_used__ internal_function
360 _dl_start (void *arg)
362 #ifdef DONT_USE_BOOTSTRAP_MAP
363 # define bootstrap_map GL(dl_rtld_map)
365 struct dl_start_final_info info;
366 # define bootstrap_map info.l
369 /* This #define produces dynamic linking inline functions for
370 bootstrap relocation instead of general-purpose relocation.
371 Since ld.so must not have any undefined symbols the result
372 is trivial: always the map of ld.so itself. */
373 #define RTLD_BOOTSTRAP
374 #define RESOLVE_MAP(sym, version, flags) (&bootstrap_map)
375 #include "dynamic-link.h"
377 if (HP_TIMING_INLINE && HP_TIMING_AVAIL)
378 #ifdef DONT_USE_BOOTSTRAP_MAP
379 HP_TIMING_NOW (start_time);
381 HP_TIMING_NOW (info.start_time);
384 /* Partly clean the `bootstrap_map' structure up. Don't use
385 `memset' since it might not be built in or inlined and we cannot
386 make function calls at this point. Use '__builtin_memset' if we
387 know it is available. We do not have to clear the memory if we
388 do not have to use the temporary bootstrap_map. Global variables
389 are initialized to zero by default. */
390 #ifndef DONT_USE_BOOTSTRAP_MAP
391 # ifdef HAVE_BUILTIN_MEMSET
392 __builtin_memset (bootstrap_map.l_info, '\0', sizeof (bootstrap_map.l_info));
395 cnt < sizeof (bootstrap_map.l_info) / sizeof (bootstrap_map.l_info[0]);
397 bootstrap_map.l_info[cnt] = 0;
400 bootstrap_map.l_tls_modid = 0;
404 /* Figure out the run-time load address of the dynamic linker itself. */
405 bootstrap_map.l_addr = elf_machine_load_address ();
407 /* Read our own dynamic section and fill in the info array. */
408 bootstrap_map.l_ld = (void *) bootstrap_map.l_addr + elf_machine_dynamic ();
409 elf_get_dynamic_info (&bootstrap_map, NULL);
411 #if NO_TLS_OFFSET != 0
412 bootstrap_map.l_tls_offset = NO_TLS_OFFSET;
415 /* Get the dynamic linker's own program header. First we need the ELF
416 file header. The `_begin' symbol created by the linker script points
417 to it. When we have something like GOTOFF relocs, we can use a plain
418 reference to find the runtime address. Without that, we have to rely
419 on the `l_addr' value, which is not the value we want when prelinked. */
423 # ifdef DONT_USE_BOOTSTRAP_MAP
424 = (ElfW(Ehdr) *) &_begin;
426 # error This will not work with prelink.
427 = (ElfW(Ehdr) *) bootstrap_map.l_addr;
429 ElfW(Phdr) *phdr = (ElfW(Phdr) *) ((void *) ehdr + ehdr->e_phoff);
430 size_t cnt = ehdr->e_phnum; /* PT_TLS is usually the last phdr. */
432 if (phdr[cnt].p_type == PT_TLS)
435 size_t max_align = MAX (TLS_INIT_TCB_ALIGN, phdr[cnt].p_align);
438 bootstrap_map.l_tls_blocksize = phdr[cnt].p_memsz;
439 bootstrap_map.l_tls_align = phdr[cnt].p_align;
440 if (phdr[cnt].p_align == 0)
441 bootstrap_map.l_tls_firstbyte_offset = 0;
443 bootstrap_map.l_tls_firstbyte_offset = (phdr[cnt].p_vaddr
444 & (phdr[cnt].p_align - 1));
445 assert (bootstrap_map.l_tls_blocksize != 0);
446 bootstrap_map.l_tls_initimage_size = phdr[cnt].p_filesz;
447 bootstrap_map.l_tls_initimage = (void *) (bootstrap_map.l_addr
448 + phdr[cnt].p_vaddr);
450 /* We can now allocate the initial TLS block. This can happen
451 on the stack. We'll get the final memory later when we
452 know all about the various objects loaded at startup
455 tlsblock = alloca (roundup (bootstrap_map.l_tls_blocksize,
460 tlsblock = alloca (roundup (TLS_INIT_TCB_SIZE,
461 bootstrap_map.l_tls_align)
462 + bootstrap_map.l_tls_blocksize
465 /* In case a model with a different layout for the TCB and DTV
466 is defined add another #elif here and in the following #ifs. */
467 # error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
469 /* Align the TLS block. */
470 tlsblock = (void *) (((uintptr_t) tlsblock + max_align - 1)
473 /* Initialize the dtv. [0] is the length, [1] the generation
475 initdtv[0].counter = 1;
476 initdtv[1].counter = 0;
478 /* Initialize the TLS block. */
480 initdtv[2].pointer = tlsblock;
482 bootstrap_map.l_tls_offset = roundup (TLS_INIT_TCB_SIZE,
483 bootstrap_map.l_tls_align);
484 initdtv[2].pointer = (char *) tlsblock + bootstrap_map.l_tls_offset;
486 # error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
488 p = __mempcpy (initdtv[2].pointer, bootstrap_map.l_tls_initimage,
489 bootstrap_map.l_tls_initimage_size);
490 # ifdef HAVE_BUILTIN_MEMSET
491 __builtin_memset (p, '\0', (bootstrap_map.l_tls_blocksize
492 - bootstrap_map.l_tls_initimage_size));
495 size_t remaining = (bootstrap_map.l_tls_blocksize
496 - bootstrap_map.l_tls_initimage_size);
497 while (remaining-- > 0)
502 /* Install the pointer to the dtv. */
504 /* Initialize the thread pointer. */
506 bootstrap_map.l_tls_offset
507 = roundup (bootstrap_map.l_tls_blocksize, TLS_INIT_TCB_ALIGN);
509 INSTALL_DTV ((char *) tlsblock + bootstrap_map.l_tls_offset,
512 const char *lossage = TLS_INIT_TP ((char *) tlsblock
513 + bootstrap_map.l_tls_offset, 0);
515 INSTALL_DTV (tlsblock, initdtv);
516 const char *lossage = TLS_INIT_TP (tlsblock, 0);
518 # error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
520 if (__glibc_unlikely (lossage != NULL))
521 _dl_fatal_printf ("cannot set up thread-local storage: %s\n",
524 /* So far this is module number one. */
525 bootstrap_map.l_tls_modid = 1;
527 /* There can only be one PT_TLS entry. */
530 #endif /* USE___THREAD */
532 #ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
533 ELF_MACHINE_BEFORE_RTLD_RELOC (bootstrap_map.l_info);
536 if (bootstrap_map.l_addr || ! bootstrap_map.l_info[VALIDX(DT_GNU_PRELINKED)])
538 /* Relocate ourselves so we can do normal function calls and
539 data access using the global offset table. */
541 ELF_DYNAMIC_RELOCATE (&bootstrap_map, 0, 0, 0);
543 bootstrap_map.l_relocated = 1;
545 /* Please note that we don't allow profiling of this object and
546 therefore need not test whether we have to allocate the array
547 for the relocation results (as done in dl-reloc.c). */
549 /* Now life is sane; we can call functions and access global data.
550 Set up to use the operating system facilities, and find out from
551 the operating system's program loader where to find the program
552 header table in core. Put the rest of _dl_start into a separate
553 function, that way the compiler cannot put accesses to the GOT
554 before ELF_DYNAMIC_RELOCATE. */
556 #ifdef DONT_USE_BOOTSTRAP_MAP
557 ElfW(Addr) entry = _dl_start_final (arg);
559 ElfW(Addr) entry = _dl_start_final (arg, &info);
562 #ifndef ELF_MACHINE_START_ADDRESS
563 # define ELF_MACHINE_START_ADDRESS(map, start) (start)
566 return ELF_MACHINE_START_ADDRESS (GL(dl_ns)[LM_ID_BASE]._ns_loaded, entry);
572 /* Now life is peachy; we can do all normal operations.
573 On to the real work. */
575 /* Some helper functions. */
577 /* Arguments to relocate_doit. */
586 /* Argument to map_doit. */
588 struct link_map *loader;
590 /* Return value of map_doit. */
591 struct link_map *map;
597 struct link_map *map;
603 struct link_map *map;
607 /* Arguments to version_check_doit. */
608 struct version_check_args
615 relocate_doit (void *a)
617 struct relocate_args *args = (struct relocate_args *) a;
619 _dl_relocate_object (args->l, args->l->l_scope, args->reloc_mode, 0);
625 struct map_args *args = (struct map_args *) a;
626 int type = (args->mode == __RTLD_OPENEXEC) ? lt_executable : lt_library;
627 args->map = _dl_map_object (args->loader, args->str, type, 0,
628 args->mode, LM_ID_BASE);
632 dlmopen_doit (void *a)
634 struct dlmopen_args *args = (struct dlmopen_args *) a;
635 args->map = _dl_open (args->fname,
636 (RTLD_LAZY | __RTLD_DLOPEN | __RTLD_AUDIT
638 dl_main, LM_ID_NEWLM, _dl_argc, INTUSE(_dl_argv),
643 lookup_doit (void *a)
645 struct lookup_args *args = (struct lookup_args *) a;
646 const ElfW(Sym) *ref = NULL;
648 lookup_t l = _dl_lookup_symbol_x (args->name, args->map, &ref,
649 args->map->l_local_scope, NULL, 0,
650 DL_LOOKUP_RETURN_NEWEST, NULL);
652 args->result = DL_SYMBOL_ADDRESS (l, ref);
656 version_check_doit (void *a)
658 struct version_check_args *args = (struct version_check_args *) a;
659 if (_dl_check_all_versions (GL(dl_ns)[LM_ID_BASE]._ns_loaded, 1,
660 args->dotrace) && args->doexit)
661 /* We cannot start the application. Abort now. */
666 static inline struct link_map *
667 find_needed (const char *name)
669 struct r_scope_elem *scope = &GL(dl_ns)[LM_ID_BASE]._ns_loaded->l_searchlist;
670 unsigned int n = scope->r_nlist;
673 if (_dl_name_match_p (name, scope->r_list[n]))
674 return scope->r_list[n];
676 /* Should never happen. */
681 match_version (const char *string, struct link_map *map)
683 const char *strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
686 #define VERDEFTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERDEF))
687 if (map->l_info[VERDEFTAG] == NULL)
688 /* The file has no symbol versioning. */
691 def = (ElfW(Verdef) *) ((char *) map->l_addr
692 + map->l_info[VERDEFTAG]->d_un.d_ptr);
695 ElfW(Verdaux) *aux = (ElfW(Verdaux) *) ((char *) def + def->vd_aux);
697 /* Compare the version strings. */
698 if (strcmp (string, strtab + aux->vda_name) == 0)
702 /* If no more definitions we failed to find what we want. */
703 if (def->vd_next == 0)
706 /* Next definition. */
707 def = (ElfW(Verdef) *) ((char *) def + def->vd_next);
713 static bool tls_init_tp_called;
718 /* Number of elements in the static TLS block. */
719 GL(dl_tls_static_nelem) = GL(dl_tls_max_dtv_idx);
721 /* Do not do this twice. The audit interface might have required
722 the DTV interfaces to be set up early. */
723 if (GL(dl_initial_dtv) != NULL)
726 /* Allocate the array which contains the information about the
727 dtv slots. We allocate a few entries more than needed to
728 avoid the need for reallocation. */
729 size_t nelem = GL(dl_tls_max_dtv_idx) + 1 + TLS_SLOTINFO_SURPLUS;
732 GL(dl_tls_dtv_slotinfo_list) = (struct dtv_slotinfo_list *)
733 calloc (sizeof (struct dtv_slotinfo_list)
734 + nelem * sizeof (struct dtv_slotinfo), 1);
735 /* No need to check the return value. If memory allocation failed
736 the program would have been terminated. */
738 struct dtv_slotinfo *slotinfo = GL(dl_tls_dtv_slotinfo_list)->slotinfo;
739 GL(dl_tls_dtv_slotinfo_list)->len = nelem;
740 GL(dl_tls_dtv_slotinfo_list)->next = NULL;
742 /* Fill in the information from the loaded modules. No namespace
743 but the base one can be filled at this time. */
744 assert (GL(dl_ns)[LM_ID_BASE + 1]._ns_loaded == NULL);
746 for (struct link_map *l = GL(dl_ns)[LM_ID_BASE]._ns_loaded; l != NULL;
748 if (l->l_tls_blocksize != 0)
750 /* This is a module with TLS data. Store the map reference.
751 The generation counter is zero. */
753 /* slotinfo[i].gen = 0; */
756 assert (i == GL(dl_tls_max_dtv_idx));
758 /* Compute the TLS offsets for the various blocks. */
759 _dl_determine_tlsoffset ();
761 /* Construct the static TLS block and the dtv for the initial
762 thread. For some platforms this will include allocating memory
763 for the thread descriptor. The memory for the TLS block will
764 never be freed. It should be allocated accordingly. The dtv
765 array can be changed if dynamic loading requires it. */
766 void *tcbp = _dl_allocate_tls_storage ();
769 cannot allocate TLS data structures for initial thread");
771 /* Store for detection of the special case by __tls_get_addr
772 so it knows not to pass this dtv to the normal realloc. */
773 GL(dl_initial_dtv) = GET_DTV (tcbp);
775 /* And finally install it for the main thread. If ld.so itself uses
776 TLS we know the thread pointer was initialized earlier. */
779 = TLS_INIT_TP (tcbp, USE___THREAD);
781 = TLS_INIT_TP (tcbp, 0);
783 if (__glibc_unlikely (lossage != NULL))
784 _dl_fatal_printf ("cannot set up thread-local storage: %s\n", lossage);
785 tls_init_tp_called = true;
790 #ifdef _LIBC_REENTRANT
791 /* _dl_error_catch_tsd points to this for the single-threaded case.
792 It's reset by the thread library for multithreaded programs. */
793 void ** __attribute__ ((const))
794 _dl_initial_error_catch_tsd (void)
803 do_preload (char *fname, struct link_map *main_map, const char *where)
806 const char *err_str = NULL;
807 struct map_args args;
811 args.loader = main_map;
812 args.mode = __RTLD_SECURE;
814 unsigned int old_nloaded = GL(dl_ns)[LM_ID_BASE]._ns_nloaded;
816 (void) _dl_catch_error (&objname, &err_str, &malloced, map_doit, &args);
817 if (__glibc_unlikely (err_str != NULL))
820 ERROR: ld.so: object '%s' from %s cannot be preloaded (%s): ignored.\n",
821 fname, where, err_str);
822 /* No need to call free, this is still before
823 the libc's malloc is used. */
825 else if (GL(dl_ns)[LM_ID_BASE]._ns_nloaded != old_nloaded)
826 /* It is no duplicate. */
829 /* Nothing loaded. */
833 #if defined SHARED && defined _LIBC_REENTRANT \
834 && defined __rtld_lock_default_lock_recursive
836 rtld_lock_default_lock_recursive (void *lock)
838 __rtld_lock_default_lock_recursive (lock);
842 rtld_lock_default_unlock_recursive (void *lock)
844 __rtld_lock_default_unlock_recursive (lock);
852 /* Set up the stack checker's canary. */
853 uintptr_t stack_chk_guard = _dl_setup_stack_chk_guard (_dl_random);
854 #ifdef THREAD_SET_STACK_GUARD
855 THREAD_SET_STACK_GUARD (stack_chk_guard);
857 __stack_chk_guard = stack_chk_guard;
860 /* Set up the pointer guard as well, if necessary. */
861 if (GLRO(dl_pointer_guard))
863 uintptr_t pointer_chk_guard = _dl_setup_pointer_guard (_dl_random,
865 #ifdef THREAD_SET_POINTER_GUARD
866 THREAD_SET_POINTER_GUARD (pointer_chk_guard);
868 __pointer_chk_guard_local = pointer_chk_guard;
871 /* We do not need the _dl_random value anymore. The less
872 information we leave behind, the better, so clear the
877 #include "setup-vdso.h"
879 /* The library search path. */
880 static const char *library_path attribute_relro;
881 /* The list preloaded objects. */
882 static const char *preloadlist attribute_relro;
883 /* Nonzero if information about versions has to be printed. */
884 static int version_info attribute_relro;
887 dl_main (const ElfW(Phdr) *phdr,
889 ElfW(Addr) *user_entry,
892 const ElfW(Phdr) *ph;
894 struct link_map *main_map;
897 bool has_interp = false;
899 bool prelinked = false;
900 bool rtld_is_main = false;
901 #ifndef HP_TIMING_NONAVAIL
908 #ifdef _LIBC_REENTRANT
909 /* Explicit initialization since the reloc would just be more work. */
910 GL(dl_error_catch_tsd) = &_dl_initial_error_catch_tsd;
913 GL(dl_init_static_tls) = &_dl_nothread_init_static_tls;
915 #if defined SHARED && defined _LIBC_REENTRANT \
916 && defined __rtld_lock_default_lock_recursive
917 GL(dl_rtld_lock_recursive) = rtld_lock_default_lock_recursive;
918 GL(dl_rtld_unlock_recursive) = rtld_lock_default_unlock_recursive;
921 /* The explicit initialization here is cheaper than processing the reloc
922 in the _rtld_local definition's initializer. */
923 GL(dl_make_stack_executable_hook) = &_dl_make_stack_executable;
925 /* Process the environment variable which control the behaviour. */
926 process_envvars (&mode);
928 #ifndef HAVE_INLINED_SYSCALLS
929 /* Set up a flag which tells we are just starting. */
930 INTUSE(_dl_starting_up) = 1;
933 if (*user_entry == (ElfW(Addr)) ENTRY_POINT)
935 /* Ho ho. We are not the program interpreter! We are the program
936 itself! This means someone ran ld.so as a command. Well, that
937 might be convenient to do sometimes. We support it by
938 interpreting the args like this:
940 ld.so PROGRAM ARGS...
942 The first argument is the name of a file containing an ELF
943 executable we will load and run with the following arguments.
944 To simplify life here, PROGRAM is searched for using the
945 normal rules for shared objects, rather than $PATH or anything
946 like that. We just load it and use its entry point; we don't
947 pay attention to its PT_INTERP command (we are the interpreter
948 ourselves). This is an easy way to test a new ld.so before
952 /* Note the place where the dynamic linker actually came from. */
953 GL(dl_rtld_map).l_name = rtld_progname;
956 if (! strcmp (INTUSE(_dl_argv)[1], "--list"))
959 GLRO(dl_lazy) = -1; /* This means do no dependency analysis. */
965 else if (! strcmp (INTUSE(_dl_argv)[1], "--verify"))
973 else if (! strcmp (INTUSE(_dl_argv)[1], "--inhibit-cache"))
975 GLRO(dl_inhibit_cache) = 1;
980 else if (! strcmp (INTUSE(_dl_argv)[1], "--library-path")
983 library_path = INTUSE(_dl_argv)[2];
987 INTUSE(_dl_argv) += 2;
989 else if (! strcmp (INTUSE(_dl_argv)[1], "--inhibit-rpath")
992 GLRO(dl_inhibit_rpath) = INTUSE(_dl_argv)[2];
996 INTUSE(_dl_argv) += 2;
998 else if (! strcmp (INTUSE(_dl_argv)[1], "--audit") && _dl_argc > 2)
1000 process_dl_audit (INTUSE(_dl_argv)[2]);
1004 INTUSE(_dl_argv) += 2;
1009 /* If we have no further argument the program was called incorrectly.
1010 Grant the user some education. */
1012 _dl_fatal_printf ("\
1013 Usage: ld.so [OPTION]... EXECUTABLE-FILE [ARGS-FOR-PROGRAM...]\n\
1014 You have invoked `ld.so', the helper program for shared library executables.\n\
1015 This program usually lives in the file `/lib/ld.so', and special directives\n\
1016 in executable files using ELF shared libraries tell the system's program\n\
1017 loader to load the helper program from this file. This helper program loads\n\
1018 the shared libraries needed by the program executable, prepares the program\n\
1019 to run, and runs it. You may invoke this helper program directly from the\n\
1020 command line to load and run an ELF executable file; this is like executing\n\
1021 that file itself, but always uses this helper program from the file you\n\
1022 specified, instead of the helper program file specified in the executable\n\
1023 file you run. This is mostly of use for maintainers to test new versions\n\
1024 of this helper program; chances are you did not intend to run this program.\n\
1026 --list list all dependencies and how they are resolved\n\
1027 --verify verify that given object really is a dynamically linked\n\
1028 object we can handle\n\
1029 --inhibit-cache Do not use " LD_SO_CACHE "\n\
1030 --library-path PATH use given PATH instead of content of the environment\n\
1031 variable LD_LIBRARY_PATH\n\
1032 --inhibit-rpath LIST ignore RUNPATH and RPATH information in object names\n\
1034 --audit LIST use objects named in LIST as auditors\n");
1040 /* The initialization of _dl_stack_flags done below assumes the
1041 executable's PT_GNU_STACK may have been honored by the kernel, and
1042 so a PT_GNU_STACK with PF_X set means the stack started out with
1043 execute permission. However, this is not really true if the
1044 dynamic linker is the executable the kernel loaded. For this
1045 case, we must reinitialize _dl_stack_flags to match the dynamic
1046 linker itself. If the dynamic linker was built with a
1047 PT_GNU_STACK, then the kernel may have loaded us with a
1048 nonexecutable stack that we will have to make executable when we
1049 load the program below unless it has a PT_GNU_STACK indicating
1050 nonexecutable stack is ok. */
1052 for (ph = phdr; ph < &phdr[phnum]; ++ph)
1053 if (ph->p_type == PT_GNU_STACK)
1055 GL(dl_stack_flags) = ph->p_flags;
1059 if (__builtin_expect (mode, normal) == verify)
1061 const char *objname;
1062 const char *err_str = NULL;
1063 struct map_args args;
1066 args.str = rtld_progname;
1068 args.mode = __RTLD_OPENEXEC;
1069 (void) _dl_catch_error (&objname, &err_str, &malloced, map_doit,
1071 if (__glibc_unlikely (err_str != NULL))
1072 /* We don't free the returned string, the programs stops
1074 _exit (EXIT_FAILURE);
1078 HP_TIMING_NOW (start);
1079 _dl_map_object (NULL, rtld_progname, lt_executable, 0,
1080 __RTLD_OPENEXEC, LM_ID_BASE);
1081 HP_TIMING_NOW (stop);
1083 HP_TIMING_DIFF (load_time, start, stop);
1086 /* Now the map for the main executable is available. */
1087 main_map = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
1089 if (__builtin_expect (mode, normal) == normal
1090 && GL(dl_rtld_map).l_info[DT_SONAME] != NULL
1091 && main_map->l_info[DT_SONAME] != NULL
1092 && strcmp ((const char *) D_PTR (&GL(dl_rtld_map), l_info[DT_STRTAB])
1093 + GL(dl_rtld_map).l_info[DT_SONAME]->d_un.d_val,
1094 (const char *) D_PTR (main_map, l_info[DT_STRTAB])
1095 + main_map->l_info[DT_SONAME]->d_un.d_val) == 0)
1096 _dl_fatal_printf ("loader cannot load itself\n");
1098 phdr = main_map->l_phdr;
1099 phnum = main_map->l_phnum;
1100 /* We overwrite here a pointer to a malloc()ed string. But since
1101 the malloc() implementation used at this point is the dummy
1102 implementations which has no real free() function it does not
1103 makes sense to free the old string first. */
1104 main_map->l_name = (char *) "";
1105 *user_entry = main_map->l_entry;
1107 #ifdef HAVE_AUX_VECTOR
1108 /* Adjust the on-stack auxiliary vector so that it looks like the
1109 binary was executed directly. */
1110 for (ElfW(auxv_t) *av = auxv; av->a_type != AT_NULL; av++)
1114 av->a_un.a_val = (uintptr_t) phdr;
1117 av->a_un.a_val = phnum;
1120 av->a_un.a_val = *user_entry;
1123 av->a_un.a_val = (uintptr_t) _dl_argv[0];
1130 /* Create a link_map for the executable itself.
1131 This will be what dlopen on "" returns. */
1132 main_map = _dl_new_object ((char *) "", "", lt_executable, NULL,
1133 __RTLD_OPENEXEC, LM_ID_BASE);
1134 assert (main_map != NULL);
1135 main_map->l_phdr = phdr;
1136 main_map->l_phnum = phnum;
1137 main_map->l_entry = *user_entry;
1139 /* Even though the link map is not yet fully initialized we can add
1140 it to the map list since there are no possible users running yet. */
1141 _dl_add_to_namespace_list (main_map, LM_ID_BASE);
1142 assert (main_map == GL(dl_ns)[LM_ID_BASE]._ns_loaded);
1144 /* At this point we are in a bit of trouble. We would have to
1145 fill in the values for l_dev and l_ino. But in general we
1146 do not know where the file is. We also do not handle AT_EXECFD
1147 even if it would be passed up.
1149 We leave the values here defined to 0. This is normally no
1150 problem as the program code itself is normally no shared
1151 object and therefore cannot be loaded dynamically. Nothing
1152 prevent the use of dynamic binaries and in these situations
1153 we might get problems. We might not be able to find out
1154 whether the object is already loaded. But since there is no
1155 easy way out and because the dynamic binary must also not
1156 have an SONAME we ignore this program for now. If it becomes
1157 a problem we can force people using SONAMEs. */
1159 /* We delay initializing the path structure until we got the dynamic
1160 information for the program. */
1163 main_map->l_map_end = 0;
1164 main_map->l_text_end = 0;
1165 /* Perhaps the executable has no PT_LOAD header entries at all. */
1166 main_map->l_map_start = ~0;
1167 /* And it was opened directly. */
1168 ++main_map->l_direct_opencount;
1170 /* Scan the program header table for the dynamic section. */
1171 for (ph = phdr; ph < &phdr[phnum]; ++ph)
1175 /* Find out the load address. */
1176 main_map->l_addr = (ElfW(Addr)) phdr - ph->p_vaddr;
1179 /* This tells us where to find the dynamic section,
1180 which tells us everything we need to do. */
1181 main_map->l_ld = (void *) main_map->l_addr + ph->p_vaddr;
1184 /* This "interpreter segment" was used by the program loader to
1185 find the program interpreter, which is this program itself, the
1186 dynamic linker. We note what name finds us, so that a future
1187 dlopen call or DT_NEEDED entry, for something that wants to link
1188 against the dynamic linker as a shared library, will know that
1189 the shared object is already loaded. */
1190 _dl_rtld_libname.name = ((const char *) main_map->l_addr
1192 /* _dl_rtld_libname.next = NULL; Already zero. */
1193 GL(dl_rtld_map).l_libname = &_dl_rtld_libname;
1195 /* Ordinarilly, we would get additional names for the loader from
1196 our DT_SONAME. This can't happen if we were actually linked as
1197 a static executable (detect this case when we have no DYNAMIC).
1198 If so, assume the filename component of the interpreter path to
1199 be our SONAME, and add it to our name list. */
1200 if (GL(dl_rtld_map).l_ld == NULL)
1202 const char *p = NULL;
1203 const char *cp = _dl_rtld_libname.name;
1205 /* Find the filename part of the path. */
1212 _dl_rtld_libname2.name = p;
1213 /* _dl_rtld_libname2.next = NULL; Already zero. */
1214 _dl_rtld_libname.next = &_dl_rtld_libname2;
1222 ElfW(Addr) mapstart;
1223 ElfW(Addr) allocend;
1225 /* Remember where the main program starts in memory. */
1226 mapstart = (main_map->l_addr
1227 + (ph->p_vaddr & ~(GLRO(dl_pagesize) - 1)));
1228 if (main_map->l_map_start > mapstart)
1229 main_map->l_map_start = mapstart;
1231 /* Also where it ends. */
1232 allocend = main_map->l_addr + ph->p_vaddr + ph->p_memsz;
1233 if (main_map->l_map_end < allocend)
1234 main_map->l_map_end = allocend;
1235 if ((ph->p_flags & PF_X) && allocend > main_map->l_text_end)
1236 main_map->l_text_end = allocend;
1241 if (ph->p_memsz > 0)
1243 /* Note that in the case the dynamic linker we duplicate work
1244 here since we read the PT_TLS entry already in
1245 _dl_start_final. But the result is repeatable so do not
1246 check for this special but unimportant case. */
1247 main_map->l_tls_blocksize = ph->p_memsz;
1248 main_map->l_tls_align = ph->p_align;
1249 if (ph->p_align == 0)
1250 main_map->l_tls_firstbyte_offset = 0;
1252 main_map->l_tls_firstbyte_offset = (ph->p_vaddr
1253 & (ph->p_align - 1));
1254 main_map->l_tls_initimage_size = ph->p_filesz;
1255 main_map->l_tls_initimage = (void *) ph->p_vaddr;
1257 /* This image gets the ID one. */
1258 GL(dl_tls_max_dtv_idx) = main_map->l_tls_modid = 1;
1263 GL(dl_stack_flags) = ph->p_flags;
1267 main_map->l_relro_addr = ph->p_vaddr;
1268 main_map->l_relro_size = ph->p_memsz;
1272 /* Adjust the address of the TLS initialization image in case
1273 the executable is actually an ET_DYN object. */
1274 if (main_map->l_tls_initimage != NULL)
1275 main_map->l_tls_initimage
1276 = (char *) main_map->l_tls_initimage + main_map->l_addr;
1277 if (! main_map->l_map_end)
1278 main_map->l_map_end = ~0;
1279 if (! main_map->l_text_end)
1280 main_map->l_text_end = ~0;
1281 if (! GL(dl_rtld_map).l_libname && GL(dl_rtld_map).l_name)
1283 /* We were invoked directly, so the program might not have a
1285 _dl_rtld_libname.name = GL(dl_rtld_map).l_name;
1286 /* _dl_rtld_libname.next = NULL; Already zero. */
1287 GL(dl_rtld_map).l_libname = &_dl_rtld_libname;
1290 assert (GL(dl_rtld_map).l_libname); /* How else did we get here? */
1292 /* If the current libname is different from the SONAME, add the
1294 if (GL(dl_rtld_map).l_info[DT_SONAME] != NULL
1295 && strcmp (GL(dl_rtld_map).l_libname->name,
1296 (const char *) D_PTR (&GL(dl_rtld_map), l_info[DT_STRTAB])
1297 + GL(dl_rtld_map).l_info[DT_SONAME]->d_un.d_val) != 0)
1299 static struct libname_list newname;
1300 newname.name = ((char *) D_PTR (&GL(dl_rtld_map), l_info[DT_STRTAB])
1301 + GL(dl_rtld_map).l_info[DT_SONAME]->d_un.d_ptr);
1302 newname.next = NULL;
1303 newname.dont_free = 1;
1305 assert (GL(dl_rtld_map).l_libname->next == NULL);
1306 GL(dl_rtld_map).l_libname->next = &newname;
1308 /* The ld.so must be relocated since otherwise loading audit modules
1309 will fail since they reuse the very same ld.so. */
1310 assert (GL(dl_rtld_map).l_relocated);
1314 /* Extract the contents of the dynamic section for easy access. */
1315 elf_get_dynamic_info (main_map, NULL);
1316 /* Set up our cache of pointers into the hash table. */
1317 _dl_setup_hash (main_map);
1320 if (__builtin_expect (mode, normal) == verify)
1322 /* We were called just to verify that this is a dynamic
1323 executable using us as the program interpreter. Exit with an
1324 error if we were not able to load the binary or no interpreter
1325 is specified (i.e., this is no dynamically linked binary. */
1326 if (main_map->l_ld == NULL)
1329 /* We allow here some platform specific code. */
1330 #ifdef DISTINGUISH_LIB_VERSIONS
1331 DISTINGUISH_LIB_VERSIONS;
1333 _exit (has_interp ? 0 : 2);
1336 struct link_map **first_preload = &GL(dl_rtld_map).l_next;
1337 /* Set up the data structures for the system-supplied DSO early,
1338 so they can influence _dl_init_paths. */
1339 setup_vdso (main_map, &first_preload);
1341 #ifdef DL_SYSDEP_OSCHECK
1342 DL_SYSDEP_OSCHECK (_dl_fatal_printf);
1345 /* Initialize the data structures for the search paths for shared
1347 _dl_init_paths (library_path);
1349 /* Initialize _r_debug. */
1350 struct r_debug *r = _dl_debug_initialize (GL(dl_rtld_map).l_addr,
1352 r->r_state = RT_CONSISTENT;
1354 /* Put the link_map for ourselves on the chain so it can be found by
1355 name. Note that at this point the global chain of link maps contains
1356 exactly one element, which is pointed to by dl_loaded. */
1357 if (! GL(dl_rtld_map).l_name)
1358 /* If not invoked directly, the dynamic linker shared object file was
1359 found by the PT_INTERP name. */
1360 GL(dl_rtld_map).l_name = (char *) GL(dl_rtld_map).l_libname->name;
1361 GL(dl_rtld_map).l_type = lt_library;
1362 main_map->l_next = &GL(dl_rtld_map);
1363 GL(dl_rtld_map).l_prev = main_map;
1364 ++GL(dl_ns)[LM_ID_BASE]._ns_nloaded;
1367 /* If LD_USE_LOAD_BIAS env variable has not been seen, default
1368 to not using bias for non-prelinked PIEs and libraries
1369 and using it for executables or prelinked PIEs or libraries. */
1370 if (GLRO(dl_use_load_bias) == (ElfW(Addr)) -2)
1371 GLRO(dl_use_load_bias) = main_map->l_addr == 0 ? -1 : 0;
1373 /* Set up the program header information for the dynamic linker
1374 itself. It is needed in the dl_iterate_phdr() callbacks. */
1375 ElfW(Ehdr) *rtld_ehdr = (ElfW(Ehdr) *) GL(dl_rtld_map).l_map_start;
1376 ElfW(Phdr) *rtld_phdr = (ElfW(Phdr) *) (GL(dl_rtld_map).l_map_start
1377 + rtld_ehdr->e_phoff);
1378 GL(dl_rtld_map).l_phdr = rtld_phdr;
1379 GL(dl_rtld_map).l_phnum = rtld_ehdr->e_phnum;
1382 /* PT_GNU_RELRO is usually the last phdr. */
1383 size_t cnt = rtld_ehdr->e_phnum;
1385 if (rtld_phdr[cnt].p_type == PT_GNU_RELRO)
1387 GL(dl_rtld_map).l_relro_addr = rtld_phdr[cnt].p_vaddr;
1388 GL(dl_rtld_map).l_relro_size = rtld_phdr[cnt].p_memsz;
1392 /* Add the dynamic linker to the TLS list if it also uses TLS. */
1393 if (GL(dl_rtld_map).l_tls_blocksize != 0)
1394 /* Assign a module ID. Do this before loading any audit modules. */
1395 GL(dl_rtld_map).l_tls_modid = _dl_next_tls_modid ();
1397 /* If we have auditing DSOs to load, do it now. */
1398 if (__glibc_unlikely (audit_list != NULL))
1400 /* Iterate over all entries in the list. The order is important. */
1401 struct audit_ifaces *last_audit = NULL;
1402 struct audit_list *al = audit_list->next;
1404 /* Since we start using the auditing DSOs right away we need to
1405 initialize the data structures now. */
1408 /* Initialize security features. We need to do it this early
1409 since otherwise the constructors of the audit libraries will
1410 use different values (especially the pointer guard) and will
1416 int tls_idx = GL(dl_tls_max_dtv_idx);
1418 /* Now it is time to determine the layout of the static TLS
1419 block and allocate it for the initial thread. Note that we
1420 always allocate the static block, we never defer it even if
1421 no DF_STATIC_TLS bit is set. The reason is that we know
1422 glibc will use the static model. */
1423 struct dlmopen_args dlmargs;
1424 dlmargs.fname = al->name;
1427 const char *objname;
1428 const char *err_str = NULL;
1430 (void) _dl_catch_error (&objname, &err_str, &malloced, dlmopen_doit,
1432 if (__glibc_unlikely (err_str != NULL))
1435 _dl_error_printf ("\
1436 ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n",
1439 free ((char *) err_str);
1443 struct lookup_args largs;
1444 largs.name = "la_version";
1445 largs.map = dlmargs.map;
1447 /* Check whether the interface version matches. */
1448 (void) _dl_catch_error (&objname, &err_str, &malloced,
1449 lookup_doit, &largs);
1451 unsigned int (*laversion) (unsigned int);
1454 && (laversion = largs.result) != NULL
1455 && (lav = laversion (LAV_CURRENT)) > 0
1456 && lav <= LAV_CURRENT)
1458 /* Allocate structure for the callback function pointers.
1459 This call can never fail. */
1462 struct audit_ifaces ifaces;
1463 #define naudit_ifaces 8
1464 void (*fptr[naudit_ifaces]) (void);
1465 } *newp = malloc (sizeof (*newp));
1467 /* Names of the auditing interfaces. All in one
1469 static const char audit_iface_names[] =
1474 #if __ELF_NATIVE_CLASS == 32
1476 #elif __ELF_NATIVE_CLASS == 64
1479 # error "__ELF_NATIVE_CLASS must be defined"
1481 #define STRING(s) __STRING (s)
1482 "la_" STRING (ARCH_LA_PLTENTER) "\0"
1483 "la_" STRING (ARCH_LA_PLTEXIT) "\0"
1485 unsigned int cnt = 0;
1486 const char *cp = audit_iface_names;
1490 (void) _dl_catch_error (&objname, &err_str, &malloced,
1491 lookup_doit, &largs);
1493 /* Store the pointer. */
1494 if (err_str == NULL && largs.result != NULL)
1496 newp->fptr[cnt] = largs.result;
1498 /* The dynamic linker link map is statically
1499 allocated, initialize the data now. */
1500 GL(dl_rtld_map).l_audit[cnt].cookie
1501 = (intptr_t) &GL(dl_rtld_map);
1504 newp->fptr[cnt] = NULL;
1507 cp = (char *) rawmemchr (cp, '\0') + 1;
1509 while (*cp != '\0');
1510 assert (cnt == naudit_ifaces);
1512 /* Now append the new auditing interface to the list. */
1513 newp->ifaces.next = NULL;
1514 if (last_audit == NULL)
1515 last_audit = GLRO(dl_audit) = &newp->ifaces;
1517 last_audit = last_audit->next = &newp->ifaces;
1520 /* Mark the DSO as being used for auditing. */
1521 dlmargs.map->l_auditing = 1;
1525 /* We cannot use the DSO, it does not have the
1526 appropriate interfaces or it expects something
1529 Lmid_t ns = dlmargs.map->l_ns;
1531 _dl_close (dlmargs.map);
1533 /* Make sure the namespace has been cleared entirely. */
1534 assert (GL(dl_ns)[ns]._ns_loaded == NULL);
1535 assert (GL(dl_ns)[ns]._ns_nloaded == 0);
1537 GL(dl_tls_max_dtv_idx) = tls_idx;
1544 while (al != audit_list->next);
1546 /* If we have any auditing modules, announce that we already
1547 have two objects loaded. */
1548 if (__glibc_unlikely (GLRO(dl_naudit) > 0))
1550 struct link_map *ls[2] = { main_map, &GL(dl_rtld_map) };
1552 for (unsigned int outer = 0; outer < 2; ++outer)
1554 struct audit_ifaces *afct = GLRO(dl_audit);
1555 for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
1557 if (afct->objopen != NULL)
1559 ls[outer]->l_audit[cnt].bindflags
1560 = afct->objopen (ls[outer], LM_ID_BASE,
1561 &ls[outer]->l_audit[cnt].cookie);
1563 ls[outer]->l_audit_any_plt
1564 |= ls[outer]->l_audit[cnt].bindflags != 0;
1573 /* Keep track of the currently loaded modules to count how many
1574 non-audit modules which use TLS are loaded. */
1575 size_t count_modids = _dl_count_modids ();
1577 /* Set up debugging before the debugger is notified for the first time. */
1578 #ifdef ELF_MACHINE_DEBUG_SETUP
1579 /* Some machines (e.g. MIPS) don't use DT_DEBUG in this way. */
1580 ELF_MACHINE_DEBUG_SETUP (main_map, r);
1581 ELF_MACHINE_DEBUG_SETUP (&GL(dl_rtld_map), r);
1583 if (main_map->l_info[DT_DEBUG] != NULL)
1584 /* There is a DT_DEBUG entry in the dynamic section. Fill it in
1585 with the run-time address of the r_debug structure */
1586 main_map->l_info[DT_DEBUG]->d_un.d_ptr = (ElfW(Addr)) r;
1588 /* Fill in the pointer in the dynamic linker's own dynamic section, in
1589 case you run gdb on the dynamic linker directly. */
1590 if (GL(dl_rtld_map).l_info[DT_DEBUG] != NULL)
1591 GL(dl_rtld_map).l_info[DT_DEBUG]->d_un.d_ptr = (ElfW(Addr)) r;
1594 /* We start adding objects. */
1595 r->r_state = RT_ADD;
1597 LIBC_PROBE (init_start, 2, LM_ID_BASE, r);
1599 /* Auditing checkpoint: we are ready to signal that the initial map
1600 is being constructed. */
1601 if (__glibc_unlikely (GLRO(dl_naudit) > 0))
1603 struct audit_ifaces *afct = GLRO(dl_audit);
1604 for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
1606 if (afct->activity != NULL)
1607 afct->activity (&main_map->l_audit[cnt].cookie, LA_ACT_ADD);
1613 /* We have two ways to specify objects to preload: via environment
1614 variable and via the file /etc/ld.so.preload. The latter can also
1615 be used when security is enabled. */
1616 assert (*first_preload == NULL);
1617 struct link_map **preloads = NULL;
1618 unsigned int npreloads = 0;
1620 if (__glibc_unlikely (preloadlist != NULL))
1622 /* The LD_PRELOAD environment variable gives list of libraries
1623 separated by white space or colons that are loaded before the
1624 executable's dependencies and prepended to the global scope
1625 list. If the binary is running setuid all elements
1626 containing a '/' are ignored since it is insecure. */
1627 char *list = strdupa (preloadlist);
1630 HP_TIMING_NOW (start);
1632 /* Prevent optimizing strsep. Speed is not important here. */
1633 while ((p = (strsep) (&list, " :")) != NULL)
1635 && (__builtin_expect (! INTUSE(__libc_enable_secure), 1)
1636 || strchr (p, '/') == NULL))
1637 npreloads += do_preload (p, main_map, "LD_PRELOAD");
1639 HP_TIMING_NOW (stop);
1640 HP_TIMING_DIFF (diff, start, stop);
1641 HP_TIMING_ACCUM_NT (load_time, diff);
1644 /* There usually is no ld.so.preload file, it should only be used
1645 for emergencies and testing. So the open call etc should usually
1646 fail. Using access() on a non-existing file is faster than using
1647 open(). So we do this first. If it succeeds we do almost twice
1648 the work but this does not matter, since it is not for production
1650 static const char preload_file[] = "/etc/ld.so.preload";
1651 if (__glibc_unlikely (__access (preload_file, R_OK) == 0))
1653 /* Read the contents of the file. */
1654 file = _dl_sysdep_read_whole_file (preload_file, &file_size,
1655 PROT_READ | PROT_WRITE);
1656 if (__glibc_unlikely (file != MAP_FAILED))
1658 /* Parse the file. It contains names of libraries to be loaded,
1659 separated by white spaces or `:'. It may also contain
1660 comments introduced by `#'. */
1665 /* Eliminate comments. */
1670 char *comment = memchr (runp, '#', rest);
1671 if (comment == NULL)
1674 rest -= comment - runp;
1677 while (--rest > 0 && *++comment != '\n');
1680 /* We have one problematic case: if we have a name at the end of
1681 the file without a trailing terminating characters, we cannot
1682 place the \0. Handle the case separately. */
1683 if (file[file_size - 1] != ' ' && file[file_size - 1] != '\t'
1684 && file[file_size - 1] != '\n' && file[file_size - 1] != ':')
1686 problem = &file[file_size];
1687 while (problem > file && problem[-1] != ' '
1688 && problem[-1] != '\t'
1689 && problem[-1] != '\n' && problem[-1] != ':')
1698 file[file_size - 1] = '\0';
1701 HP_TIMING_NOW (start);
1703 if (file != problem)
1707 while ((p = strsep (&runp, ": \t\n")) != NULL)
1709 npreloads += do_preload (p, main_map, preload_file);
1712 if (problem != NULL)
1714 char *p = strndupa (problem, file_size - (problem - file));
1716 npreloads += do_preload (p, main_map, preload_file);
1719 HP_TIMING_NOW (stop);
1720 HP_TIMING_DIFF (diff, start, stop);
1721 HP_TIMING_ACCUM_NT (load_time, diff);
1723 /* We don't need the file anymore. */
1724 __munmap (file, file_size);
1728 if (__glibc_unlikely (*first_preload != NULL))
1730 /* Set up PRELOADS with a vector of the preloaded libraries. */
1731 struct link_map *l = *first_preload;
1732 preloads = __alloca (npreloads * sizeof preloads[0]);
1739 assert (i == npreloads);
1742 /* Load all the libraries specified by DT_NEEDED entries. If LD_PRELOAD
1743 specified some libraries to load, these are inserted before the actual
1744 dependencies in the executable's searchlist for symbol resolution. */
1745 HP_TIMING_NOW (start);
1746 _dl_map_object_deps (main_map, preloads, npreloads, mode == trace, 0);
1747 HP_TIMING_NOW (stop);
1748 HP_TIMING_DIFF (diff, start, stop);
1749 HP_TIMING_ACCUM_NT (load_time, diff);
1751 /* Mark all objects as being in the global scope. */
1752 for (i = main_map->l_searchlist.r_nlist; i > 0; )
1753 main_map->l_searchlist.r_list[--i]->l_global = 1;
1755 /* Remove _dl_rtld_map from the chain. */
1756 GL(dl_rtld_map).l_prev->l_next = GL(dl_rtld_map).l_next;
1757 if (GL(dl_rtld_map).l_next != NULL)
1758 GL(dl_rtld_map).l_next->l_prev = GL(dl_rtld_map).l_prev;
1760 for (i = 1; i < main_map->l_searchlist.r_nlist; ++i)
1761 if (main_map->l_searchlist.r_list[i] == &GL(dl_rtld_map))
1764 bool rtld_multiple_ref = false;
1765 if (__glibc_likely (i < main_map->l_searchlist.r_nlist))
1767 /* Some DT_NEEDED entry referred to the interpreter object itself, so
1768 put it back in the list of visible objects. We insert it into the
1769 chain in symbol search order because gdb uses the chain's order as
1770 its symbol search order. */
1771 rtld_multiple_ref = true;
1773 GL(dl_rtld_map).l_prev = main_map->l_searchlist.r_list[i - 1];
1774 if (__builtin_expect (mode, normal) == normal)
1776 GL(dl_rtld_map).l_next = (i + 1 < main_map->l_searchlist.r_nlist
1777 ? main_map->l_searchlist.r_list[i + 1]
1779 #ifdef NEED_DL_SYSINFO_DSO
1780 if (GLRO(dl_sysinfo_map) != NULL
1781 && GL(dl_rtld_map).l_prev->l_next == GLRO(dl_sysinfo_map)
1782 && GL(dl_rtld_map).l_next != GLRO(dl_sysinfo_map))
1783 GL(dl_rtld_map).l_prev = GLRO(dl_sysinfo_map);
1787 /* In trace mode there might be an invisible object (which we
1788 could not find) after the previous one in the search list.
1789 In this case it doesn't matter much where we put the
1790 interpreter object, so we just initialize the list pointer so
1791 that the assertion below holds. */
1792 GL(dl_rtld_map).l_next = GL(dl_rtld_map).l_prev->l_next;
1794 assert (GL(dl_rtld_map).l_prev->l_next == GL(dl_rtld_map).l_next);
1795 GL(dl_rtld_map).l_prev->l_next = &GL(dl_rtld_map);
1796 if (GL(dl_rtld_map).l_next != NULL)
1798 assert (GL(dl_rtld_map).l_next->l_prev == GL(dl_rtld_map).l_prev);
1799 GL(dl_rtld_map).l_next->l_prev = &GL(dl_rtld_map);
1803 /* Now let us see whether all libraries are available in the
1804 versions we need. */
1806 struct version_check_args args;
1807 args.doexit = mode == normal;
1808 args.dotrace = mode == trace;
1809 _dl_receive_error (print_missing_version, version_check_doit, &args);
1812 /* We do not initialize any of the TLS functionality unless any of the
1813 initial modules uses TLS. This makes dynamic loading of modules with
1814 TLS impossible, but to support it requires either eagerly doing setup
1815 now or lazily doing it later. Doing it now makes us incompatible with
1816 an old kernel that can't perform TLS_INIT_TP, even if no TLS is ever
1817 used. Trying to do it lazily is too hairy to try when there could be
1818 multiple threads (from a non-TLS-using libpthread). */
1819 bool was_tls_init_tp_called = tls_init_tp_called;
1823 if (__glibc_likely (audit_list == NULL))
1824 /* Initialize security features. But only if we have not done it
1828 if (__builtin_expect (mode, normal) != normal)
1830 /* We were run just to list the shared libraries. It is
1831 important that we do this before real relocation, because the
1832 functions we call below for output may no longer work properly
1833 after relocation. */
1836 if (GLRO(dl_debug_mask) & DL_DEBUG_PRELINK)
1838 struct r_scope_elem *scope = &main_map->l_searchlist;
1840 for (i = 0; i < scope->r_nlist; i++)
1842 l = scope->r_list [i];
1845 _dl_printf ("\t%s => not found\n", l->l_libname->name);
1848 if (_dl_name_match_p (GLRO(dl_trace_prelink), l))
1849 GLRO(dl_trace_prelink_map) = l;
1850 _dl_printf ("\t%s => %s (0x%0*Zx, 0x%0*Zx)",
1851 DSO_FILENAME (l->l_libname->name),
1852 DSO_FILENAME (l->l_name),
1853 (int) sizeof l->l_map_start * 2,
1854 (size_t) l->l_map_start,
1855 (int) sizeof l->l_addr * 2,
1856 (size_t) l->l_addr);
1859 _dl_printf (" TLS(0x%Zx, 0x%0*Zx)\n", l->l_tls_modid,
1860 (int) sizeof l->l_tls_offset * 2,
1861 (size_t) l->l_tls_offset);
1866 else if (GLRO(dl_debug_mask) & DL_DEBUG_UNUSED)
1868 /* Look through the dependencies of the main executable
1869 and determine which of them is not actually
1871 struct link_map *l = main_map;
1873 /* Relocate the main executable. */
1874 struct relocate_args args = { .l = l,
1875 .reloc_mode = ((GLRO(dl_lazy)
1877 | __RTLD_NOIFUNC) };
1878 _dl_receive_error (print_unresolved, relocate_doit, &args);
1880 /* This loop depends on the dependencies of the executable to
1881 correspond in number and order to the DT_NEEDED entries. */
1882 ElfW(Dyn) *dyn = main_map->l_ld;
1884 while (dyn->d_tag != DT_NULL)
1886 if (dyn->d_tag == DT_NEEDED)
1889 #ifdef NEED_DL_SYSINFO_DSO
1890 /* Skip the VDSO since it's not part of the list
1891 of objects we brought in via DT_NEEDED entries. */
1892 if (l == GLRO(dl_sysinfo_map))
1899 _dl_printf ("Unused direct dependencies:\n");
1903 _dl_printf ("\t%s\n", l->l_name);
1910 _exit (first != true);
1912 else if (! main_map->l_info[DT_NEEDED])
1913 _dl_printf ("\tstatically linked\n");
1916 for (l = main_map->l_next; l; l = l->l_next)
1918 /* The library was not found. */
1919 _dl_printf ("\t%s => not found\n", l->l_libname->name);
1920 else if (strcmp (l->l_libname->name, l->l_name) == 0)
1921 _dl_printf ("\t%s (0x%0*Zx)\n", l->l_libname->name,
1922 (int) sizeof l->l_map_start * 2,
1923 (size_t) l->l_map_start);
1925 _dl_printf ("\t%s => %s (0x%0*Zx)\n", l->l_libname->name,
1926 l->l_name, (int) sizeof l->l_map_start * 2,
1927 (size_t) l->l_map_start);
1930 if (__builtin_expect (mode, trace) != trace)
1931 for (i = 1; i < (unsigned int) _dl_argc; ++i)
1933 const ElfW(Sym) *ref = NULL;
1934 ElfW(Addr) loadbase;
1937 result = _dl_lookup_symbol_x (INTUSE(_dl_argv)[i], main_map,
1938 &ref, main_map->l_scope,
1939 NULL, ELF_RTYPE_CLASS_PLT,
1940 DL_LOOKUP_ADD_DEPENDENCY, NULL);
1942 loadbase = LOOKUP_VALUE_ADDRESS (result);
1944 _dl_printf ("%s found at 0x%0*Zd in object at 0x%0*Zd\n",
1945 INTUSE(_dl_argv)[i],
1946 (int) sizeof ref->st_value * 2,
1947 (size_t) ref->st_value,
1948 (int) sizeof loadbase * 2, (size_t) loadbase);
1952 /* If LD_WARN is set, warn about undefined symbols. */
1953 if (GLRO(dl_lazy) >= 0 && GLRO(dl_verbose))
1955 /* We have to do symbol dependency testing. */
1956 struct relocate_args args;
1959 args.reloc_mode = ((GLRO(dl_lazy) ? RTLD_LAZY : 0)
1962 i = main_map->l_searchlist.r_nlist;
1965 struct link_map *l = main_map->l_initfini[i];
1966 if (l != &GL(dl_rtld_map) && ! l->l_faked)
1969 _dl_receive_error (print_unresolved, relocate_doit,
1974 if ((GLRO(dl_debug_mask) & DL_DEBUG_PRELINK)
1975 && rtld_multiple_ref)
1977 /* Mark the link map as not yet relocated again. */
1978 GL(dl_rtld_map).l_relocated = 0;
1979 _dl_relocate_object (&GL(dl_rtld_map),
1980 main_map->l_scope, __RTLD_NOIFUNC, 0);
1983 #define VERNEEDTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERNEED))
1986 /* Print more information. This means here, print information
1987 about the versions needed. */
1989 struct link_map *map;
1991 for (map = main_map; map != NULL; map = map->l_next)
1994 ElfW(Dyn) *dyn = map->l_info[VERNEEDTAG];
2000 strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
2001 ent = (ElfW(Verneed) *) (map->l_addr + dyn->d_un.d_ptr);
2005 _dl_printf ("\n\tVersion information:\n");
2009 _dl_printf ("\t%s:\n", DSO_FILENAME (map->l_name));
2014 struct link_map *needed;
2016 needed = find_needed (strtab + ent->vn_file);
2017 aux = (ElfW(Vernaux) *) ((char *) ent + ent->vn_aux);
2021 const char *fname = NULL;
2024 && match_version (strtab + aux->vna_name,
2026 fname = needed->l_name;
2028 _dl_printf ("\t\t%s (%s) %s=> %s\n",
2029 strtab + ent->vn_file,
2030 strtab + aux->vna_name,
2031 aux->vna_flags & VER_FLG_WEAK
2033 fname ?: "not found");
2035 if (aux->vna_next == 0)
2036 /* No more symbols. */
2040 aux = (ElfW(Vernaux) *) ((char *) aux
2044 if (ent->vn_next == 0)
2045 /* No more dependencies. */
2048 /* Next dependency. */
2049 ent = (ElfW(Verneed) *) ((char *) ent + ent->vn_next);
2058 if (main_map->l_info[ADDRIDX (DT_GNU_LIBLIST)]
2059 && ! __builtin_expect (GLRO(dl_profile) != NULL, 0)
2060 && ! __builtin_expect (GLRO(dl_dynamic_weak), 0))
2062 ElfW(Lib) *liblist, *liblistend;
2063 struct link_map **r_list, **r_listend, *l;
2064 const char *strtab = (const void *) D_PTR (main_map, l_info[DT_STRTAB]);
2066 assert (main_map->l_info[VALIDX (DT_GNU_LIBLISTSZ)] != NULL);
2067 liblist = (ElfW(Lib) *)
2068 main_map->l_info[ADDRIDX (DT_GNU_LIBLIST)]->d_un.d_ptr;
2069 liblistend = (ElfW(Lib) *)
2071 main_map->l_info[VALIDX (DT_GNU_LIBLISTSZ)]->d_un.d_val);
2072 r_list = main_map->l_searchlist.r_list;
2073 r_listend = r_list + main_map->l_searchlist.r_nlist;
2075 for (; r_list < r_listend && liblist < liblistend; r_list++)
2082 /* If the library is not mapped where it should, fail. */
2086 /* Next, check if checksum matches. */
2087 if (l->l_info [VALIDX(DT_CHECKSUM)] == NULL
2088 || l->l_info [VALIDX(DT_CHECKSUM)]->d_un.d_val
2089 != liblist->l_checksum)
2092 if (l->l_info [VALIDX(DT_GNU_PRELINKED)] == NULL
2093 || l->l_info [VALIDX(DT_GNU_PRELINKED)]->d_un.d_val
2094 != liblist->l_time_stamp)
2097 if (! _dl_name_match_p (strtab + liblist->l_name, l))
2104 if (r_list == r_listend && liblist == liblistend)
2107 if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_LIBS))
2108 _dl_debug_printf ("\nprelink checking: %s\n",
2109 prelinked ? "ok" : "failed");
2113 /* Now set up the variable which helps the assembler startup code. */
2114 GL(dl_ns)[LM_ID_BASE]._ns_main_searchlist = &main_map->l_searchlist;
2116 /* Save the information about the original global scope list since
2117 we need it in the memory handling later. */
2118 GLRO(dl_initial_searchlist) = *GL(dl_ns)[LM_ID_BASE]._ns_main_searchlist;
2120 /* Remember the last search directory added at startup, now that
2121 malloc will no longer be the one from dl-minimal.c. */
2122 GLRO(dl_init_all_dirs) = GL(dl_all_dirs);
2124 /* Print scope information. */
2125 if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_SCOPES))
2127 _dl_debug_printf ("\nInitial object scopes\n");
2129 for (struct link_map *l = main_map; l != NULL; l = l->l_next)
2130 _dl_show_scope (l, 0);
2135 if (main_map->l_info [ADDRIDX (DT_GNU_CONFLICT)] != NULL)
2137 ElfW(Rela) *conflict, *conflictend;
2138 #ifndef HP_TIMING_NONAVAIL
2143 HP_TIMING_NOW (start);
2144 assert (main_map->l_info [VALIDX (DT_GNU_CONFLICTSZ)] != NULL);
2145 conflict = (ElfW(Rela) *)
2146 main_map->l_info [ADDRIDX (DT_GNU_CONFLICT)]->d_un.d_ptr;
2147 conflictend = (ElfW(Rela) *)
2149 + main_map->l_info [VALIDX (DT_GNU_CONFLICTSZ)]->d_un.d_val);
2150 _dl_resolve_conflicts (main_map, conflict, conflictend);
2151 HP_TIMING_NOW (stop);
2152 HP_TIMING_DIFF (relocate_time, start, stop);
2156 /* Mark all the objects so we know they have been already relocated. */
2157 for (struct link_map *l = main_map; l != NULL; l = l->l_next)
2160 if (l->l_relro_size)
2161 _dl_protect_relro (l);
2163 /* Add object to slot information data if necessasy. */
2164 if (l->l_tls_blocksize != 0 && tls_init_tp_called)
2165 _dl_add_to_slotinfo (l);
2170 /* Now we have all the objects loaded. Relocate them all except for
2171 the dynamic linker itself. We do this in reverse order so that copy
2172 relocs of earlier objects overwrite the data written by later
2173 objects. We do not re-relocate the dynamic linker itself in this
2174 loop because that could result in the GOT entries for functions we
2175 call being changed, and that would break us. It is safe to relocate
2176 the dynamic linker out of order because it has no copy relocs (we
2177 know that because it is self-contained). */
2179 int consider_profiling = GLRO(dl_profile) != NULL;
2180 #ifndef HP_TIMING_NONAVAIL
2185 /* If we are profiling we also must do lazy reloaction. */
2186 GLRO(dl_lazy) |= consider_profiling;
2188 HP_TIMING_NOW (start);
2189 unsigned i = main_map->l_searchlist.r_nlist;
2192 struct link_map *l = main_map->l_initfini[i];
2194 /* While we are at it, help the memory handling a bit. We have to
2195 mark some data structures as allocated with the fake malloc()
2196 implementation in ld.so. */
2197 struct libname_list *lnp = l->l_libname->next;
2199 while (__builtin_expect (lnp != NULL, 0))
2204 /* Also allocated with the fake malloc(). */
2205 l->l_free_initfini = 0;
2207 if (l != &GL(dl_rtld_map))
2208 _dl_relocate_object (l, l->l_scope, GLRO(dl_lazy) ? RTLD_LAZY : 0,
2209 consider_profiling);
2211 /* Add object to slot information data if necessasy. */
2212 if (l->l_tls_blocksize != 0 && tls_init_tp_called)
2213 _dl_add_to_slotinfo (l);
2215 HP_TIMING_NOW (stop);
2217 HP_TIMING_DIFF (relocate_time, start, stop);
2219 /* Now enable profiling if needed. Like the previous call,
2220 this has to go here because the calls it makes should use the
2221 rtld versions of the functions (particularly calloc()), but it
2222 needs to have _dl_profile_map set up by the relocator. */
2223 if (__glibc_unlikely (GL(dl_profile_map) != NULL))
2224 /* We must prepare the profiling. */
2225 _dl_start_profile ();
2228 if ((!was_tls_init_tp_called && GL(dl_tls_max_dtv_idx) > 0)
2229 || count_modids != _dl_count_modids ())
2230 ++GL(dl_tls_generation);
2232 /* Now that we have completed relocation, the initializer data
2233 for the TLS blocks has its final values and we can copy them
2234 into the main thread's TLS area, which we allocated above. */
2235 _dl_allocate_tls_init (tcbp);
2237 /* And finally install it for the main thread. If ld.so itself uses
2238 TLS we know the thread pointer was initialized earlier. */
2239 if (! tls_init_tp_called)
2243 = TLS_INIT_TP (tcbp, USE___THREAD);
2245 = TLS_INIT_TP (tcbp, 0);
2247 if (__glibc_unlikely (lossage != NULL))
2248 _dl_fatal_printf ("cannot set up thread-local storage: %s\n",
2252 /* Make sure no new search directories have been added. */
2253 assert (GLRO(dl_init_all_dirs) == GL(dl_all_dirs));
2255 if (! prelinked && rtld_multiple_ref)
2257 /* There was an explicit ref to the dynamic linker as a shared lib.
2258 Re-relocate ourselves with user-controlled symbol definitions.
2260 We must do this after TLS initialization in case after this
2261 re-relocation, we might call a user-supplied function
2262 (e.g. calloc from _dl_relocate_object) that uses TLS data. */
2264 #ifndef HP_TIMING_NONAVAIL
2270 HP_TIMING_NOW (start);
2271 /* Mark the link map as not yet relocated again. */
2272 GL(dl_rtld_map).l_relocated = 0;
2273 _dl_relocate_object (&GL(dl_rtld_map), main_map->l_scope, 0, 0);
2274 HP_TIMING_NOW (stop);
2275 HP_TIMING_DIFF (add, start, stop);
2276 HP_TIMING_ACCUM_NT (relocate_time, add);
2279 /* Do any necessary cleanups for the startup OS interface code.
2280 We do these now so that no calls are made after rtld re-relocation
2281 which might be resolved to different functions than we expect.
2282 We cannot do this before relocating the other objects because
2283 _dl_relocate_object might need to call `mprotect' for DT_TEXTREL. */
2284 _dl_sysdep_start_cleanup ();
2287 /* Auditing checkpoint: we have added all objects. */
2288 if (__glibc_unlikely (GLRO(dl_naudit) > 0))
2290 struct link_map *head = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
2291 /* Do not call the functions for any auditing object. */
2292 if (head->l_auditing == 0)
2294 struct audit_ifaces *afct = GLRO(dl_audit);
2295 for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
2297 if (afct->activity != NULL)
2298 afct->activity (&head->l_audit[cnt].cookie, LA_ACT_CONSISTENT);
2306 /* Notify the debugger all new objects are now ready to go. We must re-get
2307 the address since by now the variable might be in another object. */
2308 r = _dl_debug_initialize (0, LM_ID_BASE);
2309 r->r_state = RT_CONSISTENT;
2311 LIBC_PROBE (init_complete, 2, LM_ID_BASE, r);
2313 #if defined USE_LDCONFIG && !defined MAP_COPY
2314 /* We must munmap() the cache file. */
2315 _dl_unload_cache ();
2318 /* Once we return, _dl_sysdep_start will invoke
2319 the DT_INIT functions and then *USER_ENTRY. */
2322 /* This is a little helper function for resolving symbols while
2323 tracing the binary. */
2325 print_unresolved (int errcode __attribute__ ((unused)), const char *objname,
2326 const char *errstring)
2328 if (objname[0] == '\0')
2329 objname = RTLD_PROGNAME;
2330 _dl_error_printf ("%s (%s)\n", errstring, objname);
2333 /* This is a little helper function for resolving symbols while
2334 tracing the binary. */
2336 print_missing_version (int errcode __attribute__ ((unused)),
2337 const char *objname, const char *errstring)
2339 _dl_error_printf ("%s: %s: %s\n", RTLD_PROGNAME,
2340 objname, errstring);
2343 /* Nonzero if any of the debugging options is enabled. */
2344 static int any_debug attribute_relro;
2346 /* Process the string given as the parameter which explains which debugging
2347 options are enabled. */
2349 process_dl_debug (const char *dl_debug)
2351 /* When adding new entries make sure that the maximal length of a name
2352 is correctly handled in the LD_DEBUG_HELP code below. */
2356 const char name[10];
2357 const char helptext[41];
2358 unsigned short int mask;
2361 #define LEN_AND_STR(str) sizeof (str) - 1, str
2362 { LEN_AND_STR ("libs"), "display library search paths",
2363 DL_DEBUG_LIBS | DL_DEBUG_IMPCALLS },
2364 { LEN_AND_STR ("reloc"), "display relocation processing",
2365 DL_DEBUG_RELOC | DL_DEBUG_IMPCALLS },
2366 { LEN_AND_STR ("files"), "display progress for input file",
2367 DL_DEBUG_FILES | DL_DEBUG_IMPCALLS },
2368 { LEN_AND_STR ("symbols"), "display symbol table processing",
2369 DL_DEBUG_SYMBOLS | DL_DEBUG_IMPCALLS },
2370 { LEN_AND_STR ("bindings"), "display information about symbol binding",
2371 DL_DEBUG_BINDINGS | DL_DEBUG_IMPCALLS },
2372 { LEN_AND_STR ("versions"), "display version dependencies",
2373 DL_DEBUG_VERSIONS | DL_DEBUG_IMPCALLS },
2374 { LEN_AND_STR ("scopes"), "display scope information",
2376 { LEN_AND_STR ("all"), "all previous options combined",
2377 DL_DEBUG_LIBS | DL_DEBUG_RELOC | DL_DEBUG_FILES | DL_DEBUG_SYMBOLS
2378 | DL_DEBUG_BINDINGS | DL_DEBUG_VERSIONS | DL_DEBUG_IMPCALLS
2379 | DL_DEBUG_SCOPES },
2380 { LEN_AND_STR ("statistics"), "display relocation statistics",
2381 DL_DEBUG_STATISTICS },
2382 { LEN_AND_STR ("unused"), "determined unused DSOs",
2384 { LEN_AND_STR ("help"), "display this help message and exit",
2387 #define ndebopts (sizeof (debopts) / sizeof (debopts[0]))
2389 /* Skip separating white spaces and commas. */
2390 while (*dl_debug != '\0')
2392 if (*dl_debug != ' ' && *dl_debug != ',' && *dl_debug != ':')
2397 while (dl_debug[len] != '\0' && dl_debug[len] != ' '
2398 && dl_debug[len] != ',' && dl_debug[len] != ':')
2401 for (cnt = 0; cnt < ndebopts; ++cnt)
2402 if (debopts[cnt].len == len
2403 && memcmp (dl_debug, debopts[cnt].name, len) == 0)
2405 GLRO(dl_debug_mask) |= debopts[cnt].mask;
2410 if (cnt == ndebopts)
2412 /* Display a warning and skip everything until next
2414 char *copy = strndupa (dl_debug, len);
2415 _dl_error_printf ("\
2416 warning: debug option `%s' unknown; try LD_DEBUG=help\n", copy);
2426 if (GLRO(dl_debug_mask) & DL_DEBUG_UNUSED)
2428 /* In order to get an accurate picture of whether a particular
2429 DT_NEEDED entry is actually used we have to process both
2430 the PLT and non-PLT relocation entries. */
2434 if (GLRO(dl_debug_mask) & DL_DEBUG_HELP)
2439 Valid options for the LD_DEBUG environment variable are:\n\n");
2441 for (cnt = 0; cnt < ndebopts; ++cnt)
2442 _dl_printf (" %.*s%s%s\n", debopts[cnt].len, debopts[cnt].name,
2443 " " + debopts[cnt].len - 3,
2444 debopts[cnt].helptext);
2447 To direct the debugging output into a file instead of standard output\n\
2448 a filename can be specified using the LD_DEBUG_OUTPUT environment variable.\n");
2454 process_dl_audit (char *str)
2456 /* The parameter is a colon separated list of DSO names. */
2459 while ((p = (strsep) (&str, ":")) != NULL)
2461 && (__builtin_expect (! INTUSE(__libc_enable_secure), 1)
2462 || strchr (p, '/') == NULL))
2464 /* This is using the local malloc, not the system malloc. The
2465 memory can never be freed. */
2466 struct audit_list *newp = malloc (sizeof (*newp));
2469 if (audit_list == NULL)
2470 audit_list = newp->next = newp;
2473 newp->next = audit_list->next;
2474 audit_list = audit_list->next = newp;
2479 /* Process all environments variables the dynamic linker must recognize.
2480 Since all of them start with `LD_' we are a bit smarter while finding
2482 extern char **_environ attribute_hidden;
2486 process_envvars (enum mode *modep)
2488 char **runp = _environ;
2490 enum mode mode = normal;
2491 char *debug_output = NULL;
2493 /* This is the default place for profiling data file. */
2494 GLRO(dl_profile_output)
2495 = &"/var/tmp\0/var/profile"[INTUSE(__libc_enable_secure) ? 9 : 0];
2497 while ((envline = _dl_next_ld_env_entry (&runp)) != NULL)
2501 while (envline[len] != '\0' && envline[len] != '=')
2504 if (envline[len] != '=')
2505 /* This is a "LD_" variable at the end of the string without
2506 a '=' character. Ignore it since otherwise we will access
2507 invalid memory below. */
2513 /* Warning level, verbose or not. */
2514 if (memcmp (envline, "WARN", 4) == 0)
2515 GLRO(dl_verbose) = envline[5] != '\0';
2519 /* Debugging of the dynamic linker? */
2520 if (memcmp (envline, "DEBUG", 5) == 0)
2522 process_dl_debug (&envline[6]);
2525 if (memcmp (envline, "AUDIT", 5) == 0)
2526 process_dl_audit (&envline[6]);
2530 /* Print information about versions. */
2531 if (memcmp (envline, "VERBOSE", 7) == 0)
2533 version_info = envline[8] != '\0';
2537 /* List of objects to be preloaded. */
2538 if (memcmp (envline, "PRELOAD", 7) == 0)
2540 preloadlist = &envline[8];
2544 /* Which shared object shall be profiled. */
2545 if (memcmp (envline, "PROFILE", 7) == 0 && envline[8] != '\0')
2546 GLRO(dl_profile) = &envline[8];
2550 /* Do we bind early? */
2551 if (memcmp (envline, "BIND_NOW", 8) == 0)
2553 GLRO(dl_lazy) = envline[9] == '\0';
2556 if (memcmp (envline, "BIND_NOT", 8) == 0)
2557 GLRO(dl_bind_not) = envline[9] != '\0';
2561 /* Test whether we want to see the content of the auxiliary
2562 array passed up from the kernel. */
2563 if (!INTUSE(__libc_enable_secure)
2564 && memcmp (envline, "SHOW_AUXV", 9) == 0)
2569 /* Mask for the important hardware capabilities. */
2570 if (memcmp (envline, "HWCAP_MASK", 10) == 0)
2571 GLRO(dl_hwcap_mask) = __strtoul_internal (&envline[11], NULL,
2576 /* Path where the binary is found. */
2577 if (!INTUSE(__libc_enable_secure)
2578 && memcmp (envline, "ORIGIN_PATH", 11) == 0)
2579 GLRO(dl_origin_path) = &envline[12];
2583 /* The library search path. */
2584 if (memcmp (envline, "LIBRARY_PATH", 12) == 0)
2586 library_path = &envline[13];
2590 /* Where to place the profiling data file. */
2591 if (memcmp (envline, "DEBUG_OUTPUT", 12) == 0)
2593 debug_output = &envline[13];
2597 if (!INTUSE(__libc_enable_secure)
2598 && memcmp (envline, "DYNAMIC_WEAK", 12) == 0)
2599 GLRO(dl_dynamic_weak) = 1;
2603 /* We might have some extra environment variable with length 13
2605 #ifdef EXTRA_LD_ENVVARS_13
2608 if (!INTUSE(__libc_enable_secure)
2609 && memcmp (envline, "USE_LOAD_BIAS", 13) == 0)
2611 GLRO(dl_use_load_bias) = envline[14] == '1' ? -1 : 0;
2615 if (memcmp (envline, "POINTER_GUARD", 13) == 0)
2616 GLRO(dl_pointer_guard) = envline[14] != '0';
2620 /* Where to place the profiling data file. */
2621 if (!INTUSE(__libc_enable_secure)
2622 && memcmp (envline, "PROFILE_OUTPUT", 14) == 0
2623 && envline[15] != '\0')
2624 GLRO(dl_profile_output) = &envline[15];
2628 /* The mode of the dynamic linker can be set. */
2629 if (memcmp (envline, "TRACE_PRELINKING", 16) == 0)
2632 GLRO(dl_verbose) = 1;
2633 GLRO(dl_debug_mask) |= DL_DEBUG_PRELINK;
2634 GLRO(dl_trace_prelink) = &envline[17];
2639 /* The mode of the dynamic linker can be set. */
2640 if (memcmp (envline, "TRACE_LOADED_OBJECTS", 20) == 0)
2644 /* We might have some extra environment variable to handle. This
2645 is tricky due to the pre-processing of the length of the name
2646 in the switch statement here. The code here assumes that added
2647 environment variables have a different length. */
2648 #ifdef EXTRA_LD_ENVVARS
2654 /* The caller wants this information. */
2657 /* Extra security for SUID binaries. Remove all dangerous environment
2659 if (__builtin_expect (INTUSE(__libc_enable_secure), 0))
2661 static const char unsecure_envvars[] =
2662 #ifdef EXTRA_UNSECURE_ENVVARS
2663 EXTRA_UNSECURE_ENVVARS
2668 nextp = unsecure_envvars;
2672 /* We could use rawmemchr but this need not be fast. */
2673 nextp = (char *) (strchr) (nextp, '\0') + 1;
2675 while (*nextp != '\0');
2677 if (__access ("/etc/suid-debug", F_OK) != 0)
2679 unsetenv ("MALLOC_CHECK_");
2680 GLRO(dl_debug_mask) = 0;
2686 /* If we have to run the dynamic linker in debugging mode and the
2687 LD_DEBUG_OUTPUT environment variable is given, we write the debug
2688 messages to this file. */
2689 else if (any_debug && debug_output != NULL)
2692 const int flags = O_WRONLY | O_APPEND | O_CREAT | O_NOFOLLOW;
2694 const int flags = O_WRONLY | O_APPEND | O_CREAT;
2696 size_t name_len = strlen (debug_output);
2697 char buf[name_len + 12];
2700 buf[name_len + 11] = '\0';
2701 startp = _itoa (__getpid (), &buf[name_len + 11], 10, 0);
2703 startp = memcpy (startp - name_len, debug_output, name_len);
2705 GLRO(dl_debug_fd) = __open (startp, flags, DEFFILEMODE);
2706 if (GLRO(dl_debug_fd) == -1)
2707 /* We use standard output if opening the file failed. */
2708 GLRO(dl_debug_fd) = STDOUT_FILENO;
2713 /* Print the various times we collected. */
2715 __attribute ((noinline))
2716 print_statistics (hp_timing_t *rtld_total_timep)
2718 #ifndef HP_TIMING_NONAVAIL
2723 /* Total time rtld used. */
2724 if (HP_TIMING_AVAIL)
2726 HP_TIMING_PRINT (buf, sizeof (buf), *rtld_total_timep);
2727 _dl_debug_printf ("\nruntime linker statistics:\n"
2728 " total startup time in dynamic loader: %s\n", buf);
2730 /* Print relocation statistics. */
2732 HP_TIMING_PRINT (buf, sizeof (buf), relocate_time);
2733 cp = _itoa ((1000ULL * relocate_time) / *rtld_total_timep,
2734 pbuf + sizeof (pbuf), 10, 0);
2736 switch (pbuf + sizeof (pbuf) - cp)
2747 _dl_debug_printf ("\
2748 time needed for relocation: %s (%s%%)\n", buf, pbuf);
2752 unsigned long int num_relative_relocations = 0;
2753 for (Lmid_t ns = 0; ns < GL(dl_nns); ++ns)
2755 if (GL(dl_ns)[ns]._ns_loaded == NULL)
2758 struct r_scope_elem *scope = &GL(dl_ns)[ns]._ns_loaded->l_searchlist;
2760 for (unsigned int i = 0; i < scope->r_nlist; i++)
2762 struct link_map *l = scope->r_list [i];
2764 if (l->l_addr != 0 && l->l_info[VERSYMIDX (DT_RELCOUNT)])
2765 num_relative_relocations
2766 += l->l_info[VERSYMIDX (DT_RELCOUNT)]->d_un.d_val;
2767 #ifndef ELF_MACHINE_REL_RELATIVE
2768 /* Relative relocations are processed on these architectures if
2769 library is loaded to different address than p_vaddr or
2770 if not prelinked. */
2771 if ((l->l_addr != 0 || !l->l_info[VALIDX(DT_GNU_PRELINKED)])
2772 && l->l_info[VERSYMIDX (DT_RELACOUNT)])
2774 /* On e.g. IA-64 or Alpha, relative relocations are processed
2775 only if library is loaded to different address than p_vaddr. */
2776 if (l->l_addr != 0 && l->l_info[VERSYMIDX (DT_RELACOUNT)])
2778 num_relative_relocations
2779 += l->l_info[VERSYMIDX (DT_RELACOUNT)]->d_un.d_val;
2783 _dl_debug_printf (" number of relocations: %lu\n"
2784 " number of relocations from cache: %lu\n"
2785 " number of relative relocations: %lu\n",
2786 GL(dl_num_relocations),
2787 GL(dl_num_cache_relocations),
2788 num_relative_relocations);
2790 #ifndef HP_TIMING_NONAVAIL
2791 /* Time spend while loading the object and the dependencies. */
2792 if (HP_TIMING_AVAIL)
2795 HP_TIMING_PRINT (buf, sizeof (buf), load_time);
2796 cp = _itoa ((1000ULL * load_time) / *rtld_total_timep,
2797 pbuf + sizeof (pbuf), 10, 0);
2799 switch (pbuf + sizeof (pbuf) - cp)
2810 _dl_debug_printf ("\
2811 time needed to load objects: %s (%s%%)\n",