1 /* Run time dynamic linker.
2 Copyright (C) 1995-2023 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 <https://www.gnu.org/licenses/>. */
27 #include <sys/param.h>
32 #include <fpu_control.h>
33 #include <hp-timing.h>
34 #include <libc-lock.h>
35 #include <unsecvars.h>
37 #include <dl-osinfo.h>
38 #include <dl-procinfo.h>
41 #include <dl-vdso-setup.h>
43 #include <stap-probe.h>
44 #include <stackinfo.h>
45 #include <not-cancel.h>
46 #include <array_length.h>
47 #include <libc-early-init.h>
49 #include <gnu/lib-names.h>
50 #include <dl-tunables.h>
51 #include <get-dynamic-info.h>
52 #include <dl-execve.h>
53 #include <dl-find_object.h>
54 #include <dl-audit-check.h>
55 #include <dl-call_tls_init_tp.h>
59 /* This #define produces dynamic linking inline functions for
60 bootstrap relocation instead of general-purpose relocation.
61 Since ld.so must not have any undefined symbols the result
62 is trivial: always the map of ld.so itself. */
63 #define RTLD_BOOTSTRAP
64 #define RESOLVE_MAP(map, scope, sym, version, flags) map
65 #include "dynamic-link.h"
67 /* Must include after <dl-machine.h> for DT_MIPS definition. */
70 /* Only enables rtld profiling for architectures which provides non generic
71 hp-timing support. The generic support requires either syscall
72 (clock_gettime), which will incur in extra overhead on loading time.
73 Using vDSO is also an option, but it will require extra support on loader
74 to setup the vDSO pointer before its usage. */
76 # define RLTD_TIMING_DECLARE(var, classifier,...) \
77 classifier hp_timing_t var __VA_ARGS__
78 # define RTLD_TIMING_VAR(var) RLTD_TIMING_DECLARE (var, )
79 # define RTLD_TIMING_SET(var, value) (var) = (value)
80 # define RTLD_TIMING_REF(var) &(var)
83 rtld_timer_start (hp_timing_t *var)
89 rtld_timer_stop (hp_timing_t *var, hp_timing_t start)
93 HP_TIMING_DIFF (*var, start, stop);
97 rtld_timer_accum (hp_timing_t *sum, hp_timing_t start)
100 rtld_timer_stop (&stop, start);
101 HP_TIMING_ACCUM_NT(*sum, stop);
104 # define RLTD_TIMING_DECLARE(var, classifier...)
105 # define RTLD_TIMING_SET(var, value)
106 # define RTLD_TIMING_VAR(var)
107 # define RTLD_TIMING_REF(var) 0
108 # define rtld_timer_start(var)
109 # define rtld_timer_stop(var, start)
110 # define rtld_timer_accum(sum, start)
113 /* Avoid PLT use for our local calls at startup. */
114 extern __typeof (__mempcpy) __mempcpy attribute_hidden;
116 /* GCC has mental blocks about _exit. */
117 extern __typeof (_exit) exit_internal asm ("_exit") attribute_hidden;
118 #define _exit exit_internal
120 /* Helper function to handle errors while resolving symbols. */
121 static void print_unresolved (int errcode, const char *objname,
122 const char *errsting);
124 /* Helper function to handle errors when a version is missing. */
125 static void print_missing_version (int errcode, const char *objname,
126 const char *errsting);
128 /* Print the various times we collected. */
129 static void print_statistics (const hp_timing_t *total_timep);
131 /* Creates an empty audit list. */
132 static void audit_list_init (struct audit_list *);
134 /* Add a string to the end of the audit list, for later parsing. Must
135 not be called after audit_list_next. */
136 static void audit_list_add_string (struct audit_list *, const char *);
138 /* Add the audit strings from the link map, found in the dynamic
139 segment at TG (either DT_AUDIT and DT_DEPAUDIT). Must be called
140 before audit_list_next. */
141 static void audit_list_add_dynamic_tag (struct audit_list *,
145 /* Extract the next audit module from the audit list. Only modules
146 for which dso_name_valid_for_suid is true are returned. Must be
147 called after all the audit_list_add_string,
148 audit_list_add_dynamic_tags calls. */
149 static const char *audit_list_next (struct audit_list *);
151 /* Initialize *STATE with the defaults. */
152 static void dl_main_state_init (struct dl_main_state *state);
154 /* Process all environments variables the dynamic linker must recognize.
155 Since all of them start with `LD_' we are a bit smarter while finding
157 extern char **_environ attribute_hidden;
158 static void process_envvars (struct dl_main_state *state);
160 int _dl_argc attribute_relro attribute_hidden;
161 char **_dl_argv attribute_relro = NULL;
162 rtld_hidden_data_def (_dl_argv)
164 #ifndef THREAD_SET_STACK_GUARD
165 /* Only exported for architectures that don't store the stack guard canary
166 in thread local area. */
167 uintptr_t __stack_chk_guard attribute_relro;
170 /* Only exported for architectures that don't store the pointer guard
171 value in thread local area. */
172 uintptr_t __pointer_chk_guard_local attribute_relro attribute_hidden;
173 #ifndef THREAD_SET_POINTER_GUARD
174 strong_alias (__pointer_chk_guard_local, __pointer_chk_guard)
177 /* Check that AT_SECURE=0, or that the passed name does not contain
178 directories and is not overly long. Reject empty names
181 dso_name_valid_for_suid (const char *p)
183 if (__glibc_unlikely (__libc_enable_secure))
185 /* Ignore pathnames with directories for AT_SECURE=1
186 programs, and also skip overlong names. */
187 size_t len = strlen (p);
188 if (len >= SECURE_NAME_LIMIT || memchr (p, '/', len) != NULL)
195 audit_list_init (struct audit_list *list)
198 list->current_index = 0;
199 list->current_tail = NULL;
203 audit_list_add_string (struct audit_list *list, const char *string)
205 /* Empty strings do not load anything. */
209 if (list->length == array_length (list->audit_strings))
210 _dl_fatal_printf ("Fatal glibc error: Too many audit modules requested\n");
212 list->audit_strings[list->length++] = string;
214 /* Initialize processing of the first string for
216 if (list->length == 1)
217 list->current_tail = string;
221 audit_list_add_dynamic_tag (struct audit_list *list, struct link_map *main_map,
224 ElfW(Dyn) *info = main_map->l_info[ADDRIDX (tag)];
225 const char *strtab = (const char *) D_PTR (main_map, l_info[DT_STRTAB]);
227 audit_list_add_string (list, strtab + info->d_un.d_val);
231 audit_list_next (struct audit_list *list)
233 if (list->current_tail == NULL)
238 /* Advance to the next string in audit_strings if the current
239 string has been exhausted. */
240 while (*list->current_tail == '\0')
242 ++list->current_index;
243 if (list->current_index == list->length)
245 list->current_tail = NULL;
248 list->current_tail = list->audit_strings[list->current_index];
251 /* Split the in-string audit list at the next colon colon. */
252 size_t len = strcspn (list->current_tail, ":");
253 if (len > 0 && len < sizeof (list->fname))
255 memcpy (list->fname, list->current_tail, len);
256 list->fname[len] = '\0';
259 /* Mark the name as unusable for dso_name_valid_for_suid. */
260 list->fname[0] = '\0';
262 /* Skip over the substring and the following delimiter. */
263 list->current_tail += len;
264 if (*list->current_tail == ':')
265 ++list->current_tail;
267 /* If the name is valid, return it. */
268 if (dso_name_valid_for_suid (list->fname))
271 /* Otherwise wrap around to find the next list element. . */
275 /* Count audit modules before they are loaded so GLRO(dl_naudit)
276 is not yet usable. */
278 audit_list_count (struct audit_list *list)
280 /* Restore the audit_list iterator state at the end. */
281 const char *saved_tail = list->current_tail;
284 assert (list->current_index == 0);
285 while (audit_list_next (list) != NULL)
287 list->current_tail = saved_tail;
288 list->current_index = 0;
293 dl_main_state_init (struct dl_main_state *state)
295 audit_list_init (&state->audit_list);
296 state->library_path = NULL;
297 state->library_path_source = NULL;
298 state->preloadlist = NULL;
299 state->preloadarg = NULL;
300 state->glibc_hwcaps_prepend = NULL;
301 state->glibc_hwcaps_mask = NULL;
302 state->mode = rtld_mode_normal;
303 state->any_debug = false;
304 state->version_info = false;
307 #ifndef HAVE_INLINED_SYSCALLS
308 /* Set nonzero during loading and initialization of executable and
309 libraries, cleared before the executable's entry point runs. This
310 must not be initialized to nonzero, because the unused dynamic
311 linker loaded in for libc.so's "ld.so.1" dep will provide the
312 definition seen by libc.so's initializer; that value must be zero,
313 and will be since that dynamic linker's _dl_start and dl_main will
315 int _dl_starting_up = 0;
316 rtld_hidden_def (_dl_starting_up)
319 /* This is the structure which defines all variables global to ld.so
320 (except those which cannot be added for some reason). */
321 struct rtld_global _rtld_global =
323 /* Get architecture specific initializer. */
324 #include <dl-procruntime.c>
325 /* Generally the default presumption without further information is an
326 * executable stack but this is not true for all platforms. */
327 ._dl_stack_flags = DEFAULT_STACK_PERMS,
328 #ifdef _LIBC_REENTRANT
329 ._dl_load_lock = _RTLD_LOCK_RECURSIVE_INITIALIZER,
330 ._dl_load_write_lock = _RTLD_LOCK_RECURSIVE_INITIALIZER,
331 ._dl_load_tls_lock = _RTLD_LOCK_RECURSIVE_INITIALIZER,
336 #ifdef _LIBC_REENTRANT
337 [LM_ID_BASE] = { ._ns_unique_sym_table
338 = { .lock = _RTLD_LOCK_RECURSIVE_INITIALIZER } }
342 /* If we would use strong_alias here the compiler would see a
343 non-hidden definition. This would undo the effect of the previous
344 declaration. So spell out what strong_alias does plus add the
345 visibility attribute. */
346 extern struct rtld_global _rtld_local
347 __attribute__ ((alias ("_rtld_global"), visibility ("hidden")));
350 /* This variable is similar to _rtld_local, but all values are
351 read-only after relocation. */
352 struct rtld_global_ro _rtld_global_ro attribute_relro =
354 /* Get architecture specific initializer. */
355 #include <dl-procinfo.c>
356 #ifdef NEED_DL_SYSINFO
357 ._dl_sysinfo = DL_SYSINFO_DEFAULT,
359 ._dl_debug_fd = STDERR_FILENO,
361 ._dl_fpu_control = _FPU_DEFAULT,
362 ._dl_pagesize = EXEC_PAGESIZE,
363 ._dl_inhibit_cache = 0,
365 /* Function pointers. */
366 ._dl_debug_printf = _dl_debug_printf,
367 ._dl_mcount = _dl_mcount,
368 ._dl_lookup_symbol_x = _dl_lookup_symbol_x,
369 ._dl_open = _dl_open,
370 ._dl_close = _dl_close,
371 ._dl_catch_error = _dl_catch_error,
372 ._dl_error_free = _dl_error_free,
373 ._dl_tls_get_addr_soft = _dl_tls_get_addr_soft,
374 ._dl_libc_freeres = __rtld_libc_freeres,
376 /* If we would use strong_alias here the compiler would see a
377 non-hidden definition. This would undo the effect of the previous
378 declaration. So spell out was strong_alias does plus add the
379 visibility attribute. */
380 extern struct rtld_global_ro _rtld_local_ro
381 __attribute__ ((alias ("_rtld_global_ro"), visibility ("hidden")));
384 static void dl_main (const ElfW(Phdr) *phdr, ElfW(Word) phnum,
385 ElfW(Addr) *user_entry, ElfW(auxv_t) *auxv);
387 /* These two variables cannot be moved into .data.rel.ro. */
388 static struct libname_list _dl_rtld_libname;
389 static struct libname_list _dl_rtld_libname2;
391 /* Variable for statistics. */
392 RLTD_TIMING_DECLARE (relocate_time, static);
393 RLTD_TIMING_DECLARE (load_time, static, attribute_relro);
394 RLTD_TIMING_DECLARE (start_time, static, attribute_relro);
396 /* Additional definitions needed by TLS initialization. */
397 #ifdef TLS_INIT_HELPER
401 /* Helper function for syscall implementation. */
402 #ifdef DL_SYSINFO_IMPLEMENTATION
403 DL_SYSINFO_IMPLEMENTATION
406 /* Before ld.so is relocated we must not access variables which need
407 relocations. This means variables which are exported. Variables
408 declared as static are fine. If we can mark a variable hidden this
409 is fine, too. The latter is important here. We can avoid setting
410 up a temporary link map for ld.so if we can mark _rtld_global as
412 #ifndef HIDDEN_VAR_NEEDS_DYNAMIC_RELOC
413 # define DONT_USE_BOOTSTRAP_MAP 1
416 #ifdef DONT_USE_BOOTSTRAP_MAP
417 static ElfW(Addr) _dl_start_final (void *arg);
419 struct dl_start_final_info
422 RTLD_TIMING_VAR (start_time);
424 static ElfW(Addr) _dl_start_final (void *arg,
425 struct dl_start_final_info *info);
428 /* These are defined magically by the linker. */
429 extern const ElfW(Ehdr) __ehdr_start attribute_hidden;
430 extern char _etext[] attribute_hidden;
431 extern char _end[] attribute_hidden;
437 # error "sysdeps/MACHINE/dl-machine.h fails to define RTLD_START"
440 /* This is the second half of _dl_start (below). It can be inlined safely
441 under DONT_USE_BOOTSTRAP_MAP, where it is careful not to make any GOT
442 references. When the tools don't permit us to avoid using a GOT entry
443 for _dl_rtld_global (no attribute_hidden support), we must make sure
444 this function is not inlined (see below). */
446 #ifdef DONT_USE_BOOTSTRAP_MAP
447 static inline ElfW(Addr) __attribute__ ((always_inline))
448 _dl_start_final (void *arg)
450 static ElfW(Addr) __attribute__ ((noinline))
451 _dl_start_final (void *arg, struct dl_start_final_info *info)
454 ElfW(Addr) start_addr;
456 /* Do not use an initializer for these members because it would
457 interfere with __rtld_static_init. */
458 GLRO (dl_find_object) = &_dl_find_object;
460 /* If it hasn't happen yet record the startup time. */
461 rtld_timer_start (&start_time);
462 #if !defined DONT_USE_BOOTSTRAP_MAP
463 RTLD_TIMING_SET (start_time, info->start_time);
466 /* Transfer data about ourselves to the permanent link_map structure. */
467 #ifndef DONT_USE_BOOTSTRAP_MAP
468 GL(dl_rtld_map).l_addr = info->l.l_addr;
469 GL(dl_rtld_map).l_ld = info->l.l_ld;
470 GL(dl_rtld_map).l_ld_readonly = info->l.l_ld_readonly;
471 memcpy (GL(dl_rtld_map).l_info, info->l.l_info,
472 sizeof GL(dl_rtld_map).l_info);
473 GL(dl_rtld_map).l_mach = info->l.l_mach;
474 GL(dl_rtld_map).l_relocated = 1;
476 _dl_setup_hash (&GL(dl_rtld_map));
477 GL(dl_rtld_map).l_real = &GL(dl_rtld_map);
478 GL(dl_rtld_map).l_map_start = (ElfW(Addr)) &__ehdr_start;
479 GL(dl_rtld_map).l_map_end = (ElfW(Addr)) _end;
480 GL(dl_rtld_map).l_text_end = (ElfW(Addr)) _etext;
481 /* Copy the TLS related data if necessary. */
482 #ifndef DONT_USE_BOOTSTRAP_MAP
483 # if NO_TLS_OFFSET != 0
484 GL(dl_rtld_map).l_tls_offset = NO_TLS_OFFSET;
488 /* Initialize the stack end variable. */
489 __libc_stack_end = __builtin_frame_address (0);
491 /* Call the OS-dependent function to set up life so we can do things like
492 file access. It will call `dl_main' (below) to do all the real work
493 of the dynamic linker, and then unwind our frame and run the user
494 entry point on the same stack we entered on. */
495 start_addr = _dl_sysdep_start (arg, &dl_main);
497 if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_STATISTICS))
499 RTLD_TIMING_VAR (rtld_total_time);
500 rtld_timer_stop (&rtld_total_time, start_time);
501 print_statistics (RTLD_TIMING_REF(rtld_total_time));
504 #ifndef ELF_MACHINE_START_ADDRESS
505 # define ELF_MACHINE_START_ADDRESS(map, start) (start)
507 return ELF_MACHINE_START_ADDRESS (GL(dl_ns)[LM_ID_BASE]._ns_loaded, start_addr);
510 #ifdef DONT_USE_BOOTSTRAP_MAP
511 # define bootstrap_map GL(dl_rtld_map)
513 # define bootstrap_map info.l
516 static ElfW(Addr) __attribute_used__
517 _dl_start (void *arg)
519 #ifdef DONT_USE_BOOTSTRAP_MAP
520 rtld_timer_start (&start_time);
522 struct dl_start_final_info info;
523 rtld_timer_start (&info.start_time);
526 /* Partly clean the `bootstrap_map' structure up. Don't use
527 `memset' since it might not be built in or inlined and we cannot
528 make function calls at this point. Use '__builtin_memset' if we
529 know it is available. We do not have to clear the memory if we
530 do not have to use the temporary bootstrap_map. Global variables
531 are initialized to zero by default. */
532 #ifndef DONT_USE_BOOTSTRAP_MAP
533 # ifdef HAVE_BUILTIN_MEMSET
534 __builtin_memset (bootstrap_map.l_info, '\0', sizeof (bootstrap_map.l_info));
537 cnt < sizeof (bootstrap_map.l_info) / sizeof (bootstrap_map.l_info[0]);
539 bootstrap_map.l_info[cnt] = 0;
543 /* Figure out the run-time load address of the dynamic linker itself. */
544 bootstrap_map.l_addr = elf_machine_load_address ();
546 /* Read our own dynamic section and fill in the info array. */
547 bootstrap_map.l_ld = (void *) bootstrap_map.l_addr + elf_machine_dynamic ();
548 bootstrap_map.l_ld_readonly = DL_RO_DYN_SECTION;
549 elf_get_dynamic_info (&bootstrap_map, true, false);
551 #if NO_TLS_OFFSET != 0
552 bootstrap_map.l_tls_offset = NO_TLS_OFFSET;
555 #ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
556 ELF_MACHINE_BEFORE_RTLD_RELOC (&bootstrap_map, bootstrap_map.l_info);
559 if (bootstrap_map.l_addr)
561 /* Relocate ourselves so we can do normal function calls and
562 data access using the global offset table. */
564 ELF_DYNAMIC_RELOCATE (&bootstrap_map, NULL, 0, 0, 0);
566 bootstrap_map.l_relocated = 1;
568 /* Please note that we don't allow profiling of this object and
569 therefore need not test whether we have to allocate the array
570 for the relocation results (as done in dl-reloc.c). */
572 /* Now life is sane; we can call functions and access global data.
573 Set up to use the operating system facilities, and find out from
574 the operating system's program loader where to find the program
575 header table in core. Put the rest of _dl_start into a separate
576 function, that way the compiler cannot put accesses to the GOT
577 before ELF_DYNAMIC_RELOCATE. */
579 __rtld_malloc_init_stubs ();
581 #ifdef DONT_USE_BOOTSTRAP_MAP
582 return _dl_start_final (arg);
584 return _dl_start_final (arg, &info);
590 /* Now life is peachy; we can do all normal operations.
591 On to the real work. */
593 /* Some helper functions. */
595 /* Arguments to relocate_doit. */
604 /* Argument to map_doit. */
606 struct link_map *loader;
608 /* Return value of map_doit. */
609 struct link_map *map;
615 struct link_map *map;
621 struct link_map *map;
625 /* Arguments to version_check_doit. */
626 struct version_check_args
633 relocate_doit (void *a)
635 struct relocate_args *args = (struct relocate_args *) a;
637 _dl_relocate_object (args->l, args->l->l_scope, args->reloc_mode, 0);
643 struct map_args *args = (struct map_args *) a;
644 int type = (args->mode == __RTLD_OPENEXEC) ? lt_executable : lt_library;
645 args->map = _dl_map_object (args->loader, args->str, type, 0,
646 args->mode, LM_ID_BASE);
650 dlmopen_doit (void *a)
652 struct dlmopen_args *args = (struct dlmopen_args *) a;
653 args->map = _dl_open (args->fname,
654 (RTLD_LAZY | __RTLD_DLOPEN | __RTLD_AUDIT
656 dl_main, LM_ID_NEWLM, _dl_argc, _dl_argv,
661 lookup_doit (void *a)
663 struct lookup_args *args = (struct lookup_args *) a;
664 const ElfW(Sym) *ref = NULL;
666 lookup_t l = _dl_lookup_symbol_x (args->name, args->map, &ref,
667 args->map->l_local_scope, NULL, 0,
668 DL_LOOKUP_RETURN_NEWEST, NULL);
670 args->result = DL_SYMBOL_ADDRESS (l, ref);
674 version_check_doit (void *a)
676 struct version_check_args *args = (struct version_check_args *) a;
677 if (_dl_check_all_versions (GL(dl_ns)[LM_ID_BASE]._ns_loaded, 1,
678 args->dotrace) && args->doexit)
679 /* We cannot start the application. Abort now. */
684 static inline struct link_map *
685 find_needed (const char *name)
687 struct r_scope_elem *scope = &GL(dl_ns)[LM_ID_BASE]._ns_loaded->l_searchlist;
688 unsigned int n = scope->r_nlist;
691 if (_dl_name_match_p (name, scope->r_list[n]))
692 return scope->r_list[n];
694 /* Should never happen. */
699 match_version (const char *string, struct link_map *map)
701 const char *strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
704 #define VERDEFTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERDEF))
705 if (map->l_info[VERDEFTAG] == NULL)
706 /* The file has no symbol versioning. */
709 def = (ElfW(Verdef) *) ((char *) map->l_addr
710 + map->l_info[VERDEFTAG]->d_un.d_ptr);
713 ElfW(Verdaux) *aux = (ElfW(Verdaux) *) ((char *) def + def->vd_aux);
715 /* Compare the version strings. */
716 if (strcmp (string, strtab + aux->vda_name) == 0)
720 /* If no more definitions we failed to find what we want. */
721 if (def->vd_next == 0)
724 /* Next definition. */
725 def = (ElfW(Verdef) *) ((char *) def + def->vd_next);
731 bool __rtld_tls_init_tp_called;
734 init_tls (size_t naudit)
736 /* Number of elements in the static TLS block. */
737 GL(dl_tls_static_nelem) = GL(dl_tls_max_dtv_idx);
739 /* Do not do this twice. The audit interface might have required
740 the DTV interfaces to be set up early. */
741 if (GL(dl_initial_dtv) != NULL)
744 /* Allocate the array which contains the information about the
745 dtv slots. We allocate a few entries more than needed to
746 avoid the need for reallocation. */
747 size_t nelem = GL(dl_tls_max_dtv_idx) + 1 + TLS_SLOTINFO_SURPLUS;
750 GL(dl_tls_dtv_slotinfo_list) = (struct dtv_slotinfo_list *)
751 calloc (sizeof (struct dtv_slotinfo_list)
752 + nelem * sizeof (struct dtv_slotinfo), 1);
753 /* No need to check the return value. If memory allocation failed
754 the program would have been terminated. */
756 struct dtv_slotinfo *slotinfo = GL(dl_tls_dtv_slotinfo_list)->slotinfo;
757 GL(dl_tls_dtv_slotinfo_list)->len = nelem;
758 GL(dl_tls_dtv_slotinfo_list)->next = NULL;
760 /* Fill in the information from the loaded modules. No namespace
761 but the base one can be filled at this time. */
762 assert (GL(dl_ns)[LM_ID_BASE + 1]._ns_loaded == NULL);
764 for (struct link_map *l = GL(dl_ns)[LM_ID_BASE]._ns_loaded; l != NULL;
766 if (l->l_tls_blocksize != 0)
768 /* This is a module with TLS data. Store the map reference.
769 The generation counter is zero. */
771 /* slotinfo[i].gen = 0; */
774 assert (i == GL(dl_tls_max_dtv_idx));
776 /* Calculate the size of the static TLS surplus. */
777 _dl_tls_static_surplus_init (naudit);
779 /* Compute the TLS offsets for the various blocks. */
780 _dl_determine_tlsoffset ();
782 /* Construct the static TLS block and the dtv for the initial
783 thread. For some platforms this will include allocating memory
784 for the thread descriptor. The memory for the TLS block will
785 never be freed. It should be allocated accordingly. The dtv
786 array can be changed if dynamic loading requires it. */
787 void *tcbp = _dl_allocate_tls_storage ();
790 cannot allocate TLS data structures for initial thread\n");
792 /* Store for detection of the special case by __tls_get_addr
793 so it knows not to pass this dtv to the normal realloc. */
794 GL(dl_initial_dtv) = GET_DTV (tcbp);
796 /* And finally install it for the main thread. */
797 call_tls_init_tp (tcbp);
798 __rtld_tls_init_tp_called = true;
804 do_preload (const char *fname, struct link_map *main_map, const char *where)
807 const char *err_str = NULL;
808 struct map_args args;
812 args.loader = main_map;
813 args.mode = __RTLD_SECURE;
815 unsigned int old_nloaded = GL(dl_ns)[LM_ID_BASE]._ns_nloaded;
817 (void) _dl_catch_error (&objname, &err_str, &malloced, map_doit, &args);
818 if (__glibc_unlikely (err_str != NULL))
821 ERROR: ld.so: object '%s' from %s cannot be preloaded (%s): ignored.\n",
822 fname, where, err_str);
823 /* No need to call free, this is still before
824 the libc's malloc is used. */
826 else if (GL(dl_ns)[LM_ID_BASE]._ns_nloaded != old_nloaded)
827 /* It is no duplicate. */
830 /* Nothing loaded. */
837 /* Set up the stack checker's canary. */
838 uintptr_t stack_chk_guard = _dl_setup_stack_chk_guard (_dl_random);
839 #ifdef THREAD_SET_STACK_GUARD
840 THREAD_SET_STACK_GUARD (stack_chk_guard);
842 __stack_chk_guard = stack_chk_guard;
845 /* Set up the pointer guard as well, if necessary. */
846 uintptr_t pointer_chk_guard
847 = _dl_setup_pointer_guard (_dl_random, stack_chk_guard);
848 #ifdef THREAD_SET_POINTER_GUARD
849 THREAD_SET_POINTER_GUARD (pointer_chk_guard);
851 __pointer_chk_guard_local = pointer_chk_guard;
853 /* We do not need the _dl_random value anymore. The less
854 information we leave behind, the better, so clear the
859 #include <setup-vdso.h>
861 /* The LD_PRELOAD environment variable gives list of libraries
862 separated by white space or colons that are loaded before the
863 executable's dependencies and prepended to the global scope list.
864 (If the binary is running setuid all elements containing a '/' are
865 ignored since it is insecure.) Return the number of preloads
866 performed. Ditto for --preload command argument. */
868 handle_preload_list (const char *preloadlist, struct link_map *main_map,
871 unsigned int npreloads = 0;
872 const char *p = preloadlist;
873 char fname[SECURE_PATH_LIMIT];
877 /* Split preload list at space/colon. */
878 size_t len = strcspn (p, " :");
879 if (len > 0 && len < sizeof (fname))
881 memcpy (fname, p, len);
887 /* Skip over the substring and the following delimiter. */
892 if (dso_name_valid_for_suid (fname))
893 npreloads += do_preload (fname, main_map, where);
898 /* Called if the audit DSO cannot be used: if it does not have the
899 appropriate interfaces, or it expects a more recent version library
900 version than what the dynamic linker provides. */
902 unload_audit_module (struct link_map *map, int original_tls_idx)
905 Lmid_t ns = map->l_ns;
909 /* Make sure the namespace has been cleared entirely. */
910 assert (GL(dl_ns)[ns]._ns_loaded == NULL);
911 assert (GL(dl_ns)[ns]._ns_nloaded == 0);
913 GL(dl_tls_max_dtv_idx) = original_tls_idx;
916 /* Called to print an error message if loading of an audit module
919 report_audit_module_load_error (const char *name, const char *err_str,
923 ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n",
926 free ((char *) err_str);
929 /* Load one audit module. */
931 load_audit_module (const char *name, struct audit_ifaces **last_audit)
933 int original_tls_idx = GL(dl_tls_max_dtv_idx);
935 struct dlmopen_args dlmargs;
936 dlmargs.fname = name;
940 const char *err_str = NULL;
942 _dl_catch_error (&objname, &err_str, &malloced, dlmopen_doit, &dlmargs);
943 if (__glibc_unlikely (err_str != NULL))
945 report_audit_module_load_error (name, err_str, malloced);
949 struct lookup_args largs;
950 largs.name = "la_version";
951 largs.map = dlmargs.map;
952 _dl_catch_error (&objname, &err_str, &malloced, lookup_doit, &largs);
953 if (__glibc_likely (err_str != NULL))
955 unload_audit_module (dlmargs.map, original_tls_idx);
956 report_audit_module_load_error (name, err_str, malloced);
960 unsigned int (*laversion) (unsigned int) = largs.result;
962 /* A null symbol indicates that something is very wrong with the
963 loaded object because defined symbols are supposed to have a
964 valid, non-null address. */
965 assert (laversion != NULL);
967 unsigned int lav = laversion (LAV_CURRENT);
970 /* Only print an error message if debugging because this can
971 happen deliberately. */
972 if (GLRO(dl_debug_mask) & DL_DEBUG_FILES)
974 file=%s [%lu]; audit interface function la_version returned zero; ignored.\n",
975 dlmargs.map->l_name, dlmargs.map->l_ns);
976 unload_audit_module (dlmargs.map, original_tls_idx);
980 if (!_dl_audit_check_version (lav))
983 ERROR: audit interface '%s' requires version %d (maximum supported version %d); ignored.\n",
984 name, lav, LAV_CURRENT);
985 unload_audit_module (dlmargs.map, original_tls_idx);
989 enum { naudit_ifaces = 8 };
992 struct audit_ifaces ifaces;
993 void (*fptr[naudit_ifaces]) (void);
994 } *newp = malloc (sizeof (*newp));
996 _dl_fatal_printf ("Out of memory while loading audit modules\n");
998 /* Names of the auditing interfaces. All in one
1000 static const char audit_iface_names[] =
1006 #define STRING(s) __STRING (s)
1007 "la_" STRING (ARCH_LA_PLTENTER) "\0"
1008 "la_" STRING (ARCH_LA_PLTEXIT) "\0"
1010 unsigned int cnt = 0;
1011 const char *cp = audit_iface_names;
1015 _dl_catch_error (&objname, &err_str, &malloced, lookup_doit, &largs);
1017 /* Store the pointer. */
1018 if (err_str == NULL && largs.result != NULL)
1019 newp->fptr[cnt] = largs.result;
1021 newp->fptr[cnt] = NULL;
1024 cp = strchr (cp, '\0') + 1;
1026 while (*cp != '\0');
1027 assert (cnt == naudit_ifaces);
1029 /* Now append the new auditing interface to the list. */
1030 newp->ifaces.next = NULL;
1031 if (*last_audit == NULL)
1032 *last_audit = GLRO(dl_audit) = &newp->ifaces;
1034 *last_audit = (*last_audit)->next = &newp->ifaces;
1036 /* The dynamic linker link map is statically allocated, so the
1037 cookie in _dl_new_object has not happened. */
1038 link_map_audit_state (&GL (dl_rtld_map), GLRO (dl_naudit))->cookie
1039 = (intptr_t) &GL (dl_rtld_map);
1043 /* Mark the DSO as being used for auditing. */
1044 dlmargs.map->l_auditing = 1;
1047 /* Load all audit modules. */
1049 load_audit_modules (struct link_map *main_map, struct audit_list *audit_list)
1051 struct audit_ifaces *last_audit = NULL;
1055 const char *name = audit_list_next (audit_list);
1058 load_audit_module (name, &last_audit);
1061 /* Notify audit modules of the initially loaded modules (the main
1062 program and the dynamic linker itself). */
1063 if (GLRO(dl_naudit) > 0)
1065 _dl_audit_objopen (main_map, LM_ID_BASE);
1066 _dl_audit_objopen (&GL(dl_rtld_map), LM_ID_BASE);
1070 /* Check if the executable is not actually dynamically linked, and
1071 invoke it directly in that case. */
1073 rtld_chain_load (struct link_map *main_map, char *argv0)
1075 /* The dynamic loader run against itself. */
1076 const char *rtld_soname
1077 = ((const char *) D_PTR (&GL(dl_rtld_map), l_info[DT_STRTAB])
1078 + GL(dl_rtld_map).l_info[DT_SONAME]->d_un.d_val);
1079 if (main_map->l_info[DT_SONAME] != NULL
1080 && strcmp (rtld_soname,
1081 ((const char *) D_PTR (main_map, l_info[DT_STRTAB])
1082 + main_map->l_info[DT_SONAME]->d_un.d_val)) == 0)
1083 _dl_fatal_printf ("%s: loader cannot load itself\n", rtld_soname);
1085 /* With DT_NEEDED dependencies, the executable is dynamically
1087 if (__glibc_unlikely (main_map->l_info[DT_NEEDED] != NULL))
1090 /* If the executable has program interpreter, it is dynamically
1092 for (size_t i = 0; i < main_map->l_phnum; ++i)
1093 if (main_map->l_phdr[i].p_type == PT_INTERP)
1096 const char *pathname = _dl_argv[0];
1098 _dl_argv[0] = argv0;
1099 int errcode = __rtld_execve (pathname, _dl_argv, _environ);
1100 const char *errname = strerrorname_np (errcode);
1101 if (errname != NULL)
1102 _dl_fatal_printf("%s: cannot execute %s: %s\n",
1103 rtld_soname, pathname, errname);
1105 _dl_fatal_printf("%s: cannot execute %s: %d\n",
1106 rtld_soname, pathname, errcode);
1109 /* Called to complete the initialization of the link map for the main
1110 executable. Returns true if there is a PT_INTERP segment. */
1112 rtld_setup_main_map (struct link_map *main_map)
1114 /* This have already been filled in right after _dl_new_object, or
1115 as part of _dl_map_object. */
1116 const ElfW(Phdr) *phdr = main_map->l_phdr;
1117 ElfW(Word) phnum = main_map->l_phnum;
1119 bool has_interp = false;
1121 main_map->l_map_end = 0;
1122 main_map->l_text_end = 0;
1123 /* Perhaps the executable has no PT_LOAD header entries at all. */
1124 main_map->l_map_start = ~0;
1125 /* And it was opened directly. */
1126 ++main_map->l_direct_opencount;
1127 main_map->l_contiguous = 1;
1129 /* A PT_LOAD segment at an unexpected address will clear the
1130 l_contiguous flag. The ELF specification says that PT_LOAD
1131 segments need to be sorted in in increasing order, but perhaps
1132 not all executables follow this requirement. Having l_contiguous
1133 equal to 1 is just an optimization, so the code below does not
1134 try to sort the segments in case they are unordered.
1136 There is one corner case in which l_contiguous is not set to 1,
1137 but where it could be set: If a PIE (ET_DYN) binary is loaded by
1138 glibc itself (not the kernel), it is always contiguous due to the
1139 way the glibc loader works. However, the kernel loader may still
1140 create holes in this case, and the code here still uses 0
1141 conservatively for the glibc-loaded case, too. */
1142 ElfW(Addr) expected_load_address = 0;
1144 /* Scan the program header table for the dynamic section. */
1145 for (const ElfW(Phdr) *ph = phdr; ph < &phdr[phnum]; ++ph)
1149 /* Find out the load address. */
1150 main_map->l_addr = (ElfW(Addr)) phdr - ph->p_vaddr;
1153 /* This tells us where to find the dynamic section,
1154 which tells us everything we need to do. */
1155 main_map->l_ld = (void *) main_map->l_addr + ph->p_vaddr;
1156 main_map->l_ld_readonly = (ph->p_flags & PF_W) == 0;
1159 /* This "interpreter segment" was used by the program loader to
1160 find the program interpreter, which is this program itself, the
1161 dynamic linker. We note what name finds us, so that a future
1162 dlopen call or DT_NEEDED entry, for something that wants to link
1163 against the dynamic linker as a shared library, will know that
1164 the shared object is already loaded. */
1165 _dl_rtld_libname.name = ((const char *) main_map->l_addr
1167 /* _dl_rtld_libname.next = NULL; Already zero. */
1168 GL(dl_rtld_map).l_libname = &_dl_rtld_libname;
1170 /* Ordinarily, we would get additional names for the loader from
1171 our DT_SONAME. This can't happen if we were actually linked as
1172 a static executable (detect this case when we have no DYNAMIC).
1173 If so, assume the filename component of the interpreter path to
1174 be our SONAME, and add it to our name list. */
1175 if (GL(dl_rtld_map).l_ld == NULL)
1177 const char *p = NULL;
1178 const char *cp = _dl_rtld_libname.name;
1180 /* Find the filename part of the path. */
1187 _dl_rtld_libname2.name = p;
1188 /* _dl_rtld_libname2.next = NULL; Already zero. */
1189 _dl_rtld_libname.next = &_dl_rtld_libname2;
1197 ElfW(Addr) mapstart;
1198 ElfW(Addr) allocend;
1200 /* Remember where the main program starts in memory. */
1201 mapstart = (main_map->l_addr
1202 + (ph->p_vaddr & ~(GLRO(dl_pagesize) - 1)));
1203 if (main_map->l_map_start > mapstart)
1204 main_map->l_map_start = mapstart;
1206 if (main_map->l_contiguous && expected_load_address != 0
1207 && expected_load_address != mapstart)
1208 main_map->l_contiguous = 0;
1210 /* Also where it ends. */
1211 allocend = main_map->l_addr + ph->p_vaddr + ph->p_memsz;
1212 if (main_map->l_map_end < allocend)
1213 main_map->l_map_end = allocend;
1214 if ((ph->p_flags & PF_X) && allocend > main_map->l_text_end)
1215 main_map->l_text_end = allocend;
1217 /* The next expected address is the page following this load
1219 expected_load_address = ((allocend + GLRO(dl_pagesize) - 1)
1220 & ~(GLRO(dl_pagesize) - 1));
1225 if (ph->p_memsz > 0)
1227 /* Note that in the case the dynamic linker we duplicate work
1228 here since we read the PT_TLS entry already in
1229 _dl_start_final. But the result is repeatable so do not
1230 check for this special but unimportant case. */
1231 main_map->l_tls_blocksize = ph->p_memsz;
1232 main_map->l_tls_align = ph->p_align;
1233 if (ph->p_align == 0)
1234 main_map->l_tls_firstbyte_offset = 0;
1236 main_map->l_tls_firstbyte_offset = (ph->p_vaddr
1237 & (ph->p_align - 1));
1238 main_map->l_tls_initimage_size = ph->p_filesz;
1239 main_map->l_tls_initimage = (void *) ph->p_vaddr;
1241 /* This image gets the ID one. */
1242 GL(dl_tls_max_dtv_idx) = main_map->l_tls_modid = 1;
1247 GL(dl_stack_flags) = ph->p_flags;
1251 main_map->l_relro_addr = ph->p_vaddr;
1252 main_map->l_relro_size = ph->p_memsz;
1255 /* Process program headers again, but scan them backwards so
1256 that PT_NOTE can be skipped if PT_GNU_PROPERTY exits. */
1257 for (const ElfW(Phdr) *ph = &phdr[phnum]; ph != phdr; --ph)
1258 switch (ph[-1].p_type)
1261 _dl_process_pt_note (main_map, -1, &ph[-1]);
1263 case PT_GNU_PROPERTY:
1264 _dl_process_pt_gnu_property (main_map, -1, &ph[-1]);
1268 /* Adjust the address of the TLS initialization image in case
1269 the executable is actually an ET_DYN object. */
1270 if (main_map->l_tls_initimage != NULL)
1271 main_map->l_tls_initimage
1272 = (char *) main_map->l_tls_initimage + main_map->l_addr;
1273 if (! main_map->l_map_end)
1274 main_map->l_map_end = ~0;
1275 if (! main_map->l_text_end)
1276 main_map->l_text_end = ~0;
1277 if (! GL(dl_rtld_map).l_libname && GL(dl_rtld_map).l_name)
1279 /* We were invoked directly, so the program might not have a
1281 _dl_rtld_libname.name = GL(dl_rtld_map).l_name;
1282 /* _dl_rtld_libname.next = NULL; Already zero. */
1283 GL(dl_rtld_map).l_libname = &_dl_rtld_libname;
1286 assert (GL(dl_rtld_map).l_libname); /* How else did we get here? */
1291 /* Adjusts the contents of the stack and related globals for the user
1292 entry point. The ld.so processed skip_args arguments and bumped
1293 _dl_argv and _dl_argc accordingly. Those arguments are removed from
1296 _dl_start_args_adjust (int skip_args)
1298 void **sp = (void **) (_dl_argv - skip_args - 1);
1299 void **p = sp + skip_args;
1305 intptr_t argc __attribute__ ((unused)) = (intptr_t) sp[0] - skip_args;
1306 assert (argc == _dl_argc);
1308 /* Adjust argc on stack. */
1309 sp[0] = (void *) (intptr_t) _dl_argc;
1311 /* Update globals in rtld. */
1312 _dl_argv -= skip_args;
1313 _environ -= skip_args;
1315 /* Shuffle argv down. */
1320 assert (_environ == (char **) (sp + 1));
1322 /* Shuffle envp down. */
1327 #ifdef HAVE_AUX_VECTOR
1328 void **auxv = (void **) GLRO(dl_auxv) - skip_args;
1329 GLRO(dl_auxv) = (ElfW(auxv_t) *) auxv; /* Aliasing violation. */
1330 assert (auxv == sp + 1);
1332 /* Shuffle auxv down. */
1334 char *oldp = (char *) (p + 1);
1335 char *newp = (char *) (sp + 1);
1338 memcpy (&ax, oldp, sizeof (ax));
1339 memcpy (newp, &ax, sizeof (ax));
1340 oldp += sizeof (ax);
1341 newp += sizeof (ax);
1343 while (ax.a_type != AT_NULL);
1348 dl_main (const ElfW(Phdr) *phdr,
1350 ElfW(Addr) *user_entry,
1353 struct link_map *main_map;
1357 bool rtld_is_main = false;
1360 struct dl_main_state state;
1361 dl_main_state_init (&state);
1363 __tls_pre_init_tp ();
1365 #if !PTHREAD_IN_LIBC
1366 /* The explicit initialization here is cheaper than processing the reloc
1367 in the _rtld_local definition's initializer. */
1368 GL(dl_make_stack_executable_hook) = &_dl_make_stack_executable;
1371 /* Process the environment variable which control the behaviour. */
1372 process_envvars (&state);
1374 #ifndef HAVE_INLINED_SYSCALLS
1375 /* Set up a flag which tells we are just starting. */
1376 _dl_starting_up = 1;
1379 const char *ld_so_name = _dl_argv[0];
1380 if (*user_entry == (ElfW(Addr)) ENTRY_POINT)
1382 /* Ho ho. We are not the program interpreter! We are the program
1383 itself! This means someone ran ld.so as a command. Well, that
1384 might be convenient to do sometimes. We support it by
1385 interpreting the args like this:
1387 ld.so PROGRAM ARGS...
1389 The first argument is the name of a file containing an ELF
1390 executable we will load and run with the following arguments.
1391 To simplify life here, PROGRAM is searched for using the
1392 normal rules for shared objects, rather than $PATH or anything
1393 like that. We just load it and use its entry point; we don't
1394 pay attention to its PT_INTERP command (we are the interpreter
1395 ourselves). This is an easy way to test a new ld.so before
1397 rtld_is_main = true;
1400 char **orig_argv = _dl_argv;
1402 /* Note the place where the dynamic linker actually came from. */
1403 GL(dl_rtld_map).l_name = rtld_progname;
1405 while (_dl_argc > 1)
1406 if (! strcmp (_dl_argv[1], "--list"))
1408 if (state.mode != rtld_mode_help)
1410 state.mode = rtld_mode_list;
1411 /* This means do no dependency analysis. */
1418 else if (! strcmp (_dl_argv[1], "--verify"))
1420 if (state.mode != rtld_mode_help)
1421 state.mode = rtld_mode_verify;
1426 else if (! strcmp (_dl_argv[1], "--inhibit-cache"))
1428 GLRO(dl_inhibit_cache) = 1;
1432 else if (! strcmp (_dl_argv[1], "--library-path")
1435 state.library_path = _dl_argv[2];
1436 state.library_path_source = "--library-path";
1441 else if (! strcmp (_dl_argv[1], "--inhibit-rpath")
1444 GLRO(dl_inhibit_rpath) = _dl_argv[2];
1449 else if (! strcmp (_dl_argv[1], "--audit") && _dl_argc > 2)
1451 audit_list_add_string (&state.audit_list, _dl_argv[2]);
1456 else if (! strcmp (_dl_argv[1], "--preload") && _dl_argc > 2)
1458 state.preloadarg = _dl_argv[2];
1462 else if (! strcmp (_dl_argv[1], "--argv0") && _dl_argc > 2)
1464 argv0 = _dl_argv[2];
1469 else if (strcmp (_dl_argv[1], "--glibc-hwcaps-prepend") == 0
1472 state.glibc_hwcaps_prepend = _dl_argv[2];
1476 else if (strcmp (_dl_argv[1], "--glibc-hwcaps-mask") == 0
1479 state.glibc_hwcaps_mask = _dl_argv[2];
1483 else if (! strcmp (_dl_argv[1], "--list-tunables"))
1485 state.mode = rtld_mode_list_tunables;
1490 else if (! strcmp (_dl_argv[1], "--list-diagnostics"))
1492 state.mode = rtld_mode_list_diagnostics;
1497 else if (strcmp (_dl_argv[1], "--help") == 0)
1499 state.mode = rtld_mode_help;
1503 else if (strcmp (_dl_argv[1], "--version") == 0)
1505 else if (_dl_argv[1][0] == '-' && _dl_argv[1][1] == '-')
1507 if (_dl_argv[1][1] == '\0')
1508 /* End of option list. */
1511 /* Unrecognized option. */
1512 _dl_usage (ld_so_name, _dl_argv[1]);
1517 if (__glibc_unlikely (state.mode == rtld_mode_list_tunables))
1519 __tunables_print ();
1523 if (state.mode == rtld_mode_list_diagnostics)
1524 _dl_print_diagnostics (_environ);
1526 /* If we have no further argument the program was called incorrectly.
1527 Grant the user some education. */
1530 if (state.mode == rtld_mode_help)
1531 /* --help without an executable is not an error. */
1532 _dl_help (ld_so_name, &state);
1534 _dl_usage (ld_so_name, NULL);
1540 /* The initialization of _dl_stack_flags done below assumes the
1541 executable's PT_GNU_STACK may have been honored by the kernel, and
1542 so a PT_GNU_STACK with PF_X set means the stack started out with
1543 execute permission. However, this is not really true if the
1544 dynamic linker is the executable the kernel loaded. For this
1545 case, we must reinitialize _dl_stack_flags to match the dynamic
1546 linker itself. If the dynamic linker was built with a
1547 PT_GNU_STACK, then the kernel may have loaded us with a
1548 nonexecutable stack that we will have to make executable when we
1549 load the program below unless it has a PT_GNU_STACK indicating
1550 nonexecutable stack is ok. */
1552 for (const ElfW(Phdr) *ph = phdr; ph < &phdr[phnum]; ++ph)
1553 if (ph->p_type == PT_GNU_STACK)
1555 GL(dl_stack_flags) = ph->p_flags;
1559 if (__glibc_unlikely (state.mode == rtld_mode_verify
1560 || state.mode == rtld_mode_help))
1562 const char *objname;
1563 const char *err_str = NULL;
1564 struct map_args args;
1567 args.str = rtld_progname;
1569 args.mode = __RTLD_OPENEXEC;
1570 (void) _dl_catch_error (&objname, &err_str, &malloced, map_doit,
1572 if (__glibc_unlikely (err_str != NULL))
1574 /* We don't free the returned string, the programs stops
1576 if (state.mode == rtld_mode_help)
1577 /* Mask the failure to load the main object. The help
1578 message contains less information in this case. */
1579 _dl_help (ld_so_name, &state);
1581 _exit (EXIT_FAILURE);
1586 RTLD_TIMING_VAR (start);
1587 rtld_timer_start (&start);
1588 _dl_map_object (NULL, rtld_progname, lt_executable, 0,
1589 __RTLD_OPENEXEC, LM_ID_BASE);
1590 rtld_timer_stop (&load_time, start);
1593 /* Now the map for the main executable is available. */
1594 main_map = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
1596 if (__glibc_likely (state.mode == rtld_mode_normal))
1597 rtld_chain_load (main_map, argv0);
1599 phdr = main_map->l_phdr;
1600 phnum = main_map->l_phnum;
1601 /* We overwrite here a pointer to a malloc()ed string. But since
1602 the malloc() implementation used at this point is the dummy
1603 implementations which has no real free() function it does not
1604 makes sense to free the old string first. */
1605 main_map->l_name = (char *) "";
1606 *user_entry = main_map->l_entry;
1608 /* Set bit indicating this is the main program map. */
1609 main_map->l_main_map = 1;
1611 #ifdef HAVE_AUX_VECTOR
1612 /* Adjust the on-stack auxiliary vector so that it looks like the
1613 binary was executed directly. */
1614 for (ElfW(auxv_t) *av = auxv; av->a_type != AT_NULL; av++)
1618 av->a_un.a_val = (uintptr_t) phdr;
1621 av->a_un.a_val = phnum;
1624 av->a_un.a_val = *user_entry;
1627 av->a_un.a_val = (uintptr_t) _dl_argv[0];
1632 /* Set the argv[0] string now that we've processed the executable. */
1634 _dl_argv[0] = argv0;
1636 /* Adjust arguments for the application entry point. */
1637 _dl_start_args_adjust (_dl_argv - orig_argv);
1641 /* Create a link_map for the executable itself.
1642 This will be what dlopen on "" returns. */
1643 main_map = _dl_new_object ((char *) "", "", lt_executable, NULL,
1644 __RTLD_OPENEXEC, LM_ID_BASE);
1645 assert (main_map != NULL);
1646 main_map->l_phdr = phdr;
1647 main_map->l_phnum = phnum;
1648 main_map->l_entry = *user_entry;
1650 /* Even though the link map is not yet fully initialized we can add
1651 it to the map list since there are no possible users running yet. */
1652 _dl_add_to_namespace_list (main_map, LM_ID_BASE);
1653 assert (main_map == GL(dl_ns)[LM_ID_BASE]._ns_loaded);
1655 /* At this point we are in a bit of trouble. We would have to
1656 fill in the values for l_dev and l_ino. But in general we
1657 do not know where the file is. We also do not handle AT_EXECFD
1658 even if it would be passed up.
1660 We leave the values here defined to 0. This is normally no
1661 problem as the program code itself is normally no shared
1662 object and therefore cannot be loaded dynamically. Nothing
1663 prevent the use of dynamic binaries and in these situations
1664 we might get problems. We might not be able to find out
1665 whether the object is already loaded. But since there is no
1666 easy way out and because the dynamic binary must also not
1667 have an SONAME we ignore this program for now. If it becomes
1668 a problem we can force people using SONAMEs. */
1670 /* We delay initializing the path structure until we got the dynamic
1671 information for the program. */
1674 bool has_interp = rtld_setup_main_map (main_map);
1676 /* If the current libname is different from the SONAME, add the
1678 if (GL(dl_rtld_map).l_info[DT_SONAME] != NULL
1679 && strcmp (GL(dl_rtld_map).l_libname->name,
1680 (const char *) D_PTR (&GL(dl_rtld_map), l_info[DT_STRTAB])
1681 + GL(dl_rtld_map).l_info[DT_SONAME]->d_un.d_val) != 0)
1683 static struct libname_list newname;
1684 newname.name = ((char *) D_PTR (&GL(dl_rtld_map), l_info[DT_STRTAB])
1685 + GL(dl_rtld_map).l_info[DT_SONAME]->d_un.d_ptr);
1686 newname.next = NULL;
1687 newname.dont_free = 1;
1689 assert (GL(dl_rtld_map).l_libname->next == NULL);
1690 GL(dl_rtld_map).l_libname->next = &newname;
1692 /* The ld.so must be relocated since otherwise loading audit modules
1693 will fail since they reuse the very same ld.so. */
1694 assert (GL(dl_rtld_map).l_relocated);
1698 /* Extract the contents of the dynamic section for easy access. */
1699 elf_get_dynamic_info (main_map, false, false);
1701 /* If the main map is libc.so, update the base namespace to
1702 refer to this map. If libc.so is loaded later, this happens
1703 in _dl_map_object_from_fd. */
1704 if (main_map->l_info[DT_SONAME] != NULL
1705 && (strcmp (((const char *) D_PTR (main_map, l_info[DT_STRTAB])
1706 + main_map->l_info[DT_SONAME]->d_un.d_val), LIBC_SO)
1708 GL(dl_ns)[LM_ID_BASE].libc_map = main_map;
1710 /* Set up our cache of pointers into the hash table. */
1711 _dl_setup_hash (main_map);
1714 if (__glibc_unlikely (state.mode == rtld_mode_verify))
1716 /* We were called just to verify that this is a dynamic
1717 executable using us as the program interpreter. Exit with an
1718 error if we were not able to load the binary or no interpreter
1719 is specified (i.e., this is no dynamically linked binary. */
1720 if (main_map->l_ld == NULL)
1723 _exit (has_interp ? 0 : 2);
1726 struct link_map **first_preload = &GL(dl_rtld_map).l_next;
1727 /* Set up the data structures for the system-supplied DSO early,
1728 so they can influence _dl_init_paths. */
1729 setup_vdso (main_map, &first_preload);
1731 /* With vDSO setup we can initialize the function pointers. */
1732 setup_vdso_pointers ();
1734 /* Initialize the data structures for the search paths for shared
1736 call_init_paths (&state);
1738 /* Initialize _r_debug_extended. */
1739 struct r_debug *r = _dl_debug_initialize (GL(dl_rtld_map).l_addr,
1741 r->r_state = RT_CONSISTENT;
1743 /* Put the link_map for ourselves on the chain so it can be found by
1744 name. Note that at this point the global chain of link maps contains
1745 exactly one element, which is pointed to by dl_loaded. */
1746 if (! GL(dl_rtld_map).l_name)
1747 /* If not invoked directly, the dynamic linker shared object file was
1748 found by the PT_INTERP name. */
1749 GL(dl_rtld_map).l_name = (char *) GL(dl_rtld_map).l_libname->name;
1750 GL(dl_rtld_map).l_type = lt_library;
1751 main_map->l_next = &GL(dl_rtld_map);
1752 GL(dl_rtld_map).l_prev = main_map;
1753 ++GL(dl_ns)[LM_ID_BASE]._ns_nloaded;
1756 /* Starting from binutils-2.23, the linker will define the magic symbol
1757 __ehdr_start to point to our own ELF header if it is visible in a
1758 segment that also includes the phdrs. If that's not available, we use
1759 the old method that assumes the beginning of the file is part of the
1760 lowest-addressed PT_LOAD segment. */
1762 /* Set up the program header information for the dynamic linker
1763 itself. It is needed in the dl_iterate_phdr callbacks. */
1764 const ElfW(Ehdr) *rtld_ehdr = &__ehdr_start;
1765 assert (rtld_ehdr->e_ehsize == sizeof *rtld_ehdr);
1766 assert (rtld_ehdr->e_phentsize == sizeof (ElfW(Phdr)));
1768 const ElfW(Phdr) *rtld_phdr = (const void *) rtld_ehdr + rtld_ehdr->e_phoff;
1770 GL(dl_rtld_map).l_phdr = rtld_phdr;
1771 GL(dl_rtld_map).l_phnum = rtld_ehdr->e_phnum;
1774 /* PT_GNU_RELRO is usually the last phdr. */
1775 size_t cnt = rtld_ehdr->e_phnum;
1777 if (rtld_phdr[cnt].p_type == PT_GNU_RELRO)
1779 GL(dl_rtld_map).l_relro_addr = rtld_phdr[cnt].p_vaddr;
1780 GL(dl_rtld_map).l_relro_size = rtld_phdr[cnt].p_memsz;
1784 /* Add the dynamic linker to the TLS list if it also uses TLS. */
1785 if (GL(dl_rtld_map).l_tls_blocksize != 0)
1786 /* Assign a module ID. Do this before loading any audit modules. */
1787 _dl_assign_tls_modid (&GL(dl_rtld_map));
1789 audit_list_add_dynamic_tag (&state.audit_list, main_map, DT_AUDIT);
1790 audit_list_add_dynamic_tag (&state.audit_list, main_map, DT_DEPAUDIT);
1792 /* At this point, all data has been obtained that is included in the
1794 if (__glibc_unlikely (state.mode == rtld_mode_help))
1795 _dl_help (ld_so_name, &state);
1797 /* If we have auditing DSOs to load, do it now. */
1798 bool need_security_init = true;
1799 if (state.audit_list.length > 0)
1801 size_t naudit = audit_list_count (&state.audit_list);
1803 /* Since we start using the auditing DSOs right away we need to
1804 initialize the data structures now. */
1805 tcbp = init_tls (naudit);
1807 /* Initialize security features. We need to do it this early
1808 since otherwise the constructors of the audit libraries will
1809 use different values (especially the pointer guard) and will
1812 need_security_init = false;
1814 load_audit_modules (main_map, &state.audit_list);
1816 /* The count based on audit strings may overestimate the number
1817 of audit modules that got loaded, but not underestimate. */
1818 assert (GLRO(dl_naudit) <= naudit);
1821 /* Keep track of the currently loaded modules to count how many
1822 non-audit modules which use TLS are loaded. */
1823 size_t count_modids = _dl_count_modids ();
1825 /* Set up debugging before the debugger is notified for the first time. */
1826 elf_setup_debug_entry (main_map, r);
1828 /* We start adding objects. */
1829 r->r_state = RT_ADD;
1831 LIBC_PROBE (init_start, 2, LM_ID_BASE, r);
1833 /* Auditing checkpoint: we are ready to signal that the initial map
1834 is being constructed. */
1835 _dl_audit_activity_map (main_map, LA_ACT_ADD);
1837 /* We have two ways to specify objects to preload: via environment
1838 variable and via the file /etc/ld.so.preload. The latter can also
1839 be used when security is enabled. */
1840 assert (*first_preload == NULL);
1841 struct link_map **preloads = NULL;
1842 unsigned int npreloads = 0;
1844 if (__glibc_unlikely (state.preloadlist != NULL))
1846 RTLD_TIMING_VAR (start);
1847 rtld_timer_start (&start);
1848 npreloads += handle_preload_list (state.preloadlist, main_map,
1850 rtld_timer_accum (&load_time, start);
1853 if (__glibc_unlikely (state.preloadarg != NULL))
1855 RTLD_TIMING_VAR (start);
1856 rtld_timer_start (&start);
1857 npreloads += handle_preload_list (state.preloadarg, main_map,
1859 rtld_timer_accum (&load_time, start);
1862 /* There usually is no ld.so.preload file, it should only be used
1863 for emergencies and testing. So the open call etc should usually
1864 fail. Using access() on a non-existing file is faster than using
1865 open(). So we do this first. If it succeeds we do almost twice
1866 the work but this does not matter, since it is not for production
1868 static const char preload_file[] = "/etc/ld.so.preload";
1869 if (__glibc_unlikely (__access (preload_file, R_OK) == 0))
1871 /* Read the contents of the file. */
1872 file = _dl_sysdep_read_whole_file (preload_file, &file_size,
1873 PROT_READ | PROT_WRITE);
1874 if (__glibc_unlikely (file != MAP_FAILED))
1876 /* Parse the file. It contains names of libraries to be loaded,
1877 separated by white spaces or `:'. It may also contain
1878 comments introduced by `#'. */
1883 /* Eliminate comments. */
1888 char *comment = memchr (runp, '#', rest);
1889 if (comment == NULL)
1892 rest -= comment - runp;
1895 while (--rest > 0 && *++comment != '\n');
1898 /* We have one problematic case: if we have a name at the end of
1899 the file without a trailing terminating characters, we cannot
1900 place the \0. Handle the case separately. */
1901 if (file[file_size - 1] != ' ' && file[file_size - 1] != '\t'
1902 && file[file_size - 1] != '\n' && file[file_size - 1] != ':')
1904 problem = &file[file_size];
1905 while (problem > file && problem[-1] != ' '
1906 && problem[-1] != '\t'
1907 && problem[-1] != '\n' && problem[-1] != ':')
1916 file[file_size - 1] = '\0';
1919 RTLD_TIMING_VAR (start);
1920 rtld_timer_start (&start);
1922 if (file != problem)
1926 while ((p = strsep (&runp, ": \t\n")) != NULL)
1928 npreloads += do_preload (p, main_map, preload_file);
1931 if (problem != NULL)
1933 char *p = strndupa (problem, file_size - (problem - file));
1935 npreloads += do_preload (p, main_map, preload_file);
1938 rtld_timer_accum (&load_time, start);
1940 /* We don't need the file anymore. */
1941 __munmap (file, file_size);
1945 if (__glibc_unlikely (*first_preload != NULL))
1947 /* Set up PRELOADS with a vector of the preloaded libraries. */
1948 struct link_map *l = *first_preload;
1949 preloads = __alloca (npreloads * sizeof preloads[0]);
1956 assert (i == npreloads);
1959 #ifdef NEED_DL_SYSINFO_DSO
1960 /* Now that the audit modules are opened, call la_objopen for the vDSO. */
1961 if (GLRO(dl_sysinfo_map) != NULL)
1962 _dl_audit_objopen (GLRO(dl_sysinfo_map), LM_ID_BASE);
1965 /* Load all the libraries specified by DT_NEEDED entries. If LD_PRELOAD
1966 specified some libraries to load, these are inserted before the actual
1967 dependencies in the executable's searchlist for symbol resolution. */
1969 RTLD_TIMING_VAR (start);
1970 rtld_timer_start (&start);
1971 _dl_map_object_deps (main_map, preloads, npreloads,
1972 state.mode == rtld_mode_trace, 0);
1973 rtld_timer_accum (&load_time, start);
1976 /* Mark all objects as being in the global scope. */
1977 for (i = main_map->l_searchlist.r_nlist; i > 0; )
1978 main_map->l_searchlist.r_list[--i]->l_global = 1;
1980 /* Remove _dl_rtld_map from the chain. */
1981 GL(dl_rtld_map).l_prev->l_next = GL(dl_rtld_map).l_next;
1982 if (GL(dl_rtld_map).l_next != NULL)
1983 GL(dl_rtld_map).l_next->l_prev = GL(dl_rtld_map).l_prev;
1985 for (i = 1; i < main_map->l_searchlist.r_nlist; ++i)
1986 if (main_map->l_searchlist.r_list[i] == &GL(dl_rtld_map))
1989 bool rtld_multiple_ref = false;
1990 if (__glibc_likely (i < main_map->l_searchlist.r_nlist))
1992 /* Some DT_NEEDED entry referred to the interpreter object itself, so
1993 put it back in the list of visible objects. We insert it into the
1994 chain in symbol search order because gdb uses the chain's order as
1995 its symbol search order. */
1996 rtld_multiple_ref = true;
1998 GL(dl_rtld_map).l_prev = main_map->l_searchlist.r_list[i - 1];
1999 if (__glibc_likely (state.mode == rtld_mode_normal))
2001 GL(dl_rtld_map).l_next = (i + 1 < main_map->l_searchlist.r_nlist
2002 ? main_map->l_searchlist.r_list[i + 1]
2004 #ifdef NEED_DL_SYSINFO_DSO
2005 if (GLRO(dl_sysinfo_map) != NULL
2006 && GL(dl_rtld_map).l_prev->l_next == GLRO(dl_sysinfo_map)
2007 && GL(dl_rtld_map).l_next != GLRO(dl_sysinfo_map))
2008 GL(dl_rtld_map).l_prev = GLRO(dl_sysinfo_map);
2012 /* In trace mode there might be an invisible object (which we
2013 could not find) after the previous one in the search list.
2014 In this case it doesn't matter much where we put the
2015 interpreter object, so we just initialize the list pointer so
2016 that the assertion below holds. */
2017 GL(dl_rtld_map).l_next = GL(dl_rtld_map).l_prev->l_next;
2019 assert (GL(dl_rtld_map).l_prev->l_next == GL(dl_rtld_map).l_next);
2020 GL(dl_rtld_map).l_prev->l_next = &GL(dl_rtld_map);
2021 if (GL(dl_rtld_map).l_next != NULL)
2023 assert (GL(dl_rtld_map).l_next->l_prev == GL(dl_rtld_map).l_prev);
2024 GL(dl_rtld_map).l_next->l_prev = &GL(dl_rtld_map);
2028 /* Now let us see whether all libraries are available in the
2029 versions we need. */
2031 struct version_check_args args;
2032 args.doexit = state.mode == rtld_mode_normal;
2033 args.dotrace = state.mode == rtld_mode_trace;
2034 _dl_receive_error (print_missing_version, version_check_doit, &args);
2037 /* We do not initialize any of the TLS functionality unless any of the
2038 initial modules uses TLS. This makes dynamic loading of modules with
2039 TLS impossible, but to support it requires either eagerly doing setup
2040 now or lazily doing it later. Doing it now makes us incompatible with
2041 an old kernel that can't perform TLS_INIT_TP, even if no TLS is ever
2042 used. Trying to do it lazily is too hairy to try when there could be
2043 multiple threads (from a non-TLS-using libpthread). */
2044 bool was_tls_init_tp_called = __rtld_tls_init_tp_called;
2046 tcbp = init_tls (0);
2048 if (__glibc_likely (need_security_init))
2049 /* Initialize security features. But only if we have not done it
2053 if (__glibc_unlikely (state.mode != rtld_mode_normal))
2055 /* We were run just to list the shared libraries. It is
2056 important that we do this before real relocation, because the
2057 functions we call below for output may no longer work properly
2058 after relocation. */
2061 if (GLRO(dl_debug_mask) & DL_DEBUG_UNUSED)
2063 /* Look through the dependencies of the main executable
2064 and determine which of them is not actually
2066 struct link_map *l = main_map;
2068 /* Relocate the main executable. */
2069 struct relocate_args args = { .l = l,
2070 .reloc_mode = ((GLRO(dl_lazy)
2072 | __RTLD_NOIFUNC) };
2073 _dl_receive_error (print_unresolved, relocate_doit, &args);
2075 /* This loop depends on the dependencies of the executable to
2076 correspond in number and order to the DT_NEEDED entries. */
2077 ElfW(Dyn) *dyn = main_map->l_ld;
2079 while (dyn->d_tag != DT_NULL)
2081 if (dyn->d_tag == DT_NEEDED)
2084 #ifdef NEED_DL_SYSINFO_DSO
2085 /* Skip the VDSO since it's not part of the list
2086 of objects we brought in via DT_NEEDED entries. */
2087 if (l == GLRO(dl_sysinfo_map))
2094 _dl_printf ("Unused direct dependencies:\n");
2098 _dl_printf ("\t%s\n", l->l_name);
2105 _exit (first != true);
2107 else if (! main_map->l_info[DT_NEEDED])
2108 _dl_printf ("\tstatically linked\n");
2111 for (l = state.mode_trace_program ? main_map : main_map->l_next;
2114 /* The library was not found. */
2115 _dl_printf ("\t%s => not found\n", l->l_libname->name);
2116 else if (strcmp (l->l_libname->name, l->l_name) == 0)
2117 /* Print vDSO like libraries without duplicate name. Some
2118 consumers depend of this format. */
2119 _dl_printf ("\t%s (0x%0*zx)\n", l->l_libname->name,
2120 (int) sizeof l->l_map_start * 2,
2121 (size_t) l->l_map_start);
2123 _dl_printf ("\t%s => %s (0x%0*zx)\n",
2124 DSO_FILENAME (l->l_libname->name),
2125 DSO_FILENAME (l->l_name),
2126 (int) sizeof l->l_map_start * 2,
2127 (size_t) l->l_map_start);
2131 if (__glibc_unlikely (state.mode != rtld_mode_trace))
2132 for (i = 1; i < (unsigned int) _dl_argc; ++i)
2134 const ElfW(Sym) *ref = NULL;
2135 ElfW(Addr) loadbase;
2138 result = _dl_lookup_symbol_x (_dl_argv[i], main_map,
2139 &ref, main_map->l_scope,
2140 NULL, ELF_RTYPE_CLASS_PLT,
2141 DL_LOOKUP_ADD_DEPENDENCY, NULL);
2143 loadbase = LOOKUP_VALUE_ADDRESS (result, false);
2145 _dl_printf ("%s found at 0x%0*zd in object at 0x%0*zd\n",
2147 (int) sizeof ref->st_value * 2,
2148 (size_t) ref->st_value,
2149 (int) sizeof loadbase * 2, (size_t) loadbase);
2153 /* If LD_WARN is set, warn about undefined symbols. */
2154 if (GLRO(dl_lazy) >= 0 && GLRO(dl_verbose))
2156 /* We have to do symbol dependency testing. */
2157 struct relocate_args args;
2160 args.reloc_mode = ((GLRO(dl_lazy) ? RTLD_LAZY : 0)
2163 i = main_map->l_searchlist.r_nlist;
2166 struct link_map *l = main_map->l_initfini[i];
2167 if (l != &GL(dl_rtld_map) && ! l->l_faked)
2170 _dl_receive_error (print_unresolved, relocate_doit,
2176 #define VERNEEDTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERNEED))
2177 if (state.version_info)
2179 /* Print more information. This means here, print information
2180 about the versions needed. */
2182 struct link_map *map;
2184 for (map = main_map; map != NULL; map = map->l_next)
2187 ElfW(Dyn) *dyn = map->l_info[VERNEEDTAG];
2193 strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
2194 ent = (ElfW(Verneed) *) (map->l_addr + dyn->d_un.d_ptr);
2198 _dl_printf ("\n\tVersion information:\n");
2202 _dl_printf ("\t%s:\n", DSO_FILENAME (map->l_name));
2207 struct link_map *needed;
2209 needed = find_needed (strtab + ent->vn_file);
2210 aux = (ElfW(Vernaux) *) ((char *) ent + ent->vn_aux);
2214 const char *fname = NULL;
2217 && match_version (strtab + aux->vna_name,
2219 fname = needed->l_name;
2221 _dl_printf ("\t\t%s (%s) %s=> %s\n",
2222 strtab + ent->vn_file,
2223 strtab + aux->vna_name,
2224 aux->vna_flags & VER_FLG_WEAK
2226 fname ?: "not found");
2228 if (aux->vna_next == 0)
2229 /* No more symbols. */
2233 aux = (ElfW(Vernaux) *) ((char *) aux
2237 if (ent->vn_next == 0)
2238 /* No more dependencies. */
2241 /* Next dependency. */
2242 ent = (ElfW(Verneed) *) ((char *) ent + ent->vn_next);
2251 /* Now set up the variable which helps the assembler startup code. */
2252 GL(dl_ns)[LM_ID_BASE]._ns_main_searchlist = &main_map->l_searchlist;
2254 /* Save the information about the original global scope list since
2255 we need it in the memory handling later. */
2256 GLRO(dl_initial_searchlist) = *GL(dl_ns)[LM_ID_BASE]._ns_main_searchlist;
2258 /* Remember the last search directory added at startup, now that
2259 malloc will no longer be the one from dl-minimal.c. As a side
2260 effect, this marks ld.so as initialized, so that the rtld_active
2261 function returns true from now on. */
2262 GLRO(dl_init_all_dirs) = GL(dl_all_dirs);
2264 /* Print scope information. */
2265 if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_SCOPES))
2267 _dl_debug_printf ("\nInitial object scopes\n");
2269 for (struct link_map *l = main_map; l != NULL; l = l->l_next)
2270 _dl_show_scope (l, 0);
2273 _rtld_main_check (main_map, _dl_argv[0]);
2275 /* Now we have all the objects loaded. Relocate them all except for
2276 the dynamic linker itself. We do this in reverse order so that copy
2277 relocs of earlier objects overwrite the data written by later
2278 objects. We do not re-relocate the dynamic linker itself in this
2279 loop because that could result in the GOT entries for functions we
2280 call being changed, and that would break us. It is safe to relocate
2281 the dynamic linker out of order because it has no copy relocs (we
2282 know that because it is self-contained). */
2284 int consider_profiling = GLRO(dl_profile) != NULL;
2286 /* If we are profiling we also must do lazy reloaction. */
2287 GLRO(dl_lazy) |= consider_profiling;
2289 RTLD_TIMING_VAR (start);
2290 rtld_timer_start (&start);
2292 unsigned i = main_map->l_searchlist.r_nlist;
2295 struct link_map *l = main_map->l_initfini[i];
2297 /* While we are at it, help the memory handling a bit. We have to
2298 mark some data structures as allocated with the fake malloc()
2299 implementation in ld.so. */
2300 struct libname_list *lnp = l->l_libname->next;
2302 while (__builtin_expect (lnp != NULL, 0))
2307 /* Also allocated with the fake malloc(). */
2308 l->l_free_initfini = 0;
2310 if (l != &GL(dl_rtld_map))
2311 _dl_relocate_object (l, l->l_scope, GLRO(dl_lazy) ? RTLD_LAZY : 0,
2312 consider_profiling);
2314 /* Add object to slot information data if necessasy. */
2315 if (l->l_tls_blocksize != 0 && __rtld_tls_init_tp_called)
2316 _dl_add_to_slotinfo (l, true);
2319 rtld_timer_stop (&relocate_time, start);
2321 /* Now enable profiling if needed. Like the previous call,
2322 this has to go here because the calls it makes should use the
2323 rtld versions of the functions (particularly calloc()), but it
2324 needs to have _dl_profile_map set up by the relocator. */
2325 if (__glibc_unlikely (GL(dl_profile_map) != NULL))
2326 /* We must prepare the profiling. */
2327 _dl_start_profile ();
2329 if ((!was_tls_init_tp_called && GL(dl_tls_max_dtv_idx) > 0)
2330 || count_modids != _dl_count_modids ())
2331 ++GL(dl_tls_generation);
2333 /* Now that we have completed relocation, the initializer data
2334 for the TLS blocks has its final values and we can copy them
2335 into the main thread's TLS area, which we allocated above.
2336 Note: thread-local variables must only be accessed after completing
2338 _dl_allocate_tls_init (tcbp, false);
2340 /* And finally install it for the main thread. */
2341 if (! __rtld_tls_init_tp_called)
2342 call_tls_init_tp (tcbp);
2344 /* Make sure no new search directories have been added. */
2345 assert (GLRO(dl_init_all_dirs) == GL(dl_all_dirs));
2347 if (rtld_multiple_ref)
2349 /* There was an explicit ref to the dynamic linker as a shared lib.
2350 Re-relocate ourselves with user-controlled symbol definitions.
2352 We must do this after TLS initialization in case after this
2353 re-relocation, we might call a user-supplied function
2354 (e.g. calloc from _dl_relocate_object) that uses TLS data. */
2356 /* Set up the object lookup structures. */
2357 _dl_find_object_init ();
2359 /* The malloc implementation has been relocated, so resolving
2360 its symbols (and potentially calling IFUNC resolvers) is safe
2362 __rtld_malloc_init_real (main_map);
2364 /* Likewise for the locking implementation. */
2365 __rtld_mutex_init ();
2367 RTLD_TIMING_VAR (start);
2368 rtld_timer_start (&start);
2370 /* Mark the link map as not yet relocated again. */
2371 GL(dl_rtld_map).l_relocated = 0;
2372 _dl_relocate_object (&GL(dl_rtld_map), main_map->l_scope, 0, 0);
2374 rtld_timer_accum (&relocate_time, start);
2377 /* Relocation is complete. Perform early libc initialization. This
2378 is the initial libc, even if audit modules have been loaded with
2380 _dl_call_libc_early_init (GL(dl_ns)[LM_ID_BASE].libc_map, true);
2382 /* Do any necessary cleanups for the startup OS interface code.
2383 We do these now so that no calls are made after rtld re-relocation
2384 which might be resolved to different functions than we expect.
2385 We cannot do this before relocating the other objects because
2386 _dl_relocate_object might need to call `mprotect' for DT_TEXTREL. */
2387 _dl_sysdep_start_cleanup ();
2390 /* Auditing checkpoint: we have added all objects. */
2391 _dl_audit_activity_nsid (LM_ID_BASE, LA_ACT_CONSISTENT);
2394 /* Notify the debugger all new objects are now ready to go. We must re-get
2395 the address since by now the variable might be in another object. */
2396 r = _dl_debug_update (LM_ID_BASE);
2397 r->r_state = RT_CONSISTENT;
2399 LIBC_PROBE (init_complete, 2, LM_ID_BASE, r);
2401 #if defined USE_LDCONFIG && !defined MAP_COPY
2402 /* We must munmap() the cache file. */
2403 _dl_unload_cache ();
2406 /* Once we return, _dl_sysdep_start will invoke
2407 the DT_INIT functions and then *USER_ENTRY. */
2410 /* This is a little helper function for resolving symbols while
2411 tracing the binary. */
2413 print_unresolved (int errcode __attribute__ ((unused)), const char *objname,
2414 const char *errstring)
2416 if (objname[0] == '\0')
2417 objname = RTLD_PROGNAME;
2418 _dl_error_printf ("%s (%s)\n", errstring, objname);
2421 /* This is a little helper function for resolving symbols while
2422 tracing the binary. */
2424 print_missing_version (int errcode __attribute__ ((unused)),
2425 const char *objname, const char *errstring)
2427 _dl_error_printf ("%s: %s: %s\n", RTLD_PROGNAME,
2428 objname, errstring);
2431 /* Process the string given as the parameter which explains which debugging
2432 options are enabled. */
2434 process_dl_debug (struct dl_main_state *state, const char *dl_debug)
2436 /* When adding new entries make sure that the maximal length of a name
2437 is correctly handled in the LD_DEBUG_HELP code below. */
2441 const char name[10];
2442 const char helptext[41];
2443 unsigned short int mask;
2446 #define LEN_AND_STR(str) sizeof (str) - 1, str
2447 { LEN_AND_STR ("libs"), "display library search paths",
2448 DL_DEBUG_LIBS | DL_DEBUG_IMPCALLS },
2449 { LEN_AND_STR ("reloc"), "display relocation processing",
2450 DL_DEBUG_RELOC | DL_DEBUG_IMPCALLS },
2451 { LEN_AND_STR ("files"), "display progress for input file",
2452 DL_DEBUG_FILES | DL_DEBUG_IMPCALLS },
2453 { LEN_AND_STR ("symbols"), "display symbol table processing",
2454 DL_DEBUG_SYMBOLS | DL_DEBUG_IMPCALLS },
2455 { LEN_AND_STR ("bindings"), "display information about symbol binding",
2456 DL_DEBUG_BINDINGS | DL_DEBUG_IMPCALLS },
2457 { LEN_AND_STR ("versions"), "display version dependencies",
2458 DL_DEBUG_VERSIONS | DL_DEBUG_IMPCALLS },
2459 { LEN_AND_STR ("scopes"), "display scope information",
2461 { LEN_AND_STR ("all"), "all previous options combined",
2462 DL_DEBUG_LIBS | DL_DEBUG_RELOC | DL_DEBUG_FILES | DL_DEBUG_SYMBOLS
2463 | DL_DEBUG_BINDINGS | DL_DEBUG_VERSIONS | DL_DEBUG_IMPCALLS
2464 | DL_DEBUG_SCOPES },
2465 { LEN_AND_STR ("statistics"), "display relocation statistics",
2466 DL_DEBUG_STATISTICS },
2467 { LEN_AND_STR ("unused"), "determined unused DSOs",
2469 { LEN_AND_STR ("help"), "display this help message and exit",
2472 #define ndebopts (sizeof (debopts) / sizeof (debopts[0]))
2474 /* Skip separating white spaces and commas. */
2475 while (*dl_debug != '\0')
2477 if (*dl_debug != ' ' && *dl_debug != ',' && *dl_debug != ':')
2482 while (dl_debug[len] != '\0' && dl_debug[len] != ' '
2483 && dl_debug[len] != ',' && dl_debug[len] != ':')
2486 for (cnt = 0; cnt < ndebopts; ++cnt)
2487 if (debopts[cnt].len == len
2488 && memcmp (dl_debug, debopts[cnt].name, len) == 0)
2490 GLRO(dl_debug_mask) |= debopts[cnt].mask;
2491 state->any_debug = true;
2495 if (cnt == ndebopts)
2497 /* Display a warning and skip everything until next
2499 char *copy = strndupa (dl_debug, len);
2500 _dl_error_printf ("\
2501 warning: debug option `%s' unknown; try LD_DEBUG=help\n", copy);
2511 if (GLRO(dl_debug_mask) & DL_DEBUG_UNUSED)
2513 /* In order to get an accurate picture of whether a particular
2514 DT_NEEDED entry is actually used we have to process both
2515 the PLT and non-PLT relocation entries. */
2519 if (GLRO(dl_debug_mask) & DL_DEBUG_HELP)
2524 Valid options for the LD_DEBUG environment variable are:\n\n");
2526 for (cnt = 0; cnt < ndebopts; ++cnt)
2527 _dl_printf (" %.*s%s%s\n", debopts[cnt].len, debopts[cnt].name,
2528 " " + debopts[cnt].len - 3,
2529 debopts[cnt].helptext);
2532 To direct the debugging output into a file instead of standard output\n\
2533 a filename can be specified using the LD_DEBUG_OUTPUT environment variable.\n");
2539 process_envvars (struct dl_main_state *state)
2541 char **runp = _environ;
2543 char *debug_output = NULL;
2545 /* This is the default place for profiling data file. */
2546 GLRO(dl_profile_output)
2547 = &"/var/tmp\0/var/profile"[__libc_enable_secure ? 9 : 0];
2549 while ((envline = _dl_next_ld_env_entry (&runp)) != NULL)
2553 while (envline[len] != '\0' && envline[len] != '=')
2556 if (envline[len] != '=')
2557 /* This is a "LD_" variable at the end of the string without
2558 a '=' character. Ignore it since otherwise we will access
2559 invalid memory below. */
2565 /* Warning level, verbose or not. */
2566 if (memcmp (envline, "WARN", 4) == 0)
2567 GLRO(dl_verbose) = envline[5] != '\0';
2571 /* Debugging of the dynamic linker? */
2572 if (memcmp (envline, "DEBUG", 5) == 0)
2574 process_dl_debug (state, &envline[6]);
2577 if (memcmp (envline, "AUDIT", 5) == 0)
2578 audit_list_add_string (&state->audit_list, &envline[6]);
2582 /* Print information about versions. */
2583 if (memcmp (envline, "VERBOSE", 7) == 0)
2585 state->version_info = envline[8] != '\0';
2589 /* List of objects to be preloaded. */
2590 if (memcmp (envline, "PRELOAD", 7) == 0)
2592 state->preloadlist = &envline[8];
2596 /* Which shared object shall be profiled. */
2597 if (memcmp (envline, "PROFILE", 7) == 0 && envline[8] != '\0')
2598 GLRO(dl_profile) = &envline[8];
2602 /* Do we bind early? */
2603 if (memcmp (envline, "BIND_NOW", 8) == 0)
2605 GLRO(dl_lazy) = envline[9] == '\0';
2608 if (memcmp (envline, "BIND_NOT", 8) == 0)
2609 GLRO(dl_bind_not) = envline[9] != '\0';
2613 /* Test whether we want to see the content of the auxiliary
2614 array passed up from the kernel. */
2615 if (!__libc_enable_secure
2616 && memcmp (envline, "SHOW_AUXV", 9) == 0)
2621 /* Path where the binary is found. */
2622 if (!__libc_enable_secure
2623 && memcmp (envline, "ORIGIN_PATH", 11) == 0)
2624 GLRO(dl_origin_path) = &envline[12];
2628 /* The library search path. */
2629 if (!__libc_enable_secure
2630 && memcmp (envline, "LIBRARY_PATH", 12) == 0)
2632 state->library_path = &envline[13];
2633 state->library_path_source = "LD_LIBRARY_PATH";
2637 /* Where to place the profiling data file. */
2638 if (memcmp (envline, "DEBUG_OUTPUT", 12) == 0)
2640 debug_output = &envline[13];
2644 if (!__libc_enable_secure
2645 && memcmp (envline, "DYNAMIC_WEAK", 12) == 0)
2646 GLRO(dl_dynamic_weak) = 1;
2650 /* Where to place the profiling data file. */
2651 if (!__libc_enable_secure
2652 && memcmp (envline, "PROFILE_OUTPUT", 14) == 0
2653 && envline[15] != '\0')
2654 GLRO(dl_profile_output) = &envline[15];
2658 /* The mode of the dynamic linker can be set. */
2659 if (memcmp (envline, "TRACE_LOADED_OBJECTS", 20) == 0)
2661 state->mode = rtld_mode_trace;
2662 state->mode_trace_program
2663 = _dl_strtoul (&envline[21], NULL) > 1;
2669 /* Extra security for SUID binaries. Remove all dangerous environment
2671 if (__glibc_unlikely (__libc_enable_secure))
2673 const char *nextp = UNSECURE_ENVVARS;
2677 nextp = strchr (nextp, '\0') + 1;
2679 while (*nextp != '\0');
2681 if (__access ("/etc/suid-debug", F_OK) != 0)
2682 GLRO(dl_debug_mask) = 0;
2684 if (state->mode != rtld_mode_normal)
2687 /* If we have to run the dynamic linker in debugging mode and the
2688 LD_DEBUG_OUTPUT environment variable is given, we write the debug
2689 messages to this file. */
2690 else if (state->any_debug && debug_output != NULL)
2692 const int flags = O_WRONLY | O_APPEND | O_CREAT | O_NOFOLLOW;
2693 size_t name_len = strlen (debug_output);
2694 char buf[name_len + 12];
2697 buf[name_len + 11] = '\0';
2698 startp = _itoa (__getpid (), &buf[name_len + 11], 10, 0);
2700 startp = memcpy (startp - name_len, debug_output, name_len);
2702 GLRO(dl_debug_fd) = __open64_nocancel (startp, flags, DEFFILEMODE);
2703 if (GLRO(dl_debug_fd) == -1)
2704 /* We use standard output if opening the file failed. */
2705 GLRO(dl_debug_fd) = STDOUT_FILENO;
2709 #if HP_TIMING_INLINE
2711 print_statistics_item (const char *title, hp_timing_t time,
2714 char cycles[HP_TIMING_PRINT_SIZE];
2715 HP_TIMING_PRINT (cycles, sizeof (cycles), time);
2717 char relative[3 * sizeof (hp_timing_t) + 2];
2718 char *cp = _itoa ((1000ULL * time) / total, relative + sizeof (relative),
2720 /* Sets the decimal point. */
2721 char *wp = relative;
2722 switch (relative + sizeof (relative) - cp)
2735 _dl_debug_printf ("%s: %s cycles (%s%%)\n", title, cycles, relative);
2739 /* Print the various times we collected. */
2741 __attribute ((noinline))
2742 print_statistics (const hp_timing_t *rtld_total_timep)
2744 #if HP_TIMING_INLINE
2746 char cycles[HP_TIMING_PRINT_SIZE];
2747 HP_TIMING_PRINT (cycles, sizeof (cycles), *rtld_total_timep);
2748 _dl_debug_printf ("\nruntime linker statistics:\n"
2749 " total startup time in dynamic loader: %s cycles\n",
2751 print_statistics_item (" time needed for relocation",
2752 relocate_time, *rtld_total_timep);
2756 unsigned long int num_relative_relocations = 0;
2757 for (Lmid_t ns = 0; ns < GL(dl_nns); ++ns)
2759 if (GL(dl_ns)[ns]._ns_loaded == NULL)
2762 struct r_scope_elem *scope = &GL(dl_ns)[ns]._ns_loaded->l_searchlist;
2764 for (unsigned int i = 0; i < scope->r_nlist; i++)
2766 struct link_map *l = scope->r_list [i];
2768 if (l->l_addr != 0 && l->l_info[VERSYMIDX (DT_RELCOUNT)])
2769 num_relative_relocations
2770 += l->l_info[VERSYMIDX (DT_RELCOUNT)]->d_un.d_val;
2771 #ifndef ELF_MACHINE_REL_RELATIVE
2772 /* Relative relocations are processed on these architectures if
2773 library is loaded to different address than p_vaddr. */
2774 if ((l->l_addr != 0)
2775 && l->l_info[VERSYMIDX (DT_RELACOUNT)])
2777 /* On e.g. IA-64 or Alpha, relative relocations are processed
2778 only if library is loaded to different address than p_vaddr. */
2779 if (l->l_addr != 0 && l->l_info[VERSYMIDX (DT_RELACOUNT)])
2781 num_relative_relocations
2782 += l->l_info[VERSYMIDX (DT_RELACOUNT)]->d_un.d_val;
2786 _dl_debug_printf (" number of relocations: %lu\n"
2787 " number of relocations from cache: %lu\n"
2788 " number of relative relocations: %lu\n",
2789 GL(dl_num_relocations),
2790 GL(dl_num_cache_relocations),
2791 num_relative_relocations);
2793 #if HP_TIMING_INLINE
2794 print_statistics_item (" time needed to load objects",
2795 load_time, *rtld_total_timep);