1 /* Run time dynamic linker.
2 Copyright (C) 1995-2020 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 "dynamic-link.h"
36 #include <dl-librecon.h>
37 #include <unsecvars.h>
39 #include <dl-osinfo.h>
40 #include <dl-procinfo.h>
43 #include <dl-vdso-setup.h>
45 #include <stap-probe.h>
46 #include <stackinfo.h>
47 #include <not-cancel.h>
48 #include <array_length.h>
49 #include <libc-early-init.h>
52 #include <gnu/lib-names.h>
56 /* Only enables rtld profiling for architectures which provides non generic
57 hp-timing support. The generic support requires either syscall
58 (clock_gettime), which will incur in extra overhead on loading time.
59 Using vDSO is also an option, but it will require extra support on loader
60 to setup the vDSO pointer before its usage. */
62 # define RLTD_TIMING_DECLARE(var, classifier,...) \
63 classifier hp_timing_t var __VA_ARGS__
64 # define RTLD_TIMING_VAR(var) RLTD_TIMING_DECLARE (var, )
65 # define RTLD_TIMING_SET(var, value) (var) = (value)
66 # define RTLD_TIMING_REF(var) &(var)
69 rtld_timer_start (hp_timing_t
*var
)
75 rtld_timer_stop (hp_timing_t
*var
, hp_timing_t start
)
79 HP_TIMING_DIFF (*var
, start
, stop
);
83 rtld_timer_accum (hp_timing_t
*sum
, hp_timing_t start
)
86 rtld_timer_stop (&stop
, start
);
87 HP_TIMING_ACCUM_NT(*sum
, stop
);
90 # define RLTD_TIMING_DECLARE(var, classifier...)
91 # define RTLD_TIMING_SET(var, value)
92 # define RTLD_TIMING_VAR(var)
93 # define RTLD_TIMING_REF(var) 0
94 # define rtld_timer_start(var)
95 # define rtld_timer_stop(var, start)
96 # define rtld_timer_accum(sum, start)
99 /* Avoid PLT use for our local calls at startup. */
100 extern __typeof (__mempcpy
) __mempcpy attribute_hidden
;
102 /* GCC has mental blocks about _exit. */
103 extern __typeof (_exit
) exit_internal
asm ("_exit") attribute_hidden
;
104 #define _exit exit_internal
106 /* Helper function to handle errors while resolving symbols. */
107 static void print_unresolved (int errcode
, const char *objname
,
108 const char *errsting
);
110 /* Helper function to handle errors when a version is missing. */
111 static void print_missing_version (int errcode
, const char *objname
,
112 const char *errsting
);
114 /* Print the various times we collected. */
115 static void print_statistics (const hp_timing_t
*total_timep
);
117 /* Creates an empty audit list. */
118 static void audit_list_init (struct audit_list
*);
120 /* Add a string to the end of the audit list, for later parsing. Must
121 not be called after audit_list_next. */
122 static void audit_list_add_string (struct audit_list
*, const char *);
124 /* Add the audit strings from the link map, found in the dynamic
125 segment at TG (either DT_AUDIT and DT_DEPAUDIT). Must be called
126 before audit_list_next. */
127 static void audit_list_add_dynamic_tag (struct audit_list
*,
131 /* Extract the next audit module from the audit list. Only modules
132 for which dso_name_valid_for_suid is true are returned. Must be
133 called after all the audit_list_add_string,
134 audit_list_add_dynamic_tags calls. */
135 static const char *audit_list_next (struct audit_list
*);
137 /* Initialize *STATE with the defaults. */
138 static void dl_main_state_init (struct dl_main_state
*state
);
140 /* Process all environments variables the dynamic linker must recognize.
141 Since all of them start with `LD_' we are a bit smarter while finding
143 static void process_envvars (struct dl_main_state
*state
);
145 #ifdef DL_ARGV_NOT_RELRO
146 int _dl_argc attribute_hidden
;
147 char **_dl_argv
= NULL
;
148 /* Nonzero if we were run directly. */
149 unsigned int _dl_skip_args attribute_hidden
;
151 int _dl_argc attribute_relro attribute_hidden
;
152 char **_dl_argv attribute_relro
= NULL
;
153 unsigned int _dl_skip_args attribute_relro attribute_hidden
;
155 rtld_hidden_data_def (_dl_argv
)
157 #ifndef THREAD_SET_STACK_GUARD
158 /* Only exported for architectures that don't store the stack guard canary
159 in thread local area. */
160 uintptr_t __stack_chk_guard attribute_relro
;
163 /* Only exported for architectures that don't store the pointer guard
164 value in thread local area. */
165 uintptr_t __pointer_chk_guard_local
166 attribute_relro attribute_hidden
__attribute__ ((nocommon
));
167 #ifndef THREAD_SET_POINTER_GUARD
168 strong_alias (__pointer_chk_guard_local
, __pointer_chk_guard
)
171 /* Check that AT_SECURE=0, or that the passed name does not contain
172 directories and is not overly long. Reject empty names
175 dso_name_valid_for_suid (const char *p
)
177 if (__glibc_unlikely (__libc_enable_secure
))
179 /* Ignore pathnames with directories for AT_SECURE=1
180 programs, and also skip overlong names. */
181 size_t len
= strlen (p
);
182 if (len
>= SECURE_NAME_LIMIT
|| memchr (p
, '/', len
) != NULL
)
189 audit_list_init (struct audit_list
*list
)
192 list
->current_index
= 0;
193 list
->current_tail
= NULL
;
197 audit_list_add_string (struct audit_list
*list
, const char *string
)
199 /* Empty strings do not load anything. */
203 if (list
->length
== array_length (list
->audit_strings
))
204 _dl_fatal_printf ("Fatal glibc error: Too many audit modules requested\n");
206 list
->audit_strings
[list
->length
++] = string
;
208 /* Initialize processing of the first string for
210 if (list
->length
== 1)
211 list
->current_tail
= string
;
215 audit_list_add_dynamic_tag (struct audit_list
*list
, struct link_map
*main_map
,
218 ElfW(Dyn
) *info
= main_map
->l_info
[ADDRIDX (tag
)];
219 const char *strtab
= (const char *) D_PTR (main_map
, l_info
[DT_STRTAB
]);
221 audit_list_add_string (list
, strtab
+ info
->d_un
.d_val
);
225 audit_list_next (struct audit_list
*list
)
227 if (list
->current_tail
== NULL
)
232 /* Advance to the next string in audit_strings if the current
233 string has been exhausted. */
234 while (*list
->current_tail
== '\0')
236 ++list
->current_index
;
237 if (list
->current_index
== list
->length
)
239 list
->current_tail
= NULL
;
242 list
->current_tail
= list
->audit_strings
[list
->current_index
];
245 /* Split the in-string audit list at the next colon colon. */
246 size_t len
= strcspn (list
->current_tail
, ":");
247 if (len
> 0 && len
< sizeof (list
->fname
))
249 memcpy (list
->fname
, list
->current_tail
, len
);
250 list
->fname
[len
] = '\0';
253 /* Mark the name as unusable for dso_name_valid_for_suid. */
254 list
->fname
[0] = '\0';
256 /* Skip over the substring and the following delimiter. */
257 list
->current_tail
+= len
;
258 if (*list
->current_tail
== ':')
259 ++list
->current_tail
;
261 /* If the name is valid, return it. */
262 if (dso_name_valid_for_suid (list
->fname
))
265 /* Otherwise wrap around to find the next list element. . */
269 /* Count audit modules before they are loaded so GLRO(dl_naudit)
270 is not yet usable. */
272 audit_list_count (struct audit_list
*list
)
274 /* Restore the audit_list iterator state at the end. */
275 const char *saved_tail
= list
->current_tail
;
278 assert (list
->current_index
== 0);
279 while (audit_list_next (list
) != NULL
)
281 list
->current_tail
= saved_tail
;
282 list
->current_index
= 0;
287 dl_main_state_init (struct dl_main_state
*state
)
289 audit_list_init (&state
->audit_list
);
290 state
->library_path
= NULL
;
291 state
->library_path_source
= NULL
;
292 state
->preloadlist
= NULL
;
293 state
->preloadarg
= NULL
;
294 state
->glibc_hwcaps_prepend
= NULL
;
295 state
->glibc_hwcaps_mask
= NULL
;
296 state
->mode
= rtld_mode_normal
;
297 state
->any_debug
= false;
298 state
->version_info
= false;
301 #ifndef HAVE_INLINED_SYSCALLS
302 /* Set nonzero during loading and initialization of executable and
303 libraries, cleared before the executable's entry point runs. This
304 must not be initialized to nonzero, because the unused dynamic
305 linker loaded in for libc.so's "ld.so.1" dep will provide the
306 definition seen by libc.so's initializer; that value must be zero,
307 and will be since that dynamic linker's _dl_start and dl_main will
309 int _dl_starting_up
= 0;
310 rtld_hidden_def (_dl_starting_up
)
313 /* This is the structure which defines all variables global to ld.so
314 (except those which cannot be added for some reason). */
315 struct rtld_global _rtld_global
=
317 /* Get architecture specific initializer. */
318 #include <dl-procruntime.c>
319 /* Generally the default presumption without further information is an
320 * executable stack but this is not true for all platforms. */
321 ._dl_stack_flags
= DEFAULT_STACK_PERMS
,
322 #ifdef _LIBC_REENTRANT
323 ._dl_load_lock
= _RTLD_LOCK_RECURSIVE_INITIALIZER
,
324 ._dl_load_write_lock
= _RTLD_LOCK_RECURSIVE_INITIALIZER
,
329 #ifdef _LIBC_REENTRANT
330 [LM_ID_BASE
] = { ._ns_unique_sym_table
331 = { .lock
= _RTLD_LOCK_RECURSIVE_INITIALIZER
} }
335 /* If we would use strong_alias here the compiler would see a
336 non-hidden definition. This would undo the effect of the previous
337 declaration. So spell out what strong_alias does plus add the
338 visibility attribute. */
339 extern struct rtld_global _rtld_local
340 __attribute__ ((alias ("_rtld_global"), visibility ("hidden")));
343 /* This variable is similar to _rtld_local, but all values are
344 read-only after relocation. */
345 struct rtld_global_ro _rtld_global_ro attribute_relro
=
347 /* Get architecture specific initializer. */
348 #include <dl-procinfo.c>
349 #ifdef NEED_DL_SYSINFO
350 ._dl_sysinfo
= DL_SYSINFO_DEFAULT
,
352 ._dl_debug_fd
= STDERR_FILENO
,
353 ._dl_use_load_bias
= -2,
354 ._dl_correct_cache_id
= _DL_CACHE_DEFAULT_ID
,
356 ._dl_hwcap_mask
= HWCAP_IMPORTANT
,
359 ._dl_fpu_control
= _FPU_DEFAULT
,
360 ._dl_pagesize
= EXEC_PAGESIZE
,
361 ._dl_inhibit_cache
= 0,
363 /* Function pointers. */
364 ._dl_debug_printf
= _dl_debug_printf
,
365 ._dl_mcount
= _dl_mcount
,
366 ._dl_lookup_symbol_x
= _dl_lookup_symbol_x
,
367 ._dl_open
= _dl_open
,
368 ._dl_close
= _dl_close
,
369 ._dl_tls_get_addr_soft
= _dl_tls_get_addr_soft
,
370 #ifdef HAVE_DL_DISCOVER_OSVERSION
371 ._dl_discover_osversion
= _dl_discover_osversion
374 /* If we would use strong_alias here the compiler would see a
375 non-hidden definition. This would undo the effect of the previous
376 declaration. So spell out was strong_alias does plus add the
377 visibility attribute. */
378 extern struct rtld_global_ro _rtld_local_ro
379 __attribute__ ((alias ("_rtld_global_ro"), visibility ("hidden")));
382 static void dl_main (const ElfW(Phdr
) *phdr
, ElfW(Word
) phnum
,
383 ElfW(Addr
) *user_entry
, ElfW(auxv_t
) *auxv
);
385 /* These two variables cannot be moved into .data.rel.ro. */
386 static struct libname_list _dl_rtld_libname
;
387 static struct libname_list _dl_rtld_libname2
;
389 /* Variable for statistics. */
390 RLTD_TIMING_DECLARE (relocate_time
, static);
391 RLTD_TIMING_DECLARE (load_time
, static, attribute_relro
);
392 RLTD_TIMING_DECLARE (start_time
, static, attribute_relro
);
394 /* Additional definitions needed by TLS initialization. */
395 #ifdef TLS_INIT_HELPER
399 /* Helper function for syscall implementation. */
400 #ifdef DL_SYSINFO_IMPLEMENTATION
401 DL_SYSINFO_IMPLEMENTATION
404 /* Before ld.so is relocated we must not access variables which need
405 relocations. This means variables which are exported. Variables
406 declared as static are fine. If we can mark a variable hidden this
407 is fine, too. The latter is important here. We can avoid setting
408 up a temporary link map for ld.so if we can mark _rtld_global as
410 #ifdef PI_STATIC_AND_HIDDEN
411 # define DONT_USE_BOOTSTRAP_MAP 1
414 #ifdef DONT_USE_BOOTSTRAP_MAP
415 static ElfW(Addr
) _dl_start_final (void *arg
);
417 struct dl_start_final_info
420 RTLD_TIMING_VAR (start_time
);
422 static ElfW(Addr
) _dl_start_final (void *arg
,
423 struct dl_start_final_info
*info
);
426 /* These defined magically in the linker script. */
427 extern char _begin
[] attribute_hidden
;
428 extern char _etext
[] attribute_hidden
;
429 extern char _end
[] attribute_hidden
;
435 # error "sysdeps/MACHINE/dl-machine.h fails to define RTLD_START"
438 /* This is the second half of _dl_start (below). It can be inlined safely
439 under DONT_USE_BOOTSTRAP_MAP, where it is careful not to make any GOT
440 references. When the tools don't permit us to avoid using a GOT entry
441 for _dl_rtld_global (no attribute_hidden support), we must make sure
442 this function is not inlined (see below). */
444 #ifdef DONT_USE_BOOTSTRAP_MAP
445 static inline ElfW(Addr
) __attribute__ ((always_inline
))
446 _dl_start_final (void *arg
)
448 static ElfW(Addr
) __attribute__ ((noinline
))
449 _dl_start_final (void *arg
, struct dl_start_final_info
*info
)
452 ElfW(Addr
) start_addr
;
454 /* If it hasn't happen yet record the startup time. */
455 rtld_timer_start (&start_time
);
456 #if !defined DONT_USE_BOOTSTRAP_MAP
457 RTLD_TIMING_SET (start_time
, info
->start_time
);
460 /* Transfer data about ourselves to the permanent link_map structure. */
461 #ifndef DONT_USE_BOOTSTRAP_MAP
462 GL(dl_rtld_map
).l_addr
= info
->l
.l_addr
;
463 GL(dl_rtld_map
).l_ld
= info
->l
.l_ld
;
464 memcpy (GL(dl_rtld_map
).l_info
, info
->l
.l_info
,
465 sizeof GL(dl_rtld_map
).l_info
);
466 GL(dl_rtld_map
).l_mach
= info
->l
.l_mach
;
467 GL(dl_rtld_map
).l_relocated
= 1;
469 _dl_setup_hash (&GL(dl_rtld_map
));
470 GL(dl_rtld_map
).l_real
= &GL(dl_rtld_map
);
471 GL(dl_rtld_map
).l_map_start
= (ElfW(Addr
)) _begin
;
472 GL(dl_rtld_map
).l_map_end
= (ElfW(Addr
)) _end
;
473 GL(dl_rtld_map
).l_text_end
= (ElfW(Addr
)) _etext
;
474 /* Copy the TLS related data if necessary. */
475 #ifndef DONT_USE_BOOTSTRAP_MAP
476 # if NO_TLS_OFFSET != 0
477 GL(dl_rtld_map
).l_tls_offset
= NO_TLS_OFFSET
;
481 /* Initialize the stack end variable. */
482 __libc_stack_end
= __builtin_frame_address (0);
484 /* Call the OS-dependent function to set up life so we can do things like
485 file access. It will call `dl_main' (below) to do all the real work
486 of the dynamic linker, and then unwind our frame and run the user
487 entry point on the same stack we entered on. */
488 start_addr
= _dl_sysdep_start (arg
, &dl_main
);
490 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_STATISTICS
))
492 RTLD_TIMING_VAR (rtld_total_time
);
493 rtld_timer_stop (&rtld_total_time
, start_time
);
494 print_statistics (RTLD_TIMING_REF(rtld_total_time
));
500 static ElfW(Addr
) __attribute_used__
501 _dl_start (void *arg
)
503 #ifdef DONT_USE_BOOTSTRAP_MAP
504 # define bootstrap_map GL(dl_rtld_map)
506 struct dl_start_final_info info
;
507 # define bootstrap_map info.l
510 /* This #define produces dynamic linking inline functions for
511 bootstrap relocation instead of general-purpose relocation.
512 Since ld.so must not have any undefined symbols the result
513 is trivial: always the map of ld.so itself. */
514 #define RTLD_BOOTSTRAP
515 #define BOOTSTRAP_MAP (&bootstrap_map)
516 #define RESOLVE_MAP(sym, version, flags) BOOTSTRAP_MAP
517 #include "dynamic-link.h"
519 #ifdef DONT_USE_BOOTSTRAP_MAP
520 rtld_timer_start (&start_time
);
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 elf_get_dynamic_info (&bootstrap_map
, NULL
);
549 #if NO_TLS_OFFSET != 0
550 bootstrap_map
.l_tls_offset
= NO_TLS_OFFSET
;
553 #ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
554 ELF_MACHINE_BEFORE_RTLD_RELOC (bootstrap_map
.l_info
);
557 if (bootstrap_map
.l_addr
|| ! bootstrap_map
.l_info
[VALIDX(DT_GNU_PRELINKED
)])
559 /* Relocate ourselves so we can do normal function calls and
560 data access using the global offset table. */
562 ELF_DYNAMIC_RELOCATE (&bootstrap_map
, 0, 0, 0);
564 bootstrap_map
.l_relocated
= 1;
566 /* Please note that we don't allow profiling of this object and
567 therefore need not test whether we have to allocate the array
568 for the relocation results (as done in dl-reloc.c). */
570 /* Now life is sane; we can call functions and access global data.
571 Set up to use the operating system facilities, and find out from
572 the operating system's program loader where to find the program
573 header table in core. Put the rest of _dl_start into a separate
574 function, that way the compiler cannot put accesses to the GOT
575 before ELF_DYNAMIC_RELOCATE. */
577 __rtld_malloc_init_stubs ();
580 #ifdef DONT_USE_BOOTSTRAP_MAP
581 ElfW(Addr
) entry
= _dl_start_final (arg
);
583 ElfW(Addr
) entry
= _dl_start_final (arg
, &info
);
586 #ifndef ELF_MACHINE_START_ADDRESS
587 # define ELF_MACHINE_START_ADDRESS(map, start) (start)
590 return ELF_MACHINE_START_ADDRESS (GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
, entry
);
596 /* Now life is peachy; we can do all normal operations.
597 On to the real work. */
599 /* Some helper functions. */
601 /* Arguments to relocate_doit. */
610 /* Argument to map_doit. */
612 struct link_map
*loader
;
614 /* Return value of map_doit. */
615 struct link_map
*map
;
621 struct link_map
*map
;
627 struct link_map
*map
;
631 /* Arguments to version_check_doit. */
632 struct version_check_args
639 relocate_doit (void *a
)
641 struct relocate_args
*args
= (struct relocate_args
*) a
;
643 _dl_relocate_object (args
->l
, args
->l
->l_scope
, args
->reloc_mode
, 0);
649 struct map_args
*args
= (struct map_args
*) a
;
650 int type
= (args
->mode
== __RTLD_OPENEXEC
) ? lt_executable
: lt_library
;
651 args
->map
= _dl_map_object (args
->loader
, args
->str
, type
, 0,
652 args
->mode
, LM_ID_BASE
);
656 dlmopen_doit (void *a
)
658 struct dlmopen_args
*args
= (struct dlmopen_args
*) a
;
659 args
->map
= _dl_open (args
->fname
,
660 (RTLD_LAZY
| __RTLD_DLOPEN
| __RTLD_AUDIT
662 dl_main
, LM_ID_NEWLM
, _dl_argc
, _dl_argv
,
667 lookup_doit (void *a
)
669 struct lookup_args
*args
= (struct lookup_args
*) a
;
670 const ElfW(Sym
) *ref
= NULL
;
672 lookup_t l
= _dl_lookup_symbol_x (args
->name
, args
->map
, &ref
,
673 args
->map
->l_local_scope
, NULL
, 0,
674 DL_LOOKUP_RETURN_NEWEST
, NULL
);
676 args
->result
= DL_SYMBOL_ADDRESS (l
, ref
);
680 version_check_doit (void *a
)
682 struct version_check_args
*args
= (struct version_check_args
*) a
;
683 if (_dl_check_all_versions (GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
, 1,
684 args
->dotrace
) && args
->doexit
)
685 /* We cannot start the application. Abort now. */
690 static inline struct link_map
*
691 find_needed (const char *name
)
693 struct r_scope_elem
*scope
= &GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
->l_searchlist
;
694 unsigned int n
= scope
->r_nlist
;
697 if (_dl_name_match_p (name
, scope
->r_list
[n
]))
698 return scope
->r_list
[n
];
700 /* Should never happen. */
705 match_version (const char *string
, struct link_map
*map
)
707 const char *strtab
= (const void *) D_PTR (map
, l_info
[DT_STRTAB
]);
710 #define VERDEFTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERDEF))
711 if (map
->l_info
[VERDEFTAG
] == NULL
)
712 /* The file has no symbol versioning. */
715 def
= (ElfW(Verdef
) *) ((char *) map
->l_addr
716 + map
->l_info
[VERDEFTAG
]->d_un
.d_ptr
);
719 ElfW(Verdaux
) *aux
= (ElfW(Verdaux
) *) ((char *) def
+ def
->vd_aux
);
721 /* Compare the version strings. */
722 if (strcmp (string
, strtab
+ aux
->vda_name
) == 0)
726 /* If no more definitions we failed to find what we want. */
727 if (def
->vd_next
== 0)
730 /* Next definition. */
731 def
= (ElfW(Verdef
) *) ((char *) def
+ def
->vd_next
);
737 static bool tls_init_tp_called
;
740 init_tls (size_t naudit
)
742 /* Number of elements in the static TLS block. */
743 GL(dl_tls_static_nelem
) = GL(dl_tls_max_dtv_idx
);
745 /* Do not do this twice. The audit interface might have required
746 the DTV interfaces to be set up early. */
747 if (GL(dl_initial_dtv
) != NULL
)
750 /* Allocate the array which contains the information about the
751 dtv slots. We allocate a few entries more than needed to
752 avoid the need for reallocation. */
753 size_t nelem
= GL(dl_tls_max_dtv_idx
) + 1 + TLS_SLOTINFO_SURPLUS
;
756 GL(dl_tls_dtv_slotinfo_list
) = (struct dtv_slotinfo_list
*)
757 calloc (sizeof (struct dtv_slotinfo_list
)
758 + nelem
* sizeof (struct dtv_slotinfo
), 1);
759 /* No need to check the return value. If memory allocation failed
760 the program would have been terminated. */
762 struct dtv_slotinfo
*slotinfo
= GL(dl_tls_dtv_slotinfo_list
)->slotinfo
;
763 GL(dl_tls_dtv_slotinfo_list
)->len
= nelem
;
764 GL(dl_tls_dtv_slotinfo_list
)->next
= NULL
;
766 /* Fill in the information from the loaded modules. No namespace
767 but the base one can be filled at this time. */
768 assert (GL(dl_ns
)[LM_ID_BASE
+ 1]._ns_loaded
== NULL
);
770 for (struct link_map
*l
= GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
; l
!= NULL
;
772 if (l
->l_tls_blocksize
!= 0)
774 /* This is a module with TLS data. Store the map reference.
775 The generation counter is zero. */
777 /* slotinfo[i].gen = 0; */
780 assert (i
== GL(dl_tls_max_dtv_idx
));
782 /* Calculate the size of the static TLS surplus. */
783 _dl_tls_static_surplus_init (naudit
);
785 /* Compute the TLS offsets for the various blocks. */
786 _dl_determine_tlsoffset ();
788 /* Construct the static TLS block and the dtv for the initial
789 thread. For some platforms this will include allocating memory
790 for the thread descriptor. The memory for the TLS block will
791 never be freed. It should be allocated accordingly. The dtv
792 array can be changed if dynamic loading requires it. */
793 void *tcbp
= _dl_allocate_tls_storage ();
796 cannot allocate TLS data structures for initial thread\n");
798 /* Store for detection of the special case by __tls_get_addr
799 so it knows not to pass this dtv to the normal realloc. */
800 GL(dl_initial_dtv
) = GET_DTV (tcbp
);
802 /* And finally install it for the main thread. */
803 const char *lossage
= TLS_INIT_TP (tcbp
);
804 if (__glibc_unlikely (lossage
!= NULL
))
805 _dl_fatal_printf ("cannot set up thread-local storage: %s\n", lossage
);
806 #if THREAD_GSCOPE_IN_TCB
807 list_add (&THREAD_SELF
->list
, &GL (dl_stack_user
));
809 tls_init_tp_called
= true;
815 do_preload (const char *fname
, struct link_map
*main_map
, const char *where
)
818 const char *err_str
= NULL
;
819 struct map_args args
;
823 args
.loader
= main_map
;
824 args
.mode
= __RTLD_SECURE
;
826 unsigned int old_nloaded
= GL(dl_ns
)[LM_ID_BASE
]._ns_nloaded
;
828 (void) _dl_catch_error (&objname
, &err_str
, &malloced
, map_doit
, &args
);
829 if (__glibc_unlikely (err_str
!= NULL
))
832 ERROR: ld.so: object '%s' from %s cannot be preloaded (%s): ignored.\n",
833 fname
, where
, err_str
);
834 /* No need to call free, this is still before
835 the libc's malloc is used. */
837 else if (GL(dl_ns
)[LM_ID_BASE
]._ns_nloaded
!= old_nloaded
)
838 /* It is no duplicate. */
841 /* Nothing loaded. */
845 #if defined SHARED && defined _LIBC_REENTRANT \
846 && defined __rtld_lock_default_lock_recursive
848 rtld_lock_default_lock_recursive (void *lock
)
850 __rtld_lock_default_lock_recursive (lock
);
854 rtld_lock_default_unlock_recursive (void *lock
)
856 __rtld_lock_default_unlock_recursive (lock
);
864 /* Set up the stack checker's canary. */
865 uintptr_t stack_chk_guard
= _dl_setup_stack_chk_guard (_dl_random
);
866 #ifdef THREAD_SET_STACK_GUARD
867 THREAD_SET_STACK_GUARD (stack_chk_guard
);
869 __stack_chk_guard
= stack_chk_guard
;
872 /* Set up the pointer guard as well, if necessary. */
873 uintptr_t pointer_chk_guard
874 = _dl_setup_pointer_guard (_dl_random
, stack_chk_guard
);
875 #ifdef THREAD_SET_POINTER_GUARD
876 THREAD_SET_POINTER_GUARD (pointer_chk_guard
);
878 __pointer_chk_guard_local
= pointer_chk_guard
;
880 /* We do not need the _dl_random value anymore. The less
881 information we leave behind, the better, so clear the
886 #include <setup-vdso.h>
888 /* The LD_PRELOAD environment variable gives list of libraries
889 separated by white space or colons that are loaded before the
890 executable's dependencies and prepended to the global scope list.
891 (If the binary is running setuid all elements containing a '/' are
892 ignored since it is insecure.) Return the number of preloads
893 performed. Ditto for --preload command argument. */
895 handle_preload_list (const char *preloadlist
, struct link_map
*main_map
,
898 unsigned int npreloads
= 0;
899 const char *p
= preloadlist
;
900 char fname
[SECURE_PATH_LIMIT
];
904 /* Split preload list at space/colon. */
905 size_t len
= strcspn (p
, " :");
906 if (len
> 0 && len
< sizeof (fname
))
908 memcpy (fname
, p
, len
);
914 /* Skip over the substring and the following delimiter. */
919 if (dso_name_valid_for_suid (fname
))
920 npreloads
+= do_preload (fname
, main_map
, where
);
925 /* Called if the audit DSO cannot be used: if it does not have the
926 appropriate interfaces, or it expects a more recent version library
927 version than what the dynamic linker provides. */
929 unload_audit_module (struct link_map
*map
, int original_tls_idx
)
932 Lmid_t ns
= map
->l_ns
;
936 /* Make sure the namespace has been cleared entirely. */
937 assert (GL(dl_ns
)[ns
]._ns_loaded
== NULL
);
938 assert (GL(dl_ns
)[ns
]._ns_nloaded
== 0);
940 GL(dl_tls_max_dtv_idx
) = original_tls_idx
;
943 /* Called to print an error message if loading of an audit module
946 report_audit_module_load_error (const char *name
, const char *err_str
,
950 ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n",
953 free ((char *) err_str
);
956 /* Load one audit module. */
958 load_audit_module (const char *name
, struct audit_ifaces
**last_audit
)
960 int original_tls_idx
= GL(dl_tls_max_dtv_idx
);
962 struct dlmopen_args dlmargs
;
963 dlmargs
.fname
= name
;
967 const char *err_str
= NULL
;
969 _dl_catch_error (&objname
, &err_str
, &malloced
, dlmopen_doit
, &dlmargs
);
970 if (__glibc_unlikely (err_str
!= NULL
))
972 report_audit_module_load_error (name
, err_str
, malloced
);
976 struct lookup_args largs
;
977 largs
.name
= "la_version";
978 largs
.map
= dlmargs
.map
;
979 _dl_catch_error (&objname
, &err_str
, &malloced
, lookup_doit
, &largs
);
980 if (__glibc_likely (err_str
!= NULL
))
982 unload_audit_module (dlmargs
.map
, original_tls_idx
);
983 report_audit_module_load_error (name
, err_str
, malloced
);
987 unsigned int (*laversion
) (unsigned int) = largs
.result
;
989 /* A null symbol indicates that something is very wrong with the
990 loaded object because defined symbols are supposed to have a
991 valid, non-null address. */
992 assert (laversion
!= NULL
);
994 unsigned int lav
= laversion (LAV_CURRENT
);
997 /* Only print an error message if debugging because this can
998 happen deliberately. */
999 if (GLRO(dl_debug_mask
) & DL_DEBUG_FILES
)
1000 _dl_debug_printf ("\
1001 file=%s [%lu]; audit interface function la_version returned zero; ignored.\n",
1002 dlmargs
.map
->l_name
, dlmargs
.map
->l_ns
);
1003 unload_audit_module (dlmargs
.map
, original_tls_idx
);
1007 if (lav
> LAV_CURRENT
)
1009 _dl_debug_printf ("\
1010 ERROR: audit interface '%s' requires version %d (maximum supported version %d); ignored.\n",
1011 name
, lav
, LAV_CURRENT
);
1012 unload_audit_module (dlmargs
.map
, original_tls_idx
);
1016 enum { naudit_ifaces
= 8 };
1019 struct audit_ifaces ifaces
;
1020 void (*fptr
[naudit_ifaces
]) (void);
1021 } *newp
= malloc (sizeof (*newp
));
1023 _dl_fatal_printf ("Out of memory while loading audit modules\n");
1025 /* Names of the auditing interfaces. All in one
1027 static const char audit_iface_names
[] =
1032 #if __ELF_NATIVE_CLASS == 32
1034 #elif __ELF_NATIVE_CLASS == 64
1037 # error "__ELF_NATIVE_CLASS must be defined"
1039 #define STRING(s) __STRING (s)
1040 "la_" STRING (ARCH_LA_PLTENTER
) "\0"
1041 "la_" STRING (ARCH_LA_PLTEXIT
) "\0"
1043 unsigned int cnt
= 0;
1044 const char *cp
= audit_iface_names
;
1048 _dl_catch_error (&objname
, &err_str
, &malloced
, lookup_doit
, &largs
);
1050 /* Store the pointer. */
1051 if (err_str
== NULL
&& largs
.result
!= NULL
)
1052 newp
->fptr
[cnt
] = largs
.result
;
1054 newp
->fptr
[cnt
] = NULL
;
1057 cp
= rawmemchr (cp
, '\0') + 1;
1059 while (*cp
!= '\0');
1060 assert (cnt
== naudit_ifaces
);
1062 /* Now append the new auditing interface to the list. */
1063 newp
->ifaces
.next
= NULL
;
1064 if (*last_audit
== NULL
)
1065 *last_audit
= GLRO(dl_audit
) = &newp
->ifaces
;
1067 *last_audit
= (*last_audit
)->next
= &newp
->ifaces
;
1069 /* The dynamic linker link map is statically allocated, so the
1070 cookie in _dl_new_object has not happened. */
1071 link_map_audit_state (&GL (dl_rtld_map
), GLRO (dl_naudit
))->cookie
1072 = (intptr_t) &GL (dl_rtld_map
);
1076 /* Mark the DSO as being used for auditing. */
1077 dlmargs
.map
->l_auditing
= 1;
1080 /* Notify the the audit modules that the object MAP has already been
1083 notify_audit_modules_of_loaded_object (struct link_map
*map
)
1085 struct audit_ifaces
*afct
= GLRO(dl_audit
);
1086 for (unsigned int cnt
= 0; cnt
< GLRO(dl_naudit
); ++cnt
)
1088 if (afct
->objopen
!= NULL
)
1090 struct auditstate
*state
= link_map_audit_state (map
, cnt
);
1091 state
->bindflags
= afct
->objopen (map
, LM_ID_BASE
, &state
->cookie
);
1092 map
->l_audit_any_plt
|= state
->bindflags
!= 0;
1099 /* Load all audit modules. */
1101 load_audit_modules (struct link_map
*main_map
, struct audit_list
*audit_list
)
1103 struct audit_ifaces
*last_audit
= NULL
;
1107 const char *name
= audit_list_next (audit_list
);
1110 load_audit_module (name
, &last_audit
);
1113 /* Notify audit modules of the initially loaded modules (the main
1114 program and the dynamic linker itself). */
1115 if (GLRO(dl_naudit
) > 0)
1117 notify_audit_modules_of_loaded_object (main_map
);
1118 notify_audit_modules_of_loaded_object (&GL(dl_rtld_map
));
1123 dl_main (const ElfW(Phdr
) *phdr
,
1125 ElfW(Addr
) *user_entry
,
1128 const ElfW(Phdr
) *ph
;
1129 struct link_map
*main_map
;
1132 bool has_interp
= false;
1134 bool prelinked
= false;
1135 bool rtld_is_main
= false;
1138 struct dl_main_state state
;
1139 dl_main_state_init (&state
);
1141 GL(dl_init_static_tls
) = &_dl_nothread_init_static_tls
;
1143 #if defined SHARED && defined _LIBC_REENTRANT \
1144 && defined __rtld_lock_default_lock_recursive
1145 GL(dl_rtld_lock_recursive
) = rtld_lock_default_lock_recursive
;
1146 GL(dl_rtld_unlock_recursive
) = rtld_lock_default_unlock_recursive
;
1149 #if THREAD_GSCOPE_IN_TCB
1150 INIT_LIST_HEAD (&GL (dl_stack_used
));
1151 INIT_LIST_HEAD (&GL (dl_stack_user
));
1154 /* The explicit initialization here is cheaper than processing the reloc
1155 in the _rtld_local definition's initializer. */
1156 GL(dl_make_stack_executable_hook
) = &_dl_make_stack_executable
;
1158 /* Process the environment variable which control the behaviour. */
1159 process_envvars (&state
);
1161 #ifndef HAVE_INLINED_SYSCALLS
1162 /* Set up a flag which tells we are just starting. */
1163 _dl_starting_up
= 1;
1166 const char *ld_so_name
= _dl_argv
[0];
1167 if (*user_entry
== (ElfW(Addr
)) ENTRY_POINT
)
1169 /* Ho ho. We are not the program interpreter! We are the program
1170 itself! This means someone ran ld.so as a command. Well, that
1171 might be convenient to do sometimes. We support it by
1172 interpreting the args like this:
1174 ld.so PROGRAM ARGS...
1176 The first argument is the name of a file containing an ELF
1177 executable we will load and run with the following arguments.
1178 To simplify life here, PROGRAM is searched for using the
1179 normal rules for shared objects, rather than $PATH or anything
1180 like that. We just load it and use its entry point; we don't
1181 pay attention to its PT_INTERP command (we are the interpreter
1182 ourselves). This is an easy way to test a new ld.so before
1184 rtld_is_main
= true;
1188 /* Note the place where the dynamic linker actually came from. */
1189 GL(dl_rtld_map
).l_name
= rtld_progname
;
1191 while (_dl_argc
> 1)
1192 if (! strcmp (_dl_argv
[1], "--list"))
1194 if (state
.mode
!= rtld_mode_help
)
1196 state
.mode
= rtld_mode_list
;
1197 /* This means do no dependency analysis. */
1205 else if (! strcmp (_dl_argv
[1], "--verify"))
1207 if (state
.mode
!= rtld_mode_help
)
1208 state
.mode
= rtld_mode_verify
;
1214 else if (! strcmp (_dl_argv
[1], "--inhibit-cache"))
1216 GLRO(dl_inhibit_cache
) = 1;
1221 else if (! strcmp (_dl_argv
[1], "--library-path")
1224 state
.library_path
= _dl_argv
[2];
1225 state
.library_path_source
= "--library-path";
1231 else if (! strcmp (_dl_argv
[1], "--inhibit-rpath")
1234 GLRO(dl_inhibit_rpath
) = _dl_argv
[2];
1240 else if (! strcmp (_dl_argv
[1], "--audit") && _dl_argc
> 2)
1242 audit_list_add_string (&state
.audit_list
, _dl_argv
[2]);
1248 else if (! strcmp (_dl_argv
[1], "--preload") && _dl_argc
> 2)
1250 state
.preloadarg
= _dl_argv
[2];
1255 else if (! strcmp (_dl_argv
[1], "--argv0") && _dl_argc
> 2)
1257 argv0
= _dl_argv
[2];
1263 else if (strcmp (_dl_argv
[1], "--glibc-hwcaps-prepend") == 0
1266 state
.glibc_hwcaps_prepend
= _dl_argv
[2];
1271 else if (strcmp (_dl_argv
[1], "--glibc-hwcaps-mask") == 0
1274 state
.glibc_hwcaps_mask
= _dl_argv
[2];
1279 else if (strcmp (_dl_argv
[1], "--help") == 0)
1281 state
.mode
= rtld_mode_help
;
1285 else if (strcmp (_dl_argv
[1], "--version") == 0)
1287 else if (_dl_argv
[1][0] == '-' && _dl_argv
[1][1] == '-')
1289 if (_dl_argv
[1][1] == '\0')
1290 /* End of option list. */
1293 /* Unrecognized option. */
1294 _dl_usage (ld_so_name
, _dl_argv
[1]);
1299 /* If we have no further argument the program was called incorrectly.
1300 Grant the user some education. */
1303 if (state
.mode
== rtld_mode_help
)
1304 /* --help without an executable is not an error. */
1305 _dl_help (ld_so_name
, &state
);
1307 _dl_usage (ld_so_name
, NULL
);
1314 /* The initialization of _dl_stack_flags done below assumes the
1315 executable's PT_GNU_STACK may have been honored by the kernel, and
1316 so a PT_GNU_STACK with PF_X set means the stack started out with
1317 execute permission. However, this is not really true if the
1318 dynamic linker is the executable the kernel loaded. For this
1319 case, we must reinitialize _dl_stack_flags to match the dynamic
1320 linker itself. If the dynamic linker was built with a
1321 PT_GNU_STACK, then the kernel may have loaded us with a
1322 nonexecutable stack that we will have to make executable when we
1323 load the program below unless it has a PT_GNU_STACK indicating
1324 nonexecutable stack is ok. */
1326 for (ph
= phdr
; ph
< &phdr
[phnum
]; ++ph
)
1327 if (ph
->p_type
== PT_GNU_STACK
)
1329 GL(dl_stack_flags
) = ph
->p_flags
;
1333 if (__glibc_unlikely (state
.mode
== rtld_mode_verify
1334 || state
.mode
== rtld_mode_help
))
1336 const char *objname
;
1337 const char *err_str
= NULL
;
1338 struct map_args args
;
1341 args
.str
= rtld_progname
;
1343 args
.mode
= __RTLD_OPENEXEC
;
1344 (void) _dl_catch_error (&objname
, &err_str
, &malloced
, map_doit
,
1346 if (__glibc_unlikely (err_str
!= NULL
))
1348 /* We don't free the returned string, the programs stops
1350 if (state
.mode
== rtld_mode_help
)
1351 /* Mask the failure to load the main object. The help
1352 message contains less information in this case. */
1353 _dl_help (ld_so_name
, &state
);
1355 _exit (EXIT_FAILURE
);
1360 RTLD_TIMING_VAR (start
);
1361 rtld_timer_start (&start
);
1362 _dl_map_object (NULL
, rtld_progname
, lt_executable
, 0,
1363 __RTLD_OPENEXEC
, LM_ID_BASE
);
1364 rtld_timer_stop (&load_time
, start
);
1367 /* Now the map for the main executable is available. */
1368 main_map
= GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
;
1370 if (__glibc_likely (state
.mode
== rtld_mode_normal
)
1371 && GL(dl_rtld_map
).l_info
[DT_SONAME
] != NULL
1372 && main_map
->l_info
[DT_SONAME
] != NULL
1373 && strcmp ((const char *) D_PTR (&GL(dl_rtld_map
), l_info
[DT_STRTAB
])
1374 + GL(dl_rtld_map
).l_info
[DT_SONAME
]->d_un
.d_val
,
1375 (const char *) D_PTR (main_map
, l_info
[DT_STRTAB
])
1376 + main_map
->l_info
[DT_SONAME
]->d_un
.d_val
) == 0)
1377 _dl_fatal_printf ("loader cannot load itself\n");
1379 phdr
= main_map
->l_phdr
;
1380 phnum
= main_map
->l_phnum
;
1381 /* We overwrite here a pointer to a malloc()ed string. But since
1382 the malloc() implementation used at this point is the dummy
1383 implementations which has no real free() function it does not
1384 makes sense to free the old string first. */
1385 main_map
->l_name
= (char *) "";
1386 *user_entry
= main_map
->l_entry
;
1388 #ifdef HAVE_AUX_VECTOR
1389 /* Adjust the on-stack auxiliary vector so that it looks like the
1390 binary was executed directly. */
1391 for (ElfW(auxv_t
) *av
= auxv
; av
->a_type
!= AT_NULL
; av
++)
1395 av
->a_un
.a_val
= (uintptr_t) phdr
;
1398 av
->a_un
.a_val
= phnum
;
1401 av
->a_un
.a_val
= *user_entry
;
1404 av
->a_un
.a_val
= (uintptr_t) _dl_argv
[0];
1409 /* Set the argv[0] string now that we've processed the executable. */
1411 _dl_argv
[0] = argv0
;
1415 /* Create a link_map for the executable itself.
1416 This will be what dlopen on "" returns. */
1417 main_map
= _dl_new_object ((char *) "", "", lt_executable
, NULL
,
1418 __RTLD_OPENEXEC
, LM_ID_BASE
);
1419 assert (main_map
!= NULL
);
1420 main_map
->l_phdr
= phdr
;
1421 main_map
->l_phnum
= phnum
;
1422 main_map
->l_entry
= *user_entry
;
1424 /* Even though the link map is not yet fully initialized we can add
1425 it to the map list since there are no possible users running yet. */
1426 _dl_add_to_namespace_list (main_map
, LM_ID_BASE
);
1427 assert (main_map
== GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
);
1429 /* At this point we are in a bit of trouble. We would have to
1430 fill in the values for l_dev and l_ino. But in general we
1431 do not know where the file is. We also do not handle AT_EXECFD
1432 even if it would be passed up.
1434 We leave the values here defined to 0. This is normally no
1435 problem as the program code itself is normally no shared
1436 object and therefore cannot be loaded dynamically. Nothing
1437 prevent the use of dynamic binaries and in these situations
1438 we might get problems. We might not be able to find out
1439 whether the object is already loaded. But since there is no
1440 easy way out and because the dynamic binary must also not
1441 have an SONAME we ignore this program for now. If it becomes
1442 a problem we can force people using SONAMEs. */
1444 /* We delay initializing the path structure until we got the dynamic
1445 information for the program. */
1448 main_map
->l_map_end
= 0;
1449 main_map
->l_text_end
= 0;
1450 /* Perhaps the executable has no PT_LOAD header entries at all. */
1451 main_map
->l_map_start
= ~0;
1452 /* And it was opened directly. */
1453 ++main_map
->l_direct_opencount
;
1455 /* Scan the program header table for the dynamic section. */
1456 for (ph
= phdr
; ph
< &phdr
[phnum
]; ++ph
)
1460 /* Find out the load address. */
1461 main_map
->l_addr
= (ElfW(Addr
)) phdr
- ph
->p_vaddr
;
1464 /* This tells us where to find the dynamic section,
1465 which tells us everything we need to do. */
1466 main_map
->l_ld
= (void *) main_map
->l_addr
+ ph
->p_vaddr
;
1469 /* This "interpreter segment" was used by the program loader to
1470 find the program interpreter, which is this program itself, the
1471 dynamic linker. We note what name finds us, so that a future
1472 dlopen call or DT_NEEDED entry, for something that wants to link
1473 against the dynamic linker as a shared library, will know that
1474 the shared object is already loaded. */
1475 _dl_rtld_libname
.name
= ((const char *) main_map
->l_addr
1477 /* _dl_rtld_libname.next = NULL; Already zero. */
1478 GL(dl_rtld_map
).l_libname
= &_dl_rtld_libname
;
1480 /* Ordinarilly, we would get additional names for the loader from
1481 our DT_SONAME. This can't happen if we were actually linked as
1482 a static executable (detect this case when we have no DYNAMIC).
1483 If so, assume the filename component of the interpreter path to
1484 be our SONAME, and add it to our name list. */
1485 if (GL(dl_rtld_map
).l_ld
== NULL
)
1487 const char *p
= NULL
;
1488 const char *cp
= _dl_rtld_libname
.name
;
1490 /* Find the filename part of the path. */
1497 _dl_rtld_libname2
.name
= p
;
1498 /* _dl_rtld_libname2.next = NULL; Already zero. */
1499 _dl_rtld_libname
.next
= &_dl_rtld_libname2
;
1507 ElfW(Addr
) mapstart
;
1508 ElfW(Addr
) allocend
;
1510 /* Remember where the main program starts in memory. */
1511 mapstart
= (main_map
->l_addr
1512 + (ph
->p_vaddr
& ~(GLRO(dl_pagesize
) - 1)));
1513 if (main_map
->l_map_start
> mapstart
)
1514 main_map
->l_map_start
= mapstart
;
1516 /* Also where it ends. */
1517 allocend
= main_map
->l_addr
+ ph
->p_vaddr
+ ph
->p_memsz
;
1518 if (main_map
->l_map_end
< allocend
)
1519 main_map
->l_map_end
= allocend
;
1520 if ((ph
->p_flags
& PF_X
) && allocend
> main_map
->l_text_end
)
1521 main_map
->l_text_end
= allocend
;
1526 if (ph
->p_memsz
> 0)
1528 /* Note that in the case the dynamic linker we duplicate work
1529 here since we read the PT_TLS entry already in
1530 _dl_start_final. But the result is repeatable so do not
1531 check for this special but unimportant case. */
1532 main_map
->l_tls_blocksize
= ph
->p_memsz
;
1533 main_map
->l_tls_align
= ph
->p_align
;
1534 if (ph
->p_align
== 0)
1535 main_map
->l_tls_firstbyte_offset
= 0;
1537 main_map
->l_tls_firstbyte_offset
= (ph
->p_vaddr
1538 & (ph
->p_align
- 1));
1539 main_map
->l_tls_initimage_size
= ph
->p_filesz
;
1540 main_map
->l_tls_initimage
= (void *) ph
->p_vaddr
;
1542 /* This image gets the ID one. */
1543 GL(dl_tls_max_dtv_idx
) = main_map
->l_tls_modid
= 1;
1548 GL(dl_stack_flags
) = ph
->p_flags
;
1552 main_map
->l_relro_addr
= ph
->p_vaddr
;
1553 main_map
->l_relro_size
= ph
->p_memsz
;
1556 /* Process program headers again, but scan them backwards so
1557 that PT_NOTE can be skipped if PT_GNU_PROPERTY exits. */
1558 for (ph
= &phdr
[phnum
]; ph
!= phdr
; --ph
)
1559 switch (ph
[-1].p_type
)
1562 _dl_process_pt_note (main_map
, -1, &ph
[-1]);
1564 case PT_GNU_PROPERTY
:
1565 _dl_process_pt_gnu_property (main_map
, -1, &ph
[-1]);
1569 /* Adjust the address of the TLS initialization image in case
1570 the executable is actually an ET_DYN object. */
1571 if (main_map
->l_tls_initimage
!= NULL
)
1572 main_map
->l_tls_initimage
1573 = (char *) main_map
->l_tls_initimage
+ main_map
->l_addr
;
1574 if (! main_map
->l_map_end
)
1575 main_map
->l_map_end
= ~0;
1576 if (! main_map
->l_text_end
)
1577 main_map
->l_text_end
= ~0;
1578 if (! GL(dl_rtld_map
).l_libname
&& GL(dl_rtld_map
).l_name
)
1580 /* We were invoked directly, so the program might not have a
1582 _dl_rtld_libname
.name
= GL(dl_rtld_map
).l_name
;
1583 /* _dl_rtld_libname.next = NULL; Already zero. */
1584 GL(dl_rtld_map
).l_libname
= &_dl_rtld_libname
;
1587 assert (GL(dl_rtld_map
).l_libname
); /* How else did we get here? */
1589 /* If the current libname is different from the SONAME, add the
1591 if (GL(dl_rtld_map
).l_info
[DT_SONAME
] != NULL
1592 && strcmp (GL(dl_rtld_map
).l_libname
->name
,
1593 (const char *) D_PTR (&GL(dl_rtld_map
), l_info
[DT_STRTAB
])
1594 + GL(dl_rtld_map
).l_info
[DT_SONAME
]->d_un
.d_val
) != 0)
1596 static struct libname_list newname
;
1597 newname
.name
= ((char *) D_PTR (&GL(dl_rtld_map
), l_info
[DT_STRTAB
])
1598 + GL(dl_rtld_map
).l_info
[DT_SONAME
]->d_un
.d_ptr
);
1599 newname
.next
= NULL
;
1600 newname
.dont_free
= 1;
1602 assert (GL(dl_rtld_map
).l_libname
->next
== NULL
);
1603 GL(dl_rtld_map
).l_libname
->next
= &newname
;
1605 /* The ld.so must be relocated since otherwise loading audit modules
1606 will fail since they reuse the very same ld.so. */
1607 assert (GL(dl_rtld_map
).l_relocated
);
1611 /* Extract the contents of the dynamic section for easy access. */
1612 elf_get_dynamic_info (main_map
, NULL
);
1614 /* If the main map is libc.so, update the base namespace to
1615 refer to this map. If libc.so is loaded later, this happens
1616 in _dl_map_object_from_fd. */
1617 if (main_map
->l_info
[DT_SONAME
] != NULL
1618 && (strcmp (((const char *) D_PTR (main_map
, l_info
[DT_STRTAB
])
1619 + main_map
->l_info
[DT_SONAME
]->d_un
.d_val
), LIBC_SO
)
1621 GL(dl_ns
)[LM_ID_BASE
].libc_map
= main_map
;
1623 /* Set up our cache of pointers into the hash table. */
1624 _dl_setup_hash (main_map
);
1627 if (__glibc_unlikely (state
.mode
== rtld_mode_verify
))
1629 /* We were called just to verify that this is a dynamic
1630 executable using us as the program interpreter. Exit with an
1631 error if we were not able to load the binary or no interpreter
1632 is specified (i.e., this is no dynamically linked binary. */
1633 if (main_map
->l_ld
== NULL
)
1636 /* We allow here some platform specific code. */
1637 #ifdef DISTINGUISH_LIB_VERSIONS
1638 DISTINGUISH_LIB_VERSIONS
;
1640 _exit (has_interp
? 0 : 2);
1643 struct link_map
**first_preload
= &GL(dl_rtld_map
).l_next
;
1644 /* Set up the data structures for the system-supplied DSO early,
1645 so they can influence _dl_init_paths. */
1646 setup_vdso (main_map
, &first_preload
);
1648 /* With vDSO setup we can initialize the function pointers. */
1649 setup_vdso_pointers ();
1651 #ifdef DL_SYSDEP_OSCHECK
1652 DL_SYSDEP_OSCHECK (_dl_fatal_printf
);
1655 /* Initialize the data structures for the search paths for shared
1657 call_init_paths (&state
);
1659 /* Initialize _r_debug. */
1660 struct r_debug
*r
= _dl_debug_initialize (GL(dl_rtld_map
).l_addr
,
1662 r
->r_state
= RT_CONSISTENT
;
1664 /* Put the link_map for ourselves on the chain so it can be found by
1665 name. Note that at this point the global chain of link maps contains
1666 exactly one element, which is pointed to by dl_loaded. */
1667 if (! GL(dl_rtld_map
).l_name
)
1668 /* If not invoked directly, the dynamic linker shared object file was
1669 found by the PT_INTERP name. */
1670 GL(dl_rtld_map
).l_name
= (char *) GL(dl_rtld_map
).l_libname
->name
;
1671 GL(dl_rtld_map
).l_type
= lt_library
;
1672 main_map
->l_next
= &GL(dl_rtld_map
);
1673 GL(dl_rtld_map
).l_prev
= main_map
;
1674 ++GL(dl_ns
)[LM_ID_BASE
]._ns_nloaded
;
1677 /* If LD_USE_LOAD_BIAS env variable has not been seen, default
1678 to not using bias for non-prelinked PIEs and libraries
1679 and using it for executables or prelinked PIEs or libraries. */
1680 if (GLRO(dl_use_load_bias
) == (ElfW(Addr
)) -2)
1681 GLRO(dl_use_load_bias
) = main_map
->l_addr
== 0 ? -1 : 0;
1683 /* Set up the program header information for the dynamic linker
1684 itself. It is needed in the dl_iterate_phdr callbacks. */
1685 const ElfW(Ehdr
) *rtld_ehdr
;
1687 /* Starting from binutils-2.23, the linker will define the magic symbol
1688 __ehdr_start to point to our own ELF header if it is visible in a
1689 segment that also includes the phdrs. If that's not available, we use
1690 the old method that assumes the beginning of the file is part of the
1691 lowest-addressed PT_LOAD segment. */
1692 #ifdef HAVE_EHDR_START
1693 extern const ElfW(Ehdr
) __ehdr_start
__attribute__ ((visibility ("hidden")));
1694 rtld_ehdr
= &__ehdr_start
;
1696 rtld_ehdr
= (void *) GL(dl_rtld_map
).l_map_start
;
1698 assert (rtld_ehdr
->e_ehsize
== sizeof *rtld_ehdr
);
1699 assert (rtld_ehdr
->e_phentsize
== sizeof (ElfW(Phdr
)));
1701 const ElfW(Phdr
) *rtld_phdr
= (const void *) rtld_ehdr
+ rtld_ehdr
->e_phoff
;
1703 GL(dl_rtld_map
).l_phdr
= rtld_phdr
;
1704 GL(dl_rtld_map
).l_phnum
= rtld_ehdr
->e_phnum
;
1707 /* PT_GNU_RELRO is usually the last phdr. */
1708 size_t cnt
= rtld_ehdr
->e_phnum
;
1710 if (rtld_phdr
[cnt
].p_type
== PT_GNU_RELRO
)
1712 GL(dl_rtld_map
).l_relro_addr
= rtld_phdr
[cnt
].p_vaddr
;
1713 GL(dl_rtld_map
).l_relro_size
= rtld_phdr
[cnt
].p_memsz
;
1717 /* Add the dynamic linker to the TLS list if it also uses TLS. */
1718 if (GL(dl_rtld_map
).l_tls_blocksize
!= 0)
1719 /* Assign a module ID. Do this before loading any audit modules. */
1720 GL(dl_rtld_map
).l_tls_modid
= _dl_next_tls_modid ();
1722 audit_list_add_dynamic_tag (&state
.audit_list
, main_map
, DT_AUDIT
);
1723 audit_list_add_dynamic_tag (&state
.audit_list
, main_map
, DT_DEPAUDIT
);
1725 /* At this point, all data has been obtained that is included in the
1727 if (__glibc_unlikely (state
.mode
== rtld_mode_help
))
1728 _dl_help (ld_so_name
, &state
);
1730 /* If we have auditing DSOs to load, do it now. */
1731 bool need_security_init
= true;
1732 if (state
.audit_list
.length
> 0)
1734 size_t naudit
= audit_list_count (&state
.audit_list
);
1736 /* Since we start using the auditing DSOs right away we need to
1737 initialize the data structures now. */
1738 tcbp
= init_tls (naudit
);
1740 /* Initialize security features. We need to do it this early
1741 since otherwise the constructors of the audit libraries will
1742 use different values (especially the pointer guard) and will
1745 need_security_init
= false;
1747 load_audit_modules (main_map
, &state
.audit_list
);
1749 /* The count based on audit strings may overestimate the number
1750 of audit modules that got loaded, but not underestimate. */
1751 assert (GLRO(dl_naudit
) <= naudit
);
1754 /* Keep track of the currently loaded modules to count how many
1755 non-audit modules which use TLS are loaded. */
1756 size_t count_modids
= _dl_count_modids ();
1758 /* Set up debugging before the debugger is notified for the first time. */
1759 #ifdef ELF_MACHINE_DEBUG_SETUP
1760 /* Some machines (e.g. MIPS) don't use DT_DEBUG in this way. */
1761 ELF_MACHINE_DEBUG_SETUP (main_map
, r
);
1762 ELF_MACHINE_DEBUG_SETUP (&GL(dl_rtld_map
), r
);
1764 if (main_map
->l_info
[DT_DEBUG
] != NULL
)
1765 /* There is a DT_DEBUG entry in the dynamic section. Fill it in
1766 with the run-time address of the r_debug structure */
1767 main_map
->l_info
[DT_DEBUG
]->d_un
.d_ptr
= (ElfW(Addr
)) r
;
1769 /* Fill in the pointer in the dynamic linker's own dynamic section, in
1770 case you run gdb on the dynamic linker directly. */
1771 if (GL(dl_rtld_map
).l_info
[DT_DEBUG
] != NULL
)
1772 GL(dl_rtld_map
).l_info
[DT_DEBUG
]->d_un
.d_ptr
= (ElfW(Addr
)) r
;
1775 /* We start adding objects. */
1776 r
->r_state
= RT_ADD
;
1778 LIBC_PROBE (init_start
, 2, LM_ID_BASE
, r
);
1780 /* Auditing checkpoint: we are ready to signal that the initial map
1781 is being constructed. */
1782 if (__glibc_unlikely (GLRO(dl_naudit
) > 0))
1784 struct audit_ifaces
*afct
= GLRO(dl_audit
);
1785 for (unsigned int cnt
= 0; cnt
< GLRO(dl_naudit
); ++cnt
)
1787 if (afct
->activity
!= NULL
)
1788 afct
->activity (&link_map_audit_state (main_map
, cnt
)->cookie
,
1795 /* We have two ways to specify objects to preload: via environment
1796 variable and via the file /etc/ld.so.preload. The latter can also
1797 be used when security is enabled. */
1798 assert (*first_preload
== NULL
);
1799 struct link_map
**preloads
= NULL
;
1800 unsigned int npreloads
= 0;
1802 if (__glibc_unlikely (state
.preloadlist
!= NULL
))
1804 RTLD_TIMING_VAR (start
);
1805 rtld_timer_start (&start
);
1806 npreloads
+= handle_preload_list (state
.preloadlist
, main_map
,
1808 rtld_timer_accum (&load_time
, start
);
1811 if (__glibc_unlikely (state
.preloadarg
!= NULL
))
1813 RTLD_TIMING_VAR (start
);
1814 rtld_timer_start (&start
);
1815 npreloads
+= handle_preload_list (state
.preloadarg
, main_map
,
1817 rtld_timer_accum (&load_time
, start
);
1820 /* There usually is no ld.so.preload file, it should only be used
1821 for emergencies and testing. So the open call etc should usually
1822 fail. Using access() on a non-existing file is faster than using
1823 open(). So we do this first. If it succeeds we do almost twice
1824 the work but this does not matter, since it is not for production
1826 static const char preload_file
[] = "/etc/ld.so.preload";
1827 if (__glibc_unlikely (__access (preload_file
, R_OK
) == 0))
1829 /* Read the contents of the file. */
1830 file
= _dl_sysdep_read_whole_file (preload_file
, &file_size
,
1831 PROT_READ
| PROT_WRITE
);
1832 if (__glibc_unlikely (file
!= MAP_FAILED
))
1834 /* Parse the file. It contains names of libraries to be loaded,
1835 separated by white spaces or `:'. It may also contain
1836 comments introduced by `#'. */
1841 /* Eliminate comments. */
1846 char *comment
= memchr (runp
, '#', rest
);
1847 if (comment
== NULL
)
1850 rest
-= comment
- runp
;
1853 while (--rest
> 0 && *++comment
!= '\n');
1856 /* We have one problematic case: if we have a name at the end of
1857 the file without a trailing terminating characters, we cannot
1858 place the \0. Handle the case separately. */
1859 if (file
[file_size
- 1] != ' ' && file
[file_size
- 1] != '\t'
1860 && file
[file_size
- 1] != '\n' && file
[file_size
- 1] != ':')
1862 problem
= &file
[file_size
];
1863 while (problem
> file
&& problem
[-1] != ' '
1864 && problem
[-1] != '\t'
1865 && problem
[-1] != '\n' && problem
[-1] != ':')
1874 file
[file_size
- 1] = '\0';
1877 RTLD_TIMING_VAR (start
);
1878 rtld_timer_start (&start
);
1880 if (file
!= problem
)
1884 while ((p
= strsep (&runp
, ": \t\n")) != NULL
)
1886 npreloads
+= do_preload (p
, main_map
, preload_file
);
1889 if (problem
!= NULL
)
1891 char *p
= strndupa (problem
, file_size
- (problem
- file
));
1893 npreloads
+= do_preload (p
, main_map
, preload_file
);
1896 rtld_timer_accum (&load_time
, start
);
1898 /* We don't need the file anymore. */
1899 __munmap (file
, file_size
);
1903 if (__glibc_unlikely (*first_preload
!= NULL
))
1905 /* Set up PRELOADS with a vector of the preloaded libraries. */
1906 struct link_map
*l
= *first_preload
;
1907 preloads
= __alloca (npreloads
* sizeof preloads
[0]);
1914 assert (i
== npreloads
);
1917 /* Load all the libraries specified by DT_NEEDED entries. If LD_PRELOAD
1918 specified some libraries to load, these are inserted before the actual
1919 dependencies in the executable's searchlist for symbol resolution. */
1921 RTLD_TIMING_VAR (start
);
1922 rtld_timer_start (&start
);
1923 _dl_map_object_deps (main_map
, preloads
, npreloads
,
1924 state
.mode
== rtld_mode_trace
, 0);
1925 rtld_timer_accum (&load_time
, start
);
1928 /* Mark all objects as being in the global scope. */
1929 for (i
= main_map
->l_searchlist
.r_nlist
; i
> 0; )
1930 main_map
->l_searchlist
.r_list
[--i
]->l_global
= 1;
1932 /* Remove _dl_rtld_map from the chain. */
1933 GL(dl_rtld_map
).l_prev
->l_next
= GL(dl_rtld_map
).l_next
;
1934 if (GL(dl_rtld_map
).l_next
!= NULL
)
1935 GL(dl_rtld_map
).l_next
->l_prev
= GL(dl_rtld_map
).l_prev
;
1937 for (i
= 1; i
< main_map
->l_searchlist
.r_nlist
; ++i
)
1938 if (main_map
->l_searchlist
.r_list
[i
] == &GL(dl_rtld_map
))
1941 bool rtld_multiple_ref
= false;
1942 if (__glibc_likely (i
< main_map
->l_searchlist
.r_nlist
))
1944 /* Some DT_NEEDED entry referred to the interpreter object itself, so
1945 put it back in the list of visible objects. We insert it into the
1946 chain in symbol search order because gdb uses the chain's order as
1947 its symbol search order. */
1948 rtld_multiple_ref
= true;
1950 GL(dl_rtld_map
).l_prev
= main_map
->l_searchlist
.r_list
[i
- 1];
1951 if (__glibc_likely (state
.mode
== rtld_mode_normal
))
1953 GL(dl_rtld_map
).l_next
= (i
+ 1 < main_map
->l_searchlist
.r_nlist
1954 ? main_map
->l_searchlist
.r_list
[i
+ 1]
1956 #ifdef NEED_DL_SYSINFO_DSO
1957 if (GLRO(dl_sysinfo_map
) != NULL
1958 && GL(dl_rtld_map
).l_prev
->l_next
== GLRO(dl_sysinfo_map
)
1959 && GL(dl_rtld_map
).l_next
!= GLRO(dl_sysinfo_map
))
1960 GL(dl_rtld_map
).l_prev
= GLRO(dl_sysinfo_map
);
1964 /* In trace mode there might be an invisible object (which we
1965 could not find) after the previous one in the search list.
1966 In this case it doesn't matter much where we put the
1967 interpreter object, so we just initialize the list pointer so
1968 that the assertion below holds. */
1969 GL(dl_rtld_map
).l_next
= GL(dl_rtld_map
).l_prev
->l_next
;
1971 assert (GL(dl_rtld_map
).l_prev
->l_next
== GL(dl_rtld_map
).l_next
);
1972 GL(dl_rtld_map
).l_prev
->l_next
= &GL(dl_rtld_map
);
1973 if (GL(dl_rtld_map
).l_next
!= NULL
)
1975 assert (GL(dl_rtld_map
).l_next
->l_prev
== GL(dl_rtld_map
).l_prev
);
1976 GL(dl_rtld_map
).l_next
->l_prev
= &GL(dl_rtld_map
);
1980 /* Now let us see whether all libraries are available in the
1981 versions we need. */
1983 struct version_check_args args
;
1984 args
.doexit
= state
.mode
== rtld_mode_normal
;
1985 args
.dotrace
= state
.mode
== rtld_mode_trace
;
1986 _dl_receive_error (print_missing_version
, version_check_doit
, &args
);
1989 /* We do not initialize any of the TLS functionality unless any of the
1990 initial modules uses TLS. This makes dynamic loading of modules with
1991 TLS impossible, but to support it requires either eagerly doing setup
1992 now or lazily doing it later. Doing it now makes us incompatible with
1993 an old kernel that can't perform TLS_INIT_TP, even if no TLS is ever
1994 used. Trying to do it lazily is too hairy to try when there could be
1995 multiple threads (from a non-TLS-using libpthread). */
1996 bool was_tls_init_tp_called
= tls_init_tp_called
;
1998 tcbp
= init_tls (0);
2000 if (__glibc_likely (need_security_init
))
2001 /* Initialize security features. But only if we have not done it
2005 if (__glibc_unlikely (state
.mode
!= rtld_mode_normal
))
2007 /* We were run just to list the shared libraries. It is
2008 important that we do this before real relocation, because the
2009 functions we call below for output may no longer work properly
2010 after relocation. */
2013 if (GLRO(dl_debug_mask
) & DL_DEBUG_PRELINK
)
2015 struct r_scope_elem
*scope
= &main_map
->l_searchlist
;
2017 for (i
= 0; i
< scope
->r_nlist
; i
++)
2019 l
= scope
->r_list
[i
];
2022 _dl_printf ("\t%s => not found\n", l
->l_libname
->name
);
2025 if (_dl_name_match_p (GLRO(dl_trace_prelink
), l
))
2026 GLRO(dl_trace_prelink_map
) = l
;
2027 _dl_printf ("\t%s => %s (0x%0*Zx, 0x%0*Zx)",
2028 DSO_FILENAME (l
->l_libname
->name
),
2029 DSO_FILENAME (l
->l_name
),
2030 (int) sizeof l
->l_map_start
* 2,
2031 (size_t) l
->l_map_start
,
2032 (int) sizeof l
->l_addr
* 2,
2033 (size_t) l
->l_addr
);
2036 _dl_printf (" TLS(0x%Zx, 0x%0*Zx)\n", l
->l_tls_modid
,
2037 (int) sizeof l
->l_tls_offset
* 2,
2038 (size_t) l
->l_tls_offset
);
2043 else if (GLRO(dl_debug_mask
) & DL_DEBUG_UNUSED
)
2045 /* Look through the dependencies of the main executable
2046 and determine which of them is not actually
2048 struct link_map
*l
= main_map
;
2050 /* Relocate the main executable. */
2051 struct relocate_args args
= { .l
= l
,
2052 .reloc_mode
= ((GLRO(dl_lazy
)
2054 | __RTLD_NOIFUNC
) };
2055 _dl_receive_error (print_unresolved
, relocate_doit
, &args
);
2057 /* This loop depends on the dependencies of the executable to
2058 correspond in number and order to the DT_NEEDED entries. */
2059 ElfW(Dyn
) *dyn
= main_map
->l_ld
;
2061 while (dyn
->d_tag
!= DT_NULL
)
2063 if (dyn
->d_tag
== DT_NEEDED
)
2066 #ifdef NEED_DL_SYSINFO_DSO
2067 /* Skip the VDSO since it's not part of the list
2068 of objects we brought in via DT_NEEDED entries. */
2069 if (l
== GLRO(dl_sysinfo_map
))
2076 _dl_printf ("Unused direct dependencies:\n");
2080 _dl_printf ("\t%s\n", l
->l_name
);
2087 _exit (first
!= true);
2089 else if (! main_map
->l_info
[DT_NEEDED
])
2090 _dl_printf ("\tstatically linked\n");
2093 for (l
= main_map
->l_next
; l
; l
= l
->l_next
)
2095 /* The library was not found. */
2096 _dl_printf ("\t%s => not found\n", l
->l_libname
->name
);
2097 else if (strcmp (l
->l_libname
->name
, l
->l_name
) == 0)
2098 _dl_printf ("\t%s (0x%0*Zx)\n", l
->l_libname
->name
,
2099 (int) sizeof l
->l_map_start
* 2,
2100 (size_t) l
->l_map_start
);
2102 _dl_printf ("\t%s => %s (0x%0*Zx)\n", l
->l_libname
->name
,
2103 l
->l_name
, (int) sizeof l
->l_map_start
* 2,
2104 (size_t) l
->l_map_start
);
2107 if (__glibc_unlikely (state
.mode
!= rtld_mode_trace
))
2108 for (i
= 1; i
< (unsigned int) _dl_argc
; ++i
)
2110 const ElfW(Sym
) *ref
= NULL
;
2111 ElfW(Addr
) loadbase
;
2114 result
= _dl_lookup_symbol_x (_dl_argv
[i
], main_map
,
2115 &ref
, main_map
->l_scope
,
2116 NULL
, ELF_RTYPE_CLASS_PLT
,
2117 DL_LOOKUP_ADD_DEPENDENCY
, NULL
);
2119 loadbase
= LOOKUP_VALUE_ADDRESS (result
, false);
2121 _dl_printf ("%s found at 0x%0*Zd in object at 0x%0*Zd\n",
2123 (int) sizeof ref
->st_value
* 2,
2124 (size_t) ref
->st_value
,
2125 (int) sizeof loadbase
* 2, (size_t) loadbase
);
2129 /* If LD_WARN is set, warn about undefined symbols. */
2130 if (GLRO(dl_lazy
) >= 0 && GLRO(dl_verbose
))
2132 /* We have to do symbol dependency testing. */
2133 struct relocate_args args
;
2136 args
.reloc_mode
= ((GLRO(dl_lazy
) ? RTLD_LAZY
: 0)
2139 i
= main_map
->l_searchlist
.r_nlist
;
2142 struct link_map
*l
= main_map
->l_initfini
[i
];
2143 if (l
!= &GL(dl_rtld_map
) && ! l
->l_faked
)
2146 _dl_receive_error (print_unresolved
, relocate_doit
,
2151 if ((GLRO(dl_debug_mask
) & DL_DEBUG_PRELINK
)
2152 && rtld_multiple_ref
)
2154 /* Mark the link map as not yet relocated again. */
2155 GL(dl_rtld_map
).l_relocated
= 0;
2156 _dl_relocate_object (&GL(dl_rtld_map
),
2157 main_map
->l_scope
, __RTLD_NOIFUNC
, 0);
2160 #define VERNEEDTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERNEED))
2161 if (state
.version_info
)
2163 /* Print more information. This means here, print information
2164 about the versions needed. */
2166 struct link_map
*map
;
2168 for (map
= main_map
; map
!= NULL
; map
= map
->l_next
)
2171 ElfW(Dyn
) *dyn
= map
->l_info
[VERNEEDTAG
];
2177 strtab
= (const void *) D_PTR (map
, l_info
[DT_STRTAB
]);
2178 ent
= (ElfW(Verneed
) *) (map
->l_addr
+ dyn
->d_un
.d_ptr
);
2182 _dl_printf ("\n\tVersion information:\n");
2186 _dl_printf ("\t%s:\n", DSO_FILENAME (map
->l_name
));
2191 struct link_map
*needed
;
2193 needed
= find_needed (strtab
+ ent
->vn_file
);
2194 aux
= (ElfW(Vernaux
) *) ((char *) ent
+ ent
->vn_aux
);
2198 const char *fname
= NULL
;
2201 && match_version (strtab
+ aux
->vna_name
,
2203 fname
= needed
->l_name
;
2205 _dl_printf ("\t\t%s (%s) %s=> %s\n",
2206 strtab
+ ent
->vn_file
,
2207 strtab
+ aux
->vna_name
,
2208 aux
->vna_flags
& VER_FLG_WEAK
2210 fname
?: "not found");
2212 if (aux
->vna_next
== 0)
2213 /* No more symbols. */
2217 aux
= (ElfW(Vernaux
) *) ((char *) aux
2221 if (ent
->vn_next
== 0)
2222 /* No more dependencies. */
2225 /* Next dependency. */
2226 ent
= (ElfW(Verneed
) *) ((char *) ent
+ ent
->vn_next
);
2235 if (main_map
->l_info
[ADDRIDX (DT_GNU_LIBLIST
)]
2236 && ! __builtin_expect (GLRO(dl_profile
) != NULL
, 0)
2237 && ! __builtin_expect (GLRO(dl_dynamic_weak
), 0))
2239 ElfW(Lib
) *liblist
, *liblistend
;
2240 struct link_map
**r_list
, **r_listend
, *l
;
2241 const char *strtab
= (const void *) D_PTR (main_map
, l_info
[DT_STRTAB
]);
2243 assert (main_map
->l_info
[VALIDX (DT_GNU_LIBLISTSZ
)] != NULL
);
2244 liblist
= (ElfW(Lib
) *)
2245 main_map
->l_info
[ADDRIDX (DT_GNU_LIBLIST
)]->d_un
.d_ptr
;
2246 liblistend
= (ElfW(Lib
) *)
2248 + main_map
->l_info
[VALIDX (DT_GNU_LIBLISTSZ
)]->d_un
.d_val
);
2249 r_list
= main_map
->l_searchlist
.r_list
;
2250 r_listend
= r_list
+ main_map
->l_searchlist
.r_nlist
;
2252 for (; r_list
< r_listend
&& liblist
< liblistend
; r_list
++)
2259 /* If the library is not mapped where it should, fail. */
2263 /* Next, check if checksum matches. */
2264 if (l
->l_info
[VALIDX(DT_CHECKSUM
)] == NULL
2265 || l
->l_info
[VALIDX(DT_CHECKSUM
)]->d_un
.d_val
2266 != liblist
->l_checksum
)
2269 if (l
->l_info
[VALIDX(DT_GNU_PRELINKED
)] == NULL
2270 || l
->l_info
[VALIDX(DT_GNU_PRELINKED
)]->d_un
.d_val
2271 != liblist
->l_time_stamp
)
2274 if (! _dl_name_match_p (strtab
+ liblist
->l_name
, l
))
2281 if (r_list
== r_listend
&& liblist
== liblistend
)
2284 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_LIBS
))
2285 _dl_debug_printf ("\nprelink checking: %s\n",
2286 prelinked
? "ok" : "failed");
2290 /* Now set up the variable which helps the assembler startup code. */
2291 GL(dl_ns
)[LM_ID_BASE
]._ns_main_searchlist
= &main_map
->l_searchlist
;
2293 /* Save the information about the original global scope list since
2294 we need it in the memory handling later. */
2295 GLRO(dl_initial_searchlist
) = *GL(dl_ns
)[LM_ID_BASE
]._ns_main_searchlist
;
2297 /* Remember the last search directory added at startup, now that
2298 malloc will no longer be the one from dl-minimal.c. As a side
2299 effect, this marks ld.so as initialized, so that the rtld_active
2300 function returns true from now on. */
2301 GLRO(dl_init_all_dirs
) = GL(dl_all_dirs
);
2303 /* Print scope information. */
2304 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_SCOPES
))
2306 _dl_debug_printf ("\nInitial object scopes\n");
2308 for (struct link_map
*l
= main_map
; l
!= NULL
; l
= l
->l_next
)
2309 _dl_show_scope (l
, 0);
2312 _rtld_main_check (main_map
, _dl_argv
[0]);
2316 if (main_map
->l_info
[ADDRIDX (DT_GNU_CONFLICT
)] != NULL
)
2318 ElfW(Rela
) *conflict
, *conflictend
;
2320 RTLD_TIMING_VAR (start
);
2321 rtld_timer_start (&start
);
2323 assert (main_map
->l_info
[VALIDX (DT_GNU_CONFLICTSZ
)] != NULL
);
2324 conflict
= (ElfW(Rela
) *)
2325 main_map
->l_info
[ADDRIDX (DT_GNU_CONFLICT
)]->d_un
.d_ptr
;
2326 conflictend
= (ElfW(Rela
) *)
2328 + main_map
->l_info
[VALIDX (DT_GNU_CONFLICTSZ
)]->d_un
.d_val
);
2329 _dl_resolve_conflicts (main_map
, conflict
, conflictend
);
2331 rtld_timer_stop (&relocate_time
, start
);
2334 /* The library defining malloc has already been relocated due to
2335 prelinking. Resolve the malloc symbols for the dynamic
2337 __rtld_malloc_init_real (main_map
);
2339 /* Mark all the objects so we know they have been already relocated. */
2340 for (struct link_map
*l
= main_map
; l
!= NULL
; l
= l
->l_next
)
2343 if (l
->l_relro_size
)
2344 _dl_protect_relro (l
);
2346 /* Add object to slot information data if necessasy. */
2347 if (l
->l_tls_blocksize
!= 0 && tls_init_tp_called
)
2348 _dl_add_to_slotinfo (l
, true);
2353 /* Now we have all the objects loaded. Relocate them all except for
2354 the dynamic linker itself. We do this in reverse order so that copy
2355 relocs of earlier objects overwrite the data written by later
2356 objects. We do not re-relocate the dynamic linker itself in this
2357 loop because that could result in the GOT entries for functions we
2358 call being changed, and that would break us. It is safe to relocate
2359 the dynamic linker out of order because it has no copy relocs (we
2360 know that because it is self-contained). */
2362 int consider_profiling
= GLRO(dl_profile
) != NULL
;
2364 /* If we are profiling we also must do lazy reloaction. */
2365 GLRO(dl_lazy
) |= consider_profiling
;
2367 RTLD_TIMING_VAR (start
);
2368 rtld_timer_start (&start
);
2369 unsigned i
= main_map
->l_searchlist
.r_nlist
;
2372 struct link_map
*l
= main_map
->l_initfini
[i
];
2374 /* While we are at it, help the memory handling a bit. We have to
2375 mark some data structures as allocated with the fake malloc()
2376 implementation in ld.so. */
2377 struct libname_list
*lnp
= l
->l_libname
->next
;
2379 while (__builtin_expect (lnp
!= NULL
, 0))
2384 /* Also allocated with the fake malloc(). */
2385 l
->l_free_initfini
= 0;
2387 if (l
!= &GL(dl_rtld_map
))
2388 _dl_relocate_object (l
, l
->l_scope
, GLRO(dl_lazy
) ? RTLD_LAZY
: 0,
2389 consider_profiling
);
2391 /* Add object to slot information data if necessasy. */
2392 if (l
->l_tls_blocksize
!= 0 && tls_init_tp_called
)
2393 _dl_add_to_slotinfo (l
, true);
2395 rtld_timer_stop (&relocate_time
, start
);
2397 /* Now enable profiling if needed. Like the previous call,
2398 this has to go here because the calls it makes should use the
2399 rtld versions of the functions (particularly calloc()), but it
2400 needs to have _dl_profile_map set up by the relocator. */
2401 if (__glibc_unlikely (GL(dl_profile_map
) != NULL
))
2402 /* We must prepare the profiling. */
2403 _dl_start_profile ();
2406 if ((!was_tls_init_tp_called
&& GL(dl_tls_max_dtv_idx
) > 0)
2407 || count_modids
!= _dl_count_modids ())
2408 ++GL(dl_tls_generation
);
2410 /* Now that we have completed relocation, the initializer data
2411 for the TLS blocks has its final values and we can copy them
2412 into the main thread's TLS area, which we allocated above.
2413 Note: thread-local variables must only be accessed after completing
2415 _dl_allocate_tls_init (tcbp
);
2417 /* And finally install it for the main thread. */
2418 if (! tls_init_tp_called
)
2420 const char *lossage
= TLS_INIT_TP (tcbp
);
2421 if (__glibc_unlikely (lossage
!= NULL
))
2422 _dl_fatal_printf ("cannot set up thread-local storage: %s\n",
2424 #if THREAD_GSCOPE_IN_TCB
2425 list_add (&THREAD_SELF
->list
, &GL (dl_stack_user
));
2429 /* Make sure no new search directories have been added. */
2430 assert (GLRO(dl_init_all_dirs
) == GL(dl_all_dirs
));
2432 if (! prelinked
&& rtld_multiple_ref
)
2434 /* There was an explicit ref to the dynamic linker as a shared lib.
2435 Re-relocate ourselves with user-controlled symbol definitions.
2437 We must do this after TLS initialization in case after this
2438 re-relocation, we might call a user-supplied function
2439 (e.g. calloc from _dl_relocate_object) that uses TLS data. */
2441 /* The malloc implementation has been relocated, so resolving
2442 its symbols (and potentially calling IFUNC resolvers) is safe
2444 __rtld_malloc_init_real (main_map
);
2446 RTLD_TIMING_VAR (start
);
2447 rtld_timer_start (&start
);
2449 /* Mark the link map as not yet relocated again. */
2450 GL(dl_rtld_map
).l_relocated
= 0;
2451 _dl_relocate_object (&GL(dl_rtld_map
), main_map
->l_scope
, 0, 0);
2453 rtld_timer_accum (&relocate_time
, start
);
2456 /* Relocation is complete. Perform early libc initialization. This
2457 is the initial libc, even if audit modules have been loaded with
2459 _dl_call_libc_early_init (GL(dl_ns
)[LM_ID_BASE
].libc_map
, true);
2461 /* Do any necessary cleanups for the startup OS interface code.
2462 We do these now so that no calls are made after rtld re-relocation
2463 which might be resolved to different functions than we expect.
2464 We cannot do this before relocating the other objects because
2465 _dl_relocate_object might need to call `mprotect' for DT_TEXTREL. */
2466 _dl_sysdep_start_cleanup ();
2469 /* Auditing checkpoint: we have added all objects. */
2470 if (__glibc_unlikely (GLRO(dl_naudit
) > 0))
2472 struct link_map
*head
= GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
;
2473 /* Do not call the functions for any auditing object. */
2474 if (head
->l_auditing
== 0)
2476 struct audit_ifaces
*afct
= GLRO(dl_audit
);
2477 for (unsigned int cnt
= 0; cnt
< GLRO(dl_naudit
); ++cnt
)
2479 if (afct
->activity
!= NULL
)
2480 afct
->activity (&link_map_audit_state (head
, cnt
)->cookie
,
2489 /* Notify the debugger all new objects are now ready to go. We must re-get
2490 the address since by now the variable might be in another object. */
2491 r
= _dl_debug_initialize (0, LM_ID_BASE
);
2492 r
->r_state
= RT_CONSISTENT
;
2494 LIBC_PROBE (init_complete
, 2, LM_ID_BASE
, r
);
2496 #if defined USE_LDCONFIG && !defined MAP_COPY
2497 /* We must munmap() the cache file. */
2498 _dl_unload_cache ();
2501 /* Once we return, _dl_sysdep_start will invoke
2502 the DT_INIT functions and then *USER_ENTRY. */
2505 /* This is a little helper function for resolving symbols while
2506 tracing the binary. */
2508 print_unresolved (int errcode
__attribute__ ((unused
)), const char *objname
,
2509 const char *errstring
)
2511 if (objname
[0] == '\0')
2512 objname
= RTLD_PROGNAME
;
2513 _dl_error_printf ("%s (%s)\n", errstring
, objname
);
2516 /* This is a little helper function for resolving symbols while
2517 tracing the binary. */
2519 print_missing_version (int errcode
__attribute__ ((unused
)),
2520 const char *objname
, const char *errstring
)
2522 _dl_error_printf ("%s: %s: %s\n", RTLD_PROGNAME
,
2523 objname
, errstring
);
2526 /* Process the string given as the parameter which explains which debugging
2527 options are enabled. */
2529 process_dl_debug (struct dl_main_state
*state
, const char *dl_debug
)
2531 /* When adding new entries make sure that the maximal length of a name
2532 is correctly handled in the LD_DEBUG_HELP code below. */
2536 const char name
[10];
2537 const char helptext
[41];
2538 unsigned short int mask
;
2541 #define LEN_AND_STR(str) sizeof (str) - 1, str
2542 { LEN_AND_STR ("libs"), "display library search paths",
2543 DL_DEBUG_LIBS
| DL_DEBUG_IMPCALLS
},
2544 { LEN_AND_STR ("reloc"), "display relocation processing",
2545 DL_DEBUG_RELOC
| DL_DEBUG_IMPCALLS
},
2546 { LEN_AND_STR ("files"), "display progress for input file",
2547 DL_DEBUG_FILES
| DL_DEBUG_IMPCALLS
},
2548 { LEN_AND_STR ("symbols"), "display symbol table processing",
2549 DL_DEBUG_SYMBOLS
| DL_DEBUG_IMPCALLS
},
2550 { LEN_AND_STR ("bindings"), "display information about symbol binding",
2551 DL_DEBUG_BINDINGS
| DL_DEBUG_IMPCALLS
},
2552 { LEN_AND_STR ("versions"), "display version dependencies",
2553 DL_DEBUG_VERSIONS
| DL_DEBUG_IMPCALLS
},
2554 { LEN_AND_STR ("scopes"), "display scope information",
2556 { LEN_AND_STR ("all"), "all previous options combined",
2557 DL_DEBUG_LIBS
| DL_DEBUG_RELOC
| DL_DEBUG_FILES
| DL_DEBUG_SYMBOLS
2558 | DL_DEBUG_BINDINGS
| DL_DEBUG_VERSIONS
| DL_DEBUG_IMPCALLS
2559 | DL_DEBUG_SCOPES
},
2560 { LEN_AND_STR ("statistics"), "display relocation statistics",
2561 DL_DEBUG_STATISTICS
},
2562 { LEN_AND_STR ("unused"), "determined unused DSOs",
2564 { LEN_AND_STR ("help"), "display this help message and exit",
2567 #define ndebopts (sizeof (debopts) / sizeof (debopts[0]))
2569 /* Skip separating white spaces and commas. */
2570 while (*dl_debug
!= '\0')
2572 if (*dl_debug
!= ' ' && *dl_debug
!= ',' && *dl_debug
!= ':')
2577 while (dl_debug
[len
] != '\0' && dl_debug
[len
] != ' '
2578 && dl_debug
[len
] != ',' && dl_debug
[len
] != ':')
2581 for (cnt
= 0; cnt
< ndebopts
; ++cnt
)
2582 if (debopts
[cnt
].len
== len
2583 && memcmp (dl_debug
, debopts
[cnt
].name
, len
) == 0)
2585 GLRO(dl_debug_mask
) |= debopts
[cnt
].mask
;
2586 state
->any_debug
= true;
2590 if (cnt
== ndebopts
)
2592 /* Display a warning and skip everything until next
2594 char *copy
= strndupa (dl_debug
, len
);
2595 _dl_error_printf ("\
2596 warning: debug option `%s' unknown; try LD_DEBUG=help\n", copy
);
2606 if (GLRO(dl_debug_mask
) & DL_DEBUG_UNUSED
)
2608 /* In order to get an accurate picture of whether a particular
2609 DT_NEEDED entry is actually used we have to process both
2610 the PLT and non-PLT relocation entries. */
2614 if (GLRO(dl_debug_mask
) & DL_DEBUG_HELP
)
2619 Valid options for the LD_DEBUG environment variable are:\n\n");
2621 for (cnt
= 0; cnt
< ndebopts
; ++cnt
)
2622 _dl_printf (" %.*s%s%s\n", debopts
[cnt
].len
, debopts
[cnt
].name
,
2623 " " + debopts
[cnt
].len
- 3,
2624 debopts
[cnt
].helptext
);
2627 To direct the debugging output into a file instead of standard output\n\
2628 a filename can be specified using the LD_DEBUG_OUTPUT environment variable.\n");
2633 /* Process all environments variables the dynamic linker must recognize.
2634 Since all of them start with `LD_' we are a bit smarter while finding
2636 extern char **_environ attribute_hidden
;
2640 process_envvars (struct dl_main_state
*state
)
2642 char **runp
= _environ
;
2644 char *debug_output
= NULL
;
2646 /* This is the default place for profiling data file. */
2647 GLRO(dl_profile_output
)
2648 = &"/var/tmp\0/var/profile"[__libc_enable_secure
? 9 : 0];
2650 while ((envline
= _dl_next_ld_env_entry (&runp
)) != NULL
)
2654 while (envline
[len
] != '\0' && envline
[len
] != '=')
2657 if (envline
[len
] != '=')
2658 /* This is a "LD_" variable at the end of the string without
2659 a '=' character. Ignore it since otherwise we will access
2660 invalid memory below. */
2666 /* Warning level, verbose or not. */
2667 if (memcmp (envline
, "WARN", 4) == 0)
2668 GLRO(dl_verbose
) = envline
[5] != '\0';
2672 /* Debugging of the dynamic linker? */
2673 if (memcmp (envline
, "DEBUG", 5) == 0)
2675 process_dl_debug (state
, &envline
[6]);
2678 if (memcmp (envline
, "AUDIT", 5) == 0)
2679 audit_list_add_string (&state
->audit_list
, &envline
[6]);
2683 /* Print information about versions. */
2684 if (memcmp (envline
, "VERBOSE", 7) == 0)
2686 state
->version_info
= envline
[8] != '\0';
2690 /* List of objects to be preloaded. */
2691 if (memcmp (envline
, "PRELOAD", 7) == 0)
2693 state
->preloadlist
= &envline
[8];
2697 /* Which shared object shall be profiled. */
2698 if (memcmp (envline
, "PROFILE", 7) == 0 && envline
[8] != '\0')
2699 GLRO(dl_profile
) = &envline
[8];
2703 /* Do we bind early? */
2704 if (memcmp (envline
, "BIND_NOW", 8) == 0)
2706 GLRO(dl_lazy
) = envline
[9] == '\0';
2709 if (memcmp (envline
, "BIND_NOT", 8) == 0)
2710 GLRO(dl_bind_not
) = envline
[9] != '\0';
2714 /* Test whether we want to see the content of the auxiliary
2715 array passed up from the kernel. */
2716 if (!__libc_enable_secure
2717 && memcmp (envline
, "SHOW_AUXV", 9) == 0)
2723 /* Mask for the important hardware capabilities. */
2724 if (!__libc_enable_secure
2725 && memcmp (envline
, "HWCAP_MASK", 10) == 0)
2726 GLRO(dl_hwcap_mask
) = _dl_strtoul (&envline
[11], NULL
);
2731 /* Path where the binary is found. */
2732 if (!__libc_enable_secure
2733 && memcmp (envline
, "ORIGIN_PATH", 11) == 0)
2734 GLRO(dl_origin_path
) = &envline
[12];
2738 /* The library search path. */
2739 if (!__libc_enable_secure
2740 && memcmp (envline
, "LIBRARY_PATH", 12) == 0)
2742 state
->library_path
= &envline
[13];
2743 state
->library_path_source
= "LD_LIBRARY_PATH";
2747 /* Where to place the profiling data file. */
2748 if (memcmp (envline
, "DEBUG_OUTPUT", 12) == 0)
2750 debug_output
= &envline
[13];
2754 if (!__libc_enable_secure
2755 && memcmp (envline
, "DYNAMIC_WEAK", 12) == 0)
2756 GLRO(dl_dynamic_weak
) = 1;
2760 /* We might have some extra environment variable with length 13
2762 #ifdef EXTRA_LD_ENVVARS_13
2765 if (!__libc_enable_secure
2766 && memcmp (envline
, "USE_LOAD_BIAS", 13) == 0)
2768 GLRO(dl_use_load_bias
) = envline
[14] == '1' ? -1 : 0;
2774 /* Where to place the profiling data file. */
2775 if (!__libc_enable_secure
2776 && memcmp (envline
, "PROFILE_OUTPUT", 14) == 0
2777 && envline
[15] != '\0')
2778 GLRO(dl_profile_output
) = &envline
[15];
2782 /* The mode of the dynamic linker can be set. */
2783 if (memcmp (envline
, "TRACE_PRELINKING", 16) == 0)
2785 state
->mode
= rtld_mode_trace
;
2786 GLRO(dl_verbose
) = 1;
2787 GLRO(dl_debug_mask
) |= DL_DEBUG_PRELINK
;
2788 GLRO(dl_trace_prelink
) = &envline
[17];
2793 /* The mode of the dynamic linker can be set. */
2794 if (memcmp (envline
, "TRACE_LOADED_OBJECTS", 20) == 0)
2795 state
->mode
= rtld_mode_trace
;
2798 /* We might have some extra environment variable to handle. This
2799 is tricky due to the pre-processing of the length of the name
2800 in the switch statement here. The code here assumes that added
2801 environment variables have a different length. */
2802 #ifdef EXTRA_LD_ENVVARS
2808 /* Extra security for SUID binaries. Remove all dangerous environment
2810 if (__builtin_expect (__libc_enable_secure
, 0))
2812 static const char unsecure_envvars
[] =
2813 #ifdef EXTRA_UNSECURE_ENVVARS
2814 EXTRA_UNSECURE_ENVVARS
2819 nextp
= unsecure_envvars
;
2823 /* We could use rawmemchr but this need not be fast. */
2824 nextp
= (char *) (strchr
) (nextp
, '\0') + 1;
2826 while (*nextp
!= '\0');
2828 if (__access ("/etc/suid-debug", F_OK
) != 0)
2831 unsetenv ("MALLOC_CHECK_");
2833 GLRO(dl_debug_mask
) = 0;
2836 if (state
->mode
!= rtld_mode_normal
)
2839 /* If we have to run the dynamic linker in debugging mode and the
2840 LD_DEBUG_OUTPUT environment variable is given, we write the debug
2841 messages to this file. */
2842 else if (state
->any_debug
&& debug_output
!= NULL
)
2844 const int flags
= O_WRONLY
| O_APPEND
| O_CREAT
| O_NOFOLLOW
;
2845 size_t name_len
= strlen (debug_output
);
2846 char buf
[name_len
+ 12];
2849 buf
[name_len
+ 11] = '\0';
2850 startp
= _itoa (__getpid (), &buf
[name_len
+ 11], 10, 0);
2852 startp
= memcpy (startp
- name_len
, debug_output
, name_len
);
2854 GLRO(dl_debug_fd
) = __open64_nocancel (startp
, flags
, DEFFILEMODE
);
2855 if (GLRO(dl_debug_fd
) == -1)
2856 /* We use standard output if opening the file failed. */
2857 GLRO(dl_debug_fd
) = STDOUT_FILENO
;
2861 #if HP_TIMING_INLINE
2863 print_statistics_item (const char *title
, hp_timing_t time
,
2866 char cycles
[HP_TIMING_PRINT_SIZE
];
2867 HP_TIMING_PRINT (cycles
, sizeof (cycles
), time
);
2869 char relative
[3 * sizeof (hp_timing_t
) + 2];
2870 char *cp
= _itoa ((1000ULL * time
) / total
, relative
+ sizeof (relative
),
2872 /* Sets the decimal point. */
2873 char *wp
= relative
;
2874 switch (relative
+ sizeof (relative
) - cp
)
2887 _dl_debug_printf ("%s: %s cycles (%s%%)\n", title
, cycles
, relative
);
2891 /* Print the various times we collected. */
2893 __attribute ((noinline
))
2894 print_statistics (const hp_timing_t
*rtld_total_timep
)
2896 #if HP_TIMING_INLINE
2898 char cycles
[HP_TIMING_PRINT_SIZE
];
2899 HP_TIMING_PRINT (cycles
, sizeof (cycles
), *rtld_total_timep
);
2900 _dl_debug_printf ("\nruntime linker statistics:\n"
2901 " total startup time in dynamic loader: %s cycles\n",
2903 print_statistics_item (" time needed for relocation",
2904 relocate_time
, *rtld_total_timep
);
2908 unsigned long int num_relative_relocations
= 0;
2909 for (Lmid_t ns
= 0; ns
< GL(dl_nns
); ++ns
)
2911 if (GL(dl_ns
)[ns
]._ns_loaded
== NULL
)
2914 struct r_scope_elem
*scope
= &GL(dl_ns
)[ns
]._ns_loaded
->l_searchlist
;
2916 for (unsigned int i
= 0; i
< scope
->r_nlist
; i
++)
2918 struct link_map
*l
= scope
->r_list
[i
];
2920 if (l
->l_addr
!= 0 && l
->l_info
[VERSYMIDX (DT_RELCOUNT
)])
2921 num_relative_relocations
2922 += l
->l_info
[VERSYMIDX (DT_RELCOUNT
)]->d_un
.d_val
;
2923 #ifndef ELF_MACHINE_REL_RELATIVE
2924 /* Relative relocations are processed on these architectures if
2925 library is loaded to different address than p_vaddr or
2926 if not prelinked. */
2927 if ((l
->l_addr
!= 0 || !l
->l_info
[VALIDX(DT_GNU_PRELINKED
)])
2928 && l
->l_info
[VERSYMIDX (DT_RELACOUNT
)])
2930 /* On e.g. IA-64 or Alpha, relative relocations are processed
2931 only if library is loaded to different address than p_vaddr. */
2932 if (l
->l_addr
!= 0 && l
->l_info
[VERSYMIDX (DT_RELACOUNT
)])
2934 num_relative_relocations
2935 += l
->l_info
[VERSYMIDX (DT_RELACOUNT
)]->d_un
.d_val
;
2939 _dl_debug_printf (" number of relocations: %lu\n"
2940 " number of relocations from cache: %lu\n"
2941 " number of relative relocations: %lu\n",
2942 GL(dl_num_relocations
),
2943 GL(dl_num_cache_relocations
),
2944 num_relative_relocations
);
2946 #if HP_TIMING_INLINE
2947 print_statistics_item (" time needed to load objects",
2948 load_time
, *rtld_total_timep
);