1 /* Run time dynamic linker.
2 Copyright (C) 1995-2022 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>
58 /* This #define produces dynamic linking inline functions for
59 bootstrap relocation instead of general-purpose relocation.
60 Since ld.so must not have any undefined symbols the result
61 is trivial: always the map of ld.so itself. */
62 #define RTLD_BOOTSTRAP
63 #define RESOLVE_MAP(map, scope, sym, version, flags) map
64 #include "dynamic-link.h"
66 /* Must include after <dl-machine.h> for DT_MIPS definition. */
69 /* Only enables rtld profiling for architectures which provides non generic
70 hp-timing support. The generic support requires either syscall
71 (clock_gettime), which will incur in extra overhead on loading time.
72 Using vDSO is also an option, but it will require extra support on loader
73 to setup the vDSO pointer before its usage. */
75 # define RLTD_TIMING_DECLARE(var, classifier,...) \
76 classifier hp_timing_t var __VA_ARGS__
77 # define RTLD_TIMING_VAR(var) RLTD_TIMING_DECLARE (var, )
78 # define RTLD_TIMING_SET(var, value) (var) = (value)
79 # define RTLD_TIMING_REF(var) &(var)
82 rtld_timer_start (hp_timing_t
*var
)
88 rtld_timer_stop (hp_timing_t
*var
, hp_timing_t start
)
92 HP_TIMING_DIFF (*var
, start
, stop
);
96 rtld_timer_accum (hp_timing_t
*sum
, hp_timing_t start
)
99 rtld_timer_stop (&stop
, start
);
100 HP_TIMING_ACCUM_NT(*sum
, stop
);
103 # define RLTD_TIMING_DECLARE(var, classifier...)
104 # define RTLD_TIMING_SET(var, value)
105 # define RTLD_TIMING_VAR(var)
106 # define RTLD_TIMING_REF(var) 0
107 # define rtld_timer_start(var)
108 # define rtld_timer_stop(var, start)
109 # define rtld_timer_accum(sum, start)
112 /* Avoid PLT use for our local calls at startup. */
113 extern __typeof (__mempcpy
) __mempcpy attribute_hidden
;
115 /* GCC has mental blocks about _exit. */
116 extern __typeof (_exit
) exit_internal
asm ("_exit") attribute_hidden
;
117 #define _exit exit_internal
119 /* Helper function to handle errors while resolving symbols. */
120 static void print_unresolved (int errcode
, const char *objname
,
121 const char *errsting
);
123 /* Helper function to handle errors when a version is missing. */
124 static void print_missing_version (int errcode
, const char *objname
,
125 const char *errsting
);
127 /* Print the various times we collected. */
128 static void print_statistics (const hp_timing_t
*total_timep
);
130 /* Creates an empty audit list. */
131 static void audit_list_init (struct audit_list
*);
133 /* Add a string to the end of the audit list, for later parsing. Must
134 not be called after audit_list_next. */
135 static void audit_list_add_string (struct audit_list
*, const char *);
137 /* Add the audit strings from the link map, found in the dynamic
138 segment at TG (either DT_AUDIT and DT_DEPAUDIT). Must be called
139 before audit_list_next. */
140 static void audit_list_add_dynamic_tag (struct audit_list
*,
144 /* Extract the next audit module from the audit list. Only modules
145 for which dso_name_valid_for_suid is true are returned. Must be
146 called after all the audit_list_add_string,
147 audit_list_add_dynamic_tags calls. */
148 static const char *audit_list_next (struct audit_list
*);
150 /* Initialize *STATE with the defaults. */
151 static void dl_main_state_init (struct dl_main_state
*state
);
153 /* Process all environments variables the dynamic linker must recognize.
154 Since all of them start with `LD_' we are a bit smarter while finding
156 extern char **_environ attribute_hidden
;
157 static void process_envvars (struct dl_main_state
*state
);
159 int _dl_argc attribute_relro attribute_hidden
;
160 char **_dl_argv attribute_relro
= NULL
;
161 rtld_hidden_data_def (_dl_argv
)
163 #ifndef THREAD_SET_STACK_GUARD
164 /* Only exported for architectures that don't store the stack guard canary
165 in thread local area. */
166 uintptr_t __stack_chk_guard attribute_relro
;
169 /* Only exported for architectures that don't store the pointer guard
170 value in thread local area. */
171 uintptr_t __pointer_chk_guard_local attribute_relro attribute_hidden
;
172 #ifndef THREAD_SET_POINTER_GUARD
173 strong_alias (__pointer_chk_guard_local
, __pointer_chk_guard
)
176 /* Check that AT_SECURE=0, or that the passed name does not contain
177 directories and is not overly long. Reject empty names
180 dso_name_valid_for_suid (const char *p
)
182 if (__glibc_unlikely (__libc_enable_secure
))
184 /* Ignore pathnames with directories for AT_SECURE=1
185 programs, and also skip overlong names. */
186 size_t len
= strlen (p
);
187 if (len
>= SECURE_NAME_LIMIT
|| memchr (p
, '/', len
) != NULL
)
194 audit_list_init (struct audit_list
*list
)
197 list
->current_index
= 0;
198 list
->current_tail
= NULL
;
202 audit_list_add_string (struct audit_list
*list
, const char *string
)
204 /* Empty strings do not load anything. */
208 if (list
->length
== array_length (list
->audit_strings
))
209 _dl_fatal_printf ("Fatal glibc error: Too many audit modules requested\n");
211 list
->audit_strings
[list
->length
++] = string
;
213 /* Initialize processing of the first string for
215 if (list
->length
== 1)
216 list
->current_tail
= string
;
220 audit_list_add_dynamic_tag (struct audit_list
*list
, struct link_map
*main_map
,
223 ElfW(Dyn
) *info
= main_map
->l_info
[ADDRIDX (tag
)];
224 const char *strtab
= (const char *) D_PTR (main_map
, l_info
[DT_STRTAB
]);
226 audit_list_add_string (list
, strtab
+ info
->d_un
.d_val
);
230 audit_list_next (struct audit_list
*list
)
232 if (list
->current_tail
== NULL
)
237 /* Advance to the next string in audit_strings if the current
238 string has been exhausted. */
239 while (*list
->current_tail
== '\0')
241 ++list
->current_index
;
242 if (list
->current_index
== list
->length
)
244 list
->current_tail
= NULL
;
247 list
->current_tail
= list
->audit_strings
[list
->current_index
];
250 /* Split the in-string audit list at the next colon colon. */
251 size_t len
= strcspn (list
->current_tail
, ":");
252 if (len
> 0 && len
< sizeof (list
->fname
))
254 memcpy (list
->fname
, list
->current_tail
, len
);
255 list
->fname
[len
] = '\0';
258 /* Mark the name as unusable for dso_name_valid_for_suid. */
259 list
->fname
[0] = '\0';
261 /* Skip over the substring and the following delimiter. */
262 list
->current_tail
+= len
;
263 if (*list
->current_tail
== ':')
264 ++list
->current_tail
;
266 /* If the name is valid, return it. */
267 if (dso_name_valid_for_suid (list
->fname
))
270 /* Otherwise wrap around to find the next list element. . */
274 /* Count audit modules before they are loaded so GLRO(dl_naudit)
275 is not yet usable. */
277 audit_list_count (struct audit_list
*list
)
279 /* Restore the audit_list iterator state at the end. */
280 const char *saved_tail
= list
->current_tail
;
283 assert (list
->current_index
== 0);
284 while (audit_list_next (list
) != NULL
)
286 list
->current_tail
= saved_tail
;
287 list
->current_index
= 0;
292 dl_main_state_init (struct dl_main_state
*state
)
294 audit_list_init (&state
->audit_list
);
295 state
->library_path
= NULL
;
296 state
->library_path_source
= NULL
;
297 state
->preloadlist
= NULL
;
298 state
->preloadarg
= NULL
;
299 state
->glibc_hwcaps_prepend
= NULL
;
300 state
->glibc_hwcaps_mask
= NULL
;
301 state
->mode
= rtld_mode_normal
;
302 state
->any_debug
= false;
303 state
->version_info
= false;
306 #ifndef HAVE_INLINED_SYSCALLS
307 /* Set nonzero during loading and initialization of executable and
308 libraries, cleared before the executable's entry point runs. This
309 must not be initialized to nonzero, because the unused dynamic
310 linker loaded in for libc.so's "ld.so.1" dep will provide the
311 definition seen by libc.so's initializer; that value must be zero,
312 and will be since that dynamic linker's _dl_start and dl_main will
314 int _dl_starting_up
= 0;
315 rtld_hidden_def (_dl_starting_up
)
318 /* This is the structure which defines all variables global to ld.so
319 (except those which cannot be added for some reason). */
320 struct rtld_global _rtld_global
=
322 /* Get architecture specific initializer. */
323 #include <dl-procruntime.c>
324 /* Generally the default presumption without further information is an
325 * executable stack but this is not true for all platforms. */
326 ._dl_stack_flags
= DEFAULT_STACK_PERMS
,
327 #ifdef _LIBC_REENTRANT
328 ._dl_load_lock
= _RTLD_LOCK_RECURSIVE_INITIALIZER
,
329 ._dl_load_write_lock
= _RTLD_LOCK_RECURSIVE_INITIALIZER
,
330 ._dl_load_tls_lock
= _RTLD_LOCK_RECURSIVE_INITIALIZER
,
335 #ifdef _LIBC_REENTRANT
336 [LM_ID_BASE
] = { ._ns_unique_sym_table
337 = { .lock
= _RTLD_LOCK_RECURSIVE_INITIALIZER
} }
341 /* If we would use strong_alias here the compiler would see a
342 non-hidden definition. This would undo the effect of the previous
343 declaration. So spell out what strong_alias does plus add the
344 visibility attribute. */
345 extern struct rtld_global _rtld_local
346 __attribute__ ((alias ("_rtld_global"), visibility ("hidden")));
349 /* This variable is similar to _rtld_local, but all values are
350 read-only after relocation. */
351 struct rtld_global_ro _rtld_global_ro attribute_relro
=
353 /* Get architecture specific initializer. */
354 #include <dl-procinfo.c>
355 #ifdef NEED_DL_SYSINFO
356 ._dl_sysinfo
= DL_SYSINFO_DEFAULT
,
358 ._dl_debug_fd
= STDERR_FILENO
,
360 ._dl_hwcap_mask
= HWCAP_IMPORTANT
,
363 ._dl_fpu_control
= _FPU_DEFAULT
,
364 ._dl_pagesize
= EXEC_PAGESIZE
,
365 ._dl_inhibit_cache
= 0,
367 /* Function pointers. */
368 ._dl_debug_printf
= _dl_debug_printf
,
369 ._dl_mcount
= _dl_mcount
,
370 ._dl_lookup_symbol_x
= _dl_lookup_symbol_x
,
371 ._dl_open
= _dl_open
,
372 ._dl_close
= _dl_close
,
373 ._dl_catch_error
= _rtld_catch_error
,
374 ._dl_error_free
= _dl_error_free
,
375 ._dl_tls_get_addr_soft
= _dl_tls_get_addr_soft
,
376 ._dl_libc_freeres
= __rtld_libc_freeres
,
378 /* If we would use strong_alias here the compiler would see a
379 non-hidden definition. This would undo the effect of the previous
380 declaration. So spell out was strong_alias does plus add the
381 visibility attribute. */
382 extern struct rtld_global_ro _rtld_local_ro
383 __attribute__ ((alias ("_rtld_global_ro"), visibility ("hidden")));
386 static void dl_main (const ElfW(Phdr
) *phdr
, ElfW(Word
) phnum
,
387 ElfW(Addr
) *user_entry
, ElfW(auxv_t
) *auxv
);
389 /* These two variables cannot be moved into .data.rel.ro. */
390 static struct libname_list _dl_rtld_libname
;
391 static struct libname_list _dl_rtld_libname2
;
393 /* Variable for statistics. */
394 RLTD_TIMING_DECLARE (relocate_time
, static);
395 RLTD_TIMING_DECLARE (load_time
, static, attribute_relro
);
396 RLTD_TIMING_DECLARE (start_time
, static, attribute_relro
);
398 /* Additional definitions needed by TLS initialization. */
399 #ifdef TLS_INIT_HELPER
403 /* Helper function for syscall implementation. */
404 #ifdef DL_SYSINFO_IMPLEMENTATION
405 DL_SYSINFO_IMPLEMENTATION
408 /* Before ld.so is relocated we must not access variables which need
409 relocations. This means variables which are exported. Variables
410 declared as static are fine. If we can mark a variable hidden this
411 is fine, too. The latter is important here. We can avoid setting
412 up a temporary link map for ld.so if we can mark _rtld_global as
414 #ifndef HIDDEN_VAR_NEEDS_DYNAMIC_RELOC
415 # define DONT_USE_BOOTSTRAP_MAP 1
418 #ifdef DONT_USE_BOOTSTRAP_MAP
419 static ElfW(Addr
) _dl_start_final (void *arg
);
421 struct dl_start_final_info
424 RTLD_TIMING_VAR (start_time
);
426 static ElfW(Addr
) _dl_start_final (void *arg
,
427 struct dl_start_final_info
*info
);
430 /* These are defined magically by the linker. */
431 extern const ElfW(Ehdr
) __ehdr_start attribute_hidden
;
432 extern char _etext
[] attribute_hidden
;
433 extern char _end
[] attribute_hidden
;
439 # error "sysdeps/MACHINE/dl-machine.h fails to define RTLD_START"
442 /* This is the second half of _dl_start (below). It can be inlined safely
443 under DONT_USE_BOOTSTRAP_MAP, where it is careful not to make any GOT
444 references. When the tools don't permit us to avoid using a GOT entry
445 for _dl_rtld_global (no attribute_hidden support), we must make sure
446 this function is not inlined (see below). */
448 #ifdef DONT_USE_BOOTSTRAP_MAP
449 static inline ElfW(Addr
) __attribute__ ((always_inline
))
450 _dl_start_final (void *arg
)
452 static ElfW(Addr
) __attribute__ ((noinline
))
453 _dl_start_final (void *arg
, struct dl_start_final_info
*info
)
456 ElfW(Addr
) start_addr
;
458 /* Do not use an initializer for these members because it would
459 intefere with __rtld_static_init. */
460 GLRO (dl_find_object
) = &_dl_find_object
;
462 /* If it hasn't happen yet record the startup time. */
463 rtld_timer_start (&start_time
);
464 #if !defined DONT_USE_BOOTSTRAP_MAP
465 RTLD_TIMING_SET (start_time
, info
->start_time
);
468 /* Transfer data about ourselves to the permanent link_map structure. */
469 #ifndef DONT_USE_BOOTSTRAP_MAP
470 GL(dl_rtld_map
).l_addr
= info
->l
.l_addr
;
471 GL(dl_rtld_map
).l_ld
= info
->l
.l_ld
;
472 GL(dl_rtld_map
).l_ld_readonly
= info
->l
.l_ld_readonly
;
473 memcpy (GL(dl_rtld_map
).l_info
, info
->l
.l_info
,
474 sizeof GL(dl_rtld_map
).l_info
);
475 GL(dl_rtld_map
).l_mach
= info
->l
.l_mach
;
476 GL(dl_rtld_map
).l_relocated
= 1;
478 _dl_setup_hash (&GL(dl_rtld_map
));
479 GL(dl_rtld_map
).l_real
= &GL(dl_rtld_map
);
480 GL(dl_rtld_map
).l_map_start
= (ElfW(Addr
)) &__ehdr_start
;
481 GL(dl_rtld_map
).l_map_end
= (ElfW(Addr
)) _end
;
482 GL(dl_rtld_map
).l_text_end
= (ElfW(Addr
)) _etext
;
483 /* Copy the TLS related data if necessary. */
484 #ifndef DONT_USE_BOOTSTRAP_MAP
485 # if NO_TLS_OFFSET != 0
486 GL(dl_rtld_map
).l_tls_offset
= NO_TLS_OFFSET
;
490 /* Initialize the stack end variable. */
491 __libc_stack_end
= __builtin_frame_address (0);
493 /* Call the OS-dependent function to set up life so we can do things like
494 file access. It will call `dl_main' (below) to do all the real work
495 of the dynamic linker, and then unwind our frame and run the user
496 entry point on the same stack we entered on. */
497 start_addr
= _dl_sysdep_start (arg
, &dl_main
);
499 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_STATISTICS
))
501 RTLD_TIMING_VAR (rtld_total_time
);
502 rtld_timer_stop (&rtld_total_time
, start_time
);
503 print_statistics (RTLD_TIMING_REF(rtld_total_time
));
506 #ifndef ELF_MACHINE_START_ADDRESS
507 # define ELF_MACHINE_START_ADDRESS(map, start) (start)
509 return ELF_MACHINE_START_ADDRESS (GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
, start_addr
);
512 #ifdef DONT_USE_BOOTSTRAP_MAP
513 # define bootstrap_map GL(dl_rtld_map)
515 # define bootstrap_map info.l
518 static ElfW(Addr
) __attribute_used__
519 _dl_start (void *arg
)
521 #ifdef DONT_USE_BOOTSTRAP_MAP
522 rtld_timer_start (&start_time
);
524 struct dl_start_final_info info
;
525 rtld_timer_start (&info
.start_time
);
528 /* Partly clean the `bootstrap_map' structure up. Don't use
529 `memset' since it might not be built in or inlined and we cannot
530 make function calls at this point. Use '__builtin_memset' if we
531 know it is available. We do not have to clear the memory if we
532 do not have to use the temporary bootstrap_map. Global variables
533 are initialized to zero by default. */
534 #ifndef DONT_USE_BOOTSTRAP_MAP
535 # ifdef HAVE_BUILTIN_MEMSET
536 __builtin_memset (bootstrap_map
.l_info
, '\0', sizeof (bootstrap_map
.l_info
));
539 cnt
< sizeof (bootstrap_map
.l_info
) / sizeof (bootstrap_map
.l_info
[0]);
541 bootstrap_map
.l_info
[cnt
] = 0;
545 /* Figure out the run-time load address of the dynamic linker itself. */
546 bootstrap_map
.l_addr
= elf_machine_load_address ();
548 /* Read our own dynamic section and fill in the info array. */
549 bootstrap_map
.l_ld
= (void *) bootstrap_map
.l_addr
+ elf_machine_dynamic ();
550 bootstrap_map
.l_ld_readonly
= DL_RO_DYN_SECTION
;
551 elf_get_dynamic_info (&bootstrap_map
, true, false);
553 #if NO_TLS_OFFSET != 0
554 bootstrap_map
.l_tls_offset
= NO_TLS_OFFSET
;
557 #ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
558 ELF_MACHINE_BEFORE_RTLD_RELOC (&bootstrap_map
, bootstrap_map
.l_info
);
561 if (bootstrap_map
.l_addr
)
563 /* Relocate ourselves so we can do normal function calls and
564 data access using the global offset table. */
566 ELF_DYNAMIC_RELOCATE (&bootstrap_map
, NULL
, 0, 0, 0);
568 bootstrap_map
.l_relocated
= 1;
570 /* Please note that we don't allow profiling of this object and
571 therefore need not test whether we have to allocate the array
572 for the relocation results (as done in dl-reloc.c). */
574 /* Now life is sane; we can call functions and access global data.
575 Set up to use the operating system facilities, and find out from
576 the operating system's program loader where to find the program
577 header table in core. Put the rest of _dl_start into a separate
578 function, that way the compiler cannot put accesses to the GOT
579 before ELF_DYNAMIC_RELOCATE. */
581 __rtld_malloc_init_stubs ();
583 #ifdef DONT_USE_BOOTSTRAP_MAP
584 return _dl_start_final (arg
);
586 return _dl_start_final (arg
, &info
);
592 /* Now life is peachy; we can do all normal operations.
593 On to the real work. */
595 /* Some helper functions. */
597 /* Arguments to relocate_doit. */
606 /* Argument to map_doit. */
608 struct link_map
*loader
;
610 /* Return value of map_doit. */
611 struct link_map
*map
;
617 struct link_map
*map
;
623 struct link_map
*map
;
627 /* Arguments to version_check_doit. */
628 struct version_check_args
635 relocate_doit (void *a
)
637 struct relocate_args
*args
= (struct relocate_args
*) a
;
639 _dl_relocate_object (args
->l
, args
->l
->l_scope
, args
->reloc_mode
, 0);
645 struct map_args
*args
= (struct map_args
*) a
;
646 int type
= (args
->mode
== __RTLD_OPENEXEC
) ? lt_executable
: lt_library
;
647 args
->map
= _dl_map_object (args
->loader
, args
->str
, type
, 0,
648 args
->mode
, LM_ID_BASE
);
652 dlmopen_doit (void *a
)
654 struct dlmopen_args
*args
= (struct dlmopen_args
*) a
;
655 args
->map
= _dl_open (args
->fname
,
656 (RTLD_LAZY
| __RTLD_DLOPEN
| __RTLD_AUDIT
658 dl_main
, LM_ID_NEWLM
, _dl_argc
, _dl_argv
,
663 lookup_doit (void *a
)
665 struct lookup_args
*args
= (struct lookup_args
*) a
;
666 const ElfW(Sym
) *ref
= NULL
;
668 lookup_t l
= _dl_lookup_symbol_x (args
->name
, args
->map
, &ref
,
669 args
->map
->l_local_scope
, NULL
, 0,
670 DL_LOOKUP_RETURN_NEWEST
, NULL
);
672 args
->result
= DL_SYMBOL_ADDRESS (l
, ref
);
676 version_check_doit (void *a
)
678 struct version_check_args
*args
= (struct version_check_args
*) a
;
679 if (_dl_check_all_versions (GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
, 1,
680 args
->dotrace
) && args
->doexit
)
681 /* We cannot start the application. Abort now. */
686 static inline struct link_map
*
687 find_needed (const char *name
)
689 struct r_scope_elem
*scope
= &GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
->l_searchlist
;
690 unsigned int n
= scope
->r_nlist
;
693 if (_dl_name_match_p (name
, scope
->r_list
[n
]))
694 return scope
->r_list
[n
];
696 /* Should never happen. */
701 match_version (const char *string
, struct link_map
*map
)
703 const char *strtab
= (const void *) D_PTR (map
, l_info
[DT_STRTAB
]);
706 #define VERDEFTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERDEF))
707 if (map
->l_info
[VERDEFTAG
] == NULL
)
708 /* The file has no symbol versioning. */
711 def
= (ElfW(Verdef
) *) ((char *) map
->l_addr
712 + map
->l_info
[VERDEFTAG
]->d_un
.d_ptr
);
715 ElfW(Verdaux
) *aux
= (ElfW(Verdaux
) *) ((char *) def
+ def
->vd_aux
);
717 /* Compare the version strings. */
718 if (strcmp (string
, strtab
+ aux
->vda_name
) == 0)
722 /* If no more definitions we failed to find what we want. */
723 if (def
->vd_next
== 0)
726 /* Next definition. */
727 def
= (ElfW(Verdef
) *) ((char *) def
+ def
->vd_next
);
733 static bool tls_init_tp_called
;
736 init_tls (size_t naudit
)
738 /* Number of elements in the static TLS block. */
739 GL(dl_tls_static_nelem
) = GL(dl_tls_max_dtv_idx
);
741 /* Do not do this twice. The audit interface might have required
742 the DTV interfaces to be set up early. */
743 if (GL(dl_initial_dtv
) != NULL
)
746 /* Allocate the array which contains the information about the
747 dtv slots. We allocate a few entries more than needed to
748 avoid the need for reallocation. */
749 size_t nelem
= GL(dl_tls_max_dtv_idx
) + 1 + TLS_SLOTINFO_SURPLUS
;
752 GL(dl_tls_dtv_slotinfo_list
) = (struct dtv_slotinfo_list
*)
753 calloc (sizeof (struct dtv_slotinfo_list
)
754 + nelem
* sizeof (struct dtv_slotinfo
), 1);
755 /* No need to check the return value. If memory allocation failed
756 the program would have been terminated. */
758 struct dtv_slotinfo
*slotinfo
= GL(dl_tls_dtv_slotinfo_list
)->slotinfo
;
759 GL(dl_tls_dtv_slotinfo_list
)->len
= nelem
;
760 GL(dl_tls_dtv_slotinfo_list
)->next
= NULL
;
762 /* Fill in the information from the loaded modules. No namespace
763 but the base one can be filled at this time. */
764 assert (GL(dl_ns
)[LM_ID_BASE
+ 1]._ns_loaded
== NULL
);
766 for (struct link_map
*l
= GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
; l
!= NULL
;
768 if (l
->l_tls_blocksize
!= 0)
770 /* This is a module with TLS data. Store the map reference.
771 The generation counter is zero. */
773 /* slotinfo[i].gen = 0; */
776 assert (i
== GL(dl_tls_max_dtv_idx
));
778 /* Calculate the size of the static TLS surplus. */
779 _dl_tls_static_surplus_init (naudit
);
781 /* Compute the TLS offsets for the various blocks. */
782 _dl_determine_tlsoffset ();
784 /* Construct the static TLS block and the dtv for the initial
785 thread. For some platforms this will include allocating memory
786 for the thread descriptor. The memory for the TLS block will
787 never be freed. It should be allocated accordingly. The dtv
788 array can be changed if dynamic loading requires it. */
789 void *tcbp
= _dl_allocate_tls_storage ();
792 cannot allocate TLS data structures for initial thread\n");
794 /* Store for detection of the special case by __tls_get_addr
795 so it knows not to pass this dtv to the normal realloc. */
796 GL(dl_initial_dtv
) = GET_DTV (tcbp
);
798 /* And finally install it for the main thread. */
799 const char *lossage
= TLS_INIT_TP (tcbp
);
800 if (__glibc_unlikely (lossage
!= NULL
))
801 _dl_fatal_printf ("cannot set up thread-local storage: %s\n", lossage
);
803 tls_init_tp_called
= true;
809 do_preload (const char *fname
, struct link_map
*main_map
, const char *where
)
812 const char *err_str
= NULL
;
813 struct map_args args
;
817 args
.loader
= main_map
;
818 args
.mode
= __RTLD_SECURE
;
820 unsigned int old_nloaded
= GL(dl_ns
)[LM_ID_BASE
]._ns_nloaded
;
822 (void) _dl_catch_error (&objname
, &err_str
, &malloced
, map_doit
, &args
);
823 if (__glibc_unlikely (err_str
!= NULL
))
826 ERROR: ld.so: object '%s' from %s cannot be preloaded (%s): ignored.\n",
827 fname
, where
, err_str
);
828 /* No need to call free, this is still before
829 the libc's malloc is used. */
831 else if (GL(dl_ns
)[LM_ID_BASE
]._ns_nloaded
!= old_nloaded
)
832 /* It is no duplicate. */
835 /* Nothing loaded. */
842 /* Set up the stack checker's canary. */
843 uintptr_t stack_chk_guard
= _dl_setup_stack_chk_guard (_dl_random
);
844 #ifdef THREAD_SET_STACK_GUARD
845 THREAD_SET_STACK_GUARD (stack_chk_guard
);
847 __stack_chk_guard
= stack_chk_guard
;
850 /* Set up the pointer guard as well, if necessary. */
851 uintptr_t pointer_chk_guard
852 = _dl_setup_pointer_guard (_dl_random
, stack_chk_guard
);
853 #ifdef THREAD_SET_POINTER_GUARD
854 THREAD_SET_POINTER_GUARD (pointer_chk_guard
);
856 __pointer_chk_guard_local
= pointer_chk_guard
;
858 /* We do not need the _dl_random value anymore. The less
859 information we leave behind, the better, so clear the
864 #include <setup-vdso.h>
866 /* The LD_PRELOAD environment variable gives list of libraries
867 separated by white space or colons that are loaded before the
868 executable's dependencies and prepended to the global scope list.
869 (If the binary is running setuid all elements containing a '/' are
870 ignored since it is insecure.) Return the number of preloads
871 performed. Ditto for --preload command argument. */
873 handle_preload_list (const char *preloadlist
, struct link_map
*main_map
,
876 unsigned int npreloads
= 0;
877 const char *p
= preloadlist
;
878 char fname
[SECURE_PATH_LIMIT
];
882 /* Split preload list at space/colon. */
883 size_t len
= strcspn (p
, " :");
884 if (len
> 0 && len
< sizeof (fname
))
886 memcpy (fname
, p
, len
);
892 /* Skip over the substring and the following delimiter. */
897 if (dso_name_valid_for_suid (fname
))
898 npreloads
+= do_preload (fname
, main_map
, where
);
903 /* Called if the audit DSO cannot be used: if it does not have the
904 appropriate interfaces, or it expects a more recent version library
905 version than what the dynamic linker provides. */
907 unload_audit_module (struct link_map
*map
, int original_tls_idx
)
910 Lmid_t ns
= map
->l_ns
;
914 /* Make sure the namespace has been cleared entirely. */
915 assert (GL(dl_ns
)[ns
]._ns_loaded
== NULL
);
916 assert (GL(dl_ns
)[ns
]._ns_nloaded
== 0);
918 GL(dl_tls_max_dtv_idx
) = original_tls_idx
;
921 /* Called to print an error message if loading of an audit module
924 report_audit_module_load_error (const char *name
, const char *err_str
,
928 ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n",
931 free ((char *) err_str
);
934 /* Load one audit module. */
936 load_audit_module (const char *name
, struct audit_ifaces
**last_audit
)
938 int original_tls_idx
= GL(dl_tls_max_dtv_idx
);
940 struct dlmopen_args dlmargs
;
941 dlmargs
.fname
= name
;
945 const char *err_str
= NULL
;
947 _dl_catch_error (&objname
, &err_str
, &malloced
, dlmopen_doit
, &dlmargs
);
948 if (__glibc_unlikely (err_str
!= NULL
))
950 report_audit_module_load_error (name
, err_str
, malloced
);
954 struct lookup_args largs
;
955 largs
.name
= "la_version";
956 largs
.map
= dlmargs
.map
;
957 _dl_catch_error (&objname
, &err_str
, &malloced
, lookup_doit
, &largs
);
958 if (__glibc_likely (err_str
!= NULL
))
960 unload_audit_module (dlmargs
.map
, original_tls_idx
);
961 report_audit_module_load_error (name
, err_str
, malloced
);
965 unsigned int (*laversion
) (unsigned int) = largs
.result
;
967 /* A null symbol indicates that something is very wrong with the
968 loaded object because defined symbols are supposed to have a
969 valid, non-null address. */
970 assert (laversion
!= NULL
);
972 unsigned int lav
= laversion (LAV_CURRENT
);
975 /* Only print an error message if debugging because this can
976 happen deliberately. */
977 if (GLRO(dl_debug_mask
) & DL_DEBUG_FILES
)
979 file=%s [%lu]; audit interface function la_version returned zero; ignored.\n",
980 dlmargs
.map
->l_name
, dlmargs
.map
->l_ns
);
981 unload_audit_module (dlmargs
.map
, original_tls_idx
);
985 if (!_dl_audit_check_version (lav
))
988 ERROR: audit interface '%s' requires version %d (maximum supported version %d); ignored.\n",
989 name
, lav
, LAV_CURRENT
);
990 unload_audit_module (dlmargs
.map
, original_tls_idx
);
994 enum { naudit_ifaces
= 8 };
997 struct audit_ifaces ifaces
;
998 void (*fptr
[naudit_ifaces
]) (void);
999 } *newp
= malloc (sizeof (*newp
));
1001 _dl_fatal_printf ("Out of memory while loading audit modules\n");
1003 /* Names of the auditing interfaces. All in one
1005 static const char audit_iface_names
[] =
1011 #define STRING(s) __STRING (s)
1012 "la_" STRING (ARCH_LA_PLTENTER
) "\0"
1013 "la_" STRING (ARCH_LA_PLTEXIT
) "\0"
1015 unsigned int cnt
= 0;
1016 const char *cp
= audit_iface_names
;
1020 _dl_catch_error (&objname
, &err_str
, &malloced
, lookup_doit
, &largs
);
1022 /* Store the pointer. */
1023 if (err_str
== NULL
&& largs
.result
!= NULL
)
1024 newp
->fptr
[cnt
] = largs
.result
;
1026 newp
->fptr
[cnt
] = NULL
;
1029 cp
= rawmemchr (cp
, '\0') + 1;
1031 while (*cp
!= '\0');
1032 assert (cnt
== naudit_ifaces
);
1034 /* Now append the new auditing interface to the list. */
1035 newp
->ifaces
.next
= NULL
;
1036 if (*last_audit
== NULL
)
1037 *last_audit
= GLRO(dl_audit
) = &newp
->ifaces
;
1039 *last_audit
= (*last_audit
)->next
= &newp
->ifaces
;
1041 /* The dynamic linker link map is statically allocated, so the
1042 cookie in _dl_new_object has not happened. */
1043 link_map_audit_state (&GL (dl_rtld_map
), GLRO (dl_naudit
))->cookie
1044 = (intptr_t) &GL (dl_rtld_map
);
1048 /* Mark the DSO as being used for auditing. */
1049 dlmargs
.map
->l_auditing
= 1;
1052 /* Load all audit modules. */
1054 load_audit_modules (struct link_map
*main_map
, struct audit_list
*audit_list
)
1056 struct audit_ifaces
*last_audit
= NULL
;
1060 const char *name
= audit_list_next (audit_list
);
1063 load_audit_module (name
, &last_audit
);
1066 /* Notify audit modules of the initially loaded modules (the main
1067 program and the dynamic linker itself). */
1068 if (GLRO(dl_naudit
) > 0)
1070 _dl_audit_objopen (main_map
, LM_ID_BASE
);
1071 _dl_audit_objopen (&GL(dl_rtld_map
), LM_ID_BASE
);
1075 /* Check if the executable is not actualy dynamically linked, and
1076 invoke it directly in that case. */
1078 rtld_chain_load (struct link_map
*main_map
, char *argv0
)
1080 /* The dynamic loader run against itself. */
1081 const char *rtld_soname
1082 = ((const char *) D_PTR (&GL(dl_rtld_map
), l_info
[DT_STRTAB
])
1083 + GL(dl_rtld_map
).l_info
[DT_SONAME
]->d_un
.d_val
);
1084 if (main_map
->l_info
[DT_SONAME
] != NULL
1085 && strcmp (rtld_soname
,
1086 ((const char *) D_PTR (main_map
, l_info
[DT_STRTAB
])
1087 + main_map
->l_info
[DT_SONAME
]->d_un
.d_val
)) == 0)
1088 _dl_fatal_printf ("%s: loader cannot load itself\n", rtld_soname
);
1090 /* With DT_NEEDED dependencies, the executable is dynamically
1092 if (__glibc_unlikely (main_map
->l_info
[DT_NEEDED
] != NULL
))
1095 /* If the executable has program interpreter, it is dynamically
1097 for (size_t i
= 0; i
< main_map
->l_phnum
; ++i
)
1098 if (main_map
->l_phdr
[i
].p_type
== PT_INTERP
)
1101 const char *pathname
= _dl_argv
[0];
1103 _dl_argv
[0] = argv0
;
1104 int errcode
= __rtld_execve (pathname
, _dl_argv
, _environ
);
1105 const char *errname
= strerrorname_np (errcode
);
1106 if (errname
!= NULL
)
1107 _dl_fatal_printf("%s: cannot execute %s: %s\n",
1108 rtld_soname
, pathname
, errname
);
1110 _dl_fatal_printf("%s: cannot execute %s: %d\n",
1111 rtld_soname
, pathname
, errcode
);
1114 /* Called to complete the initialization of the link map for the main
1115 executable. Returns true if there is a PT_INTERP segment. */
1117 rtld_setup_main_map (struct link_map
*main_map
)
1119 /* This have already been filled in right after _dl_new_object, or
1120 as part of _dl_map_object. */
1121 const ElfW(Phdr
) *phdr
= main_map
->l_phdr
;
1122 ElfW(Word
) phnum
= main_map
->l_phnum
;
1124 bool has_interp
= false;
1126 main_map
->l_map_end
= 0;
1127 main_map
->l_text_end
= 0;
1128 /* Perhaps the executable has no PT_LOAD header entries at all. */
1129 main_map
->l_map_start
= ~0;
1130 /* And it was opened directly. */
1131 ++main_map
->l_direct_opencount
;
1132 main_map
->l_contiguous
= 1;
1134 /* A PT_LOAD segment at an unexpected address will clear the
1135 l_contiguous flag. The ELF specification says that PT_LOAD
1136 segments need to be sorted in in increasing order, but perhaps
1137 not all executables follow this requirement. Having l_contiguous
1138 equal to 1 is just an optimization, so the code below does not
1139 try to sort the segments in case they are unordered.
1141 There is one corner case in which l_contiguous is not set to 1,
1142 but where it could be set: If a PIE (ET_DYN) binary is loaded by
1143 glibc itself (not the kernel), it is always contiguous due to the
1144 way the glibc loader works. However, the kernel loader may still
1145 create holes in this case, and the code here still uses 0
1146 conservatively for the glibc-loaded case, too. */
1147 ElfW(Addr
) expected_load_address
= 0;
1149 /* Scan the program header table for the dynamic section. */
1150 for (const ElfW(Phdr
) *ph
= phdr
; ph
< &phdr
[phnum
]; ++ph
)
1154 /* Find out the load address. */
1155 main_map
->l_addr
= (ElfW(Addr
)) phdr
- ph
->p_vaddr
;
1158 /* This tells us where to find the dynamic section,
1159 which tells us everything we need to do. */
1160 main_map
->l_ld
= (void *) main_map
->l_addr
+ ph
->p_vaddr
;
1161 main_map
->l_ld_readonly
= (ph
->p_flags
& PF_W
) == 0;
1164 /* This "interpreter segment" was used by the program loader to
1165 find the program interpreter, which is this program itself, the
1166 dynamic linker. We note what name finds us, so that a future
1167 dlopen call or DT_NEEDED entry, for something that wants to link
1168 against the dynamic linker as a shared library, will know that
1169 the shared object is already loaded. */
1170 _dl_rtld_libname
.name
= ((const char *) main_map
->l_addr
1172 /* _dl_rtld_libname.next = NULL; Already zero. */
1173 GL(dl_rtld_map
).l_libname
= &_dl_rtld_libname
;
1175 /* Ordinarilly, we would get additional names for the loader from
1176 our DT_SONAME. This can't happen if we were actually linked as
1177 a static executable (detect this case when we have no DYNAMIC).
1178 If so, assume the filename component of the interpreter path to
1179 be our SONAME, and add it to our name list. */
1180 if (GL(dl_rtld_map
).l_ld
== NULL
)
1182 const char *p
= NULL
;
1183 const char *cp
= _dl_rtld_libname
.name
;
1185 /* Find the filename part of the path. */
1192 _dl_rtld_libname2
.name
= p
;
1193 /* _dl_rtld_libname2.next = NULL; Already zero. */
1194 _dl_rtld_libname
.next
= &_dl_rtld_libname2
;
1202 ElfW(Addr
) mapstart
;
1203 ElfW(Addr
) allocend
;
1205 /* Remember where the main program starts in memory. */
1206 mapstart
= (main_map
->l_addr
1207 + (ph
->p_vaddr
& ~(GLRO(dl_pagesize
) - 1)));
1208 if (main_map
->l_map_start
> mapstart
)
1209 main_map
->l_map_start
= mapstart
;
1211 if (main_map
->l_contiguous
&& expected_load_address
!= 0
1212 && expected_load_address
!= mapstart
)
1213 main_map
->l_contiguous
= 0;
1215 /* Also where it ends. */
1216 allocend
= main_map
->l_addr
+ ph
->p_vaddr
+ ph
->p_memsz
;
1217 if (main_map
->l_map_end
< allocend
)
1218 main_map
->l_map_end
= allocend
;
1219 if ((ph
->p_flags
& PF_X
) && allocend
> main_map
->l_text_end
)
1220 main_map
->l_text_end
= allocend
;
1222 /* The next expected address is the page following this load
1224 expected_load_address
= ((allocend
+ GLRO(dl_pagesize
) - 1)
1225 & ~(GLRO(dl_pagesize
) - 1));
1230 if (ph
->p_memsz
> 0)
1232 /* Note that in the case the dynamic linker we duplicate work
1233 here since we read the PT_TLS entry already in
1234 _dl_start_final. But the result is repeatable so do not
1235 check for this special but unimportant case. */
1236 main_map
->l_tls_blocksize
= ph
->p_memsz
;
1237 main_map
->l_tls_align
= ph
->p_align
;
1238 if (ph
->p_align
== 0)
1239 main_map
->l_tls_firstbyte_offset
= 0;
1241 main_map
->l_tls_firstbyte_offset
= (ph
->p_vaddr
1242 & (ph
->p_align
- 1));
1243 main_map
->l_tls_initimage_size
= ph
->p_filesz
;
1244 main_map
->l_tls_initimage
= (void *) ph
->p_vaddr
;
1246 /* This image gets the ID one. */
1247 GL(dl_tls_max_dtv_idx
) = main_map
->l_tls_modid
= 1;
1252 GL(dl_stack_flags
) = ph
->p_flags
;
1256 main_map
->l_relro_addr
= ph
->p_vaddr
;
1257 main_map
->l_relro_size
= ph
->p_memsz
;
1260 /* Process program headers again, but scan them backwards so
1261 that PT_NOTE can be skipped if PT_GNU_PROPERTY exits. */
1262 for (const ElfW(Phdr
) *ph
= &phdr
[phnum
]; ph
!= phdr
; --ph
)
1263 switch (ph
[-1].p_type
)
1266 _dl_process_pt_note (main_map
, -1, &ph
[-1]);
1268 case PT_GNU_PROPERTY
:
1269 _dl_process_pt_gnu_property (main_map
, -1, &ph
[-1]);
1273 /* Adjust the address of the TLS initialization image in case
1274 the executable is actually an ET_DYN object. */
1275 if (main_map
->l_tls_initimage
!= NULL
)
1276 main_map
->l_tls_initimage
1277 = (char *) main_map
->l_tls_initimage
+ main_map
->l_addr
;
1278 if (! main_map
->l_map_end
)
1279 main_map
->l_map_end
= ~0;
1280 if (! main_map
->l_text_end
)
1281 main_map
->l_text_end
= ~0;
1282 if (! GL(dl_rtld_map
).l_libname
&& GL(dl_rtld_map
).l_name
)
1284 /* We were invoked directly, so the program might not have a
1286 _dl_rtld_libname
.name
= GL(dl_rtld_map
).l_name
;
1287 /* _dl_rtld_libname.next = NULL; Already zero. */
1288 GL(dl_rtld_map
).l_libname
= &_dl_rtld_libname
;
1291 assert (GL(dl_rtld_map
).l_libname
); /* How else did we get here? */
1296 /* Adjusts the contents of the stack and related globals for the user
1297 entry point. The ld.so processed skip_args arguments and bumped
1298 _dl_argv and _dl_argc accordingly. Those arguments are removed from
1301 _dl_start_args_adjust (int skip_args
)
1303 void **sp
= (void **) (_dl_argv
- skip_args
- 1);
1304 void **p
= sp
+ skip_args
;
1310 intptr_t argc
__attribute__ ((unused
)) = (intptr_t) sp
[0] - skip_args
;
1311 assert (argc
== _dl_argc
);
1313 /* Adjust argc on stack. */
1314 sp
[0] = (void *) (intptr_t) _dl_argc
;
1316 /* Update globals in rtld. */
1317 _dl_argv
-= skip_args
;
1318 _environ
-= skip_args
;
1320 /* Shuffle argv down. */
1325 assert (_environ
== (char **) (sp
+ 1));
1327 /* Shuffle envp down. */
1332 #ifdef HAVE_AUX_VECTOR
1333 void **auxv
= (void **) GLRO(dl_auxv
) - skip_args
;
1334 GLRO(dl_auxv
) = (ElfW(auxv_t
) *) auxv
; /* Aliasing violation. */
1335 assert (auxv
== sp
+ 1);
1337 /* Shuffle auxv down. */
1339 char *oldp
= (char *) (p
+ 1);
1340 char *newp
= (char *) (sp
+ 1);
1343 memcpy (&ax
, oldp
, sizeof (ax
));
1344 memcpy (newp
, &ax
, sizeof (ax
));
1345 oldp
+= sizeof (ax
);
1346 newp
+= sizeof (ax
);
1348 while (ax
.a_type
!= AT_NULL
);
1353 dl_main (const ElfW(Phdr
) *phdr
,
1355 ElfW(Addr
) *user_entry
,
1358 struct link_map
*main_map
;
1362 bool rtld_is_main
= false;
1365 struct dl_main_state state
;
1366 dl_main_state_init (&state
);
1368 __tls_pre_init_tp ();
1370 #if !PTHREAD_IN_LIBC
1371 /* The explicit initialization here is cheaper than processing the reloc
1372 in the _rtld_local definition's initializer. */
1373 GL(dl_make_stack_executable_hook
) = &_dl_make_stack_executable
;
1376 /* Process the environment variable which control the behaviour. */
1377 process_envvars (&state
);
1379 #ifndef HAVE_INLINED_SYSCALLS
1380 /* Set up a flag which tells we are just starting. */
1381 _dl_starting_up
= 1;
1384 const char *ld_so_name
= _dl_argv
[0];
1385 if (*user_entry
== (ElfW(Addr
)) ENTRY_POINT
)
1387 /* Ho ho. We are not the program interpreter! We are the program
1388 itself! This means someone ran ld.so as a command. Well, that
1389 might be convenient to do sometimes. We support it by
1390 interpreting the args like this:
1392 ld.so PROGRAM ARGS...
1394 The first argument is the name of a file containing an ELF
1395 executable we will load and run with the following arguments.
1396 To simplify life here, PROGRAM is searched for using the
1397 normal rules for shared objects, rather than $PATH or anything
1398 like that. We just load it and use its entry point; we don't
1399 pay attention to its PT_INTERP command (we are the interpreter
1400 ourselves). This is an easy way to test a new ld.so before
1402 rtld_is_main
= true;
1405 char **orig_argv
= _dl_argv
;
1407 /* Note the place where the dynamic linker actually came from. */
1408 GL(dl_rtld_map
).l_name
= rtld_progname
;
1410 while (_dl_argc
> 1)
1411 if (! strcmp (_dl_argv
[1], "--list"))
1413 if (state
.mode
!= rtld_mode_help
)
1415 state
.mode
= rtld_mode_list
;
1416 /* This means do no dependency analysis. */
1423 else if (! strcmp (_dl_argv
[1], "--verify"))
1425 if (state
.mode
!= rtld_mode_help
)
1426 state
.mode
= rtld_mode_verify
;
1431 else if (! strcmp (_dl_argv
[1], "--inhibit-cache"))
1433 GLRO(dl_inhibit_cache
) = 1;
1437 else if (! strcmp (_dl_argv
[1], "--library-path")
1440 state
.library_path
= _dl_argv
[2];
1441 state
.library_path_source
= "--library-path";
1446 else if (! strcmp (_dl_argv
[1], "--inhibit-rpath")
1449 GLRO(dl_inhibit_rpath
) = _dl_argv
[2];
1454 else if (! strcmp (_dl_argv
[1], "--audit") && _dl_argc
> 2)
1456 audit_list_add_string (&state
.audit_list
, _dl_argv
[2]);
1461 else if (! strcmp (_dl_argv
[1], "--preload") && _dl_argc
> 2)
1463 state
.preloadarg
= _dl_argv
[2];
1467 else if (! strcmp (_dl_argv
[1], "--argv0") && _dl_argc
> 2)
1469 argv0
= _dl_argv
[2];
1474 else if (strcmp (_dl_argv
[1], "--glibc-hwcaps-prepend") == 0
1477 state
.glibc_hwcaps_prepend
= _dl_argv
[2];
1481 else if (strcmp (_dl_argv
[1], "--glibc-hwcaps-mask") == 0
1484 state
.glibc_hwcaps_mask
= _dl_argv
[2];
1489 else if (! strcmp (_dl_argv
[1], "--list-tunables"))
1491 state
.mode
= rtld_mode_list_tunables
;
1497 else if (! strcmp (_dl_argv
[1], "--list-diagnostics"))
1499 state
.mode
= rtld_mode_list_diagnostics
;
1504 else if (strcmp (_dl_argv
[1], "--help") == 0)
1506 state
.mode
= rtld_mode_help
;
1510 else if (strcmp (_dl_argv
[1], "--version") == 0)
1512 else if (_dl_argv
[1][0] == '-' && _dl_argv
[1][1] == '-')
1514 if (_dl_argv
[1][1] == '\0')
1515 /* End of option list. */
1518 /* Unrecognized option. */
1519 _dl_usage (ld_so_name
, _dl_argv
[1]);
1525 if (__glibc_unlikely (state
.mode
== rtld_mode_list_tunables
))
1527 __tunables_print ();
1532 if (state
.mode
== rtld_mode_list_diagnostics
)
1533 _dl_print_diagnostics (_environ
);
1535 /* If we have no further argument the program was called incorrectly.
1536 Grant the user some education. */
1539 if (state
.mode
== rtld_mode_help
)
1540 /* --help without an executable is not an error. */
1541 _dl_help (ld_so_name
, &state
);
1543 _dl_usage (ld_so_name
, NULL
);
1549 /* The initialization of _dl_stack_flags done below assumes the
1550 executable's PT_GNU_STACK may have been honored by the kernel, and
1551 so a PT_GNU_STACK with PF_X set means the stack started out with
1552 execute permission. However, this is not really true if the
1553 dynamic linker is the executable the kernel loaded. For this
1554 case, we must reinitialize _dl_stack_flags to match the dynamic
1555 linker itself. If the dynamic linker was built with a
1556 PT_GNU_STACK, then the kernel may have loaded us with a
1557 nonexecutable stack that we will have to make executable when we
1558 load the program below unless it has a PT_GNU_STACK indicating
1559 nonexecutable stack is ok. */
1561 for (const ElfW(Phdr
) *ph
= phdr
; ph
< &phdr
[phnum
]; ++ph
)
1562 if (ph
->p_type
== PT_GNU_STACK
)
1564 GL(dl_stack_flags
) = ph
->p_flags
;
1568 if (__glibc_unlikely (state
.mode
== rtld_mode_verify
1569 || state
.mode
== rtld_mode_help
))
1571 const char *objname
;
1572 const char *err_str
= NULL
;
1573 struct map_args args
;
1576 args
.str
= rtld_progname
;
1578 args
.mode
= __RTLD_OPENEXEC
;
1579 (void) _dl_catch_error (&objname
, &err_str
, &malloced
, map_doit
,
1581 if (__glibc_unlikely (err_str
!= NULL
))
1583 /* We don't free the returned string, the programs stops
1585 if (state
.mode
== rtld_mode_help
)
1586 /* Mask the failure to load the main object. The help
1587 message contains less information in this case. */
1588 _dl_help (ld_so_name
, &state
);
1590 _exit (EXIT_FAILURE
);
1595 RTLD_TIMING_VAR (start
);
1596 rtld_timer_start (&start
);
1597 _dl_map_object (NULL
, rtld_progname
, lt_executable
, 0,
1598 __RTLD_OPENEXEC
, LM_ID_BASE
);
1599 rtld_timer_stop (&load_time
, start
);
1602 /* Now the map for the main executable is available. */
1603 main_map
= GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
;
1605 if (__glibc_likely (state
.mode
== rtld_mode_normal
))
1606 rtld_chain_load (main_map
, argv0
);
1608 phdr
= main_map
->l_phdr
;
1609 phnum
= main_map
->l_phnum
;
1610 /* We overwrite here a pointer to a malloc()ed string. But since
1611 the malloc() implementation used at this point is the dummy
1612 implementations which has no real free() function it does not
1613 makes sense to free the old string first. */
1614 main_map
->l_name
= (char *) "";
1615 *user_entry
= main_map
->l_entry
;
1617 /* Set bit indicating this is the main program map. */
1618 main_map
->l_main_map
= 1;
1620 #ifdef HAVE_AUX_VECTOR
1621 /* Adjust the on-stack auxiliary vector so that it looks like the
1622 binary was executed directly. */
1623 for (ElfW(auxv_t
) *av
= auxv
; av
->a_type
!= AT_NULL
; av
++)
1627 av
->a_un
.a_val
= (uintptr_t) phdr
;
1630 av
->a_un
.a_val
= phnum
;
1633 av
->a_un
.a_val
= *user_entry
;
1637 av
->a_un
.a_val
= (uintptr_t) _dl_argv
[0];
1643 /* Set the argv[0] string now that we've processed the executable. */
1645 _dl_argv
[0] = argv0
;
1647 /* Adjust arguments for the application entry point. */
1648 _dl_start_args_adjust (_dl_argv
- orig_argv
);
1652 /* Create a link_map for the executable itself.
1653 This will be what dlopen on "" returns. */
1654 main_map
= _dl_new_object ((char *) "", "", lt_executable
, NULL
,
1655 __RTLD_OPENEXEC
, LM_ID_BASE
);
1656 assert (main_map
!= NULL
);
1657 main_map
->l_phdr
= phdr
;
1658 main_map
->l_phnum
= phnum
;
1659 main_map
->l_entry
= *user_entry
;
1661 /* Even though the link map is not yet fully initialized we can add
1662 it to the map list since there are no possible users running yet. */
1663 _dl_add_to_namespace_list (main_map
, LM_ID_BASE
);
1664 assert (main_map
== GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
);
1666 /* At this point we are in a bit of trouble. We would have to
1667 fill in the values for l_dev and l_ino. But in general we
1668 do not know where the file is. We also do not handle AT_EXECFD
1669 even if it would be passed up.
1671 We leave the values here defined to 0. This is normally no
1672 problem as the program code itself is normally no shared
1673 object and therefore cannot be loaded dynamically. Nothing
1674 prevent the use of dynamic binaries and in these situations
1675 we might get problems. We might not be able to find out
1676 whether the object is already loaded. But since there is no
1677 easy way out and because the dynamic binary must also not
1678 have an SONAME we ignore this program for now. If it becomes
1679 a problem we can force people using SONAMEs. */
1681 /* We delay initializing the path structure until we got the dynamic
1682 information for the program. */
1685 bool has_interp
= rtld_setup_main_map (main_map
);
1687 /* If the current libname is different from the SONAME, add the
1689 if (GL(dl_rtld_map
).l_info
[DT_SONAME
] != NULL
1690 && strcmp (GL(dl_rtld_map
).l_libname
->name
,
1691 (const char *) D_PTR (&GL(dl_rtld_map
), l_info
[DT_STRTAB
])
1692 + GL(dl_rtld_map
).l_info
[DT_SONAME
]->d_un
.d_val
) != 0)
1694 static struct libname_list newname
;
1695 newname
.name
= ((char *) D_PTR (&GL(dl_rtld_map
), l_info
[DT_STRTAB
])
1696 + GL(dl_rtld_map
).l_info
[DT_SONAME
]->d_un
.d_ptr
);
1697 newname
.next
= NULL
;
1698 newname
.dont_free
= 1;
1700 assert (GL(dl_rtld_map
).l_libname
->next
== NULL
);
1701 GL(dl_rtld_map
).l_libname
->next
= &newname
;
1703 /* The ld.so must be relocated since otherwise loading audit modules
1704 will fail since they reuse the very same ld.so. */
1705 assert (GL(dl_rtld_map
).l_relocated
);
1709 /* Extract the contents of the dynamic section for easy access. */
1710 elf_get_dynamic_info (main_map
, false, false);
1712 /* If the main map is libc.so, update the base namespace to
1713 refer to this map. If libc.so is loaded later, this happens
1714 in _dl_map_object_from_fd. */
1715 if (main_map
->l_info
[DT_SONAME
] != NULL
1716 && (strcmp (((const char *) D_PTR (main_map
, l_info
[DT_STRTAB
])
1717 + main_map
->l_info
[DT_SONAME
]->d_un
.d_val
), LIBC_SO
)
1719 GL(dl_ns
)[LM_ID_BASE
].libc_map
= main_map
;
1721 /* Set up our cache of pointers into the hash table. */
1722 _dl_setup_hash (main_map
);
1725 if (__glibc_unlikely (state
.mode
== rtld_mode_verify
))
1727 /* We were called just to verify that this is a dynamic
1728 executable using us as the program interpreter. Exit with an
1729 error if we were not able to load the binary or no interpreter
1730 is specified (i.e., this is no dynamically linked binary. */
1731 if (main_map
->l_ld
== NULL
)
1734 _exit (has_interp
? 0 : 2);
1737 struct link_map
**first_preload
= &GL(dl_rtld_map
).l_next
;
1738 /* Set up the data structures for the system-supplied DSO early,
1739 so they can influence _dl_init_paths. */
1740 setup_vdso (main_map
, &first_preload
);
1742 /* With vDSO setup we can initialize the function pointers. */
1743 setup_vdso_pointers ();
1745 /* Initialize the data structures for the search paths for shared
1747 call_init_paths (&state
);
1749 /* Initialize _r_debug_extended. */
1750 struct r_debug
*r
= _dl_debug_initialize (GL(dl_rtld_map
).l_addr
,
1752 r
->r_state
= RT_CONSISTENT
;
1754 /* Put the link_map for ourselves on the chain so it can be found by
1755 name. Note that at this point the global chain of link maps contains
1756 exactly one element, which is pointed to by dl_loaded. */
1757 if (! GL(dl_rtld_map
).l_name
)
1758 /* If not invoked directly, the dynamic linker shared object file was
1759 found by the PT_INTERP name. */
1760 GL(dl_rtld_map
).l_name
= (char *) GL(dl_rtld_map
).l_libname
->name
;
1761 GL(dl_rtld_map
).l_type
= lt_library
;
1762 main_map
->l_next
= &GL(dl_rtld_map
);
1763 GL(dl_rtld_map
).l_prev
= main_map
;
1764 ++GL(dl_ns
)[LM_ID_BASE
]._ns_nloaded
;
1767 /* Starting from binutils-2.23, the linker will define the magic symbol
1768 __ehdr_start to point to our own ELF header if it is visible in a
1769 segment that also includes the phdrs. If that's not available, we use
1770 the old method that assumes the beginning of the file is part of the
1771 lowest-addressed PT_LOAD segment. */
1773 /* Set up the program header information for the dynamic linker
1774 itself. It is needed in the dl_iterate_phdr callbacks. */
1775 const ElfW(Ehdr
) *rtld_ehdr
= &__ehdr_start
;
1776 assert (rtld_ehdr
->e_ehsize
== sizeof *rtld_ehdr
);
1777 assert (rtld_ehdr
->e_phentsize
== sizeof (ElfW(Phdr
)));
1779 const ElfW(Phdr
) *rtld_phdr
= (const void *) rtld_ehdr
+ rtld_ehdr
->e_phoff
;
1781 GL(dl_rtld_map
).l_phdr
= rtld_phdr
;
1782 GL(dl_rtld_map
).l_phnum
= rtld_ehdr
->e_phnum
;
1785 /* PT_GNU_RELRO is usually the last phdr. */
1786 size_t cnt
= rtld_ehdr
->e_phnum
;
1788 if (rtld_phdr
[cnt
].p_type
== PT_GNU_RELRO
)
1790 GL(dl_rtld_map
).l_relro_addr
= rtld_phdr
[cnt
].p_vaddr
;
1791 GL(dl_rtld_map
).l_relro_size
= rtld_phdr
[cnt
].p_memsz
;
1795 /* Add the dynamic linker to the TLS list if it also uses TLS. */
1796 if (GL(dl_rtld_map
).l_tls_blocksize
!= 0)
1797 /* Assign a module ID. Do this before loading any audit modules. */
1798 _dl_assign_tls_modid (&GL(dl_rtld_map
));
1800 audit_list_add_dynamic_tag (&state
.audit_list
, main_map
, DT_AUDIT
);
1801 audit_list_add_dynamic_tag (&state
.audit_list
, main_map
, DT_DEPAUDIT
);
1803 /* At this point, all data has been obtained that is included in the
1805 if (__glibc_unlikely (state
.mode
== rtld_mode_help
))
1806 _dl_help (ld_so_name
, &state
);
1808 /* If we have auditing DSOs to load, do it now. */
1809 bool need_security_init
= true;
1810 if (state
.audit_list
.length
> 0)
1812 size_t naudit
= audit_list_count (&state
.audit_list
);
1814 /* Since we start using the auditing DSOs right away we need to
1815 initialize the data structures now. */
1816 tcbp
= init_tls (naudit
);
1818 /* Initialize security features. We need to do it this early
1819 since otherwise the constructors of the audit libraries will
1820 use different values (especially the pointer guard) and will
1823 need_security_init
= false;
1825 load_audit_modules (main_map
, &state
.audit_list
);
1827 /* The count based on audit strings may overestimate the number
1828 of audit modules that got loaded, but not underestimate. */
1829 assert (GLRO(dl_naudit
) <= naudit
);
1832 /* Keep track of the currently loaded modules to count how many
1833 non-audit modules which use TLS are loaded. */
1834 size_t count_modids
= _dl_count_modids ();
1836 /* Set up debugging before the debugger is notified for the first time. */
1837 elf_setup_debug_entry (main_map
, r
);
1839 /* We start adding objects. */
1840 r
->r_state
= RT_ADD
;
1842 LIBC_PROBE (init_start
, 2, LM_ID_BASE
, r
);
1844 /* Auditing checkpoint: we are ready to signal that the initial map
1845 is being constructed. */
1846 _dl_audit_activity_map (main_map
, LA_ACT_ADD
);
1848 /* We have two ways to specify objects to preload: via environment
1849 variable and via the file /etc/ld.so.preload. The latter can also
1850 be used when security is enabled. */
1851 assert (*first_preload
== NULL
);
1852 struct link_map
**preloads
= NULL
;
1853 unsigned int npreloads
= 0;
1855 if (__glibc_unlikely (state
.preloadlist
!= NULL
))
1857 RTLD_TIMING_VAR (start
);
1858 rtld_timer_start (&start
);
1859 npreloads
+= handle_preload_list (state
.preloadlist
, main_map
,
1861 rtld_timer_accum (&load_time
, start
);
1864 if (__glibc_unlikely (state
.preloadarg
!= NULL
))
1866 RTLD_TIMING_VAR (start
);
1867 rtld_timer_start (&start
);
1868 npreloads
+= handle_preload_list (state
.preloadarg
, main_map
,
1870 rtld_timer_accum (&load_time
, start
);
1873 /* There usually is no ld.so.preload file, it should only be used
1874 for emergencies and testing. So the open call etc should usually
1875 fail. Using access() on a non-existing file is faster than using
1876 open(). So we do this first. If it succeeds we do almost twice
1877 the work but this does not matter, since it is not for production
1879 static const char preload_file
[] = "/etc/ld.so.preload";
1880 if (__glibc_unlikely (__access (preload_file
, R_OK
) == 0))
1882 /* Read the contents of the file. */
1883 file
= _dl_sysdep_read_whole_file (preload_file
, &file_size
,
1884 PROT_READ
| PROT_WRITE
);
1885 if (__glibc_unlikely (file
!= MAP_FAILED
))
1887 /* Parse the file. It contains names of libraries to be loaded,
1888 separated by white spaces or `:'. It may also contain
1889 comments introduced by `#'. */
1894 /* Eliminate comments. */
1899 char *comment
= memchr (runp
, '#', rest
);
1900 if (comment
== NULL
)
1903 rest
-= comment
- runp
;
1906 while (--rest
> 0 && *++comment
!= '\n');
1909 /* We have one problematic case: if we have a name at the end of
1910 the file without a trailing terminating characters, we cannot
1911 place the \0. Handle the case separately. */
1912 if (file
[file_size
- 1] != ' ' && file
[file_size
- 1] != '\t'
1913 && file
[file_size
- 1] != '\n' && file
[file_size
- 1] != ':')
1915 problem
= &file
[file_size
];
1916 while (problem
> file
&& problem
[-1] != ' '
1917 && problem
[-1] != '\t'
1918 && problem
[-1] != '\n' && problem
[-1] != ':')
1927 file
[file_size
- 1] = '\0';
1930 RTLD_TIMING_VAR (start
);
1931 rtld_timer_start (&start
);
1933 if (file
!= problem
)
1937 while ((p
= strsep (&runp
, ": \t\n")) != NULL
)
1939 npreloads
+= do_preload (p
, main_map
, preload_file
);
1942 if (problem
!= NULL
)
1944 char *p
= strndupa (problem
, file_size
- (problem
- file
));
1946 npreloads
+= do_preload (p
, main_map
, preload_file
);
1949 rtld_timer_accum (&load_time
, start
);
1951 /* We don't need the file anymore. */
1952 __munmap (file
, file_size
);
1956 if (__glibc_unlikely (*first_preload
!= NULL
))
1958 /* Set up PRELOADS with a vector of the preloaded libraries. */
1959 struct link_map
*l
= *first_preload
;
1960 preloads
= __alloca (npreloads
* sizeof preloads
[0]);
1967 assert (i
== npreloads
);
1970 #ifdef NEED_DL_SYSINFO_DSO
1971 /* Now that the audit modules are opened, call la_objopen for the vDSO. */
1972 if (GLRO(dl_sysinfo_map
) != NULL
)
1973 _dl_audit_objopen (GLRO(dl_sysinfo_map
), LM_ID_BASE
);
1976 /* Load all the libraries specified by DT_NEEDED entries. If LD_PRELOAD
1977 specified some libraries to load, these are inserted before the actual
1978 dependencies in the executable's searchlist for symbol resolution. */
1980 RTLD_TIMING_VAR (start
);
1981 rtld_timer_start (&start
);
1982 _dl_map_object_deps (main_map
, preloads
, npreloads
,
1983 state
.mode
== rtld_mode_trace
, 0);
1984 rtld_timer_accum (&load_time
, start
);
1987 /* Mark all objects as being in the global scope. */
1988 for (i
= main_map
->l_searchlist
.r_nlist
; i
> 0; )
1989 main_map
->l_searchlist
.r_list
[--i
]->l_global
= 1;
1991 /* Remove _dl_rtld_map from the chain. */
1992 GL(dl_rtld_map
).l_prev
->l_next
= GL(dl_rtld_map
).l_next
;
1993 if (GL(dl_rtld_map
).l_next
!= NULL
)
1994 GL(dl_rtld_map
).l_next
->l_prev
= GL(dl_rtld_map
).l_prev
;
1996 for (i
= 1; i
< main_map
->l_searchlist
.r_nlist
; ++i
)
1997 if (main_map
->l_searchlist
.r_list
[i
] == &GL(dl_rtld_map
))
2000 bool rtld_multiple_ref
= false;
2001 if (__glibc_likely (i
< main_map
->l_searchlist
.r_nlist
))
2003 /* Some DT_NEEDED entry referred to the interpreter object itself, so
2004 put it back in the list of visible objects. We insert it into the
2005 chain in symbol search order because gdb uses the chain's order as
2006 its symbol search order. */
2007 rtld_multiple_ref
= true;
2009 GL(dl_rtld_map
).l_prev
= main_map
->l_searchlist
.r_list
[i
- 1];
2010 if (__glibc_likely (state
.mode
== rtld_mode_normal
))
2012 GL(dl_rtld_map
).l_next
= (i
+ 1 < main_map
->l_searchlist
.r_nlist
2013 ? main_map
->l_searchlist
.r_list
[i
+ 1]
2015 #ifdef NEED_DL_SYSINFO_DSO
2016 if (GLRO(dl_sysinfo_map
) != NULL
2017 && GL(dl_rtld_map
).l_prev
->l_next
== GLRO(dl_sysinfo_map
)
2018 && GL(dl_rtld_map
).l_next
!= GLRO(dl_sysinfo_map
))
2019 GL(dl_rtld_map
).l_prev
= GLRO(dl_sysinfo_map
);
2023 /* In trace mode there might be an invisible object (which we
2024 could not find) after the previous one in the search list.
2025 In this case it doesn't matter much where we put the
2026 interpreter object, so we just initialize the list pointer so
2027 that the assertion below holds. */
2028 GL(dl_rtld_map
).l_next
= GL(dl_rtld_map
).l_prev
->l_next
;
2030 assert (GL(dl_rtld_map
).l_prev
->l_next
== GL(dl_rtld_map
).l_next
);
2031 GL(dl_rtld_map
).l_prev
->l_next
= &GL(dl_rtld_map
);
2032 if (GL(dl_rtld_map
).l_next
!= NULL
)
2034 assert (GL(dl_rtld_map
).l_next
->l_prev
== GL(dl_rtld_map
).l_prev
);
2035 GL(dl_rtld_map
).l_next
->l_prev
= &GL(dl_rtld_map
);
2039 /* Now let us see whether all libraries are available in the
2040 versions we need. */
2042 struct version_check_args args
;
2043 args
.doexit
= state
.mode
== rtld_mode_normal
;
2044 args
.dotrace
= state
.mode
== rtld_mode_trace
;
2045 _dl_receive_error (print_missing_version
, version_check_doit
, &args
);
2048 /* We do not initialize any of the TLS functionality unless any of the
2049 initial modules uses TLS. This makes dynamic loading of modules with
2050 TLS impossible, but to support it requires either eagerly doing setup
2051 now or lazily doing it later. Doing it now makes us incompatible with
2052 an old kernel that can't perform TLS_INIT_TP, even if no TLS is ever
2053 used. Trying to do it lazily is too hairy to try when there could be
2054 multiple threads (from a non-TLS-using libpthread). */
2055 bool was_tls_init_tp_called
= tls_init_tp_called
;
2057 tcbp
= init_tls (0);
2059 if (__glibc_likely (need_security_init
))
2060 /* Initialize security features. But only if we have not done it
2064 if (__glibc_unlikely (state
.mode
!= rtld_mode_normal
))
2066 /* We were run just to list the shared libraries. It is
2067 important that we do this before real relocation, because the
2068 functions we call below for output may no longer work properly
2069 after relocation. */
2072 if (GLRO(dl_debug_mask
) & DL_DEBUG_UNUSED
)
2074 /* Look through the dependencies of the main executable
2075 and determine which of them is not actually
2077 struct link_map
*l
= main_map
;
2079 /* Relocate the main executable. */
2080 struct relocate_args args
= { .l
= l
,
2081 .reloc_mode
= ((GLRO(dl_lazy
)
2083 | __RTLD_NOIFUNC
) };
2084 _dl_receive_error (print_unresolved
, relocate_doit
, &args
);
2086 /* This loop depends on the dependencies of the executable to
2087 correspond in number and order to the DT_NEEDED entries. */
2088 ElfW(Dyn
) *dyn
= main_map
->l_ld
;
2090 while (dyn
->d_tag
!= DT_NULL
)
2092 if (dyn
->d_tag
== DT_NEEDED
)
2095 #ifdef NEED_DL_SYSINFO_DSO
2096 /* Skip the VDSO since it's not part of the list
2097 of objects we brought in via DT_NEEDED entries. */
2098 if (l
== GLRO(dl_sysinfo_map
))
2105 _dl_printf ("Unused direct dependencies:\n");
2109 _dl_printf ("\t%s\n", l
->l_name
);
2116 _exit (first
!= true);
2118 else if (! main_map
->l_info
[DT_NEEDED
])
2119 _dl_printf ("\tstatically linked\n");
2122 for (l
= state
.mode_trace_program
? main_map
: main_map
->l_next
;
2125 /* The library was not found. */
2126 _dl_printf ("\t%s => not found\n", l
->l_libname
->name
);
2127 else if (strcmp (l
->l_libname
->name
, l
->l_name
) == 0)
2128 /* Print vDSO like libraries without duplicate name. Some
2129 consumers depend of this format. */
2130 _dl_printf ("\t%s (0x%0*Zx)\n", l
->l_libname
->name
,
2131 (int) sizeof l
->l_map_start
* 2,
2132 (size_t) l
->l_map_start
);
2134 _dl_printf ("\t%s => %s (0x%0*Zx)\n",
2135 DSO_FILENAME (l
->l_libname
->name
),
2136 DSO_FILENAME (l
->l_name
),
2137 (int) sizeof l
->l_map_start
* 2,
2138 (size_t) l
->l_map_start
);
2142 if (__glibc_unlikely (state
.mode
!= rtld_mode_trace
))
2143 for (i
= 1; i
< (unsigned int) _dl_argc
; ++i
)
2145 const ElfW(Sym
) *ref
= NULL
;
2146 ElfW(Addr
) loadbase
;
2149 result
= _dl_lookup_symbol_x (_dl_argv
[i
], main_map
,
2150 &ref
, main_map
->l_scope
,
2151 NULL
, ELF_RTYPE_CLASS_PLT
,
2152 DL_LOOKUP_ADD_DEPENDENCY
, NULL
);
2154 loadbase
= LOOKUP_VALUE_ADDRESS (result
, false);
2156 _dl_printf ("%s found at 0x%0*Zd in object at 0x%0*Zd\n",
2158 (int) sizeof ref
->st_value
* 2,
2159 (size_t) ref
->st_value
,
2160 (int) sizeof loadbase
* 2, (size_t) loadbase
);
2164 /* If LD_WARN is set, warn about undefined symbols. */
2165 if (GLRO(dl_lazy
) >= 0 && GLRO(dl_verbose
))
2167 /* We have to do symbol dependency testing. */
2168 struct relocate_args args
;
2171 args
.reloc_mode
= ((GLRO(dl_lazy
) ? RTLD_LAZY
: 0)
2174 i
= main_map
->l_searchlist
.r_nlist
;
2177 struct link_map
*l
= main_map
->l_initfini
[i
];
2178 if (l
!= &GL(dl_rtld_map
) && ! l
->l_faked
)
2181 _dl_receive_error (print_unresolved
, relocate_doit
,
2187 #define VERNEEDTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERNEED))
2188 if (state
.version_info
)
2190 /* Print more information. This means here, print information
2191 about the versions needed. */
2193 struct link_map
*map
;
2195 for (map
= main_map
; map
!= NULL
; map
= map
->l_next
)
2198 ElfW(Dyn
) *dyn
= map
->l_info
[VERNEEDTAG
];
2204 strtab
= (const void *) D_PTR (map
, l_info
[DT_STRTAB
]);
2205 ent
= (ElfW(Verneed
) *) (map
->l_addr
+ dyn
->d_un
.d_ptr
);
2209 _dl_printf ("\n\tVersion information:\n");
2213 _dl_printf ("\t%s:\n", DSO_FILENAME (map
->l_name
));
2218 struct link_map
*needed
;
2220 needed
= find_needed (strtab
+ ent
->vn_file
);
2221 aux
= (ElfW(Vernaux
) *) ((char *) ent
+ ent
->vn_aux
);
2225 const char *fname
= NULL
;
2228 && match_version (strtab
+ aux
->vna_name
,
2230 fname
= needed
->l_name
;
2232 _dl_printf ("\t\t%s (%s) %s=> %s\n",
2233 strtab
+ ent
->vn_file
,
2234 strtab
+ aux
->vna_name
,
2235 aux
->vna_flags
& VER_FLG_WEAK
2237 fname
?: "not found");
2239 if (aux
->vna_next
== 0)
2240 /* No more symbols. */
2244 aux
= (ElfW(Vernaux
) *) ((char *) aux
2248 if (ent
->vn_next
== 0)
2249 /* No more dependencies. */
2252 /* Next dependency. */
2253 ent
= (ElfW(Verneed
) *) ((char *) ent
+ ent
->vn_next
);
2262 /* Now set up the variable which helps the assembler startup code. */
2263 GL(dl_ns
)[LM_ID_BASE
]._ns_main_searchlist
= &main_map
->l_searchlist
;
2265 /* Save the information about the original global scope list since
2266 we need it in the memory handling later. */
2267 GLRO(dl_initial_searchlist
) = *GL(dl_ns
)[LM_ID_BASE
]._ns_main_searchlist
;
2269 /* Remember the last search directory added at startup, now that
2270 malloc will no longer be the one from dl-minimal.c. As a side
2271 effect, this marks ld.so as initialized, so that the rtld_active
2272 function returns true from now on. */
2273 GLRO(dl_init_all_dirs
) = GL(dl_all_dirs
);
2275 /* Print scope information. */
2276 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_SCOPES
))
2278 _dl_debug_printf ("\nInitial object scopes\n");
2280 for (struct link_map
*l
= main_map
; l
!= NULL
; l
= l
->l_next
)
2281 _dl_show_scope (l
, 0);
2284 _rtld_main_check (main_map
, _dl_argv
[0]);
2286 /* Now we have all the objects loaded. Relocate them all except for
2287 the dynamic linker itself. We do this in reverse order so that copy
2288 relocs of earlier objects overwrite the data written by later
2289 objects. We do not re-relocate the dynamic linker itself in this
2290 loop because that could result in the GOT entries for functions we
2291 call being changed, and that would break us. It is safe to relocate
2292 the dynamic linker out of order because it has no copy relocs (we
2293 know that because it is self-contained). */
2295 int consider_profiling
= GLRO(dl_profile
) != NULL
;
2297 /* If we are profiling we also must do lazy reloaction. */
2298 GLRO(dl_lazy
) |= consider_profiling
;
2300 RTLD_TIMING_VAR (start
);
2301 rtld_timer_start (&start
);
2303 unsigned i
= main_map
->l_searchlist
.r_nlist
;
2306 struct link_map
*l
= main_map
->l_initfini
[i
];
2308 /* While we are at it, help the memory handling a bit. We have to
2309 mark some data structures as allocated with the fake malloc()
2310 implementation in ld.so. */
2311 struct libname_list
*lnp
= l
->l_libname
->next
;
2313 while (__builtin_expect (lnp
!= NULL
, 0))
2318 /* Also allocated with the fake malloc(). */
2319 l
->l_free_initfini
= 0;
2321 if (l
!= &GL(dl_rtld_map
))
2322 _dl_relocate_object (l
, l
->l_scope
, GLRO(dl_lazy
) ? RTLD_LAZY
: 0,
2323 consider_profiling
);
2325 /* Add object to slot information data if necessasy. */
2326 if (l
->l_tls_blocksize
!= 0 && tls_init_tp_called
)
2327 _dl_add_to_slotinfo (l
, true);
2330 rtld_timer_stop (&relocate_time
, start
);
2332 /* Now enable profiling if needed. Like the previous call,
2333 this has to go here because the calls it makes should use the
2334 rtld versions of the functions (particularly calloc()), but it
2335 needs to have _dl_profile_map set up by the relocator. */
2336 if (__glibc_unlikely (GL(dl_profile_map
) != NULL
))
2337 /* We must prepare the profiling. */
2338 _dl_start_profile ();
2340 if ((!was_tls_init_tp_called
&& GL(dl_tls_max_dtv_idx
) > 0)
2341 || count_modids
!= _dl_count_modids ())
2342 ++GL(dl_tls_generation
);
2344 /* Now that we have completed relocation, the initializer data
2345 for the TLS blocks has its final values and we can copy them
2346 into the main thread's TLS area, which we allocated above.
2347 Note: thread-local variables must only be accessed after completing
2349 _dl_allocate_tls_init (tcbp
, false);
2351 /* And finally install it for the main thread. */
2352 if (! tls_init_tp_called
)
2354 const char *lossage
= TLS_INIT_TP (tcbp
);
2355 if (__glibc_unlikely (lossage
!= NULL
))
2356 _dl_fatal_printf ("cannot set up thread-local storage: %s\n",
2361 /* Make sure no new search directories have been added. */
2362 assert (GLRO(dl_init_all_dirs
) == GL(dl_all_dirs
));
2364 if (rtld_multiple_ref
)
2366 /* There was an explicit ref to the dynamic linker as a shared lib.
2367 Re-relocate ourselves with user-controlled symbol definitions.
2369 We must do this after TLS initialization in case after this
2370 re-relocation, we might call a user-supplied function
2371 (e.g. calloc from _dl_relocate_object) that uses TLS data. */
2373 /* Set up the object lookup structures. */
2374 _dl_find_object_init ();
2376 /* The malloc implementation has been relocated, so resolving
2377 its symbols (and potentially calling IFUNC resolvers) is safe
2379 __rtld_malloc_init_real (main_map
);
2381 /* Likewise for the locking implementation. */
2382 __rtld_mutex_init ();
2384 RTLD_TIMING_VAR (start
);
2385 rtld_timer_start (&start
);
2387 /* Mark the link map as not yet relocated again. */
2388 GL(dl_rtld_map
).l_relocated
= 0;
2389 _dl_relocate_object (&GL(dl_rtld_map
), main_map
->l_scope
, 0, 0);
2391 rtld_timer_accum (&relocate_time
, start
);
2394 /* Relocation is complete. Perform early libc initialization. This
2395 is the initial libc, even if audit modules have been loaded with
2397 _dl_call_libc_early_init (GL(dl_ns
)[LM_ID_BASE
].libc_map
, true);
2399 /* Do any necessary cleanups for the startup OS interface code.
2400 We do these now so that no calls are made after rtld re-relocation
2401 which might be resolved to different functions than we expect.
2402 We cannot do this before relocating the other objects because
2403 _dl_relocate_object might need to call `mprotect' for DT_TEXTREL. */
2404 _dl_sysdep_start_cleanup ();
2407 /* Auditing checkpoint: we have added all objects. */
2408 _dl_audit_activity_nsid (LM_ID_BASE
, LA_ACT_CONSISTENT
);
2411 /* Notify the debugger all new objects are now ready to go. We must re-get
2412 the address since by now the variable might be in another object. */
2413 r
= _dl_debug_update (LM_ID_BASE
);
2414 r
->r_state
= RT_CONSISTENT
;
2416 LIBC_PROBE (init_complete
, 2, LM_ID_BASE
, r
);
2418 #if defined USE_LDCONFIG && !defined MAP_COPY
2419 /* We must munmap() the cache file. */
2420 _dl_unload_cache ();
2423 /* Once we return, _dl_sysdep_start will invoke
2424 the DT_INIT functions and then *USER_ENTRY. */
2427 /* This is a little helper function for resolving symbols while
2428 tracing the binary. */
2430 print_unresolved (int errcode
__attribute__ ((unused
)), const char *objname
,
2431 const char *errstring
)
2433 if (objname
[0] == '\0')
2434 objname
= RTLD_PROGNAME
;
2435 _dl_error_printf ("%s (%s)\n", errstring
, objname
);
2438 /* This is a little helper function for resolving symbols while
2439 tracing the binary. */
2441 print_missing_version (int errcode
__attribute__ ((unused
)),
2442 const char *objname
, const char *errstring
)
2444 _dl_error_printf ("%s: %s: %s\n", RTLD_PROGNAME
,
2445 objname
, errstring
);
2448 /* Process the string given as the parameter which explains which debugging
2449 options are enabled. */
2451 process_dl_debug (struct dl_main_state
*state
, const char *dl_debug
)
2453 /* When adding new entries make sure that the maximal length of a name
2454 is correctly handled in the LD_DEBUG_HELP code below. */
2458 const char name
[10];
2459 const char helptext
[41];
2460 unsigned short int mask
;
2463 #define LEN_AND_STR(str) sizeof (str) - 1, str
2464 { LEN_AND_STR ("libs"), "display library search paths",
2465 DL_DEBUG_LIBS
| DL_DEBUG_IMPCALLS
},
2466 { LEN_AND_STR ("reloc"), "display relocation processing",
2467 DL_DEBUG_RELOC
| DL_DEBUG_IMPCALLS
},
2468 { LEN_AND_STR ("files"), "display progress for input file",
2469 DL_DEBUG_FILES
| DL_DEBUG_IMPCALLS
},
2470 { LEN_AND_STR ("symbols"), "display symbol table processing",
2471 DL_DEBUG_SYMBOLS
| DL_DEBUG_IMPCALLS
},
2472 { LEN_AND_STR ("bindings"), "display information about symbol binding",
2473 DL_DEBUG_BINDINGS
| DL_DEBUG_IMPCALLS
},
2474 { LEN_AND_STR ("versions"), "display version dependencies",
2475 DL_DEBUG_VERSIONS
| DL_DEBUG_IMPCALLS
},
2476 { LEN_AND_STR ("scopes"), "display scope information",
2478 { LEN_AND_STR ("all"), "all previous options combined",
2479 DL_DEBUG_LIBS
| DL_DEBUG_RELOC
| DL_DEBUG_FILES
| DL_DEBUG_SYMBOLS
2480 | DL_DEBUG_BINDINGS
| DL_DEBUG_VERSIONS
| DL_DEBUG_IMPCALLS
2481 | DL_DEBUG_SCOPES
},
2482 { LEN_AND_STR ("statistics"), "display relocation statistics",
2483 DL_DEBUG_STATISTICS
},
2484 { LEN_AND_STR ("unused"), "determined unused DSOs",
2486 { LEN_AND_STR ("help"), "display this help message and exit",
2489 #define ndebopts (sizeof (debopts) / sizeof (debopts[0]))
2491 /* Skip separating white spaces and commas. */
2492 while (*dl_debug
!= '\0')
2494 if (*dl_debug
!= ' ' && *dl_debug
!= ',' && *dl_debug
!= ':')
2499 while (dl_debug
[len
] != '\0' && dl_debug
[len
] != ' '
2500 && dl_debug
[len
] != ',' && dl_debug
[len
] != ':')
2503 for (cnt
= 0; cnt
< ndebopts
; ++cnt
)
2504 if (debopts
[cnt
].len
== len
2505 && memcmp (dl_debug
, debopts
[cnt
].name
, len
) == 0)
2507 GLRO(dl_debug_mask
) |= debopts
[cnt
].mask
;
2508 state
->any_debug
= true;
2512 if (cnt
== ndebopts
)
2514 /* Display a warning and skip everything until next
2516 char *copy
= strndupa (dl_debug
, len
);
2517 _dl_error_printf ("\
2518 warning: debug option `%s' unknown; try LD_DEBUG=help\n", copy
);
2528 if (GLRO(dl_debug_mask
) & DL_DEBUG_UNUSED
)
2530 /* In order to get an accurate picture of whether a particular
2531 DT_NEEDED entry is actually used we have to process both
2532 the PLT and non-PLT relocation entries. */
2536 if (GLRO(dl_debug_mask
) & DL_DEBUG_HELP
)
2541 Valid options for the LD_DEBUG environment variable are:\n\n");
2543 for (cnt
= 0; cnt
< ndebopts
; ++cnt
)
2544 _dl_printf (" %.*s%s%s\n", debopts
[cnt
].len
, debopts
[cnt
].name
,
2545 " " + debopts
[cnt
].len
- 3,
2546 debopts
[cnt
].helptext
);
2549 To direct the debugging output into a file instead of standard output\n\
2550 a filename can be specified using the LD_DEBUG_OUTPUT environment variable.\n");
2556 process_envvars (struct dl_main_state
*state
)
2558 char **runp
= _environ
;
2560 char *debug_output
= NULL
;
2562 /* This is the default place for profiling data file. */
2563 GLRO(dl_profile_output
)
2564 = &"/var/tmp\0/var/profile"[__libc_enable_secure
? 9 : 0];
2566 while ((envline
= _dl_next_ld_env_entry (&runp
)) != NULL
)
2570 while (envline
[len
] != '\0' && envline
[len
] != '=')
2573 if (envline
[len
] != '=')
2574 /* This is a "LD_" variable at the end of the string without
2575 a '=' character. Ignore it since otherwise we will access
2576 invalid memory below. */
2582 /* Warning level, verbose or not. */
2583 if (memcmp (envline
, "WARN", 4) == 0)
2584 GLRO(dl_verbose
) = envline
[5] != '\0';
2588 /* Debugging of the dynamic linker? */
2589 if (memcmp (envline
, "DEBUG", 5) == 0)
2591 process_dl_debug (state
, &envline
[6]);
2594 if (memcmp (envline
, "AUDIT", 5) == 0)
2595 audit_list_add_string (&state
->audit_list
, &envline
[6]);
2599 /* Print information about versions. */
2600 if (memcmp (envline
, "VERBOSE", 7) == 0)
2602 state
->version_info
= envline
[8] != '\0';
2606 /* List of objects to be preloaded. */
2607 if (memcmp (envline
, "PRELOAD", 7) == 0)
2609 state
->preloadlist
= &envline
[8];
2613 /* Which shared object shall be profiled. */
2614 if (memcmp (envline
, "PROFILE", 7) == 0 && envline
[8] != '\0')
2615 GLRO(dl_profile
) = &envline
[8];
2619 /* Do we bind early? */
2620 if (memcmp (envline
, "BIND_NOW", 8) == 0)
2622 GLRO(dl_lazy
) = envline
[9] == '\0';
2625 if (memcmp (envline
, "BIND_NOT", 8) == 0)
2626 GLRO(dl_bind_not
) = envline
[9] != '\0';
2630 /* Test whether we want to see the content of the auxiliary
2631 array passed up from the kernel. */
2632 if (!__libc_enable_secure
2633 && memcmp (envline
, "SHOW_AUXV", 9) == 0)
2639 /* Mask for the important hardware capabilities. */
2640 if (!__libc_enable_secure
2641 && memcmp (envline
, "HWCAP_MASK", 10) == 0)
2642 GLRO(dl_hwcap_mask
) = _dl_strtoul (&envline
[11], NULL
);
2647 /* Path where the binary is found. */
2648 if (!__libc_enable_secure
2649 && memcmp (envline
, "ORIGIN_PATH", 11) == 0)
2650 GLRO(dl_origin_path
) = &envline
[12];
2654 /* The library search path. */
2655 if (!__libc_enable_secure
2656 && memcmp (envline
, "LIBRARY_PATH", 12) == 0)
2658 state
->library_path
= &envline
[13];
2659 state
->library_path_source
= "LD_LIBRARY_PATH";
2663 /* Where to place the profiling data file. */
2664 if (memcmp (envline
, "DEBUG_OUTPUT", 12) == 0)
2666 debug_output
= &envline
[13];
2670 if (!__libc_enable_secure
2671 && memcmp (envline
, "DYNAMIC_WEAK", 12) == 0)
2672 GLRO(dl_dynamic_weak
) = 1;
2676 /* Where to place the profiling data file. */
2677 if (!__libc_enable_secure
2678 && memcmp (envline
, "PROFILE_OUTPUT", 14) == 0
2679 && envline
[15] != '\0')
2680 GLRO(dl_profile_output
) = &envline
[15];
2684 /* The mode of the dynamic linker can be set. */
2685 if (memcmp (envline
, "TRACE_LOADED_OBJECTS", 20) == 0)
2687 state
->mode
= rtld_mode_trace
;
2688 state
->mode_trace_program
2689 = _dl_strtoul (&envline
[21], NULL
) > 1;
2695 /* Extra security for SUID binaries. Remove all dangerous environment
2697 if (__glibc_unlikely (__libc_enable_secure
))
2699 const char *nextp
= UNSECURE_ENVVARS
;
2703 /* We could use rawmemchr but this need not be fast. */
2704 nextp
= (char *) (strchr
) (nextp
, '\0') + 1;
2706 while (*nextp
!= '\0');
2708 if (__access ("/etc/suid-debug", F_OK
) != 0)
2711 unsetenv ("MALLOC_CHECK_");
2713 GLRO(dl_debug_mask
) = 0;
2716 if (state
->mode
!= rtld_mode_normal
)
2719 /* If we have to run the dynamic linker in debugging mode and the
2720 LD_DEBUG_OUTPUT environment variable is given, we write the debug
2721 messages to this file. */
2722 else if (state
->any_debug
&& debug_output
!= NULL
)
2724 const int flags
= O_WRONLY
| O_APPEND
| O_CREAT
| O_NOFOLLOW
;
2725 size_t name_len
= strlen (debug_output
);
2726 char buf
[name_len
+ 12];
2729 buf
[name_len
+ 11] = '\0';
2730 startp
= _itoa (__getpid (), &buf
[name_len
+ 11], 10, 0);
2732 startp
= memcpy (startp
- name_len
, debug_output
, name_len
);
2734 GLRO(dl_debug_fd
) = __open64_nocancel (startp
, flags
, DEFFILEMODE
);
2735 if (GLRO(dl_debug_fd
) == -1)
2736 /* We use standard output if opening the file failed. */
2737 GLRO(dl_debug_fd
) = STDOUT_FILENO
;
2741 #if HP_TIMING_INLINE
2743 print_statistics_item (const char *title
, hp_timing_t time
,
2746 char cycles
[HP_TIMING_PRINT_SIZE
];
2747 HP_TIMING_PRINT (cycles
, sizeof (cycles
), time
);
2749 char relative
[3 * sizeof (hp_timing_t
) + 2];
2750 char *cp
= _itoa ((1000ULL * time
) / total
, relative
+ sizeof (relative
),
2752 /* Sets the decimal point. */
2753 char *wp
= relative
;
2754 switch (relative
+ sizeof (relative
) - cp
)
2767 _dl_debug_printf ("%s: %s cycles (%s%%)\n", title
, cycles
, relative
);
2771 /* Print the various times we collected. */
2773 __attribute ((noinline
))
2774 print_statistics (const hp_timing_t
*rtld_total_timep
)
2776 #if HP_TIMING_INLINE
2778 char cycles
[HP_TIMING_PRINT_SIZE
];
2779 HP_TIMING_PRINT (cycles
, sizeof (cycles
), *rtld_total_timep
);
2780 _dl_debug_printf ("\nruntime linker statistics:\n"
2781 " total startup time in dynamic loader: %s cycles\n",
2783 print_statistics_item (" time needed for relocation",
2784 relocate_time
, *rtld_total_timep
);
2788 unsigned long int num_relative_relocations
= 0;
2789 for (Lmid_t ns
= 0; ns
< GL(dl_nns
); ++ns
)
2791 if (GL(dl_ns
)[ns
]._ns_loaded
== NULL
)
2794 struct r_scope_elem
*scope
= &GL(dl_ns
)[ns
]._ns_loaded
->l_searchlist
;
2796 for (unsigned int i
= 0; i
< scope
->r_nlist
; i
++)
2798 struct link_map
*l
= scope
->r_list
[i
];
2800 if (l
->l_addr
!= 0 && l
->l_info
[VERSYMIDX (DT_RELCOUNT
)])
2801 num_relative_relocations
2802 += l
->l_info
[VERSYMIDX (DT_RELCOUNT
)]->d_un
.d_val
;
2803 #ifndef ELF_MACHINE_REL_RELATIVE
2804 /* Relative relocations are processed on these architectures if
2805 library is loaded to different address than p_vaddr. */
2806 if ((l
->l_addr
!= 0)
2807 && l
->l_info
[VERSYMIDX (DT_RELACOUNT
)])
2809 /* On e.g. IA-64 or Alpha, relative relocations are processed
2810 only if library is loaded to different address than p_vaddr. */
2811 if (l
->l_addr
!= 0 && l
->l_info
[VERSYMIDX (DT_RELACOUNT
)])
2813 num_relative_relocations
2814 += l
->l_info
[VERSYMIDX (DT_RELACOUNT
)]->d_un
.d_val
;
2818 _dl_debug_printf (" number of relocations: %lu\n"
2819 " number of relocations from cache: %lu\n"
2820 " number of relative relocations: %lu\n",
2821 GL(dl_num_relocations
),
2822 GL(dl_num_cache_relocations
),
2823 num_relative_relocations
);
2825 #if HP_TIMING_INLINE
2826 print_statistics_item (" time needed to load objects",
2827 load_time
, *rtld_total_timep
);