1 /* Run time dynamic linker.
2 Copyright (C) 1995-2024 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 int 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
->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_fpu_control
= _FPU_DEFAULT
,
361 ._dl_pagesize
= EXEC_PAGESIZE
,
362 ._dl_inhibit_cache
= 0,
363 ._dl_profile_output
= "/var/tmp",
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 /* Copy the TLS related data if necessary. */
481 #ifndef DONT_USE_BOOTSTRAP_MAP
482 # if NO_TLS_OFFSET != 0
483 GL(dl_rtld_map
).l_tls_offset
= NO_TLS_OFFSET
;
487 /* Initialize the stack end variable. */
488 __libc_stack_end
= __builtin_frame_address (0);
490 /* Call the OS-dependent function to set up life so we can do things like
491 file access. It will call `dl_main' (below) to do all the real work
492 of the dynamic linker, and then unwind our frame and run the user
493 entry point on the same stack we entered on. */
494 start_addr
= _dl_sysdep_start (arg
, &dl_main
);
496 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_STATISTICS
))
498 RTLD_TIMING_VAR (rtld_total_time
);
499 rtld_timer_stop (&rtld_total_time
, start_time
);
500 print_statistics (RTLD_TIMING_REF(rtld_total_time
));
503 #ifndef ELF_MACHINE_START_ADDRESS
504 # define ELF_MACHINE_START_ADDRESS(map, start) (start)
506 return ELF_MACHINE_START_ADDRESS (GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
, start_addr
);
509 #ifdef DONT_USE_BOOTSTRAP_MAP
510 # define bootstrap_map GL(dl_rtld_map)
512 # define bootstrap_map info.l
515 static ElfW(Addr
) __attribute_used__
516 _dl_start (void *arg
)
518 #ifdef DONT_USE_BOOTSTRAP_MAP
519 rtld_timer_start (&start_time
);
521 struct dl_start_final_info info
;
522 rtld_timer_start (&info
.start_time
);
525 /* Partly clean the `bootstrap_map' structure up. Don't use
526 `memset' since it might not be built in or inlined and we cannot
527 make function calls at this point. Use '__builtin_memset' if we
528 know it is available. We do not have to clear the memory if we
529 do not have to use the temporary bootstrap_map. Global variables
530 are initialized to zero by default. */
531 #ifndef DONT_USE_BOOTSTRAP_MAP
532 # ifdef HAVE_BUILTIN_MEMSET
533 __builtin_memset (bootstrap_map
.l_info
, '\0', sizeof (bootstrap_map
.l_info
));
536 cnt
< sizeof (bootstrap_map
.l_info
) / sizeof (bootstrap_map
.l_info
[0]);
538 bootstrap_map
.l_info
[cnt
] = 0;
542 /* Figure out the run-time load address of the dynamic linker itself. */
543 bootstrap_map
.l_addr
= elf_machine_load_address ();
545 /* Read our own dynamic section and fill in the info array. */
546 bootstrap_map
.l_ld
= (void *) bootstrap_map
.l_addr
+ elf_machine_dynamic ();
547 bootstrap_map
.l_ld_readonly
= DL_RO_DYN_SECTION
;
548 elf_get_dynamic_info (&bootstrap_map
, true, false);
550 #if NO_TLS_OFFSET != 0
551 bootstrap_map
.l_tls_offset
= NO_TLS_OFFSET
;
554 #ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
555 ELF_MACHINE_BEFORE_RTLD_RELOC (&bootstrap_map
, bootstrap_map
.l_info
);
558 if (bootstrap_map
.l_addr
)
560 /* Relocate ourselves so we can do normal function calls and
561 data access using the global offset table. */
563 ELF_DYNAMIC_RELOCATE (&bootstrap_map
, NULL
, 0, 0, 0);
565 bootstrap_map
.l_relocated
= 1;
567 /* Please note that we don't allow profiling of this object and
568 therefore need not test whether we have to allocate the array
569 for the relocation results (as done in dl-reloc.c). */
571 /* Now life is sane; we can call functions and access global data.
572 Set up to use the operating system facilities, and find out from
573 the operating system's program loader where to find the program
574 header table in core. Put the rest of _dl_start into a separate
575 function, that way the compiler cannot put accesses to the GOT
576 before ELF_DYNAMIC_RELOCATE. */
578 __rtld_malloc_init_stubs ();
580 #ifdef DONT_USE_BOOTSTRAP_MAP
581 return _dl_start_final (arg
);
583 return _dl_start_final (arg
, &info
);
589 /* Now life is peachy; we can do all normal operations.
590 On to the real work. */
592 /* Some helper functions. */
594 /* Arguments to relocate_doit. */
603 /* Argument to map_doit. */
605 struct link_map
*loader
;
607 /* Return value of map_doit. */
608 struct link_map
*map
;
614 struct link_map
*map
;
620 struct link_map
*map
;
624 /* Arguments to version_check_doit. */
625 struct version_check_args
632 relocate_doit (void *a
)
634 struct relocate_args
*args
= (struct relocate_args
*) a
;
636 _dl_relocate_object (args
->l
, args
->l
->l_scope
, args
->reloc_mode
, 0);
642 struct map_args
*args
= (struct map_args
*) a
;
643 int type
= (args
->mode
== __RTLD_OPENEXEC
) ? lt_executable
: lt_library
;
644 args
->map
= _dl_map_object (args
->loader
, args
->str
, type
, 0,
645 args
->mode
, LM_ID_BASE
);
649 dlmopen_doit (void *a
)
651 struct dlmopen_args
*args
= (struct dlmopen_args
*) a
;
652 args
->map
= _dl_open (args
->fname
,
653 (RTLD_LAZY
| __RTLD_DLOPEN
| __RTLD_AUDIT
655 dl_main
, LM_ID_NEWLM
, _dl_argc
, _dl_argv
,
660 lookup_doit (void *a
)
662 struct lookup_args
*args
= (struct lookup_args
*) a
;
663 const ElfW(Sym
) *ref
= NULL
;
665 lookup_t l
= _dl_lookup_symbol_x (args
->name
, args
->map
, &ref
,
666 args
->map
->l_local_scope
, NULL
, 0,
667 DL_LOOKUP_RETURN_NEWEST
, NULL
);
669 args
->result
= DL_SYMBOL_ADDRESS (l
, ref
);
673 version_check_doit (void *a
)
675 struct version_check_args
*args
= (struct version_check_args
*) a
;
676 if (_dl_check_all_versions (GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
, 1,
677 args
->dotrace
) && args
->doexit
)
678 /* We cannot start the application. Abort now. */
683 static inline struct link_map
*
684 find_needed (const char *name
)
686 struct r_scope_elem
*scope
= &GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
->l_searchlist
;
687 unsigned int n
= scope
->r_nlist
;
690 if (_dl_name_match_p (name
, scope
->r_list
[n
]))
691 return scope
->r_list
[n
];
693 /* Should never happen. */
698 match_version (const char *string
, struct link_map
*map
)
700 const char *strtab
= (const void *) D_PTR (map
, l_info
[DT_STRTAB
]);
703 #define VERDEFTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERDEF))
704 if (map
->l_info
[VERDEFTAG
] == NULL
)
705 /* The file has no symbol versioning. */
708 def
= (ElfW(Verdef
) *) ((char *) map
->l_addr
709 + map
->l_info
[VERDEFTAG
]->d_un
.d_ptr
);
712 ElfW(Verdaux
) *aux
= (ElfW(Verdaux
) *) ((char *) def
+ def
->vd_aux
);
714 /* Compare the version strings. */
715 if (strcmp (string
, strtab
+ aux
->vda_name
) == 0)
719 /* If no more definitions we failed to find what we want. */
720 if (def
->vd_next
== 0)
723 /* Next definition. */
724 def
= (ElfW(Verdef
) *) ((char *) def
+ def
->vd_next
);
730 bool __rtld_tls_init_tp_called
;
733 init_tls (size_t naudit
)
735 /* Number of elements in the static TLS block. */
736 GL(dl_tls_static_nelem
) = GL(dl_tls_max_dtv_idx
);
738 /* Do not do this twice. The audit interface might have required
739 the DTV interfaces to be set up early. */
740 if (GL(dl_initial_dtv
) != NULL
)
743 /* Allocate the array which contains the information about the
744 dtv slots. We allocate a few entries more than needed to
745 avoid the need for reallocation. */
746 size_t nelem
= GL(dl_tls_max_dtv_idx
) + 1 + TLS_SLOTINFO_SURPLUS
;
749 GL(dl_tls_dtv_slotinfo_list
) = (struct dtv_slotinfo_list
*)
750 calloc (sizeof (struct dtv_slotinfo_list
)
751 + nelem
* sizeof (struct dtv_slotinfo
), 1);
752 /* No need to check the return value. If memory allocation failed
753 the program would have been terminated. */
755 struct dtv_slotinfo
*slotinfo
= GL(dl_tls_dtv_slotinfo_list
)->slotinfo
;
756 GL(dl_tls_dtv_slotinfo_list
)->len
= nelem
;
757 GL(dl_tls_dtv_slotinfo_list
)->next
= NULL
;
759 /* Fill in the information from the loaded modules. No namespace
760 but the base one can be filled at this time. */
761 assert (GL(dl_ns
)[LM_ID_BASE
+ 1]._ns_loaded
== NULL
);
763 for (struct link_map
*l
= GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
; l
!= NULL
;
765 if (l
->l_tls_blocksize
!= 0)
767 /* This is a module with TLS data. Store the map reference.
768 The generation counter is zero. */
770 /* slotinfo[i].gen = 0; */
773 assert (i
== GL(dl_tls_max_dtv_idx
));
775 /* Calculate the size of the static TLS surplus. */
776 _dl_tls_static_surplus_init (naudit
);
778 /* Compute the TLS offsets for the various blocks. */
779 _dl_determine_tlsoffset ();
781 /* Construct the static TLS block and the dtv for the initial
782 thread. For some platforms this will include allocating memory
783 for the thread descriptor. The memory for the TLS block will
784 never be freed. It should be allocated accordingly. The dtv
785 array can be changed if dynamic loading requires it. */
786 void *tcbp
= _dl_allocate_tls_storage ();
789 cannot allocate TLS data structures for initial thread\n");
791 _dl_tls_initial_modid_limit_setup ();
793 /* Store for detection of the special case by __tls_get_addr
794 so it knows not to pass this dtv to the normal realloc. */
795 GL(dl_initial_dtv
) = GET_DTV (tcbp
);
797 /* And finally install it for the main thread. */
798 call_tls_init_tp (tcbp
);
799 __rtld_tls_init_tp_called
= true;
805 do_preload (const char *fname
, struct link_map
*main_map
, const char *where
)
808 const char *err_str
= NULL
;
809 struct map_args args
;
813 args
.loader
= main_map
;
814 args
.mode
= __RTLD_SECURE
;
816 unsigned int old_nloaded
= GL(dl_ns
)[LM_ID_BASE
]._ns_nloaded
;
818 (void) _dl_catch_error (&objname
, &err_str
, &malloced
, map_doit
, &args
);
819 if (__glibc_unlikely (err_str
!= NULL
))
822 ERROR: ld.so: object '%s' from %s cannot be preloaded (%s): ignored.\n",
823 fname
, where
, err_str
);
824 /* No need to call free, this is still before
825 the libc's malloc is used. */
827 else if (GL(dl_ns
)[LM_ID_BASE
]._ns_nloaded
!= old_nloaded
)
828 /* It is no duplicate. */
831 /* Nothing loaded. */
838 /* Set up the stack checker's canary. */
839 uintptr_t stack_chk_guard
= _dl_setup_stack_chk_guard (_dl_random
);
840 #ifdef THREAD_SET_STACK_GUARD
841 THREAD_SET_STACK_GUARD (stack_chk_guard
);
843 __stack_chk_guard
= stack_chk_guard
;
846 /* Set up the pointer guard as well, if necessary. */
847 uintptr_t pointer_chk_guard
848 = _dl_setup_pointer_guard (_dl_random
, stack_chk_guard
);
849 #ifdef THREAD_SET_POINTER_GUARD
850 THREAD_SET_POINTER_GUARD (pointer_chk_guard
);
852 __pointer_chk_guard_local
= pointer_chk_guard
;
854 /* We do not need the _dl_random value anymore. The less
855 information we leave behind, the better, so clear the
860 #include <setup-vdso.h>
862 /* The LD_PRELOAD environment variable gives list of libraries
863 separated by white space or colons that are loaded before the
864 executable's dependencies and prepended to the global scope list.
865 (If the binary is running setuid all elements containing a '/' are
866 ignored since it is insecure.) Return the number of preloads
867 performed. Ditto for --preload command argument. */
869 handle_preload_list (const char *preloadlist
, struct link_map
*main_map
,
872 unsigned int npreloads
= 0;
873 const char *p
= preloadlist
;
874 char fname
[SECURE_PATH_LIMIT
];
878 /* Split preload list at space/colon. */
879 size_t len
= strcspn (p
, " :");
880 if (len
> 0 && len
< sizeof (fname
))
882 memcpy (fname
, p
, len
);
888 /* Skip over the substring and the following delimiter. */
893 if (dso_name_valid_for_suid (fname
))
894 npreloads
+= do_preload (fname
, main_map
, where
);
899 /* Called if the audit DSO cannot be used: if it does not have the
900 appropriate interfaces, or it expects a more recent version library
901 version than what the dynamic linker provides. */
903 unload_audit_module (struct link_map
*map
, int original_tls_idx
)
906 Lmid_t ns
= map
->l_ns
;
910 /* Make sure the namespace has been cleared entirely. */
911 assert (GL(dl_ns
)[ns
]._ns_loaded
== NULL
);
912 assert (GL(dl_ns
)[ns
]._ns_nloaded
== 0);
914 GL(dl_tls_max_dtv_idx
) = original_tls_idx
;
917 /* Called to print an error message if loading of an audit module
920 report_audit_module_load_error (const char *name
, const char *err_str
,
924 ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n",
927 free ((char *) err_str
);
930 /* Load one audit module. */
932 load_audit_module (const char *name
, struct audit_ifaces
**last_audit
)
934 int original_tls_idx
= GL(dl_tls_max_dtv_idx
);
936 struct dlmopen_args dlmargs
;
937 dlmargs
.fname
= name
;
941 const char *err_str
= NULL
;
943 _dl_catch_error (&objname
, &err_str
, &malloced
, dlmopen_doit
, &dlmargs
);
944 if (__glibc_unlikely (err_str
!= NULL
))
946 report_audit_module_load_error (name
, err_str
, malloced
);
950 struct lookup_args largs
;
951 largs
.name
= "la_version";
952 largs
.map
= dlmargs
.map
;
953 _dl_catch_error (&objname
, &err_str
, &malloced
, lookup_doit
, &largs
);
954 if (__glibc_likely (err_str
!= NULL
))
956 unload_audit_module (dlmargs
.map
, original_tls_idx
);
957 report_audit_module_load_error (name
, err_str
, malloced
);
961 unsigned int (*laversion
) (unsigned int) = largs
.result
;
963 /* A null symbol indicates that something is very wrong with the
964 loaded object because defined symbols are supposed to have a
965 valid, non-null address. */
966 assert (laversion
!= NULL
);
968 unsigned int lav
= laversion (LAV_CURRENT
);
971 /* Only print an error message if debugging because this can
972 happen deliberately. */
973 if (GLRO(dl_debug_mask
) & DL_DEBUG_FILES
)
975 file=%s [%lu]; audit interface function la_version returned zero; ignored.\n",
976 dlmargs
.map
->l_name
, dlmargs
.map
->l_ns
);
977 unload_audit_module (dlmargs
.map
, original_tls_idx
);
981 if (!_dl_audit_check_version (lav
))
984 ERROR: audit interface '%s' requires version %d (maximum supported version %d); ignored.\n",
985 name
, lav
, LAV_CURRENT
);
986 unload_audit_module (dlmargs
.map
, original_tls_idx
);
990 enum { naudit_ifaces
= 8 };
993 struct audit_ifaces ifaces
;
994 void (*fptr
[naudit_ifaces
]) (void);
995 } *newp
= malloc (sizeof (*newp
));
997 _dl_fatal_printf ("Out of memory while loading audit modules\n");
999 /* Names of the auditing interfaces. All in one
1001 static const char audit_iface_names
[] =
1007 #define STRING(s) __STRING (s)
1008 "la_" STRING (ARCH_LA_PLTENTER
) "\0"
1009 "la_" STRING (ARCH_LA_PLTEXIT
) "\0"
1011 unsigned int cnt
= 0;
1012 const char *cp
= audit_iface_names
;
1016 _dl_catch_error (&objname
, &err_str
, &malloced
, lookup_doit
, &largs
);
1018 /* Store the pointer. */
1019 if (err_str
== NULL
&& largs
.result
!= NULL
)
1020 newp
->fptr
[cnt
] = largs
.result
;
1022 newp
->fptr
[cnt
] = NULL
;
1025 cp
= strchr (cp
, '\0') + 1;
1027 while (*cp
!= '\0');
1028 assert (cnt
== naudit_ifaces
);
1030 /* Now append the new auditing interface to the list. */
1031 newp
->ifaces
.next
= NULL
;
1032 if (*last_audit
== NULL
)
1033 *last_audit
= GLRO(dl_audit
) = &newp
->ifaces
;
1035 *last_audit
= (*last_audit
)->next
= &newp
->ifaces
;
1037 /* The dynamic linker link map is statically allocated, so the
1038 cookie in _dl_new_object has not happened. */
1039 link_map_audit_state (&GL (dl_rtld_map
), GLRO (dl_naudit
))->cookie
1040 = (intptr_t) &GL (dl_rtld_map
);
1044 /* Mark the DSO as being used for auditing. */
1045 dlmargs
.map
->l_auditing
= 1;
1048 /* Load all audit modules. */
1050 load_audit_modules (struct link_map
*main_map
, struct audit_list
*audit_list
)
1052 struct audit_ifaces
*last_audit
= NULL
;
1056 const char *name
= audit_list_next (audit_list
);
1059 load_audit_module (name
, &last_audit
);
1062 /* Notify audit modules of the initially loaded modules (the main
1063 program and the dynamic linker itself). */
1064 if (GLRO(dl_naudit
) > 0)
1066 _dl_audit_objopen (main_map
, LM_ID_BASE
);
1067 _dl_audit_objopen (&GL(dl_rtld_map
), LM_ID_BASE
);
1071 /* Check if the executable is not actually dynamically linked, and
1072 invoke it directly in that case. */
1074 rtld_chain_load (struct link_map
*main_map
, char *argv0
)
1076 /* The dynamic loader run against itself. */
1077 const char *rtld_soname
1078 = ((const char *) D_PTR (&GL(dl_rtld_map
), l_info
[DT_STRTAB
])
1079 + GL(dl_rtld_map
).l_info
[DT_SONAME
]->d_un
.d_val
);
1080 if (main_map
->l_info
[DT_SONAME
] != NULL
1081 && strcmp (rtld_soname
,
1082 ((const char *) D_PTR (main_map
, l_info
[DT_STRTAB
])
1083 + main_map
->l_info
[DT_SONAME
]->d_un
.d_val
)) == 0)
1084 _dl_fatal_printf ("%s: loader cannot load itself\n", rtld_soname
);
1086 /* With DT_NEEDED dependencies, the executable is dynamically
1088 if (__glibc_unlikely (main_map
->l_info
[DT_NEEDED
] != NULL
))
1091 /* If the executable has program interpreter, it is dynamically
1093 for (size_t i
= 0; i
< main_map
->l_phnum
; ++i
)
1094 if (main_map
->l_phdr
[i
].p_type
== PT_INTERP
)
1097 const char *pathname
= _dl_argv
[0];
1099 _dl_argv
[0] = argv0
;
1100 int errcode
= __rtld_execve (pathname
, _dl_argv
, _environ
);
1101 const char *errname
= strerrorname_np (errcode
);
1102 if (errname
!= NULL
)
1103 _dl_fatal_printf("%s: cannot execute %s: %s\n",
1104 rtld_soname
, pathname
, errname
);
1106 _dl_fatal_printf("%s: cannot execute %s: %d\n",
1107 rtld_soname
, pathname
, errcode
);
1110 /* Called to complete the initialization of the link map for the main
1111 executable. Returns true if there is a PT_INTERP segment. */
1113 rtld_setup_main_map (struct link_map
*main_map
)
1115 /* This have already been filled in right after _dl_new_object, or
1116 as part of _dl_map_object. */
1117 const ElfW(Phdr
) *phdr
= main_map
->l_phdr
;
1118 ElfW(Word
) phnum
= main_map
->l_phnum
;
1120 bool has_interp
= false;
1122 main_map
->l_map_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
;
1215 /* The next expected address is the page following this load
1217 expected_load_address
= ((allocend
+ GLRO(dl_pagesize
) - 1)
1218 & ~(GLRO(dl_pagesize
) - 1));
1223 if (ph
->p_memsz
> 0)
1225 /* Note that in the case the dynamic linker we duplicate work
1226 here since we read the PT_TLS entry already in
1227 _dl_start_final. But the result is repeatable so do not
1228 check for this special but unimportant case. */
1229 main_map
->l_tls_blocksize
= ph
->p_memsz
;
1230 main_map
->l_tls_align
= ph
->p_align
;
1231 if (ph
->p_align
== 0)
1232 main_map
->l_tls_firstbyte_offset
= 0;
1234 main_map
->l_tls_firstbyte_offset
= (ph
->p_vaddr
1235 & (ph
->p_align
- 1));
1236 main_map
->l_tls_initimage_size
= ph
->p_filesz
;
1237 main_map
->l_tls_initimage
= (void *) ph
->p_vaddr
;
1239 /* This image gets the ID one. */
1240 GL(dl_tls_max_dtv_idx
) = main_map
->l_tls_modid
= 1;
1245 GL(dl_stack_flags
) = ph
->p_flags
;
1249 main_map
->l_relro_addr
= ph
->p_vaddr
;
1250 main_map
->l_relro_size
= ph
->p_memsz
;
1253 /* Process program headers again, but scan them backwards so
1254 that PT_NOTE can be skipped if PT_GNU_PROPERTY exits. */
1255 for (const ElfW(Phdr
) *ph
= &phdr
[phnum
]; ph
!= phdr
; --ph
)
1256 switch (ph
[-1].p_type
)
1259 _dl_process_pt_note (main_map
, -1, &ph
[-1]);
1261 case PT_GNU_PROPERTY
:
1262 _dl_process_pt_gnu_property (main_map
, -1, &ph
[-1]);
1266 /* Adjust the address of the TLS initialization image in case
1267 the executable is actually an ET_DYN object. */
1268 if (main_map
->l_tls_initimage
!= NULL
)
1269 main_map
->l_tls_initimage
1270 = (char *) main_map
->l_tls_initimage
+ main_map
->l_addr
;
1271 if (! main_map
->l_map_end
)
1272 main_map
->l_map_end
= ~0;
1273 if (! GL(dl_rtld_map
).l_libname
&& GL(dl_rtld_map
).l_name
)
1275 /* We were invoked directly, so the program might not have a
1277 _dl_rtld_libname
.name
= GL(dl_rtld_map
).l_name
;
1278 /* _dl_rtld_libname.next = NULL; Already zero. */
1279 GL(dl_rtld_map
).l_libname
= &_dl_rtld_libname
;
1282 assert (GL(dl_rtld_map
).l_libname
); /* How else did we get here? */
1287 /* Adjusts the contents of the stack and related globals for the user
1288 entry point. The ld.so processed skip_args arguments and bumped
1289 _dl_argv and _dl_argc accordingly. Those arguments are removed from
1292 _dl_start_args_adjust (int skip_args
, int skip_env
)
1294 void **sp
= (void **) (_dl_argv
- skip_args
- 1);
1295 void **p
= sp
+ skip_args
;
1301 intptr_t argc
__attribute__ ((unused
)) = (intptr_t) sp
[0] - skip_args
;
1302 assert (argc
== _dl_argc
);
1304 /* Adjust argc on stack. */
1305 sp
[0] = (void *) (intptr_t) _dl_argc
;
1307 /* Update globals in rtld. */
1308 _dl_argv
-= skip_args
;
1309 _environ
-= skip_args
;
1311 /* Shuffle argv down. */
1316 assert (_environ
== (char **) (sp
+ 1));
1318 /* Shuffle envp down. */
1323 #ifdef HAVE_AUX_VECTOR
1324 void **auxv
= (void **) GLRO(dl_auxv
) - skip_args
- skip_env
;
1325 GLRO(dl_auxv
) = (ElfW(auxv_t
) *) auxv
; /* Aliasing violation. */
1326 assert (auxv
== sp
+ 1);
1328 /* Shuffle auxv down. */
1330 char *oldp
= (char *) (p
+ 1 + skip_env
);
1331 char *newp
= (char *) (sp
+ 1);
1334 memcpy (&ax
, oldp
, sizeof (ax
));
1335 memcpy (newp
, &ax
, sizeof (ax
));
1336 oldp
+= sizeof (ax
);
1337 newp
+= sizeof (ax
);
1339 while (ax
.a_type
!= AT_NULL
);
1344 dl_main (const ElfW(Phdr
) *phdr
,
1346 ElfW(Addr
) *user_entry
,
1349 struct link_map
*main_map
;
1353 bool rtld_is_main
= false;
1357 struct dl_main_state state
;
1358 dl_main_state_init (&state
);
1360 __tls_pre_init_tp ();
1362 #if !PTHREAD_IN_LIBC
1363 /* The explicit initialization here is cheaper than processing the reloc
1364 in the _rtld_local definition's initializer. */
1365 GL(dl_make_stack_executable_hook
) = &_dl_make_stack_executable
;
1368 /* Process the environment variable which control the behaviour. */
1369 skip_env
= process_envvars (&state
);
1371 #ifndef HAVE_INLINED_SYSCALLS
1372 /* Set up a flag which tells we are just starting. */
1373 _dl_starting_up
= 1;
1376 const char *ld_so_name
= _dl_argv
[0];
1377 if (*user_entry
== (ElfW(Addr
)) ENTRY_POINT
)
1379 /* Ho ho. We are not the program interpreter! We are the program
1380 itself! This means someone ran ld.so as a command. Well, that
1381 might be convenient to do sometimes. We support it by
1382 interpreting the args like this:
1384 ld.so PROGRAM ARGS...
1386 The first argument is the name of a file containing an ELF
1387 executable we will load and run with the following arguments.
1388 To simplify life here, PROGRAM is searched for using the
1389 normal rules for shared objects, rather than $PATH or anything
1390 like that. We just load it and use its entry point; we don't
1391 pay attention to its PT_INTERP command (we are the interpreter
1392 ourselves). This is an easy way to test a new ld.so before
1394 rtld_is_main
= true;
1397 char **orig_argv
= _dl_argv
;
1399 /* Note the place where the dynamic linker actually came from. */
1400 GL(dl_rtld_map
).l_name
= rtld_progname
;
1402 while (_dl_argc
> 1)
1403 if (! strcmp (_dl_argv
[1], "--list"))
1405 if (state
.mode
!= rtld_mode_help
)
1407 state
.mode
= rtld_mode_list
;
1408 /* This means do no dependency analysis. */
1415 else if (! strcmp (_dl_argv
[1], "--verify"))
1417 if (state
.mode
!= rtld_mode_help
)
1418 state
.mode
= rtld_mode_verify
;
1423 else if (! strcmp (_dl_argv
[1], "--inhibit-cache"))
1425 GLRO(dl_inhibit_cache
) = 1;
1429 else if (! strcmp (_dl_argv
[1], "--library-path")
1432 state
.library_path
= _dl_argv
[2];
1433 state
.library_path_source
= "--library-path";
1438 else if (! strcmp (_dl_argv
[1], "--inhibit-rpath")
1441 GLRO(dl_inhibit_rpath
) = _dl_argv
[2];
1446 else if (! strcmp (_dl_argv
[1], "--audit") && _dl_argc
> 2)
1448 audit_list_add_string (&state
.audit_list
, _dl_argv
[2]);
1453 else if (! strcmp (_dl_argv
[1], "--preload") && _dl_argc
> 2)
1455 state
.preloadarg
= _dl_argv
[2];
1459 else if (! strcmp (_dl_argv
[1], "--argv0") && _dl_argc
> 2)
1461 argv0
= _dl_argv
[2];
1466 else if (strcmp (_dl_argv
[1], "--glibc-hwcaps-prepend") == 0
1469 state
.glibc_hwcaps_prepend
= _dl_argv
[2];
1473 else if (strcmp (_dl_argv
[1], "--glibc-hwcaps-mask") == 0
1476 state
.glibc_hwcaps_mask
= _dl_argv
[2];
1480 else if (! strcmp (_dl_argv
[1], "--list-tunables"))
1482 state
.mode
= rtld_mode_list_tunables
;
1487 else if (! strcmp (_dl_argv
[1], "--list-diagnostics"))
1489 state
.mode
= rtld_mode_list_diagnostics
;
1494 else if (strcmp (_dl_argv
[1], "--help") == 0)
1496 state
.mode
= rtld_mode_help
;
1500 else if (strcmp (_dl_argv
[1], "--version") == 0)
1502 else if (_dl_argv
[1][0] == '-' && _dl_argv
[1][1] == '-')
1504 if (_dl_argv
[1][2] == '\0')
1506 /* End of option list. */
1512 /* Unrecognized option. */
1513 _dl_usage (ld_so_name
, _dl_argv
[1]);
1518 if (__glibc_unlikely (state
.mode
== rtld_mode_list_tunables
))
1520 __tunables_print ();
1524 if (state
.mode
== rtld_mode_list_diagnostics
)
1525 _dl_print_diagnostics (_environ
);
1527 /* If we have no further argument the program was called incorrectly.
1528 Grant the user some education. */
1531 if (state
.mode
== rtld_mode_help
)
1532 /* --help without an executable is not an error. */
1533 _dl_help (ld_so_name
, &state
);
1535 _dl_usage (ld_so_name
, NULL
);
1541 /* The initialization of _dl_stack_flags done below assumes the
1542 executable's PT_GNU_STACK may have been honored by the kernel, and
1543 so a PT_GNU_STACK with PF_X set means the stack started out with
1544 execute permission. However, this is not really true if the
1545 dynamic linker is the executable the kernel loaded. For this
1546 case, we must reinitialize _dl_stack_flags to match the dynamic
1547 linker itself. If the dynamic linker was built with a
1548 PT_GNU_STACK, then the kernel may have loaded us with a
1549 nonexecutable stack that we will have to make executable when we
1550 load the program below unless it has a PT_GNU_STACK indicating
1551 nonexecutable stack is ok. */
1553 for (const ElfW(Phdr
) *ph
= phdr
; ph
< &phdr
[phnum
]; ++ph
)
1554 if (ph
->p_type
== PT_GNU_STACK
)
1556 GL(dl_stack_flags
) = ph
->p_flags
;
1560 if (__glibc_unlikely (state
.mode
== rtld_mode_verify
1561 || state
.mode
== rtld_mode_help
))
1563 const char *objname
;
1564 const char *err_str
= NULL
;
1565 struct map_args args
;
1568 args
.str
= rtld_progname
;
1570 args
.mode
= __RTLD_OPENEXEC
;
1571 (void) _dl_catch_error (&objname
, &err_str
, &malloced
, map_doit
,
1573 if (__glibc_unlikely (err_str
!= NULL
))
1575 /* We don't free the returned string, the programs stops
1577 if (state
.mode
== rtld_mode_help
)
1578 /* Mask the failure to load the main object. The help
1579 message contains less information in this case. */
1580 _dl_help (ld_so_name
, &state
);
1582 _exit (EXIT_FAILURE
);
1587 RTLD_TIMING_VAR (start
);
1588 rtld_timer_start (&start
);
1589 _dl_map_object (NULL
, rtld_progname
, lt_executable
, 0,
1590 __RTLD_OPENEXEC
, LM_ID_BASE
);
1591 rtld_timer_stop (&load_time
, start
);
1594 /* Now the map for the main executable is available. */
1595 main_map
= GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
;
1597 if (__glibc_likely (state
.mode
== rtld_mode_normal
))
1598 rtld_chain_load (main_map
, argv0
);
1600 phdr
= main_map
->l_phdr
;
1601 phnum
= main_map
->l_phnum
;
1602 /* We overwrite here a pointer to a malloc()ed string. But since
1603 the malloc() implementation used at this point is the dummy
1604 implementations which has no real free() function it does not
1605 makes sense to free the old string first. */
1606 main_map
->l_name
= (char *) "";
1607 *user_entry
= main_map
->l_entry
;
1609 /* Set bit indicating this is the main program map. */
1610 main_map
->l_main_map
= 1;
1612 #ifdef HAVE_AUX_VECTOR
1613 /* Adjust the on-stack auxiliary vector so that it looks like the
1614 binary was executed directly. */
1615 for (ElfW(auxv_t
) *av
= auxv
; av
->a_type
!= AT_NULL
; av
++)
1619 av
->a_un
.a_val
= (uintptr_t) phdr
;
1622 av
->a_un
.a_val
= phnum
;
1625 av
->a_un
.a_val
= *user_entry
;
1628 av
->a_un
.a_val
= (uintptr_t) _dl_argv
[0];
1633 /* Set the argv[0] string now that we've processed the executable. */
1635 _dl_argv
[0] = argv0
;
1637 /* Adjust arguments for the application entry point. */
1638 _dl_start_args_adjust (_dl_argv
- orig_argv
, skip_env
);
1642 /* Create a link_map for the executable itself.
1643 This will be what dlopen on "" returns. */
1644 main_map
= _dl_new_object ((char *) "", "", lt_executable
, NULL
,
1645 __RTLD_OPENEXEC
, LM_ID_BASE
);
1646 assert (main_map
!= NULL
);
1647 main_map
->l_phdr
= phdr
;
1648 main_map
->l_phnum
= phnum
;
1649 main_map
->l_entry
= *user_entry
;
1651 /* Even though the link map is not yet fully initialized we can add
1652 it to the map list since there are no possible users running yet. */
1653 _dl_add_to_namespace_list (main_map
, LM_ID_BASE
);
1654 assert (main_map
== GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
);
1656 /* At this point we are in a bit of trouble. We would have to
1657 fill in the values for l_dev and l_ino. But in general we
1658 do not know where the file is. We also do not handle AT_EXECFD
1659 even if it would be passed up.
1661 We leave the values here defined to 0. This is normally no
1662 problem as the program code itself is normally no shared
1663 object and therefore cannot be loaded dynamically. Nothing
1664 prevent the use of dynamic binaries and in these situations
1665 we might get problems. We might not be able to find out
1666 whether the object is already loaded. But since there is no
1667 easy way out and because the dynamic binary must also not
1668 have an SONAME we ignore this program for now. If it becomes
1669 a problem we can force people using SONAMEs. */
1671 /* We delay initializing the path structure until we got the dynamic
1672 information for the program. */
1675 bool has_interp
= rtld_setup_main_map (main_map
);
1677 /* If the current libname is different from the SONAME, add the
1679 if (GL(dl_rtld_map
).l_info
[DT_SONAME
] != NULL
1680 && strcmp (GL(dl_rtld_map
).l_libname
->name
,
1681 (const char *) D_PTR (&GL(dl_rtld_map
), l_info
[DT_STRTAB
])
1682 + GL(dl_rtld_map
).l_info
[DT_SONAME
]->d_un
.d_val
) != 0)
1684 static struct libname_list newname
;
1685 newname
.name
= ((char *) D_PTR (&GL(dl_rtld_map
), l_info
[DT_STRTAB
])
1686 + GL(dl_rtld_map
).l_info
[DT_SONAME
]->d_un
.d_ptr
);
1687 newname
.next
= NULL
;
1688 newname
.dont_free
= 1;
1690 assert (GL(dl_rtld_map
).l_libname
->next
== NULL
);
1691 GL(dl_rtld_map
).l_libname
->next
= &newname
;
1693 /* The ld.so must be relocated since otherwise loading audit modules
1694 will fail since they reuse the very same ld.so. */
1695 assert (GL(dl_rtld_map
).l_relocated
);
1699 /* Extract the contents of the dynamic section for easy access. */
1700 elf_get_dynamic_info (main_map
, false, false);
1702 /* If the main map is libc.so, update the base namespace to
1703 refer to this map. If libc.so is loaded later, this happens
1704 in _dl_map_object_from_fd. */
1705 if (main_map
->l_info
[DT_SONAME
] != NULL
1706 && (strcmp (((const char *) D_PTR (main_map
, l_info
[DT_STRTAB
])
1707 + main_map
->l_info
[DT_SONAME
]->d_un
.d_val
), LIBC_SO
)
1709 GL(dl_ns
)[LM_ID_BASE
].libc_map
= main_map
;
1711 /* Set up our cache of pointers into the hash table. */
1712 _dl_setup_hash (main_map
);
1715 if (__glibc_unlikely (state
.mode
== rtld_mode_verify
))
1717 /* We were called just to verify that this is a dynamic
1718 executable using us as the program interpreter. Exit with an
1719 error if we were not able to load the binary or no interpreter
1720 is specified (i.e., this is no dynamically linked binary. */
1721 if (main_map
->l_ld
== NULL
)
1724 _exit (has_interp
? 0 : 2);
1727 struct link_map
**first_preload
= &GL(dl_rtld_map
).l_next
;
1728 /* Set up the data structures for the system-supplied DSO early,
1729 so they can influence _dl_init_paths. */
1730 setup_vdso (main_map
, &first_preload
);
1732 /* With vDSO setup we can initialize the function pointers. */
1733 setup_vdso_pointers ();
1735 /* Initialize the data structures for the search paths for shared
1737 call_init_paths (&state
);
1739 /* Initialize _r_debug_extended. */
1740 struct r_debug
*r
= _dl_debug_initialize (GL(dl_rtld_map
).l_addr
,
1742 r
->r_state
= RT_CONSISTENT
;
1744 /* Put the link_map for ourselves on the chain so it can be found by
1745 name. Note that at this point the global chain of link maps contains
1746 exactly one element, which is pointed to by dl_loaded. */
1747 if (! GL(dl_rtld_map
).l_name
)
1748 /* If not invoked directly, the dynamic linker shared object file was
1749 found by the PT_INTERP name. */
1750 GL(dl_rtld_map
).l_name
= (char *) GL(dl_rtld_map
).l_libname
->name
;
1751 GL(dl_rtld_map
).l_type
= lt_library
;
1752 main_map
->l_next
= &GL(dl_rtld_map
);
1753 GL(dl_rtld_map
).l_prev
= main_map
;
1754 ++GL(dl_ns
)[LM_ID_BASE
]._ns_nloaded
;
1757 /* Starting from binutils-2.23, the linker will define the magic symbol
1758 __ehdr_start to point to our own ELF header if it is visible in a
1759 segment that also includes the phdrs. If that's not available, we use
1760 the old method that assumes the beginning of the file is part of the
1761 lowest-addressed PT_LOAD segment. */
1763 /* Set up the program header information for the dynamic linker
1764 itself. It is needed in the dl_iterate_phdr callbacks. */
1765 const ElfW(Ehdr
) *rtld_ehdr
= &__ehdr_start
;
1766 assert (rtld_ehdr
->e_ehsize
== sizeof *rtld_ehdr
);
1767 assert (rtld_ehdr
->e_phentsize
== sizeof (ElfW(Phdr
)));
1769 const ElfW(Phdr
) *rtld_phdr
= (const void *) rtld_ehdr
+ rtld_ehdr
->e_phoff
;
1771 GL(dl_rtld_map
).l_phdr
= rtld_phdr
;
1772 GL(dl_rtld_map
).l_phnum
= rtld_ehdr
->e_phnum
;
1775 /* PT_GNU_RELRO is usually the last phdr. */
1776 size_t cnt
= rtld_ehdr
->e_phnum
;
1778 if (rtld_phdr
[cnt
].p_type
== PT_GNU_RELRO
)
1780 GL(dl_rtld_map
).l_relro_addr
= rtld_phdr
[cnt
].p_vaddr
;
1781 GL(dl_rtld_map
).l_relro_size
= rtld_phdr
[cnt
].p_memsz
;
1785 /* Add the dynamic linker to the TLS list if it also uses TLS. */
1786 if (GL(dl_rtld_map
).l_tls_blocksize
!= 0)
1787 /* Assign a module ID. Do this before loading any audit modules. */
1788 _dl_assign_tls_modid (&GL(dl_rtld_map
));
1790 audit_list_add_dynamic_tag (&state
.audit_list
, main_map
, DT_AUDIT
);
1791 audit_list_add_dynamic_tag (&state
.audit_list
, main_map
, DT_DEPAUDIT
);
1793 /* At this point, all data has been obtained that is included in the
1795 if (__glibc_unlikely (state
.mode
== rtld_mode_help
))
1796 _dl_help (ld_so_name
, &state
);
1798 /* If we have auditing DSOs to load, do it now. */
1799 bool need_security_init
= true;
1800 if (state
.audit_list
.length
> 0)
1802 size_t naudit
= audit_list_count (&state
.audit_list
);
1804 /* Since we start using the auditing DSOs right away we need to
1805 initialize the data structures now. */
1806 tcbp
= init_tls (naudit
);
1808 /* Initialize security features. We need to do it this early
1809 since otherwise the constructors of the audit libraries will
1810 use different values (especially the pointer guard) and will
1813 need_security_init
= false;
1815 load_audit_modules (main_map
, &state
.audit_list
);
1817 /* The count based on audit strings may overestimate the number
1818 of audit modules that got loaded, but not underestimate. */
1819 assert (GLRO(dl_naudit
) <= naudit
);
1822 /* Keep track of the currently loaded modules to count how many
1823 non-audit modules which use TLS are loaded. */
1824 size_t count_modids
= _dl_count_modids ();
1826 /* Set up debugging before the debugger is notified for the first time. */
1827 elf_setup_debug_entry (main_map
, r
);
1829 /* We start adding objects. */
1830 r
->r_state
= RT_ADD
;
1832 LIBC_PROBE (init_start
, 2, LM_ID_BASE
, r
);
1834 /* Auditing checkpoint: we are ready to signal that the initial map
1835 is being constructed. */
1836 _dl_audit_activity_map (main_map
, LA_ACT_ADD
);
1838 /* We have two ways to specify objects to preload: via environment
1839 variable and via the file /etc/ld.so.preload. The latter can also
1840 be used when security is enabled. */
1841 assert (*first_preload
== NULL
);
1842 struct link_map
**preloads
= NULL
;
1843 unsigned int npreloads
= 0;
1845 if (__glibc_unlikely (state
.preloadlist
!= NULL
))
1847 RTLD_TIMING_VAR (start
);
1848 rtld_timer_start (&start
);
1849 npreloads
+= handle_preload_list (state
.preloadlist
, main_map
,
1851 rtld_timer_accum (&load_time
, start
);
1854 if (__glibc_unlikely (state
.preloadarg
!= NULL
))
1856 RTLD_TIMING_VAR (start
);
1857 rtld_timer_start (&start
);
1858 npreloads
+= handle_preload_list (state
.preloadarg
, main_map
,
1860 rtld_timer_accum (&load_time
, start
);
1863 /* There usually is no ld.so.preload file, it should only be used
1864 for emergencies and testing. So the open call etc should usually
1865 fail. Using access() on a non-existing file is faster than using
1866 open(). So we do this first. If it succeeds we do almost twice
1867 the work but this does not matter, since it is not for production
1869 static const char preload_file
[] = "/etc/ld.so.preload";
1870 if (__glibc_unlikely (__access (preload_file
, R_OK
) == 0))
1872 /* Read the contents of the file. */
1873 file
= _dl_sysdep_read_whole_file (preload_file
, &file_size
,
1874 PROT_READ
| PROT_WRITE
);
1875 if (__glibc_unlikely (file
!= MAP_FAILED
))
1877 /* Parse the file. It contains names of libraries to be loaded,
1878 separated by white spaces or `:'. It may also contain
1879 comments introduced by `#'. */
1884 /* Eliminate comments. */
1889 char *comment
= memchr (runp
, '#', rest
);
1890 if (comment
== NULL
)
1893 rest
-= comment
- runp
;
1896 while (--rest
> 0 && *++comment
!= '\n');
1899 /* We have one problematic case: if we have a name at the end of
1900 the file without a trailing terminating characters, we cannot
1901 place the \0. Handle the case separately. */
1902 if (file
[file_size
- 1] != ' ' && file
[file_size
- 1] != '\t'
1903 && file
[file_size
- 1] != '\n' && file
[file_size
- 1] != ':')
1905 problem
= &file
[file_size
];
1906 while (problem
> file
&& problem
[-1] != ' '
1907 && problem
[-1] != '\t'
1908 && problem
[-1] != '\n' && problem
[-1] != ':')
1917 file
[file_size
- 1] = '\0';
1920 RTLD_TIMING_VAR (start
);
1921 rtld_timer_start (&start
);
1923 if (file
!= problem
)
1927 while ((p
= strsep (&runp
, ": \t\n")) != NULL
)
1929 npreloads
+= do_preload (p
, main_map
, preload_file
);
1932 if (problem
!= NULL
)
1934 char *p
= strndupa (problem
, file_size
- (problem
- file
));
1936 npreloads
+= do_preload (p
, main_map
, preload_file
);
1939 rtld_timer_accum (&load_time
, start
);
1941 /* We don't need the file anymore. */
1942 __munmap (file
, file_size
);
1946 if (__glibc_unlikely (*first_preload
!= NULL
))
1948 /* Set up PRELOADS with a vector of the preloaded libraries. */
1949 struct link_map
*l
= *first_preload
;
1950 preloads
= __alloca (npreloads
* sizeof preloads
[0]);
1957 assert (i
== npreloads
);
1960 #ifdef NEED_DL_SYSINFO_DSO
1961 /* Now that the audit modules are opened, call la_objopen for the vDSO. */
1962 if (GLRO(dl_sysinfo_map
) != NULL
)
1963 _dl_audit_objopen (GLRO(dl_sysinfo_map
), LM_ID_BASE
);
1966 /* Load all the libraries specified by DT_NEEDED entries. If LD_PRELOAD
1967 specified some libraries to load, these are inserted before the actual
1968 dependencies in the executable's searchlist for symbol resolution. */
1970 RTLD_TIMING_VAR (start
);
1971 rtld_timer_start (&start
);
1972 _dl_map_object_deps (main_map
, preloads
, npreloads
,
1973 state
.mode
== rtld_mode_trace
, 0);
1974 rtld_timer_accum (&load_time
, start
);
1977 /* Mark all objects as being in the global scope. */
1978 for (i
= main_map
->l_searchlist
.r_nlist
; i
> 0; )
1979 main_map
->l_searchlist
.r_list
[--i
]->l_global
= 1;
1981 /* Remove _dl_rtld_map from the chain. */
1982 GL(dl_rtld_map
).l_prev
->l_next
= GL(dl_rtld_map
).l_next
;
1983 if (GL(dl_rtld_map
).l_next
!= NULL
)
1984 GL(dl_rtld_map
).l_next
->l_prev
= GL(dl_rtld_map
).l_prev
;
1986 for (i
= 1; i
< main_map
->l_searchlist
.r_nlist
; ++i
)
1987 if (main_map
->l_searchlist
.r_list
[i
] == &GL(dl_rtld_map
))
1990 bool rtld_multiple_ref
= false;
1991 if (__glibc_likely (i
< main_map
->l_searchlist
.r_nlist
))
1993 /* Some DT_NEEDED entry referred to the interpreter object itself, so
1994 put it back in the list of visible objects. We insert it into the
1995 chain in symbol search order because gdb uses the chain's order as
1996 its symbol search order. */
1997 rtld_multiple_ref
= true;
1999 GL(dl_rtld_map
).l_prev
= main_map
->l_searchlist
.r_list
[i
- 1];
2000 if (__glibc_likely (state
.mode
== rtld_mode_normal
))
2002 GL(dl_rtld_map
).l_next
= (i
+ 1 < main_map
->l_searchlist
.r_nlist
2003 ? main_map
->l_searchlist
.r_list
[i
+ 1]
2005 #ifdef NEED_DL_SYSINFO_DSO
2006 if (GLRO(dl_sysinfo_map
) != NULL
2007 && GL(dl_rtld_map
).l_prev
->l_next
== GLRO(dl_sysinfo_map
)
2008 && GL(dl_rtld_map
).l_next
!= GLRO(dl_sysinfo_map
))
2009 GL(dl_rtld_map
).l_prev
= GLRO(dl_sysinfo_map
);
2013 /* In trace mode there might be an invisible object (which we
2014 could not find) after the previous one in the search list.
2015 In this case it doesn't matter much where we put the
2016 interpreter object, so we just initialize the list pointer so
2017 that the assertion below holds. */
2018 GL(dl_rtld_map
).l_next
= GL(dl_rtld_map
).l_prev
->l_next
;
2020 assert (GL(dl_rtld_map
).l_prev
->l_next
== GL(dl_rtld_map
).l_next
);
2021 GL(dl_rtld_map
).l_prev
->l_next
= &GL(dl_rtld_map
);
2022 if (GL(dl_rtld_map
).l_next
!= NULL
)
2024 assert (GL(dl_rtld_map
).l_next
->l_prev
== GL(dl_rtld_map
).l_prev
);
2025 GL(dl_rtld_map
).l_next
->l_prev
= &GL(dl_rtld_map
);
2029 /* Now let us see whether all libraries are available in the
2030 versions we need. */
2032 struct version_check_args args
;
2033 args
.doexit
= state
.mode
== rtld_mode_normal
;
2034 args
.dotrace
= state
.mode
== rtld_mode_trace
;
2035 _dl_receive_error (print_missing_version
, version_check_doit
, &args
);
2038 /* We do not initialize any of the TLS functionality unless any of the
2039 initial modules uses TLS. This makes dynamic loading of modules with
2040 TLS impossible, but to support it requires either eagerly doing setup
2041 now or lazily doing it later. Doing it now makes us incompatible with
2042 an old kernel that can't perform TLS_INIT_TP, even if no TLS is ever
2043 used. Trying to do it lazily is too hairy to try when there could be
2044 multiple threads (from a non-TLS-using libpthread). */
2045 bool was_tls_init_tp_called
= __rtld_tls_init_tp_called
;
2047 tcbp
= init_tls (0);
2049 if (__glibc_likely (need_security_init
))
2050 /* Initialize security features. But only if we have not done it
2054 if (__glibc_unlikely (state
.mode
!= rtld_mode_normal
))
2056 /* We were run just to list the shared libraries. It is
2057 important that we do this before real relocation, because the
2058 functions we call below for output may no longer work properly
2059 after relocation. */
2062 if (GLRO(dl_debug_mask
) & DL_DEBUG_UNUSED
)
2064 /* Look through the dependencies of the main executable
2065 and determine which of them is not actually
2067 struct link_map
*l
= main_map
;
2069 /* Relocate the main executable. */
2070 struct relocate_args args
= { .l
= l
,
2071 .reloc_mode
= ((GLRO(dl_lazy
)
2073 | __RTLD_NOIFUNC
) };
2074 _dl_receive_error (print_unresolved
, relocate_doit
, &args
);
2076 /* This loop depends on the dependencies of the executable to
2077 correspond in number and order to the DT_NEEDED entries. */
2078 ElfW(Dyn
) *dyn
= main_map
->l_ld
;
2080 while (dyn
->d_tag
!= DT_NULL
)
2082 if (dyn
->d_tag
== DT_NEEDED
)
2085 #ifdef NEED_DL_SYSINFO_DSO
2086 /* Skip the VDSO since it's not part of the list
2087 of objects we brought in via DT_NEEDED entries. */
2088 if (l
== GLRO(dl_sysinfo_map
))
2095 _dl_printf ("Unused direct dependencies:\n");
2099 _dl_printf ("\t%s\n", l
->l_name
);
2106 _exit (first
!= true);
2108 else if (! main_map
->l_info
[DT_NEEDED
])
2109 _dl_printf ("\tstatically linked\n");
2112 for (l
= state
.mode_trace_program
? main_map
: main_map
->l_next
;
2115 /* The library was not found. */
2116 _dl_printf ("\t%s => not found\n", l
->l_libname
->name
);
2117 else if (strcmp (l
->l_libname
->name
, l
->l_name
) == 0)
2118 /* Print vDSO like libraries without duplicate name. Some
2119 consumers depend of this format. */
2120 _dl_printf ("\t%s (0x%0*zx)\n", l
->l_libname
->name
,
2121 (int) sizeof l
->l_map_start
* 2,
2122 (size_t) l
->l_map_start
);
2124 _dl_printf ("\t%s => %s (0x%0*zx)\n",
2125 DSO_FILENAME (l
->l_libname
->name
),
2126 DSO_FILENAME (l
->l_name
),
2127 (int) sizeof l
->l_map_start
* 2,
2128 (size_t) l
->l_map_start
);
2132 if (__glibc_unlikely (state
.mode
!= rtld_mode_trace
))
2133 for (i
= 1; i
< (unsigned int) _dl_argc
; ++i
)
2135 const ElfW(Sym
) *ref
= NULL
;
2136 ElfW(Addr
) loadbase
;
2139 result
= _dl_lookup_symbol_x (_dl_argv
[i
], main_map
,
2140 &ref
, main_map
->l_scope
,
2141 NULL
, ELF_RTYPE_CLASS_PLT
,
2142 DL_LOOKUP_ADD_DEPENDENCY
, NULL
);
2144 loadbase
= LOOKUP_VALUE_ADDRESS (result
, false);
2146 _dl_printf ("%s found at 0x%0*zd in object at 0x%0*zd\n",
2148 (int) sizeof ref
->st_value
* 2,
2149 (size_t) ref
->st_value
,
2150 (int) sizeof loadbase
* 2, (size_t) loadbase
);
2154 /* If LD_WARN is set, warn about undefined symbols. */
2155 if (GLRO(dl_lazy
) >= 0 && GLRO(dl_verbose
))
2157 /* We have to do symbol dependency testing. */
2158 struct relocate_args args
;
2161 args
.reloc_mode
= ((GLRO(dl_lazy
) ? RTLD_LAZY
: 0)
2164 i
= main_map
->l_searchlist
.r_nlist
;
2167 struct link_map
*l
= main_map
->l_initfini
[i
];
2168 if (l
!= &GL(dl_rtld_map
) && ! l
->l_faked
)
2171 _dl_receive_error (print_unresolved
, relocate_doit
,
2177 #define VERNEEDTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERNEED))
2178 if (state
.version_info
)
2180 /* Print more information. This means here, print information
2181 about the versions needed. */
2183 struct link_map
*map
;
2185 for (map
= main_map
; map
!= NULL
; map
= map
->l_next
)
2188 ElfW(Dyn
) *dyn
= map
->l_info
[VERNEEDTAG
];
2194 strtab
= (const void *) D_PTR (map
, l_info
[DT_STRTAB
]);
2195 ent
= (ElfW(Verneed
) *) (map
->l_addr
+ dyn
->d_un
.d_ptr
);
2199 _dl_printf ("\n\tVersion information:\n");
2203 _dl_printf ("\t%s:\n", DSO_FILENAME (map
->l_name
));
2208 struct link_map
*needed
;
2210 needed
= find_needed (strtab
+ ent
->vn_file
);
2211 aux
= (ElfW(Vernaux
) *) ((char *) ent
+ ent
->vn_aux
);
2215 const char *fname
= NULL
;
2218 && match_version (strtab
+ aux
->vna_name
,
2220 fname
= needed
->l_name
;
2222 _dl_printf ("\t\t%s (%s) %s=> %s\n",
2223 strtab
+ ent
->vn_file
,
2224 strtab
+ aux
->vna_name
,
2225 aux
->vna_flags
& VER_FLG_WEAK
2227 fname
?: "not found");
2229 if (aux
->vna_next
== 0)
2230 /* No more symbols. */
2234 aux
= (ElfW(Vernaux
) *) ((char *) aux
2238 if (ent
->vn_next
== 0)
2239 /* No more dependencies. */
2242 /* Next dependency. */
2243 ent
= (ElfW(Verneed
) *) ((char *) ent
+ ent
->vn_next
);
2252 /* Now set up the variable which helps the assembler startup code. */
2253 GL(dl_ns
)[LM_ID_BASE
]._ns_main_searchlist
= &main_map
->l_searchlist
;
2255 /* Save the information about the original global scope list since
2256 we need it in the memory handling later. */
2257 GLRO(dl_initial_searchlist
) = *GL(dl_ns
)[LM_ID_BASE
]._ns_main_searchlist
;
2259 /* Remember the last search directory added at startup, now that
2260 malloc will no longer be the one from dl-minimal.c. As a side
2261 effect, this marks ld.so as initialized, so that the rtld_active
2262 function returns true from now on. */
2263 GLRO(dl_init_all_dirs
) = GL(dl_all_dirs
);
2265 /* Print scope information. */
2266 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_SCOPES
))
2268 _dl_debug_printf ("\nInitial object scopes\n");
2270 for (struct link_map
*l
= main_map
; l
!= NULL
; l
= l
->l_next
)
2271 _dl_show_scope (l
, 0);
2274 _rtld_main_check (main_map
, _dl_argv
[0]);
2276 /* Now we have all the objects loaded. Relocate them all except for
2277 the dynamic linker itself. We do this in reverse order so that copy
2278 relocs of earlier objects overwrite the data written by later
2279 objects. We do not re-relocate the dynamic linker itself in this
2280 loop because that could result in the GOT entries for functions we
2281 call being changed, and that would break us. It is safe to relocate
2282 the dynamic linker out of order because it has no copy relocations.
2283 Likewise for libc, which is relocated early to ensure that IFUNC
2284 resolvers in libc work. */
2286 int consider_profiling
= GLRO(dl_profile
) != NULL
;
2288 /* If we are profiling we also must do lazy reloaction. */
2289 GLRO(dl_lazy
) |= consider_profiling
;
2291 if (GL(dl_ns
)[LM_ID_BASE
].libc_map
!= NULL
)
2292 _dl_relocate_object (GL(dl_ns
)[LM_ID_BASE
].libc_map
,
2293 GL(dl_ns
)[LM_ID_BASE
].libc_map
->l_scope
,
2294 GLRO(dl_lazy
) ? RTLD_LAZY
: 0, consider_profiling
);
2296 RTLD_TIMING_VAR (start
);
2297 rtld_timer_start (&start
);
2299 unsigned i
= main_map
->l_searchlist
.r_nlist
;
2302 struct link_map
*l
= main_map
->l_initfini
[i
];
2304 /* While we are at it, help the memory handling a bit. We have to
2305 mark some data structures as allocated with the fake malloc()
2306 implementation in ld.so. */
2307 struct libname_list
*lnp
= l
->l_libname
->next
;
2309 while (__builtin_expect (lnp
!= NULL
, 0))
2314 /* Also allocated with the fake malloc(). */
2315 l
->l_free_initfini
= 0;
2317 if (l
!= &GL(dl_rtld_map
))
2318 _dl_relocate_object (l
, l
->l_scope
, GLRO(dl_lazy
) ? RTLD_LAZY
: 0,
2319 consider_profiling
);
2321 /* Add object to slot information data if necessasy. */
2322 if (l
->l_tls_blocksize
!= 0 && __rtld_tls_init_tp_called
)
2323 _dl_add_to_slotinfo (l
, true);
2326 rtld_timer_stop (&relocate_time
, start
);
2328 /* Now enable profiling if needed. Like the previous call,
2329 this has to go here because the calls it makes should use the
2330 rtld versions of the functions (particularly calloc()), but it
2331 needs to have _dl_profile_map set up by the relocator. */
2332 if (__glibc_unlikely (GL(dl_profile_map
) != NULL
))
2333 /* We must prepare the profiling. */
2334 _dl_start_profile ();
2336 if ((!was_tls_init_tp_called
&& GL(dl_tls_max_dtv_idx
) > 0)
2337 || count_modids
!= _dl_count_modids ())
2338 ++GL(dl_tls_generation
);
2340 /* Now that we have completed relocation, the initializer data
2341 for the TLS blocks has its final values and we can copy them
2342 into the main thread's TLS area, which we allocated above.
2343 Note: thread-local variables must only be accessed after completing
2345 _dl_allocate_tls_init (tcbp
, true);
2347 /* And finally install it for the main thread. */
2348 if (! __rtld_tls_init_tp_called
)
2349 call_tls_init_tp (tcbp
);
2351 /* Make sure no new search directories have been added. */
2352 assert (GLRO(dl_init_all_dirs
) == GL(dl_all_dirs
));
2354 if (rtld_multiple_ref
)
2356 /* There was an explicit ref to the dynamic linker as a shared lib.
2357 Re-relocate ourselves with user-controlled symbol definitions.
2359 We must do this after TLS initialization in case after this
2360 re-relocation, we might call a user-supplied function
2361 (e.g. calloc from _dl_relocate_object) that uses TLS data. */
2363 /* Set up the object lookup structures. */
2364 _dl_find_object_init ();
2366 /* The malloc implementation has been relocated, so resolving
2367 its symbols (and potentially calling IFUNC resolvers) is safe
2369 __rtld_malloc_init_real (main_map
);
2371 /* Likewise for the locking implementation. */
2372 __rtld_mutex_init ();
2374 RTLD_TIMING_VAR (start
);
2375 rtld_timer_start (&start
);
2377 /* Mark the link map as not yet relocated again. */
2378 GL(dl_rtld_map
).l_relocated
= 0;
2379 _dl_relocate_object (&GL(dl_rtld_map
), main_map
->l_scope
, 0, 0);
2381 rtld_timer_accum (&relocate_time
, start
);
2384 /* Relocation is complete. Perform early libc initialization. This
2385 is the initial libc, even if audit modules have been loaded with
2387 _dl_call_libc_early_init (GL(dl_ns
)[LM_ID_BASE
].libc_map
, true);
2389 /* Do any necessary cleanups for the startup OS interface code.
2390 We do these now so that no calls are made after rtld re-relocation
2391 which might be resolved to different functions than we expect.
2392 We cannot do this before relocating the other objects because
2393 _dl_relocate_object might need to call `mprotect' for DT_TEXTREL. */
2394 _dl_sysdep_start_cleanup ();
2396 /* Auditing checkpoint: we have added all objects. */
2397 _dl_audit_activity_nsid (LM_ID_BASE
, LA_ACT_CONSISTENT
);
2399 /* Notify the debugger all new objects are now ready to go. We must re-get
2400 the address since by now the variable might be in another object. */
2401 r
= _dl_debug_update (LM_ID_BASE
);
2402 r
->r_state
= RT_CONSISTENT
;
2404 LIBC_PROBE (init_complete
, 2, LM_ID_BASE
, r
);
2406 #if defined USE_LDCONFIG && !defined MAP_COPY
2407 /* We must munmap() the cache file. */
2408 _dl_unload_cache ();
2411 /* Once we return, _dl_sysdep_start will invoke
2412 the DT_INIT functions and then *USER_ENTRY. */
2415 /* This is a little helper function for resolving symbols while
2416 tracing the binary. */
2418 print_unresolved (int errcode
__attribute__ ((unused
)), const char *objname
,
2419 const char *errstring
)
2421 if (objname
[0] == '\0')
2422 objname
= RTLD_PROGNAME
;
2423 _dl_error_printf ("%s (%s)\n", errstring
, objname
);
2426 /* This is a little helper function for resolving symbols while
2427 tracing the binary. */
2429 print_missing_version (int errcode
__attribute__ ((unused
)),
2430 const char *objname
, const char *errstring
)
2432 _dl_error_printf ("%s: %s: %s\n", RTLD_PROGNAME
,
2433 objname
, errstring
);
2436 /* Process the string given as the parameter which explains which debugging
2437 options are enabled. */
2439 process_dl_debug (struct dl_main_state
*state
, const char *dl_debug
)
2441 /* When adding new entries make sure that the maximal length of a name
2442 is correctly handled in the LD_DEBUG_HELP code below. */
2446 const char name
[10];
2447 const char helptext
[41];
2448 unsigned short int mask
;
2451 #define LEN_AND_STR(str) sizeof (str) - 1, str
2452 { LEN_AND_STR ("libs"), "display library search paths",
2453 DL_DEBUG_LIBS
| DL_DEBUG_IMPCALLS
},
2454 { LEN_AND_STR ("reloc"), "display relocation processing",
2455 DL_DEBUG_RELOC
| DL_DEBUG_IMPCALLS
},
2456 { LEN_AND_STR ("files"), "display progress for input file",
2457 DL_DEBUG_FILES
| DL_DEBUG_IMPCALLS
},
2458 { LEN_AND_STR ("symbols"), "display symbol table processing",
2459 DL_DEBUG_SYMBOLS
| DL_DEBUG_IMPCALLS
},
2460 { LEN_AND_STR ("bindings"), "display information about symbol binding",
2461 DL_DEBUG_BINDINGS
| DL_DEBUG_IMPCALLS
},
2462 { LEN_AND_STR ("versions"), "display version dependencies",
2463 DL_DEBUG_VERSIONS
| DL_DEBUG_IMPCALLS
},
2464 { LEN_AND_STR ("scopes"), "display scope information",
2466 { LEN_AND_STR ("all"), "all previous options combined",
2467 DL_DEBUG_LIBS
| DL_DEBUG_RELOC
| DL_DEBUG_FILES
| DL_DEBUG_SYMBOLS
2468 | DL_DEBUG_BINDINGS
| DL_DEBUG_VERSIONS
| DL_DEBUG_IMPCALLS
2469 | DL_DEBUG_SCOPES
},
2470 { LEN_AND_STR ("statistics"), "display relocation statistics",
2471 DL_DEBUG_STATISTICS
},
2472 { LEN_AND_STR ("unused"), "determined unused DSOs",
2474 { LEN_AND_STR ("help"), "display this help message and exit",
2477 #define ndebopts (sizeof (debopts) / sizeof (debopts[0]))
2479 /* Skip separating white spaces and commas. */
2480 while (*dl_debug
!= '\0')
2482 if (*dl_debug
!= ' ' && *dl_debug
!= ',' && *dl_debug
!= ':')
2487 while (dl_debug
[len
] != '\0' && dl_debug
[len
] != ' '
2488 && dl_debug
[len
] != ',' && dl_debug
[len
] != ':')
2491 for (cnt
= 0; cnt
< ndebopts
; ++cnt
)
2492 if (debopts
[cnt
].len
== len
2493 && memcmp (dl_debug
, debopts
[cnt
].name
, len
) == 0)
2495 GLRO(dl_debug_mask
) |= debopts
[cnt
].mask
;
2499 if (cnt
== ndebopts
)
2501 /* Display a warning and skip everything until next
2503 char *copy
= strndupa (dl_debug
, len
);
2504 _dl_error_printf ("\
2505 warning: debug option `%s' unknown; try LD_DEBUG=help\n", copy
);
2515 if (GLRO(dl_debug_mask
) & DL_DEBUG_UNUSED
)
2517 /* In order to get an accurate picture of whether a particular
2518 DT_NEEDED entry is actually used we have to process both
2519 the PLT and non-PLT relocation entries. */
2523 if (GLRO(dl_debug_mask
) & DL_DEBUG_HELP
)
2528 Valid options for the LD_DEBUG environment variable are:\n\n");
2530 for (cnt
= 0; cnt
< ndebopts
; ++cnt
)
2531 _dl_printf (" %.*s%s%s\n", debopts
[cnt
].len
, debopts
[cnt
].name
,
2532 " " + debopts
[cnt
].len
- 3,
2533 debopts
[cnt
].helptext
);
2536 To direct the debugging output into a file instead of standard output\n\
2537 a filename can be specified using the LD_DEBUG_OUTPUT environment variable.\n");
2543 process_envvars_secure (struct dl_main_state
*state
)
2545 char **runp
= _environ
;
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 /* For __libc_enable_secure mode, audit pathnames containing slashes
2566 are ignored. Also, shared audit objects are only loaded only from
2567 the standard search directories and only if they have set-user-ID
2568 mode bit enabled. */
2569 if (memcmp (envline
, "AUDIT", 5) == 0)
2570 audit_list_add_string (&state
->audit_list
, &envline
[6]);
2574 /* For __libc_enable_secure mode, preload pathnames containing slashes
2575 are ignored. Also, shared objects are only preloaded from the
2576 standard search directories and only if they have set-user-ID mode
2578 if (memcmp (envline
, "PRELOAD", 7) == 0)
2579 state
->preloadlist
= &envline
[8];
2584 /* Extra security for SUID binaries. Remove all dangerous environment
2586 const char *nextp
= UNSECURE_ENVVARS
;
2589 /* Keep track of the number of environment variables that were set in
2590 the environment and are unset below. Use getenv() which returns
2591 non-NULL if the variable is set in the environment. This count is
2592 needed if we need to adjust the location of the AUX vector on the
2593 stack when running ld.so directly. */
2594 if (getenv (nextp
) != NULL
)
2598 nextp
= strchr (nextp
, '\0') + 1;
2600 while (*nextp
!= '\0');
2602 if (GLRO(dl_debug_mask
) != 0
2603 || GLRO(dl_verbose
) != 0
2604 || GLRO(dl_lazy
) != 1
2605 || GLRO(dl_bind_not
) != 0
2606 || state
->mode
!= rtld_mode_normal
2607 || state
->version_info
)
2614 process_envvars_default (struct dl_main_state
*state
)
2616 char **runp
= _environ
;
2618 char *debug_output
= NULL
;
2620 while ((envline
= _dl_next_ld_env_entry (&runp
)) != NULL
)
2624 while (envline
[len
] != '\0' && envline
[len
] != '=')
2627 if (envline
[len
] != '=')
2628 /* This is a "LD_" variable at the end of the string without
2629 a '=' character. Ignore it since otherwise we will access
2630 invalid memory below. */
2636 /* Warning level, verbose or not. */
2637 if (memcmp (envline
, "WARN", 4) == 0)
2638 GLRO(dl_verbose
) = envline
[5] != '\0';
2642 /* Debugging of the dynamic linker? */
2643 if (memcmp (envline
, "DEBUG", 5) == 0)
2645 process_dl_debug (state
, &envline
[6]);
2648 /* For __libc_enable_secure mode, audit pathnames containing slashes
2649 are ignored. Also, shared audit objects are only loaded only from
2650 the standard search directories and only if they have set-user-ID
2651 mode bit enabled. */
2652 if (memcmp (envline
, "AUDIT", 5) == 0)
2653 audit_list_add_string (&state
->audit_list
, &envline
[6]);
2657 /* Print information about versions. */
2658 if (memcmp (envline
, "VERBOSE", 7) == 0)
2660 state
->version_info
= envline
[8] != '\0';
2664 /* For __libc_enable_secure mode, preload pathnames containing slashes
2665 are ignored. Also, shared objects are only preloaded from the
2666 standard search directories and only if they have set-user-ID mode
2668 if (memcmp (envline
, "PRELOAD", 7) == 0)
2670 state
->preloadlist
= &envline
[8];
2674 /* Which shared object shall be profiled. */
2675 if (memcmp (envline
, "PROFILE", 7) == 0 && envline
[8] != '\0')
2676 GLRO(dl_profile
) = &envline
[8];
2680 /* Do we bind early? */
2681 if (memcmp (envline
, "BIND_NOW", 8) == 0)
2683 GLRO(dl_lazy
) = envline
[9] == '\0';
2686 if (memcmp (envline
, "BIND_NOT", 8) == 0)
2687 GLRO(dl_bind_not
) = envline
[9] != '\0';
2691 /* Test whether we want to see the content of the auxiliary
2692 array passed up from the kernel. */
2693 if (memcmp (envline
, "SHOW_AUXV", 9) == 0)
2698 /* Path where the binary is found. */
2699 if (memcmp (envline
, "ORIGIN_PATH", 11) == 0)
2700 GLRO(dl_origin_path
) = &envline
[12];
2704 /* The library search path. */
2705 if (memcmp (envline
, "LIBRARY_PATH", 12) == 0)
2707 state
->library_path
= &envline
[13];
2708 state
->library_path_source
= "LD_LIBRARY_PATH";
2712 /* Where to place the profiling data file. */
2713 if (memcmp (envline
, "DEBUG_OUTPUT", 12) == 0)
2715 debug_output
= &envline
[13];
2719 if (memcmp (envline
, "DYNAMIC_WEAK", 12) == 0)
2720 GLRO(dl_dynamic_weak
) = 1;
2724 /* Where to place the profiling data file. */
2725 if (memcmp (envline
, "PROFILE_OUTPUT", 14) == 0
2726 && envline
[15] != '\0')
2727 GLRO(dl_profile_output
) = &envline
[15];
2731 /* The mode of the dynamic linker can be set. */
2732 if (memcmp (envline
, "TRACE_LOADED_OBJECTS", 20) == 0)
2734 state
->mode
= rtld_mode_trace
;
2735 state
->mode_trace_program
2736 = _dl_strtoul (&envline
[21], NULL
) > 1;
2742 /* If we have to run the dynamic linker in debugging mode and the
2743 LD_DEBUG_OUTPUT environment variable is given, we write the debug
2744 messages to this file. */
2745 if (GLRO(dl_debug_mask
) != 0 && debug_output
!= NULL
)
2747 const int flags
= O_WRONLY
| O_APPEND
| O_CREAT
| O_NOFOLLOW
;
2748 size_t name_len
= strlen (debug_output
);
2749 char buf
[name_len
+ 12];
2752 buf
[name_len
+ 11] = '\0';
2753 startp
= _itoa (__getpid (), &buf
[name_len
+ 11], 10, 0);
2755 startp
= memcpy (startp
- name_len
, debug_output
, name_len
);
2757 GLRO(dl_debug_fd
) = __open64_nocancel (startp
, flags
, DEFFILEMODE
);
2758 if (GLRO(dl_debug_fd
) == -1)
2759 /* We use standard output if opening the file failed. */
2760 GLRO(dl_debug_fd
) = STDOUT_FILENO
;
2765 process_envvars (struct dl_main_state
*state
)
2768 if (__glibc_unlikely (__libc_enable_secure
))
2769 skip_env
+= process_envvars_secure (state
);
2771 process_envvars_default (state
);
2776 #if HP_TIMING_INLINE
2778 print_statistics_item (const char *title
, hp_timing_t time
,
2781 char cycles
[HP_TIMING_PRINT_SIZE
];
2782 HP_TIMING_PRINT (cycles
, sizeof (cycles
), time
);
2784 char relative
[3 * sizeof (hp_timing_t
) + 2];
2785 char *cp
= _itoa ((1000ULL * time
) / total
, relative
+ sizeof (relative
),
2787 /* Sets the decimal point. */
2788 char *wp
= relative
;
2789 switch (relative
+ sizeof (relative
) - cp
)
2802 _dl_debug_printf ("%s: %s cycles (%s%%)\n", title
, cycles
, relative
);
2806 /* Print the various times we collected. */
2808 __attribute ((noinline
))
2809 print_statistics (const hp_timing_t
*rtld_total_timep
)
2811 #if HP_TIMING_INLINE
2813 char cycles
[HP_TIMING_PRINT_SIZE
];
2814 HP_TIMING_PRINT (cycles
, sizeof (cycles
), *rtld_total_timep
);
2815 _dl_debug_printf ("\nruntime linker statistics:\n"
2816 " total startup time in dynamic loader: %s cycles\n",
2818 print_statistics_item (" time needed for relocation",
2819 relocate_time
, *rtld_total_timep
);
2823 unsigned long int num_relative_relocations
= 0;
2824 for (Lmid_t ns
= 0; ns
< GL(dl_nns
); ++ns
)
2826 if (GL(dl_ns
)[ns
]._ns_loaded
== NULL
)
2829 struct r_scope_elem
*scope
= &GL(dl_ns
)[ns
]._ns_loaded
->l_searchlist
;
2831 for (unsigned int i
= 0; i
< scope
->r_nlist
; i
++)
2833 struct link_map
*l
= scope
->r_list
[i
];
2835 if (l
->l_addr
!= 0 && l
->l_info
[VERSYMIDX (DT_RELCOUNT
)])
2836 num_relative_relocations
2837 += l
->l_info
[VERSYMIDX (DT_RELCOUNT
)]->d_un
.d_val
;
2838 #ifndef ELF_MACHINE_REL_RELATIVE
2839 /* Relative relocations are always processed on these
2841 if (l
->l_info
[VERSYMIDX (DT_RELACOUNT
)])
2843 /* On e.g. IA-64 or Alpha, relative relocations are processed
2844 only if library is loaded to different address than p_vaddr. */
2845 if (l
->l_addr
!= 0 && l
->l_info
[VERSYMIDX (DT_RELACOUNT
)])
2847 num_relative_relocations
2848 += l
->l_info
[VERSYMIDX (DT_RELACOUNT
)]->d_un
.d_val
;
2852 _dl_debug_printf (" number of relocations: %lu\n"
2853 " number of relocations from cache: %lu\n"
2854 " number of relative relocations: %lu\n",
2855 GL(dl_num_relocations
),
2856 GL(dl_num_cache_relocations
),
2857 num_relative_relocations
);
2859 #if HP_TIMING_INLINE
2860 print_statistics_item (" time needed to load objects",
2861 load_time
, *rtld_total_timep
);