1 /* Run time dynamic linker.
2 Copyright (C) 1995-2021 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>
51 #include <gnu/lib-names.h>
52 #include <dl-tunables.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 extern char **_environ attribute_hidden
;
144 static void process_envvars (struct dl_main_state
*state
);
146 #ifdef DL_ARGV_NOT_RELRO
147 int _dl_argc attribute_hidden
;
148 char **_dl_argv
= NULL
;
149 /* Nonzero if we were run directly. */
150 unsigned int _dl_skip_args attribute_hidden
;
152 int _dl_argc attribute_relro attribute_hidden
;
153 char **_dl_argv attribute_relro
= NULL
;
154 unsigned int _dl_skip_args attribute_relro attribute_hidden
;
156 rtld_hidden_data_def (_dl_argv
)
158 #ifndef THREAD_SET_STACK_GUARD
159 /* Only exported for architectures that don't store the stack guard canary
160 in thread local area. */
161 uintptr_t __stack_chk_guard attribute_relro
;
164 /* Only exported for architectures that don't store the pointer guard
165 value in thread local area. */
166 uintptr_t __pointer_chk_guard_local
167 attribute_relro attribute_hidden
__attribute__ ((nocommon
));
168 #ifndef THREAD_SET_POINTER_GUARD
169 strong_alias (__pointer_chk_guard_local
, __pointer_chk_guard
)
172 /* Check that AT_SECURE=0, or that the passed name does not contain
173 directories and is not overly long. Reject empty names
176 dso_name_valid_for_suid (const char *p
)
178 if (__glibc_unlikely (__libc_enable_secure
))
180 /* Ignore pathnames with directories for AT_SECURE=1
181 programs, and also skip overlong names. */
182 size_t len
= strlen (p
);
183 if (len
>= SECURE_NAME_LIMIT
|| memchr (p
, '/', len
) != NULL
)
190 audit_list_init (struct audit_list
*list
)
193 list
->current_index
= 0;
194 list
->current_tail
= NULL
;
198 audit_list_add_string (struct audit_list
*list
, const char *string
)
200 /* Empty strings do not load anything. */
204 if (list
->length
== array_length (list
->audit_strings
))
205 _dl_fatal_printf ("Fatal glibc error: Too many audit modules requested\n");
207 list
->audit_strings
[list
->length
++] = string
;
209 /* Initialize processing of the first string for
211 if (list
->length
== 1)
212 list
->current_tail
= string
;
216 audit_list_add_dynamic_tag (struct audit_list
*list
, struct link_map
*main_map
,
219 ElfW(Dyn
) *info
= main_map
->l_info
[ADDRIDX (tag
)];
220 const char *strtab
= (const char *) D_PTR (main_map
, l_info
[DT_STRTAB
]);
222 audit_list_add_string (list
, strtab
+ info
->d_un
.d_val
);
226 audit_list_next (struct audit_list
*list
)
228 if (list
->current_tail
== NULL
)
233 /* Advance to the next string in audit_strings if the current
234 string has been exhausted. */
235 while (*list
->current_tail
== '\0')
237 ++list
->current_index
;
238 if (list
->current_index
== list
->length
)
240 list
->current_tail
= NULL
;
243 list
->current_tail
= list
->audit_strings
[list
->current_index
];
246 /* Split the in-string audit list at the next colon colon. */
247 size_t len
= strcspn (list
->current_tail
, ":");
248 if (len
> 0 && len
< sizeof (list
->fname
))
250 memcpy (list
->fname
, list
->current_tail
, len
);
251 list
->fname
[len
] = '\0';
254 /* Mark the name as unusable for dso_name_valid_for_suid. */
255 list
->fname
[0] = '\0';
257 /* Skip over the substring and the following delimiter. */
258 list
->current_tail
+= len
;
259 if (*list
->current_tail
== ':')
260 ++list
->current_tail
;
262 /* If the name is valid, return it. */
263 if (dso_name_valid_for_suid (list
->fname
))
266 /* Otherwise wrap around to find the next list element. . */
270 /* Count audit modules before they are loaded so GLRO(dl_naudit)
271 is not yet usable. */
273 audit_list_count (struct audit_list
*list
)
275 /* Restore the audit_list iterator state at the end. */
276 const char *saved_tail
= list
->current_tail
;
279 assert (list
->current_index
== 0);
280 while (audit_list_next (list
) != NULL
)
282 list
->current_tail
= saved_tail
;
283 list
->current_index
= 0;
288 dl_main_state_init (struct dl_main_state
*state
)
290 audit_list_init (&state
->audit_list
);
291 state
->library_path
= NULL
;
292 state
->library_path_source
= NULL
;
293 state
->preloadlist
= NULL
;
294 state
->preloadarg
= NULL
;
295 state
->glibc_hwcaps_prepend
= NULL
;
296 state
->glibc_hwcaps_mask
= NULL
;
297 state
->mode
= rtld_mode_normal
;
298 state
->any_debug
= false;
299 state
->version_info
= false;
302 #ifndef HAVE_INLINED_SYSCALLS
303 /* Set nonzero during loading and initialization of executable and
304 libraries, cleared before the executable's entry point runs. This
305 must not be initialized to nonzero, because the unused dynamic
306 linker loaded in for libc.so's "ld.so.1" dep will provide the
307 definition seen by libc.so's initializer; that value must be zero,
308 and will be since that dynamic linker's _dl_start and dl_main will
310 int _dl_starting_up
= 0;
311 rtld_hidden_def (_dl_starting_up
)
314 /* This is the structure which defines all variables global to ld.so
315 (except those which cannot be added for some reason). */
316 struct rtld_global _rtld_global
=
318 /* Get architecture specific initializer. */
319 #include <dl-procruntime.c>
320 /* Generally the default presumption without further information is an
321 * executable stack but this is not true for all platforms. */
322 ._dl_stack_flags
= DEFAULT_STACK_PERMS
,
323 #ifdef _LIBC_REENTRANT
324 ._dl_load_lock
= _RTLD_LOCK_RECURSIVE_INITIALIZER
,
325 ._dl_load_write_lock
= _RTLD_LOCK_RECURSIVE_INITIALIZER
,
330 #ifdef _LIBC_REENTRANT
331 [LM_ID_BASE
] = { ._ns_unique_sym_table
332 = { .lock
= _RTLD_LOCK_RECURSIVE_INITIALIZER
} }
336 /* If we would use strong_alias here the compiler would see a
337 non-hidden definition. This would undo the effect of the previous
338 declaration. So spell out what strong_alias does plus add the
339 visibility attribute. */
340 extern struct rtld_global _rtld_local
341 __attribute__ ((alias ("_rtld_global"), visibility ("hidden")));
344 /* This variable is similar to _rtld_local, but all values are
345 read-only after relocation. */
346 struct rtld_global_ro _rtld_global_ro attribute_relro
=
348 /* Get architecture specific initializer. */
349 #include <dl-procinfo.c>
350 #ifdef NEED_DL_SYSINFO
351 ._dl_sysinfo
= DL_SYSINFO_DEFAULT
,
353 ._dl_debug_fd
= STDERR_FILENO
,
354 ._dl_use_load_bias
= -2,
355 ._dl_correct_cache_id
= _DL_CACHE_DEFAULT_ID
,
357 ._dl_hwcap_mask
= HWCAP_IMPORTANT
,
360 ._dl_fpu_control
= _FPU_DEFAULT
,
361 ._dl_pagesize
= EXEC_PAGESIZE
,
362 ._dl_inhibit_cache
= 0,
364 /* Function pointers. */
365 ._dl_debug_printf
= _dl_debug_printf
,
366 ._dl_mcount
= _dl_mcount
,
367 ._dl_lookup_symbol_x
= _dl_lookup_symbol_x
,
368 ._dl_open
= _dl_open
,
369 ._dl_close
= _dl_close
,
370 ._dl_catch_error
= _rtld_catch_error
,
371 ._dl_error_free
= _dl_error_free
,
372 ._dl_tls_get_addr_soft
= _dl_tls_get_addr_soft
,
373 #ifdef HAVE_DL_DISCOVER_OSVERSION
374 ._dl_discover_osversion
= _dl_discover_osversion
377 /* If we would use strong_alias here the compiler would see a
378 non-hidden definition. This would undo the effect of the previous
379 declaration. So spell out was strong_alias does plus add the
380 visibility attribute. */
381 extern struct rtld_global_ro _rtld_local_ro
382 __attribute__ ((alias ("_rtld_global_ro"), visibility ("hidden")));
385 static void dl_main (const ElfW(Phdr
) *phdr
, ElfW(Word
) phnum
,
386 ElfW(Addr
) *user_entry
, ElfW(auxv_t
) *auxv
);
388 /* These two variables cannot be moved into .data.rel.ro. */
389 static struct libname_list _dl_rtld_libname
;
390 static struct libname_list _dl_rtld_libname2
;
392 /* Variable for statistics. */
393 RLTD_TIMING_DECLARE (relocate_time
, static);
394 RLTD_TIMING_DECLARE (load_time
, static, attribute_relro
);
395 RLTD_TIMING_DECLARE (start_time
, static, attribute_relro
);
397 /* Additional definitions needed by TLS initialization. */
398 #ifdef TLS_INIT_HELPER
402 /* Helper function for syscall implementation. */
403 #ifdef DL_SYSINFO_IMPLEMENTATION
404 DL_SYSINFO_IMPLEMENTATION
407 /* Before ld.so is relocated we must not access variables which need
408 relocations. This means variables which are exported. Variables
409 declared as static are fine. If we can mark a variable hidden this
410 is fine, too. The latter is important here. We can avoid setting
411 up a temporary link map for ld.so if we can mark _rtld_global as
413 #ifdef PI_STATIC_AND_HIDDEN
414 # define DONT_USE_BOOTSTRAP_MAP 1
417 #ifdef DONT_USE_BOOTSTRAP_MAP
418 static ElfW(Addr
) _dl_start_final (void *arg
);
420 struct dl_start_final_info
423 RTLD_TIMING_VAR (start_time
);
425 static ElfW(Addr
) _dl_start_final (void *arg
,
426 struct dl_start_final_info
*info
);
429 /* These defined magically in the linker script. */
430 extern char _begin
[] attribute_hidden
;
431 extern char _etext
[] attribute_hidden
;
432 extern char _end
[] attribute_hidden
;
438 # error "sysdeps/MACHINE/dl-machine.h fails to define RTLD_START"
441 /* This is the second half of _dl_start (below). It can be inlined safely
442 under DONT_USE_BOOTSTRAP_MAP, where it is careful not to make any GOT
443 references. When the tools don't permit us to avoid using a GOT entry
444 for _dl_rtld_global (no attribute_hidden support), we must make sure
445 this function is not inlined (see below). */
447 #ifdef DONT_USE_BOOTSTRAP_MAP
448 static inline ElfW(Addr
) __attribute__ ((always_inline
))
449 _dl_start_final (void *arg
)
451 static ElfW(Addr
) __attribute__ ((noinline
))
452 _dl_start_final (void *arg
, struct dl_start_final_info
*info
)
455 ElfW(Addr
) start_addr
;
457 /* If it hasn't happen yet record the startup time. */
458 rtld_timer_start (&start_time
);
459 #if !defined DONT_USE_BOOTSTRAP_MAP
460 RTLD_TIMING_SET (start_time
, info
->start_time
);
463 /* Transfer data about ourselves to the permanent link_map structure. */
464 #ifndef DONT_USE_BOOTSTRAP_MAP
465 GL(dl_rtld_map
).l_addr
= info
->l
.l_addr
;
466 GL(dl_rtld_map
).l_ld
= info
->l
.l_ld
;
467 memcpy (GL(dl_rtld_map
).l_info
, info
->l
.l_info
,
468 sizeof GL(dl_rtld_map
).l_info
);
469 GL(dl_rtld_map
).l_mach
= info
->l
.l_mach
;
470 GL(dl_rtld_map
).l_relocated
= 1;
472 _dl_setup_hash (&GL(dl_rtld_map
));
473 GL(dl_rtld_map
).l_real
= &GL(dl_rtld_map
);
474 GL(dl_rtld_map
).l_map_start
= (ElfW(Addr
)) _begin
;
475 GL(dl_rtld_map
).l_map_end
= (ElfW(Addr
)) _end
;
476 GL(dl_rtld_map
).l_text_end
= (ElfW(Addr
)) _etext
;
477 /* Copy the TLS related data if necessary. */
478 #ifndef DONT_USE_BOOTSTRAP_MAP
479 # if NO_TLS_OFFSET != 0
480 GL(dl_rtld_map
).l_tls_offset
= NO_TLS_OFFSET
;
484 /* Initialize the stack end variable. */
485 __libc_stack_end
= __builtin_frame_address (0);
487 /* Call the OS-dependent function to set up life so we can do things like
488 file access. It will call `dl_main' (below) to do all the real work
489 of the dynamic linker, and then unwind our frame and run the user
490 entry point on the same stack we entered on. */
491 start_addr
= _dl_sysdep_start (arg
, &dl_main
);
493 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_STATISTICS
))
495 RTLD_TIMING_VAR (rtld_total_time
);
496 rtld_timer_stop (&rtld_total_time
, start_time
);
497 print_statistics (RTLD_TIMING_REF(rtld_total_time
));
503 static ElfW(Addr
) __attribute_used__
504 _dl_start (void *arg
)
506 #ifdef DONT_USE_BOOTSTRAP_MAP
507 # define bootstrap_map GL(dl_rtld_map)
509 struct dl_start_final_info info
;
510 # define bootstrap_map info.l
513 /* This #define produces dynamic linking inline functions for
514 bootstrap relocation instead of general-purpose relocation.
515 Since ld.so must not have any undefined symbols the result
516 is trivial: always the map of ld.so itself. */
517 #define RTLD_BOOTSTRAP
518 #define BOOTSTRAP_MAP (&bootstrap_map)
519 #define RESOLVE_MAP(sym, version, flags) BOOTSTRAP_MAP
520 #include "dynamic-link.h"
522 #ifdef DONT_USE_BOOTSTRAP_MAP
523 rtld_timer_start (&start_time
);
525 rtld_timer_start (&info
.start_time
);
528 /* Partly clean the `bootstrap_map' structure up. Don't use
529 `memset' since it might not be built in or inlined and we cannot
530 make function calls at this point. Use '__builtin_memset' if we
531 know it is available. We do not have to clear the memory if we
532 do not have to use the temporary bootstrap_map. Global variables
533 are initialized to zero by default. */
534 #ifndef DONT_USE_BOOTSTRAP_MAP
535 # ifdef HAVE_BUILTIN_MEMSET
536 __builtin_memset (bootstrap_map
.l_info
, '\0', sizeof (bootstrap_map
.l_info
));
539 cnt
< sizeof (bootstrap_map
.l_info
) / sizeof (bootstrap_map
.l_info
[0]);
541 bootstrap_map
.l_info
[cnt
] = 0;
545 /* Figure out the run-time load address of the dynamic linker itself. */
546 bootstrap_map
.l_addr
= elf_machine_load_address ();
548 /* Read our own dynamic section and fill in the info array. */
549 bootstrap_map
.l_ld
= (void *) bootstrap_map
.l_addr
+ elf_machine_dynamic ();
550 elf_get_dynamic_info (&bootstrap_map
, NULL
);
552 #if NO_TLS_OFFSET != 0
553 bootstrap_map
.l_tls_offset
= NO_TLS_OFFSET
;
556 #ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
557 ELF_MACHINE_BEFORE_RTLD_RELOC (bootstrap_map
.l_info
);
560 if (bootstrap_map
.l_addr
|| ! bootstrap_map
.l_info
[VALIDX(DT_GNU_PRELINKED
)])
562 /* Relocate ourselves so we can do normal function calls and
563 data access using the global offset table. */
565 ELF_DYNAMIC_RELOCATE (&bootstrap_map
, 0, 0, 0);
567 bootstrap_map
.l_relocated
= 1;
569 /* Please note that we don't allow profiling of this object and
570 therefore need not test whether we have to allocate the array
571 for the relocation results (as done in dl-reloc.c). */
573 /* Now life is sane; we can call functions and access global data.
574 Set up to use the operating system facilities, and find out from
575 the operating system's program loader where to find the program
576 header table in core. Put the rest of _dl_start into a separate
577 function, that way the compiler cannot put accesses to the GOT
578 before ELF_DYNAMIC_RELOCATE. */
580 __rtld_malloc_init_stubs ();
583 #ifdef DONT_USE_BOOTSTRAP_MAP
584 ElfW(Addr
) entry
= _dl_start_final (arg
);
586 ElfW(Addr
) entry
= _dl_start_final (arg
, &info
);
589 #ifndef ELF_MACHINE_START_ADDRESS
590 # define ELF_MACHINE_START_ADDRESS(map, start) (start)
593 return ELF_MACHINE_START_ADDRESS (GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
, entry
);
599 /* Now life is peachy; we can do all normal operations.
600 On to the real work. */
602 /* Some helper functions. */
604 /* Arguments to relocate_doit. */
613 /* Argument to map_doit. */
615 struct link_map
*loader
;
617 /* Return value of map_doit. */
618 struct link_map
*map
;
624 struct link_map
*map
;
630 struct link_map
*map
;
634 /* Arguments to version_check_doit. */
635 struct version_check_args
642 relocate_doit (void *a
)
644 struct relocate_args
*args
= (struct relocate_args
*) a
;
646 _dl_relocate_object (args
->l
, args
->l
->l_scope
, args
->reloc_mode
, 0);
652 struct map_args
*args
= (struct map_args
*) a
;
653 int type
= (args
->mode
== __RTLD_OPENEXEC
) ? lt_executable
: lt_library
;
654 args
->map
= _dl_map_object (args
->loader
, args
->str
, type
, 0,
655 args
->mode
, LM_ID_BASE
);
659 dlmopen_doit (void *a
)
661 struct dlmopen_args
*args
= (struct dlmopen_args
*) a
;
662 args
->map
= _dl_open (args
->fname
,
663 (RTLD_LAZY
| __RTLD_DLOPEN
| __RTLD_AUDIT
665 dl_main
, LM_ID_NEWLM
, _dl_argc
, _dl_argv
,
670 lookup_doit (void *a
)
672 struct lookup_args
*args
= (struct lookup_args
*) a
;
673 const ElfW(Sym
) *ref
= NULL
;
675 lookup_t l
= _dl_lookup_symbol_x (args
->name
, args
->map
, &ref
,
676 args
->map
->l_local_scope
, NULL
, 0,
677 DL_LOOKUP_RETURN_NEWEST
, NULL
);
679 args
->result
= DL_SYMBOL_ADDRESS (l
, ref
);
683 version_check_doit (void *a
)
685 struct version_check_args
*args
= (struct version_check_args
*) a
;
686 if (_dl_check_all_versions (GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
, 1,
687 args
->dotrace
) && args
->doexit
)
688 /* We cannot start the application. Abort now. */
693 static inline struct link_map
*
694 find_needed (const char *name
)
696 struct r_scope_elem
*scope
= &GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
->l_searchlist
;
697 unsigned int n
= scope
->r_nlist
;
700 if (_dl_name_match_p (name
, scope
->r_list
[n
]))
701 return scope
->r_list
[n
];
703 /* Should never happen. */
708 match_version (const char *string
, struct link_map
*map
)
710 const char *strtab
= (const void *) D_PTR (map
, l_info
[DT_STRTAB
]);
713 #define VERDEFTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERDEF))
714 if (map
->l_info
[VERDEFTAG
] == NULL
)
715 /* The file has no symbol versioning. */
718 def
= (ElfW(Verdef
) *) ((char *) map
->l_addr
719 + map
->l_info
[VERDEFTAG
]->d_un
.d_ptr
);
722 ElfW(Verdaux
) *aux
= (ElfW(Verdaux
) *) ((char *) def
+ def
->vd_aux
);
724 /* Compare the version strings. */
725 if (strcmp (string
, strtab
+ aux
->vda_name
) == 0)
729 /* If no more definitions we failed to find what we want. */
730 if (def
->vd_next
== 0)
733 /* Next definition. */
734 def
= (ElfW(Verdef
) *) ((char *) def
+ def
->vd_next
);
740 static bool tls_init_tp_called
;
743 init_tls (size_t naudit
)
745 /* Number of elements in the static TLS block. */
746 GL(dl_tls_static_nelem
) = GL(dl_tls_max_dtv_idx
);
748 /* Do not do this twice. The audit interface might have required
749 the DTV interfaces to be set up early. */
750 if (GL(dl_initial_dtv
) != NULL
)
753 /* Allocate the array which contains the information about the
754 dtv slots. We allocate a few entries more than needed to
755 avoid the need for reallocation. */
756 size_t nelem
= GL(dl_tls_max_dtv_idx
) + 1 + TLS_SLOTINFO_SURPLUS
;
759 GL(dl_tls_dtv_slotinfo_list
) = (struct dtv_slotinfo_list
*)
760 calloc (sizeof (struct dtv_slotinfo_list
)
761 + nelem
* sizeof (struct dtv_slotinfo
), 1);
762 /* No need to check the return value. If memory allocation failed
763 the program would have been terminated. */
765 struct dtv_slotinfo
*slotinfo
= GL(dl_tls_dtv_slotinfo_list
)->slotinfo
;
766 GL(dl_tls_dtv_slotinfo_list
)->len
= nelem
;
767 GL(dl_tls_dtv_slotinfo_list
)->next
= NULL
;
769 /* Fill in the information from the loaded modules. No namespace
770 but the base one can be filled at this time. */
771 assert (GL(dl_ns
)[LM_ID_BASE
+ 1]._ns_loaded
== NULL
);
773 for (struct link_map
*l
= GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
; l
!= NULL
;
775 if (l
->l_tls_blocksize
!= 0)
777 /* This is a module with TLS data. Store the map reference.
778 The generation counter is zero. */
780 /* slotinfo[i].gen = 0; */
783 assert (i
== GL(dl_tls_max_dtv_idx
));
785 /* Calculate the size of the static TLS surplus. */
786 _dl_tls_static_surplus_init (naudit
);
788 /* Compute the TLS offsets for the various blocks. */
789 _dl_determine_tlsoffset ();
791 /* Construct the static TLS block and the dtv for the initial
792 thread. For some platforms this will include allocating memory
793 for the thread descriptor. The memory for the TLS block will
794 never be freed. It should be allocated accordingly. The dtv
795 array can be changed if dynamic loading requires it. */
796 void *tcbp
= _dl_allocate_tls_storage ();
799 cannot allocate TLS data structures for initial thread\n");
801 /* Store for detection of the special case by __tls_get_addr
802 so it knows not to pass this dtv to the normal realloc. */
803 GL(dl_initial_dtv
) = GET_DTV (tcbp
);
805 /* And finally install it for the main thread. */
806 const char *lossage
= TLS_INIT_TP (tcbp
);
807 if (__glibc_unlikely (lossage
!= NULL
))
808 _dl_fatal_printf ("cannot set up thread-local storage: %s\n", lossage
);
810 tls_init_tp_called
= true;
816 do_preload (const char *fname
, struct link_map
*main_map
, const char *where
)
819 const char *err_str
= NULL
;
820 struct map_args args
;
824 args
.loader
= main_map
;
825 args
.mode
= __RTLD_SECURE
;
827 unsigned int old_nloaded
= GL(dl_ns
)[LM_ID_BASE
]._ns_nloaded
;
829 (void) _dl_catch_error (&objname
, &err_str
, &malloced
, map_doit
, &args
);
830 if (__glibc_unlikely (err_str
!= NULL
))
833 ERROR: ld.so: object '%s' from %s cannot be preloaded (%s): ignored.\n",
834 fname
, where
, err_str
);
835 /* No need to call free, this is still before
836 the libc's malloc is used. */
838 else if (GL(dl_ns
)[LM_ID_BASE
]._ns_nloaded
!= old_nloaded
)
839 /* It is no duplicate. */
842 /* Nothing loaded. */
846 #if defined SHARED && defined _LIBC_REENTRANT \
847 && defined __rtld_lock_default_lock_recursive
849 rtld_lock_default_lock_recursive (void *lock
)
851 __rtld_lock_default_lock_recursive (lock
);
855 rtld_lock_default_unlock_recursive (void *lock
)
857 __rtld_lock_default_unlock_recursive (lock
);
865 /* Set up the stack checker's canary. */
866 uintptr_t stack_chk_guard
= _dl_setup_stack_chk_guard (_dl_random
);
867 #ifdef THREAD_SET_STACK_GUARD
868 THREAD_SET_STACK_GUARD (stack_chk_guard
);
870 __stack_chk_guard
= stack_chk_guard
;
873 /* Set up the pointer guard as well, if necessary. */
874 uintptr_t pointer_chk_guard
875 = _dl_setup_pointer_guard (_dl_random
, stack_chk_guard
);
876 #ifdef THREAD_SET_POINTER_GUARD
877 THREAD_SET_POINTER_GUARD (pointer_chk_guard
);
879 __pointer_chk_guard_local
= pointer_chk_guard
;
881 /* We do not need the _dl_random value anymore. The less
882 information we leave behind, the better, so clear the
887 #include <setup-vdso.h>
889 /* The LD_PRELOAD environment variable gives list of libraries
890 separated by white space or colons that are loaded before the
891 executable's dependencies and prepended to the global scope list.
892 (If the binary is running setuid all elements containing a '/' are
893 ignored since it is insecure.) Return the number of preloads
894 performed. Ditto for --preload command argument. */
896 handle_preload_list (const char *preloadlist
, struct link_map
*main_map
,
899 unsigned int npreloads
= 0;
900 const char *p
= preloadlist
;
901 char fname
[SECURE_PATH_LIMIT
];
905 /* Split preload list at space/colon. */
906 size_t len
= strcspn (p
, " :");
907 if (len
> 0 && len
< sizeof (fname
))
909 memcpy (fname
, p
, len
);
915 /* Skip over the substring and the following delimiter. */
920 if (dso_name_valid_for_suid (fname
))
921 npreloads
+= do_preload (fname
, main_map
, where
);
926 /* Called if the audit DSO cannot be used: if it does not have the
927 appropriate interfaces, or it expects a more recent version library
928 version than what the dynamic linker provides. */
930 unload_audit_module (struct link_map
*map
, int original_tls_idx
)
933 Lmid_t ns
= map
->l_ns
;
937 /* Make sure the namespace has been cleared entirely. */
938 assert (GL(dl_ns
)[ns
]._ns_loaded
== NULL
);
939 assert (GL(dl_ns
)[ns
]._ns_nloaded
== 0);
941 GL(dl_tls_max_dtv_idx
) = original_tls_idx
;
944 /* Called to print an error message if loading of an audit module
947 report_audit_module_load_error (const char *name
, const char *err_str
,
951 ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n",
954 free ((char *) err_str
);
957 /* Load one audit module. */
959 load_audit_module (const char *name
, struct audit_ifaces
**last_audit
)
961 int original_tls_idx
= GL(dl_tls_max_dtv_idx
);
963 struct dlmopen_args dlmargs
;
964 dlmargs
.fname
= name
;
968 const char *err_str
= NULL
;
970 _dl_catch_error (&objname
, &err_str
, &malloced
, dlmopen_doit
, &dlmargs
);
971 if (__glibc_unlikely (err_str
!= NULL
))
973 report_audit_module_load_error (name
, err_str
, malloced
);
977 struct lookup_args largs
;
978 largs
.name
= "la_version";
979 largs
.map
= dlmargs
.map
;
980 _dl_catch_error (&objname
, &err_str
, &malloced
, lookup_doit
, &largs
);
981 if (__glibc_likely (err_str
!= NULL
))
983 unload_audit_module (dlmargs
.map
, original_tls_idx
);
984 report_audit_module_load_error (name
, err_str
, malloced
);
988 unsigned int (*laversion
) (unsigned int) = largs
.result
;
990 /* A null symbol indicates that something is very wrong with the
991 loaded object because defined symbols are supposed to have a
992 valid, non-null address. */
993 assert (laversion
!= NULL
);
995 unsigned int lav
= laversion (LAV_CURRENT
);
998 /* Only print an error message if debugging because this can
999 happen deliberately. */
1000 if (GLRO(dl_debug_mask
) & DL_DEBUG_FILES
)
1001 _dl_debug_printf ("\
1002 file=%s [%lu]; audit interface function la_version returned zero; ignored.\n",
1003 dlmargs
.map
->l_name
, dlmargs
.map
->l_ns
);
1004 unload_audit_module (dlmargs
.map
, original_tls_idx
);
1008 if (lav
> LAV_CURRENT
)
1010 _dl_debug_printf ("\
1011 ERROR: audit interface '%s' requires version %d (maximum supported version %d); ignored.\n",
1012 name
, lav
, LAV_CURRENT
);
1013 unload_audit_module (dlmargs
.map
, original_tls_idx
);
1017 enum { naudit_ifaces
= 8 };
1020 struct audit_ifaces ifaces
;
1021 void (*fptr
[naudit_ifaces
]) (void);
1022 } *newp
= malloc (sizeof (*newp
));
1024 _dl_fatal_printf ("Out of memory while loading audit modules\n");
1026 /* Names of the auditing interfaces. All in one
1028 static const char audit_iface_names
[] =
1033 #if __ELF_NATIVE_CLASS == 32
1035 #elif __ELF_NATIVE_CLASS == 64
1038 # error "__ELF_NATIVE_CLASS must be defined"
1040 #define STRING(s) __STRING (s)
1041 "la_" STRING (ARCH_LA_PLTENTER
) "\0"
1042 "la_" STRING (ARCH_LA_PLTEXIT
) "\0"
1044 unsigned int cnt
= 0;
1045 const char *cp
= audit_iface_names
;
1049 _dl_catch_error (&objname
, &err_str
, &malloced
, lookup_doit
, &largs
);
1051 /* Store the pointer. */
1052 if (err_str
== NULL
&& largs
.result
!= NULL
)
1053 newp
->fptr
[cnt
] = largs
.result
;
1055 newp
->fptr
[cnt
] = NULL
;
1058 cp
= rawmemchr (cp
, '\0') + 1;
1060 while (*cp
!= '\0');
1061 assert (cnt
== naudit_ifaces
);
1063 /* Now append the new auditing interface to the list. */
1064 newp
->ifaces
.next
= NULL
;
1065 if (*last_audit
== NULL
)
1066 *last_audit
= GLRO(dl_audit
) = &newp
->ifaces
;
1068 *last_audit
= (*last_audit
)->next
= &newp
->ifaces
;
1070 /* The dynamic linker link map is statically allocated, so the
1071 cookie in _dl_new_object has not happened. */
1072 link_map_audit_state (&GL (dl_rtld_map
), GLRO (dl_naudit
))->cookie
1073 = (intptr_t) &GL (dl_rtld_map
);
1077 /* Mark the DSO as being used for auditing. */
1078 dlmargs
.map
->l_auditing
= 1;
1081 /* Notify the the audit modules that the object MAP has already been
1084 notify_audit_modules_of_loaded_object (struct link_map
*map
)
1086 struct audit_ifaces
*afct
= GLRO(dl_audit
);
1087 for (unsigned int cnt
= 0; cnt
< GLRO(dl_naudit
); ++cnt
)
1089 if (afct
->objopen
!= NULL
)
1091 struct auditstate
*state
= link_map_audit_state (map
, cnt
);
1092 state
->bindflags
= afct
->objopen (map
, LM_ID_BASE
, &state
->cookie
);
1093 map
->l_audit_any_plt
|= state
->bindflags
!= 0;
1100 /* Load all audit modules. */
1102 load_audit_modules (struct link_map
*main_map
, struct audit_list
*audit_list
)
1104 struct audit_ifaces
*last_audit
= NULL
;
1108 const char *name
= audit_list_next (audit_list
);
1111 load_audit_module (name
, &last_audit
);
1114 /* Notify audit modules of the initially loaded modules (the main
1115 program and the dynamic linker itself). */
1116 if (GLRO(dl_naudit
) > 0)
1118 notify_audit_modules_of_loaded_object (main_map
);
1119 notify_audit_modules_of_loaded_object (&GL(dl_rtld_map
));
1124 dl_main (const ElfW(Phdr
) *phdr
,
1126 ElfW(Addr
) *user_entry
,
1129 const ElfW(Phdr
) *ph
;
1130 struct link_map
*main_map
;
1133 bool has_interp
= false;
1135 bool prelinked
= false;
1136 bool rtld_is_main
= false;
1139 struct dl_main_state state
;
1140 dl_main_state_init (&state
);
1142 #if !THREAD_GSCOPE_IN_TCB
1143 GL(dl_init_static_tls
) = &_dl_nothread_init_static_tls
;
1146 #if defined SHARED && defined _LIBC_REENTRANT \
1147 && defined __rtld_lock_default_lock_recursive
1148 GL(dl_rtld_lock_recursive
) = rtld_lock_default_lock_recursive
;
1149 GL(dl_rtld_unlock_recursive
) = rtld_lock_default_unlock_recursive
;
1152 /* The explicit initialization here is cheaper than processing the reloc
1153 in the _rtld_local definition's initializer. */
1154 GL(dl_make_stack_executable_hook
) = &_dl_make_stack_executable
;
1156 /* Process the environment variable which control the behaviour. */
1157 process_envvars (&state
);
1159 #ifndef HAVE_INLINED_SYSCALLS
1160 /* Set up a flag which tells we are just starting. */
1161 _dl_starting_up
= 1;
1164 const char *ld_so_name
= _dl_argv
[0];
1165 if (*user_entry
== (ElfW(Addr
)) ENTRY_POINT
)
1167 /* Ho ho. We are not the program interpreter! We are the program
1168 itself! This means someone ran ld.so as a command. Well, that
1169 might be convenient to do sometimes. We support it by
1170 interpreting the args like this:
1172 ld.so PROGRAM ARGS...
1174 The first argument is the name of a file containing an ELF
1175 executable we will load and run with the following arguments.
1176 To simplify life here, PROGRAM is searched for using the
1177 normal rules for shared objects, rather than $PATH or anything
1178 like that. We just load it and use its entry point; we don't
1179 pay attention to its PT_INTERP command (we are the interpreter
1180 ourselves). This is an easy way to test a new ld.so before
1182 rtld_is_main
= true;
1186 /* Note the place where the dynamic linker actually came from. */
1187 GL(dl_rtld_map
).l_name
= rtld_progname
;
1189 while (_dl_argc
> 1)
1190 if (! strcmp (_dl_argv
[1], "--list"))
1192 if (state
.mode
!= rtld_mode_help
)
1194 state
.mode
= rtld_mode_list
;
1195 /* This means do no dependency analysis. */
1203 else if (! strcmp (_dl_argv
[1], "--verify"))
1205 if (state
.mode
!= rtld_mode_help
)
1206 state
.mode
= rtld_mode_verify
;
1212 else if (! strcmp (_dl_argv
[1], "--inhibit-cache"))
1214 GLRO(dl_inhibit_cache
) = 1;
1219 else if (! strcmp (_dl_argv
[1], "--library-path")
1222 state
.library_path
= _dl_argv
[2];
1223 state
.library_path_source
= "--library-path";
1229 else if (! strcmp (_dl_argv
[1], "--inhibit-rpath")
1232 GLRO(dl_inhibit_rpath
) = _dl_argv
[2];
1238 else if (! strcmp (_dl_argv
[1], "--audit") && _dl_argc
> 2)
1240 audit_list_add_string (&state
.audit_list
, _dl_argv
[2]);
1246 else if (! strcmp (_dl_argv
[1], "--preload") && _dl_argc
> 2)
1248 state
.preloadarg
= _dl_argv
[2];
1253 else if (! strcmp (_dl_argv
[1], "--argv0") && _dl_argc
> 2)
1255 argv0
= _dl_argv
[2];
1261 else if (strcmp (_dl_argv
[1], "--glibc-hwcaps-prepend") == 0
1264 state
.glibc_hwcaps_prepend
= _dl_argv
[2];
1269 else if (strcmp (_dl_argv
[1], "--glibc-hwcaps-mask") == 0
1272 state
.glibc_hwcaps_mask
= _dl_argv
[2];
1278 else if (! strcmp (_dl_argv
[1], "--list-tunables"))
1280 state
.mode
= rtld_mode_list_tunables
;
1287 else if (! strcmp (_dl_argv
[1], "--list-diagnostics"))
1289 state
.mode
= rtld_mode_list_diagnostics
;
1295 else if (strcmp (_dl_argv
[1], "--help") == 0)
1297 state
.mode
= rtld_mode_help
;
1301 else if (strcmp (_dl_argv
[1], "--version") == 0)
1303 else if (_dl_argv
[1][0] == '-' && _dl_argv
[1][1] == '-')
1305 if (_dl_argv
[1][1] == '\0')
1306 /* End of option list. */
1309 /* Unrecognized option. */
1310 _dl_usage (ld_so_name
, _dl_argv
[1]);
1316 if (__glibc_unlikely (state
.mode
== rtld_mode_list_tunables
))
1318 __tunables_print ();
1323 if (state
.mode
== rtld_mode_list_diagnostics
)
1324 _dl_print_diagnostics (_environ
);
1326 /* If we have no further argument the program was called incorrectly.
1327 Grant the user some education. */
1330 if (state
.mode
== rtld_mode_help
)
1331 /* --help without an executable is not an error. */
1332 _dl_help (ld_so_name
, &state
);
1334 _dl_usage (ld_so_name
, NULL
);
1341 /* The initialization of _dl_stack_flags done below assumes the
1342 executable's PT_GNU_STACK may have been honored by the kernel, and
1343 so a PT_GNU_STACK with PF_X set means the stack started out with
1344 execute permission. However, this is not really true if the
1345 dynamic linker is the executable the kernel loaded. For this
1346 case, we must reinitialize _dl_stack_flags to match the dynamic
1347 linker itself. If the dynamic linker was built with a
1348 PT_GNU_STACK, then the kernel may have loaded us with a
1349 nonexecutable stack that we will have to make executable when we
1350 load the program below unless it has a PT_GNU_STACK indicating
1351 nonexecutable stack is ok. */
1353 for (ph
= phdr
; ph
< &phdr
[phnum
]; ++ph
)
1354 if (ph
->p_type
== PT_GNU_STACK
)
1356 GL(dl_stack_flags
) = ph
->p_flags
;
1360 if (__glibc_unlikely (state
.mode
== rtld_mode_verify
1361 || state
.mode
== rtld_mode_help
))
1363 const char *objname
;
1364 const char *err_str
= NULL
;
1365 struct map_args args
;
1368 args
.str
= rtld_progname
;
1370 args
.mode
= __RTLD_OPENEXEC
;
1371 (void) _dl_catch_error (&objname
, &err_str
, &malloced
, map_doit
,
1373 if (__glibc_unlikely (err_str
!= NULL
))
1375 /* We don't free the returned string, the programs stops
1377 if (state
.mode
== rtld_mode_help
)
1378 /* Mask the failure to load the main object. The help
1379 message contains less information in this case. */
1380 _dl_help (ld_so_name
, &state
);
1382 _exit (EXIT_FAILURE
);
1387 RTLD_TIMING_VAR (start
);
1388 rtld_timer_start (&start
);
1389 _dl_map_object (NULL
, rtld_progname
, lt_executable
, 0,
1390 __RTLD_OPENEXEC
, LM_ID_BASE
);
1391 rtld_timer_stop (&load_time
, start
);
1394 /* Now the map for the main executable is available. */
1395 main_map
= GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
;
1397 if (__glibc_likely (state
.mode
== rtld_mode_normal
)
1398 && GL(dl_rtld_map
).l_info
[DT_SONAME
] != NULL
1399 && main_map
->l_info
[DT_SONAME
] != NULL
1400 && strcmp ((const char *) D_PTR (&GL(dl_rtld_map
), l_info
[DT_STRTAB
])
1401 + GL(dl_rtld_map
).l_info
[DT_SONAME
]->d_un
.d_val
,
1402 (const char *) D_PTR (main_map
, l_info
[DT_STRTAB
])
1403 + main_map
->l_info
[DT_SONAME
]->d_un
.d_val
) == 0)
1404 _dl_fatal_printf ("loader cannot load itself\n");
1406 phdr
= main_map
->l_phdr
;
1407 phnum
= main_map
->l_phnum
;
1408 /* We overwrite here a pointer to a malloc()ed string. But since
1409 the malloc() implementation used at this point is the dummy
1410 implementations which has no real free() function it does not
1411 makes sense to free the old string first. */
1412 main_map
->l_name
= (char *) "";
1413 *user_entry
= main_map
->l_entry
;
1415 #ifdef HAVE_AUX_VECTOR
1416 /* Adjust the on-stack auxiliary vector so that it looks like the
1417 binary was executed directly. */
1418 for (ElfW(auxv_t
) *av
= auxv
; av
->a_type
!= AT_NULL
; av
++)
1422 av
->a_un
.a_val
= (uintptr_t) phdr
;
1425 av
->a_un
.a_val
= phnum
;
1428 av
->a_un
.a_val
= *user_entry
;
1431 av
->a_un
.a_val
= (uintptr_t) _dl_argv
[0];
1436 /* Set the argv[0] string now that we've processed the executable. */
1438 _dl_argv
[0] = argv0
;
1442 /* Create a link_map for the executable itself.
1443 This will be what dlopen on "" returns. */
1444 main_map
= _dl_new_object ((char *) "", "", lt_executable
, NULL
,
1445 __RTLD_OPENEXEC
, LM_ID_BASE
);
1446 assert (main_map
!= NULL
);
1447 main_map
->l_phdr
= phdr
;
1448 main_map
->l_phnum
= phnum
;
1449 main_map
->l_entry
= *user_entry
;
1451 /* Even though the link map is not yet fully initialized we can add
1452 it to the map list since there are no possible users running yet. */
1453 _dl_add_to_namespace_list (main_map
, LM_ID_BASE
);
1454 assert (main_map
== GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
);
1456 /* At this point we are in a bit of trouble. We would have to
1457 fill in the values for l_dev and l_ino. But in general we
1458 do not know where the file is. We also do not handle AT_EXECFD
1459 even if it would be passed up.
1461 We leave the values here defined to 0. This is normally no
1462 problem as the program code itself is normally no shared
1463 object and therefore cannot be loaded dynamically. Nothing
1464 prevent the use of dynamic binaries and in these situations
1465 we might get problems. We might not be able to find out
1466 whether the object is already loaded. But since there is no
1467 easy way out and because the dynamic binary must also not
1468 have an SONAME we ignore this program for now. If it becomes
1469 a problem we can force people using SONAMEs. */
1471 /* We delay initializing the path structure until we got the dynamic
1472 information for the program. */
1475 main_map
->l_map_end
= 0;
1476 main_map
->l_text_end
= 0;
1477 /* Perhaps the executable has no PT_LOAD header entries at all. */
1478 main_map
->l_map_start
= ~0;
1479 /* And it was opened directly. */
1480 ++main_map
->l_direct_opencount
;
1482 /* Scan the program header table for the dynamic section. */
1483 for (ph
= phdr
; ph
< &phdr
[phnum
]; ++ph
)
1487 /* Find out the load address. */
1488 main_map
->l_addr
= (ElfW(Addr
)) phdr
- ph
->p_vaddr
;
1491 /* This tells us where to find the dynamic section,
1492 which tells us everything we need to do. */
1493 main_map
->l_ld
= (void *) main_map
->l_addr
+ ph
->p_vaddr
;
1496 /* This "interpreter segment" was used by the program loader to
1497 find the program interpreter, which is this program itself, the
1498 dynamic linker. We note what name finds us, so that a future
1499 dlopen call or DT_NEEDED entry, for something that wants to link
1500 against the dynamic linker as a shared library, will know that
1501 the shared object is already loaded. */
1502 _dl_rtld_libname
.name
= ((const char *) main_map
->l_addr
1504 /* _dl_rtld_libname.next = NULL; Already zero. */
1505 GL(dl_rtld_map
).l_libname
= &_dl_rtld_libname
;
1507 /* Ordinarilly, we would get additional names for the loader from
1508 our DT_SONAME. This can't happen if we were actually linked as
1509 a static executable (detect this case when we have no DYNAMIC).
1510 If so, assume the filename component of the interpreter path to
1511 be our SONAME, and add it to our name list. */
1512 if (GL(dl_rtld_map
).l_ld
== NULL
)
1514 const char *p
= NULL
;
1515 const char *cp
= _dl_rtld_libname
.name
;
1517 /* Find the filename part of the path. */
1524 _dl_rtld_libname2
.name
= p
;
1525 /* _dl_rtld_libname2.next = NULL; Already zero. */
1526 _dl_rtld_libname
.next
= &_dl_rtld_libname2
;
1534 ElfW(Addr
) mapstart
;
1535 ElfW(Addr
) allocend
;
1537 /* Remember where the main program starts in memory. */
1538 mapstart
= (main_map
->l_addr
1539 + (ph
->p_vaddr
& ~(GLRO(dl_pagesize
) - 1)));
1540 if (main_map
->l_map_start
> mapstart
)
1541 main_map
->l_map_start
= mapstart
;
1543 /* Also where it ends. */
1544 allocend
= main_map
->l_addr
+ ph
->p_vaddr
+ ph
->p_memsz
;
1545 if (main_map
->l_map_end
< allocend
)
1546 main_map
->l_map_end
= allocend
;
1547 if ((ph
->p_flags
& PF_X
) && allocend
> main_map
->l_text_end
)
1548 main_map
->l_text_end
= allocend
;
1553 if (ph
->p_memsz
> 0)
1555 /* Note that in the case the dynamic linker we duplicate work
1556 here since we read the PT_TLS entry already in
1557 _dl_start_final. But the result is repeatable so do not
1558 check for this special but unimportant case. */
1559 main_map
->l_tls_blocksize
= ph
->p_memsz
;
1560 main_map
->l_tls_align
= ph
->p_align
;
1561 if (ph
->p_align
== 0)
1562 main_map
->l_tls_firstbyte_offset
= 0;
1564 main_map
->l_tls_firstbyte_offset
= (ph
->p_vaddr
1565 & (ph
->p_align
- 1));
1566 main_map
->l_tls_initimage_size
= ph
->p_filesz
;
1567 main_map
->l_tls_initimage
= (void *) ph
->p_vaddr
;
1569 /* This image gets the ID one. */
1570 GL(dl_tls_max_dtv_idx
) = main_map
->l_tls_modid
= 1;
1575 GL(dl_stack_flags
) = ph
->p_flags
;
1579 main_map
->l_relro_addr
= ph
->p_vaddr
;
1580 main_map
->l_relro_size
= ph
->p_memsz
;
1583 /* Process program headers again, but scan them backwards so
1584 that PT_NOTE can be skipped if PT_GNU_PROPERTY exits. */
1585 for (ph
= &phdr
[phnum
]; ph
!= phdr
; --ph
)
1586 switch (ph
[-1].p_type
)
1589 _dl_process_pt_note (main_map
, -1, &ph
[-1]);
1591 case PT_GNU_PROPERTY
:
1592 _dl_process_pt_gnu_property (main_map
, -1, &ph
[-1]);
1596 /* Adjust the address of the TLS initialization image in case
1597 the executable is actually an ET_DYN object. */
1598 if (main_map
->l_tls_initimage
!= NULL
)
1599 main_map
->l_tls_initimage
1600 = (char *) main_map
->l_tls_initimage
+ main_map
->l_addr
;
1601 if (! main_map
->l_map_end
)
1602 main_map
->l_map_end
= ~0;
1603 if (! main_map
->l_text_end
)
1604 main_map
->l_text_end
= ~0;
1605 if (! GL(dl_rtld_map
).l_libname
&& GL(dl_rtld_map
).l_name
)
1607 /* We were invoked directly, so the program might not have a
1609 _dl_rtld_libname
.name
= GL(dl_rtld_map
).l_name
;
1610 /* _dl_rtld_libname.next = NULL; Already zero. */
1611 GL(dl_rtld_map
).l_libname
= &_dl_rtld_libname
;
1614 assert (GL(dl_rtld_map
).l_libname
); /* How else did we get here? */
1616 /* If the current libname is different from the SONAME, add the
1618 if (GL(dl_rtld_map
).l_info
[DT_SONAME
] != NULL
1619 && strcmp (GL(dl_rtld_map
).l_libname
->name
,
1620 (const char *) D_PTR (&GL(dl_rtld_map
), l_info
[DT_STRTAB
])
1621 + GL(dl_rtld_map
).l_info
[DT_SONAME
]->d_un
.d_val
) != 0)
1623 static struct libname_list newname
;
1624 newname
.name
= ((char *) D_PTR (&GL(dl_rtld_map
), l_info
[DT_STRTAB
])
1625 + GL(dl_rtld_map
).l_info
[DT_SONAME
]->d_un
.d_ptr
);
1626 newname
.next
= NULL
;
1627 newname
.dont_free
= 1;
1629 assert (GL(dl_rtld_map
).l_libname
->next
== NULL
);
1630 GL(dl_rtld_map
).l_libname
->next
= &newname
;
1632 /* The ld.so must be relocated since otherwise loading audit modules
1633 will fail since they reuse the very same ld.so. */
1634 assert (GL(dl_rtld_map
).l_relocated
);
1638 /* Extract the contents of the dynamic section for easy access. */
1639 elf_get_dynamic_info (main_map
, NULL
);
1641 /* If the main map is libc.so, update the base namespace to
1642 refer to this map. If libc.so is loaded later, this happens
1643 in _dl_map_object_from_fd. */
1644 if (main_map
->l_info
[DT_SONAME
] != NULL
1645 && (strcmp (((const char *) D_PTR (main_map
, l_info
[DT_STRTAB
])
1646 + main_map
->l_info
[DT_SONAME
]->d_un
.d_val
), LIBC_SO
)
1648 GL(dl_ns
)[LM_ID_BASE
].libc_map
= main_map
;
1650 /* Set up our cache of pointers into the hash table. */
1651 _dl_setup_hash (main_map
);
1654 if (__glibc_unlikely (state
.mode
== rtld_mode_verify
))
1656 /* We were called just to verify that this is a dynamic
1657 executable using us as the program interpreter. Exit with an
1658 error if we were not able to load the binary or no interpreter
1659 is specified (i.e., this is no dynamically linked binary. */
1660 if (main_map
->l_ld
== NULL
)
1663 /* We allow here some platform specific code. */
1664 #ifdef DISTINGUISH_LIB_VERSIONS
1665 DISTINGUISH_LIB_VERSIONS
;
1667 _exit (has_interp
? 0 : 2);
1670 struct link_map
**first_preload
= &GL(dl_rtld_map
).l_next
;
1671 /* Set up the data structures for the system-supplied DSO early,
1672 so they can influence _dl_init_paths. */
1673 setup_vdso (main_map
, &first_preload
);
1675 /* With vDSO setup we can initialize the function pointers. */
1676 setup_vdso_pointers ();
1678 #ifdef DL_SYSDEP_OSCHECK
1679 DL_SYSDEP_OSCHECK (_dl_fatal_printf
);
1682 /* Initialize the data structures for the search paths for shared
1684 call_init_paths (&state
);
1686 /* Initialize _r_debug. */
1687 struct r_debug
*r
= _dl_debug_initialize (GL(dl_rtld_map
).l_addr
,
1689 r
->r_state
= RT_CONSISTENT
;
1691 /* Put the link_map for ourselves on the chain so it can be found by
1692 name. Note that at this point the global chain of link maps contains
1693 exactly one element, which is pointed to by dl_loaded. */
1694 if (! GL(dl_rtld_map
).l_name
)
1695 /* If not invoked directly, the dynamic linker shared object file was
1696 found by the PT_INTERP name. */
1697 GL(dl_rtld_map
).l_name
= (char *) GL(dl_rtld_map
).l_libname
->name
;
1698 GL(dl_rtld_map
).l_type
= lt_library
;
1699 main_map
->l_next
= &GL(dl_rtld_map
);
1700 GL(dl_rtld_map
).l_prev
= main_map
;
1701 ++GL(dl_ns
)[LM_ID_BASE
]._ns_nloaded
;
1704 /* If LD_USE_LOAD_BIAS env variable has not been seen, default
1705 to not using bias for non-prelinked PIEs and libraries
1706 and using it for executables or prelinked PIEs or libraries. */
1707 if (GLRO(dl_use_load_bias
) == (ElfW(Addr
)) -2)
1708 GLRO(dl_use_load_bias
) = main_map
->l_addr
== 0 ? -1 : 0;
1710 /* Set up the program header information for the dynamic linker
1711 itself. It is needed in the dl_iterate_phdr callbacks. */
1712 const ElfW(Ehdr
) *rtld_ehdr
;
1714 /* Starting from binutils-2.23, the linker will define the magic symbol
1715 __ehdr_start to point to our own ELF header if it is visible in a
1716 segment that also includes the phdrs. If that's not available, we use
1717 the old method that assumes the beginning of the file is part of the
1718 lowest-addressed PT_LOAD segment. */
1719 #ifdef HAVE_EHDR_START
1720 extern const ElfW(Ehdr
) __ehdr_start
__attribute__ ((visibility ("hidden")));
1721 rtld_ehdr
= &__ehdr_start
;
1723 rtld_ehdr
= (void *) GL(dl_rtld_map
).l_map_start
;
1725 assert (rtld_ehdr
->e_ehsize
== sizeof *rtld_ehdr
);
1726 assert (rtld_ehdr
->e_phentsize
== sizeof (ElfW(Phdr
)));
1728 const ElfW(Phdr
) *rtld_phdr
= (const void *) rtld_ehdr
+ rtld_ehdr
->e_phoff
;
1730 GL(dl_rtld_map
).l_phdr
= rtld_phdr
;
1731 GL(dl_rtld_map
).l_phnum
= rtld_ehdr
->e_phnum
;
1734 /* PT_GNU_RELRO is usually the last phdr. */
1735 size_t cnt
= rtld_ehdr
->e_phnum
;
1737 if (rtld_phdr
[cnt
].p_type
== PT_GNU_RELRO
)
1739 GL(dl_rtld_map
).l_relro_addr
= rtld_phdr
[cnt
].p_vaddr
;
1740 GL(dl_rtld_map
).l_relro_size
= rtld_phdr
[cnt
].p_memsz
;
1744 /* Add the dynamic linker to the TLS list if it also uses TLS. */
1745 if (GL(dl_rtld_map
).l_tls_blocksize
!= 0)
1746 /* Assign a module ID. Do this before loading any audit modules. */
1747 GL(dl_rtld_map
).l_tls_modid
= _dl_next_tls_modid ();
1749 audit_list_add_dynamic_tag (&state
.audit_list
, main_map
, DT_AUDIT
);
1750 audit_list_add_dynamic_tag (&state
.audit_list
, main_map
, DT_DEPAUDIT
);
1752 /* At this point, all data has been obtained that is included in the
1754 if (__glibc_unlikely (state
.mode
== rtld_mode_help
))
1755 _dl_help (ld_so_name
, &state
);
1757 /* If we have auditing DSOs to load, do it now. */
1758 bool need_security_init
= true;
1759 if (state
.audit_list
.length
> 0)
1761 size_t naudit
= audit_list_count (&state
.audit_list
);
1763 /* Since we start using the auditing DSOs right away we need to
1764 initialize the data structures now. */
1765 tcbp
= init_tls (naudit
);
1767 /* Initialize security features. We need to do it this early
1768 since otherwise the constructors of the audit libraries will
1769 use different values (especially the pointer guard) and will
1772 need_security_init
= false;
1774 load_audit_modules (main_map
, &state
.audit_list
);
1776 /* The count based on audit strings may overestimate the number
1777 of audit modules that got loaded, but not underestimate. */
1778 assert (GLRO(dl_naudit
) <= naudit
);
1781 /* Keep track of the currently loaded modules to count how many
1782 non-audit modules which use TLS are loaded. */
1783 size_t count_modids
= _dl_count_modids ();
1785 /* Set up debugging before the debugger is notified for the first time. */
1786 #ifdef ELF_MACHINE_DEBUG_SETUP
1787 /* Some machines (e.g. MIPS) don't use DT_DEBUG in this way. */
1788 ELF_MACHINE_DEBUG_SETUP (main_map
, r
);
1789 ELF_MACHINE_DEBUG_SETUP (&GL(dl_rtld_map
), r
);
1791 if (main_map
->l_info
[DT_DEBUG
] != NULL
)
1792 /* There is a DT_DEBUG entry in the dynamic section. Fill it in
1793 with the run-time address of the r_debug structure */
1794 main_map
->l_info
[DT_DEBUG
]->d_un
.d_ptr
= (ElfW(Addr
)) r
;
1796 /* Fill in the pointer in the dynamic linker's own dynamic section, in
1797 case you run gdb on the dynamic linker directly. */
1798 if (GL(dl_rtld_map
).l_info
[DT_DEBUG
] != NULL
)
1799 GL(dl_rtld_map
).l_info
[DT_DEBUG
]->d_un
.d_ptr
= (ElfW(Addr
)) r
;
1802 /* We start adding objects. */
1803 r
->r_state
= RT_ADD
;
1805 LIBC_PROBE (init_start
, 2, LM_ID_BASE
, r
);
1807 /* Auditing checkpoint: we are ready to signal that the initial map
1808 is being constructed. */
1809 if (__glibc_unlikely (GLRO(dl_naudit
) > 0))
1811 struct audit_ifaces
*afct
= GLRO(dl_audit
);
1812 for (unsigned int cnt
= 0; cnt
< GLRO(dl_naudit
); ++cnt
)
1814 if (afct
->activity
!= NULL
)
1815 afct
->activity (&link_map_audit_state (main_map
, cnt
)->cookie
,
1822 /* We have two ways to specify objects to preload: via environment
1823 variable and via the file /etc/ld.so.preload. The latter can also
1824 be used when security is enabled. */
1825 assert (*first_preload
== NULL
);
1826 struct link_map
**preloads
= NULL
;
1827 unsigned int npreloads
= 0;
1829 if (__glibc_unlikely (state
.preloadlist
!= NULL
))
1831 RTLD_TIMING_VAR (start
);
1832 rtld_timer_start (&start
);
1833 npreloads
+= handle_preload_list (state
.preloadlist
, main_map
,
1835 rtld_timer_accum (&load_time
, start
);
1838 if (__glibc_unlikely (state
.preloadarg
!= NULL
))
1840 RTLD_TIMING_VAR (start
);
1841 rtld_timer_start (&start
);
1842 npreloads
+= handle_preload_list (state
.preloadarg
, main_map
,
1844 rtld_timer_accum (&load_time
, start
);
1847 /* There usually is no ld.so.preload file, it should only be used
1848 for emergencies and testing. So the open call etc should usually
1849 fail. Using access() on a non-existing file is faster than using
1850 open(). So we do this first. If it succeeds we do almost twice
1851 the work but this does not matter, since it is not for production
1853 static const char preload_file
[] = "/etc/ld.so.preload";
1854 if (__glibc_unlikely (__access (preload_file
, R_OK
) == 0))
1856 /* Read the contents of the file. */
1857 file
= _dl_sysdep_read_whole_file (preload_file
, &file_size
,
1858 PROT_READ
| PROT_WRITE
);
1859 if (__glibc_unlikely (file
!= MAP_FAILED
))
1861 /* Parse the file. It contains names of libraries to be loaded,
1862 separated by white spaces or `:'. It may also contain
1863 comments introduced by `#'. */
1868 /* Eliminate comments. */
1873 char *comment
= memchr (runp
, '#', rest
);
1874 if (comment
== NULL
)
1877 rest
-= comment
- runp
;
1880 while (--rest
> 0 && *++comment
!= '\n');
1883 /* We have one problematic case: if we have a name at the end of
1884 the file without a trailing terminating characters, we cannot
1885 place the \0. Handle the case separately. */
1886 if (file
[file_size
- 1] != ' ' && file
[file_size
- 1] != '\t'
1887 && file
[file_size
- 1] != '\n' && file
[file_size
- 1] != ':')
1889 problem
= &file
[file_size
];
1890 while (problem
> file
&& problem
[-1] != ' '
1891 && problem
[-1] != '\t'
1892 && problem
[-1] != '\n' && problem
[-1] != ':')
1901 file
[file_size
- 1] = '\0';
1904 RTLD_TIMING_VAR (start
);
1905 rtld_timer_start (&start
);
1907 if (file
!= problem
)
1911 while ((p
= strsep (&runp
, ": \t\n")) != NULL
)
1913 npreloads
+= do_preload (p
, main_map
, preload_file
);
1916 if (problem
!= NULL
)
1918 char *p
= strndupa (problem
, file_size
- (problem
- file
));
1920 npreloads
+= do_preload (p
, main_map
, preload_file
);
1923 rtld_timer_accum (&load_time
, start
);
1925 /* We don't need the file anymore. */
1926 __munmap (file
, file_size
);
1930 if (__glibc_unlikely (*first_preload
!= NULL
))
1932 /* Set up PRELOADS with a vector of the preloaded libraries. */
1933 struct link_map
*l
= *first_preload
;
1934 preloads
= __alloca (npreloads
* sizeof preloads
[0]);
1941 assert (i
== npreloads
);
1944 /* Load all the libraries specified by DT_NEEDED entries. If LD_PRELOAD
1945 specified some libraries to load, these are inserted before the actual
1946 dependencies in the executable's searchlist for symbol resolution. */
1948 RTLD_TIMING_VAR (start
);
1949 rtld_timer_start (&start
);
1950 _dl_map_object_deps (main_map
, preloads
, npreloads
,
1951 state
.mode
== rtld_mode_trace
, 0);
1952 rtld_timer_accum (&load_time
, start
);
1955 /* Mark all objects as being in the global scope. */
1956 for (i
= main_map
->l_searchlist
.r_nlist
; i
> 0; )
1957 main_map
->l_searchlist
.r_list
[--i
]->l_global
= 1;
1959 /* Remove _dl_rtld_map from the chain. */
1960 GL(dl_rtld_map
).l_prev
->l_next
= GL(dl_rtld_map
).l_next
;
1961 if (GL(dl_rtld_map
).l_next
!= NULL
)
1962 GL(dl_rtld_map
).l_next
->l_prev
= GL(dl_rtld_map
).l_prev
;
1964 for (i
= 1; i
< main_map
->l_searchlist
.r_nlist
; ++i
)
1965 if (main_map
->l_searchlist
.r_list
[i
] == &GL(dl_rtld_map
))
1968 bool rtld_multiple_ref
= false;
1969 if (__glibc_likely (i
< main_map
->l_searchlist
.r_nlist
))
1971 /* Some DT_NEEDED entry referred to the interpreter object itself, so
1972 put it back in the list of visible objects. We insert it into the
1973 chain in symbol search order because gdb uses the chain's order as
1974 its symbol search order. */
1975 rtld_multiple_ref
= true;
1977 GL(dl_rtld_map
).l_prev
= main_map
->l_searchlist
.r_list
[i
- 1];
1978 if (__glibc_likely (state
.mode
== rtld_mode_normal
))
1980 GL(dl_rtld_map
).l_next
= (i
+ 1 < main_map
->l_searchlist
.r_nlist
1981 ? main_map
->l_searchlist
.r_list
[i
+ 1]
1983 #ifdef NEED_DL_SYSINFO_DSO
1984 if (GLRO(dl_sysinfo_map
) != NULL
1985 && GL(dl_rtld_map
).l_prev
->l_next
== GLRO(dl_sysinfo_map
)
1986 && GL(dl_rtld_map
).l_next
!= GLRO(dl_sysinfo_map
))
1987 GL(dl_rtld_map
).l_prev
= GLRO(dl_sysinfo_map
);
1991 /* In trace mode there might be an invisible object (which we
1992 could not find) after the previous one in the search list.
1993 In this case it doesn't matter much where we put the
1994 interpreter object, so we just initialize the list pointer so
1995 that the assertion below holds. */
1996 GL(dl_rtld_map
).l_next
= GL(dl_rtld_map
).l_prev
->l_next
;
1998 assert (GL(dl_rtld_map
).l_prev
->l_next
== GL(dl_rtld_map
).l_next
);
1999 GL(dl_rtld_map
).l_prev
->l_next
= &GL(dl_rtld_map
);
2000 if (GL(dl_rtld_map
).l_next
!= NULL
)
2002 assert (GL(dl_rtld_map
).l_next
->l_prev
== GL(dl_rtld_map
).l_prev
);
2003 GL(dl_rtld_map
).l_next
->l_prev
= &GL(dl_rtld_map
);
2007 /* Now let us see whether all libraries are available in the
2008 versions we need. */
2010 struct version_check_args args
;
2011 args
.doexit
= state
.mode
== rtld_mode_normal
;
2012 args
.dotrace
= state
.mode
== rtld_mode_trace
;
2013 _dl_receive_error (print_missing_version
, version_check_doit
, &args
);
2016 /* We do not initialize any of the TLS functionality unless any of the
2017 initial modules uses TLS. This makes dynamic loading of modules with
2018 TLS impossible, but to support it requires either eagerly doing setup
2019 now or lazily doing it later. Doing it now makes us incompatible with
2020 an old kernel that can't perform TLS_INIT_TP, even if no TLS is ever
2021 used. Trying to do it lazily is too hairy to try when there could be
2022 multiple threads (from a non-TLS-using libpthread). */
2023 bool was_tls_init_tp_called
= tls_init_tp_called
;
2025 tcbp
= init_tls (0);
2027 if (__glibc_likely (need_security_init
))
2028 /* Initialize security features. But only if we have not done it
2032 if (__glibc_unlikely (state
.mode
!= rtld_mode_normal
))
2034 /* We were run just to list the shared libraries. It is
2035 important that we do this before real relocation, because the
2036 functions we call below for output may no longer work properly
2037 after relocation. */
2040 if (GLRO(dl_debug_mask
) & DL_DEBUG_PRELINK
)
2042 struct r_scope_elem
*scope
= &main_map
->l_searchlist
;
2044 for (i
= 0; i
< scope
->r_nlist
; i
++)
2046 l
= scope
->r_list
[i
];
2049 _dl_printf ("\t%s => not found\n", l
->l_libname
->name
);
2052 if (_dl_name_match_p (GLRO(dl_trace_prelink
), l
))
2053 GLRO(dl_trace_prelink_map
) = l
;
2054 _dl_printf ("\t%s => %s (0x%0*Zx, 0x%0*Zx)",
2055 DSO_FILENAME (l
->l_libname
->name
),
2056 DSO_FILENAME (l
->l_name
),
2057 (int) sizeof l
->l_map_start
* 2,
2058 (size_t) l
->l_map_start
,
2059 (int) sizeof l
->l_addr
* 2,
2060 (size_t) l
->l_addr
);
2063 _dl_printf (" TLS(0x%Zx, 0x%0*Zx)\n", l
->l_tls_modid
,
2064 (int) sizeof l
->l_tls_offset
* 2,
2065 (size_t) l
->l_tls_offset
);
2070 else if (GLRO(dl_debug_mask
) & DL_DEBUG_UNUSED
)
2072 /* Look through the dependencies of the main executable
2073 and determine which of them is not actually
2075 struct link_map
*l
= main_map
;
2077 /* Relocate the main executable. */
2078 struct relocate_args args
= { .l
= l
,
2079 .reloc_mode
= ((GLRO(dl_lazy
)
2081 | __RTLD_NOIFUNC
) };
2082 _dl_receive_error (print_unresolved
, relocate_doit
, &args
);
2084 /* This loop depends on the dependencies of the executable to
2085 correspond in number and order to the DT_NEEDED entries. */
2086 ElfW(Dyn
) *dyn
= main_map
->l_ld
;
2088 while (dyn
->d_tag
!= DT_NULL
)
2090 if (dyn
->d_tag
== DT_NEEDED
)
2093 #ifdef NEED_DL_SYSINFO_DSO
2094 /* Skip the VDSO since it's not part of the list
2095 of objects we brought in via DT_NEEDED entries. */
2096 if (l
== GLRO(dl_sysinfo_map
))
2103 _dl_printf ("Unused direct dependencies:\n");
2107 _dl_printf ("\t%s\n", l
->l_name
);
2114 _exit (first
!= true);
2116 else if (! main_map
->l_info
[DT_NEEDED
])
2117 _dl_printf ("\tstatically linked\n");
2120 for (l
= main_map
->l_next
; l
; l
= l
->l_next
)
2122 /* The library was not found. */
2123 _dl_printf ("\t%s => not found\n", l
->l_libname
->name
);
2124 else if (strcmp (l
->l_libname
->name
, l
->l_name
) == 0)
2125 _dl_printf ("\t%s (0x%0*Zx)\n", l
->l_libname
->name
,
2126 (int) sizeof l
->l_map_start
* 2,
2127 (size_t) l
->l_map_start
);
2129 _dl_printf ("\t%s => %s (0x%0*Zx)\n", l
->l_libname
->name
,
2130 l
->l_name
, (int) sizeof l
->l_map_start
* 2,
2131 (size_t) l
->l_map_start
);
2134 if (__glibc_unlikely (state
.mode
!= rtld_mode_trace
))
2135 for (i
= 1; i
< (unsigned int) _dl_argc
; ++i
)
2137 const ElfW(Sym
) *ref
= NULL
;
2138 ElfW(Addr
) loadbase
;
2141 result
= _dl_lookup_symbol_x (_dl_argv
[i
], main_map
,
2142 &ref
, main_map
->l_scope
,
2143 NULL
, ELF_RTYPE_CLASS_PLT
,
2144 DL_LOOKUP_ADD_DEPENDENCY
, NULL
);
2146 loadbase
= LOOKUP_VALUE_ADDRESS (result
, false);
2148 _dl_printf ("%s found at 0x%0*Zd in object at 0x%0*Zd\n",
2150 (int) sizeof ref
->st_value
* 2,
2151 (size_t) ref
->st_value
,
2152 (int) sizeof loadbase
* 2, (size_t) loadbase
);
2156 /* If LD_WARN is set, warn about undefined symbols. */
2157 if (GLRO(dl_lazy
) >= 0 && GLRO(dl_verbose
))
2159 /* We have to do symbol dependency testing. */
2160 struct relocate_args args
;
2163 args
.reloc_mode
= ((GLRO(dl_lazy
) ? RTLD_LAZY
: 0)
2166 i
= main_map
->l_searchlist
.r_nlist
;
2169 struct link_map
*l
= main_map
->l_initfini
[i
];
2170 if (l
!= &GL(dl_rtld_map
) && ! l
->l_faked
)
2173 _dl_receive_error (print_unresolved
, relocate_doit
,
2178 if ((GLRO(dl_debug_mask
) & DL_DEBUG_PRELINK
)
2179 && rtld_multiple_ref
)
2181 /* Mark the link map as not yet relocated again. */
2182 GL(dl_rtld_map
).l_relocated
= 0;
2183 _dl_relocate_object (&GL(dl_rtld_map
),
2184 main_map
->l_scope
, __RTLD_NOIFUNC
, 0);
2187 #define VERNEEDTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERNEED))
2188 if (state
.version_info
)
2190 /* Print more information. This means here, print information
2191 about the versions needed. */
2193 struct link_map
*map
;
2195 for (map
= main_map
; map
!= NULL
; map
= map
->l_next
)
2198 ElfW(Dyn
) *dyn
= map
->l_info
[VERNEEDTAG
];
2204 strtab
= (const void *) D_PTR (map
, l_info
[DT_STRTAB
]);
2205 ent
= (ElfW(Verneed
) *) (map
->l_addr
+ dyn
->d_un
.d_ptr
);
2209 _dl_printf ("\n\tVersion information:\n");
2213 _dl_printf ("\t%s:\n", DSO_FILENAME (map
->l_name
));
2218 struct link_map
*needed
;
2220 needed
= find_needed (strtab
+ ent
->vn_file
);
2221 aux
= (ElfW(Vernaux
) *) ((char *) ent
+ ent
->vn_aux
);
2225 const char *fname
= NULL
;
2228 && match_version (strtab
+ aux
->vna_name
,
2230 fname
= needed
->l_name
;
2232 _dl_printf ("\t\t%s (%s) %s=> %s\n",
2233 strtab
+ ent
->vn_file
,
2234 strtab
+ aux
->vna_name
,
2235 aux
->vna_flags
& VER_FLG_WEAK
2237 fname
?: "not found");
2239 if (aux
->vna_next
== 0)
2240 /* No more symbols. */
2244 aux
= (ElfW(Vernaux
) *) ((char *) aux
2248 if (ent
->vn_next
== 0)
2249 /* No more dependencies. */
2252 /* Next dependency. */
2253 ent
= (ElfW(Verneed
) *) ((char *) ent
+ ent
->vn_next
);
2262 if (main_map
->l_info
[ADDRIDX (DT_GNU_LIBLIST
)]
2263 && ! __builtin_expect (GLRO(dl_profile
) != NULL
, 0)
2264 && ! __builtin_expect (GLRO(dl_dynamic_weak
), 0))
2266 ElfW(Lib
) *liblist
, *liblistend
;
2267 struct link_map
**r_list
, **r_listend
, *l
;
2268 const char *strtab
= (const void *) D_PTR (main_map
, l_info
[DT_STRTAB
]);
2270 assert (main_map
->l_info
[VALIDX (DT_GNU_LIBLISTSZ
)] != NULL
);
2271 liblist
= (ElfW(Lib
) *)
2272 main_map
->l_info
[ADDRIDX (DT_GNU_LIBLIST
)]->d_un
.d_ptr
;
2273 liblistend
= (ElfW(Lib
) *)
2275 + main_map
->l_info
[VALIDX (DT_GNU_LIBLISTSZ
)]->d_un
.d_val
);
2276 r_list
= main_map
->l_searchlist
.r_list
;
2277 r_listend
= r_list
+ main_map
->l_searchlist
.r_nlist
;
2279 for (; r_list
< r_listend
&& liblist
< liblistend
; r_list
++)
2286 /* If the library is not mapped where it should, fail. */
2290 /* Next, check if checksum matches. */
2291 if (l
->l_info
[VALIDX(DT_CHECKSUM
)] == NULL
2292 || l
->l_info
[VALIDX(DT_CHECKSUM
)]->d_un
.d_val
2293 != liblist
->l_checksum
)
2296 if (l
->l_info
[VALIDX(DT_GNU_PRELINKED
)] == NULL
2297 || l
->l_info
[VALIDX(DT_GNU_PRELINKED
)]->d_un
.d_val
2298 != liblist
->l_time_stamp
)
2301 if (! _dl_name_match_p (strtab
+ liblist
->l_name
, l
))
2308 if (r_list
== r_listend
&& liblist
== liblistend
)
2311 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_LIBS
))
2312 _dl_debug_printf ("\nprelink checking: %s\n",
2313 prelinked
? "ok" : "failed");
2317 /* Now set up the variable which helps the assembler startup code. */
2318 GL(dl_ns
)[LM_ID_BASE
]._ns_main_searchlist
= &main_map
->l_searchlist
;
2320 /* Save the information about the original global scope list since
2321 we need it in the memory handling later. */
2322 GLRO(dl_initial_searchlist
) = *GL(dl_ns
)[LM_ID_BASE
]._ns_main_searchlist
;
2324 /* Remember the last search directory added at startup, now that
2325 malloc will no longer be the one from dl-minimal.c. As a side
2326 effect, this marks ld.so as initialized, so that the rtld_active
2327 function returns true from now on. */
2328 GLRO(dl_init_all_dirs
) = GL(dl_all_dirs
);
2330 /* Print scope information. */
2331 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_SCOPES
))
2333 _dl_debug_printf ("\nInitial object scopes\n");
2335 for (struct link_map
*l
= main_map
; l
!= NULL
; l
= l
->l_next
)
2336 _dl_show_scope (l
, 0);
2339 _rtld_main_check (main_map
, _dl_argv
[0]);
2343 if (main_map
->l_info
[ADDRIDX (DT_GNU_CONFLICT
)] != NULL
)
2345 ElfW(Rela
) *conflict
, *conflictend
;
2347 RTLD_TIMING_VAR (start
);
2348 rtld_timer_start (&start
);
2350 assert (main_map
->l_info
[VALIDX (DT_GNU_CONFLICTSZ
)] != NULL
);
2351 conflict
= (ElfW(Rela
) *)
2352 main_map
->l_info
[ADDRIDX (DT_GNU_CONFLICT
)]->d_un
.d_ptr
;
2353 conflictend
= (ElfW(Rela
) *)
2355 + main_map
->l_info
[VALIDX (DT_GNU_CONFLICTSZ
)]->d_un
.d_val
);
2356 _dl_resolve_conflicts (main_map
, conflict
, conflictend
);
2358 rtld_timer_stop (&relocate_time
, start
);
2361 /* The library defining malloc has already been relocated due to
2362 prelinking. Resolve the malloc symbols for the dynamic
2364 __rtld_malloc_init_real (main_map
);
2366 /* Mark all the objects so we know they have been already relocated. */
2367 for (struct link_map
*l
= main_map
; l
!= NULL
; l
= l
->l_next
)
2370 if (l
->l_relro_size
)
2371 _dl_protect_relro (l
);
2373 /* Add object to slot information data if necessasy. */
2374 if (l
->l_tls_blocksize
!= 0 && tls_init_tp_called
)
2375 _dl_add_to_slotinfo (l
, true);
2380 /* Now we have all the objects loaded. Relocate them all except for
2381 the dynamic linker itself. We do this in reverse order so that copy
2382 relocs of earlier objects overwrite the data written by later
2383 objects. We do not re-relocate the dynamic linker itself in this
2384 loop because that could result in the GOT entries for functions we
2385 call being changed, and that would break us. It is safe to relocate
2386 the dynamic linker out of order because it has no copy relocs (we
2387 know that because it is self-contained). */
2389 int consider_profiling
= GLRO(dl_profile
) != NULL
;
2391 /* If we are profiling we also must do lazy reloaction. */
2392 GLRO(dl_lazy
) |= consider_profiling
;
2394 RTLD_TIMING_VAR (start
);
2395 rtld_timer_start (&start
);
2396 unsigned i
= main_map
->l_searchlist
.r_nlist
;
2399 struct link_map
*l
= main_map
->l_initfini
[i
];
2401 /* While we are at it, help the memory handling a bit. We have to
2402 mark some data structures as allocated with the fake malloc()
2403 implementation in ld.so. */
2404 struct libname_list
*lnp
= l
->l_libname
->next
;
2406 while (__builtin_expect (lnp
!= NULL
, 0))
2411 /* Also allocated with the fake malloc(). */
2412 l
->l_free_initfini
= 0;
2414 if (l
!= &GL(dl_rtld_map
))
2415 _dl_relocate_object (l
, l
->l_scope
, GLRO(dl_lazy
) ? RTLD_LAZY
: 0,
2416 consider_profiling
);
2418 /* Add object to slot information data if necessasy. */
2419 if (l
->l_tls_blocksize
!= 0 && tls_init_tp_called
)
2420 _dl_add_to_slotinfo (l
, true);
2422 rtld_timer_stop (&relocate_time
, start
);
2424 /* Now enable profiling if needed. Like the previous call,
2425 this has to go here because the calls it makes should use the
2426 rtld versions of the functions (particularly calloc()), but it
2427 needs to have _dl_profile_map set up by the relocator. */
2428 if (__glibc_unlikely (GL(dl_profile_map
) != NULL
))
2429 /* We must prepare the profiling. */
2430 _dl_start_profile ();
2433 if ((!was_tls_init_tp_called
&& GL(dl_tls_max_dtv_idx
) > 0)
2434 || count_modids
!= _dl_count_modids ())
2435 ++GL(dl_tls_generation
);
2437 /* Now that we have completed relocation, the initializer data
2438 for the TLS blocks has its final values and we can copy them
2439 into the main thread's TLS area, which we allocated above.
2440 Note: thread-local variables must only be accessed after completing
2442 _dl_allocate_tls_init (tcbp
);
2444 /* And finally install it for the main thread. */
2445 if (! tls_init_tp_called
)
2447 const char *lossage
= TLS_INIT_TP (tcbp
);
2448 if (__glibc_unlikely (lossage
!= NULL
))
2449 _dl_fatal_printf ("cannot set up thread-local storage: %s\n",
2454 /* Make sure no new search directories have been added. */
2455 assert (GLRO(dl_init_all_dirs
) == GL(dl_all_dirs
));
2457 if (! prelinked
&& rtld_multiple_ref
)
2459 /* There was an explicit ref to the dynamic linker as a shared lib.
2460 Re-relocate ourselves with user-controlled symbol definitions.
2462 We must do this after TLS initialization in case after this
2463 re-relocation, we might call a user-supplied function
2464 (e.g. calloc from _dl_relocate_object) that uses TLS data. */
2466 /* The malloc implementation has been relocated, so resolving
2467 its symbols (and potentially calling IFUNC resolvers) is safe
2469 __rtld_malloc_init_real (main_map
);
2471 RTLD_TIMING_VAR (start
);
2472 rtld_timer_start (&start
);
2474 /* Mark the link map as not yet relocated again. */
2475 GL(dl_rtld_map
).l_relocated
= 0;
2476 _dl_relocate_object (&GL(dl_rtld_map
), main_map
->l_scope
, 0, 0);
2478 rtld_timer_accum (&relocate_time
, start
);
2481 /* Relocation is complete. Perform early libc initialization. This
2482 is the initial libc, even if audit modules have been loaded with
2484 _dl_call_libc_early_init (GL(dl_ns
)[LM_ID_BASE
].libc_map
, true);
2486 /* Do any necessary cleanups for the startup OS interface code.
2487 We do these now so that no calls are made after rtld re-relocation
2488 which might be resolved to different functions than we expect.
2489 We cannot do this before relocating the other objects because
2490 _dl_relocate_object might need to call `mprotect' for DT_TEXTREL. */
2491 _dl_sysdep_start_cleanup ();
2494 /* Auditing checkpoint: we have added all objects. */
2495 if (__glibc_unlikely (GLRO(dl_naudit
) > 0))
2497 struct link_map
*head
= GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
;
2498 /* Do not call the functions for any auditing object. */
2499 if (head
->l_auditing
== 0)
2501 struct audit_ifaces
*afct
= GLRO(dl_audit
);
2502 for (unsigned int cnt
= 0; cnt
< GLRO(dl_naudit
); ++cnt
)
2504 if (afct
->activity
!= NULL
)
2505 afct
->activity (&link_map_audit_state (head
, cnt
)->cookie
,
2514 /* Notify the debugger all new objects are now ready to go. We must re-get
2515 the address since by now the variable might be in another object. */
2516 r
= _dl_debug_initialize (0, LM_ID_BASE
);
2517 r
->r_state
= RT_CONSISTENT
;
2519 LIBC_PROBE (init_complete
, 2, LM_ID_BASE
, r
);
2521 #if defined USE_LDCONFIG && !defined MAP_COPY
2522 /* We must munmap() the cache file. */
2523 _dl_unload_cache ();
2526 /* Once we return, _dl_sysdep_start will invoke
2527 the DT_INIT functions and then *USER_ENTRY. */
2530 /* This is a little helper function for resolving symbols while
2531 tracing the binary. */
2533 print_unresolved (int errcode
__attribute__ ((unused
)), const char *objname
,
2534 const char *errstring
)
2536 if (objname
[0] == '\0')
2537 objname
= RTLD_PROGNAME
;
2538 _dl_error_printf ("%s (%s)\n", errstring
, objname
);
2541 /* This is a little helper function for resolving symbols while
2542 tracing the binary. */
2544 print_missing_version (int errcode
__attribute__ ((unused
)),
2545 const char *objname
, const char *errstring
)
2547 _dl_error_printf ("%s: %s: %s\n", RTLD_PROGNAME
,
2548 objname
, errstring
);
2551 /* Process the string given as the parameter which explains which debugging
2552 options are enabled. */
2554 process_dl_debug (struct dl_main_state
*state
, const char *dl_debug
)
2556 /* When adding new entries make sure that the maximal length of a name
2557 is correctly handled in the LD_DEBUG_HELP code below. */
2561 const char name
[10];
2562 const char helptext
[41];
2563 unsigned short int mask
;
2566 #define LEN_AND_STR(str) sizeof (str) - 1, str
2567 { LEN_AND_STR ("libs"), "display library search paths",
2568 DL_DEBUG_LIBS
| DL_DEBUG_IMPCALLS
},
2569 { LEN_AND_STR ("reloc"), "display relocation processing",
2570 DL_DEBUG_RELOC
| DL_DEBUG_IMPCALLS
},
2571 { LEN_AND_STR ("files"), "display progress for input file",
2572 DL_DEBUG_FILES
| DL_DEBUG_IMPCALLS
},
2573 { LEN_AND_STR ("symbols"), "display symbol table processing",
2574 DL_DEBUG_SYMBOLS
| DL_DEBUG_IMPCALLS
},
2575 { LEN_AND_STR ("bindings"), "display information about symbol binding",
2576 DL_DEBUG_BINDINGS
| DL_DEBUG_IMPCALLS
},
2577 { LEN_AND_STR ("versions"), "display version dependencies",
2578 DL_DEBUG_VERSIONS
| DL_DEBUG_IMPCALLS
},
2579 { LEN_AND_STR ("scopes"), "display scope information",
2581 { LEN_AND_STR ("all"), "all previous options combined",
2582 DL_DEBUG_LIBS
| DL_DEBUG_RELOC
| DL_DEBUG_FILES
| DL_DEBUG_SYMBOLS
2583 | DL_DEBUG_BINDINGS
| DL_DEBUG_VERSIONS
| DL_DEBUG_IMPCALLS
2584 | DL_DEBUG_SCOPES
},
2585 { LEN_AND_STR ("statistics"), "display relocation statistics",
2586 DL_DEBUG_STATISTICS
},
2587 { LEN_AND_STR ("unused"), "determined unused DSOs",
2589 { LEN_AND_STR ("help"), "display this help message and exit",
2592 #define ndebopts (sizeof (debopts) / sizeof (debopts[0]))
2594 /* Skip separating white spaces and commas. */
2595 while (*dl_debug
!= '\0')
2597 if (*dl_debug
!= ' ' && *dl_debug
!= ',' && *dl_debug
!= ':')
2602 while (dl_debug
[len
] != '\0' && dl_debug
[len
] != ' '
2603 && dl_debug
[len
] != ',' && dl_debug
[len
] != ':')
2606 for (cnt
= 0; cnt
< ndebopts
; ++cnt
)
2607 if (debopts
[cnt
].len
== len
2608 && memcmp (dl_debug
, debopts
[cnt
].name
, len
) == 0)
2610 GLRO(dl_debug_mask
) |= debopts
[cnt
].mask
;
2611 state
->any_debug
= true;
2615 if (cnt
== ndebopts
)
2617 /* Display a warning and skip everything until next
2619 char *copy
= strndupa (dl_debug
, len
);
2620 _dl_error_printf ("\
2621 warning: debug option `%s' unknown; try LD_DEBUG=help\n", copy
);
2631 if (GLRO(dl_debug_mask
) & DL_DEBUG_UNUSED
)
2633 /* In order to get an accurate picture of whether a particular
2634 DT_NEEDED entry is actually used we have to process both
2635 the PLT and non-PLT relocation entries. */
2639 if (GLRO(dl_debug_mask
) & DL_DEBUG_HELP
)
2644 Valid options for the LD_DEBUG environment variable are:\n\n");
2646 for (cnt
= 0; cnt
< ndebopts
; ++cnt
)
2647 _dl_printf (" %.*s%s%s\n", debopts
[cnt
].len
, debopts
[cnt
].name
,
2648 " " + debopts
[cnt
].len
- 3,
2649 debopts
[cnt
].helptext
);
2652 To direct the debugging output into a file instead of standard output\n\
2653 a filename can be specified using the LD_DEBUG_OUTPUT environment variable.\n");
2659 process_envvars (struct dl_main_state
*state
)
2661 char **runp
= _environ
;
2663 char *debug_output
= NULL
;
2665 /* This is the default place for profiling data file. */
2666 GLRO(dl_profile_output
)
2667 = &"/var/tmp\0/var/profile"[__libc_enable_secure
? 9 : 0];
2669 while ((envline
= _dl_next_ld_env_entry (&runp
)) != NULL
)
2673 while (envline
[len
] != '\0' && envline
[len
] != '=')
2676 if (envline
[len
] != '=')
2677 /* This is a "LD_" variable at the end of the string without
2678 a '=' character. Ignore it since otherwise we will access
2679 invalid memory below. */
2685 /* Warning level, verbose or not. */
2686 if (memcmp (envline
, "WARN", 4) == 0)
2687 GLRO(dl_verbose
) = envline
[5] != '\0';
2691 /* Debugging of the dynamic linker? */
2692 if (memcmp (envline
, "DEBUG", 5) == 0)
2694 process_dl_debug (state
, &envline
[6]);
2697 if (memcmp (envline
, "AUDIT", 5) == 0)
2698 audit_list_add_string (&state
->audit_list
, &envline
[6]);
2702 /* Print information about versions. */
2703 if (memcmp (envline
, "VERBOSE", 7) == 0)
2705 state
->version_info
= envline
[8] != '\0';
2709 /* List of objects to be preloaded. */
2710 if (memcmp (envline
, "PRELOAD", 7) == 0)
2712 state
->preloadlist
= &envline
[8];
2716 /* Which shared object shall be profiled. */
2717 if (memcmp (envline
, "PROFILE", 7) == 0 && envline
[8] != '\0')
2718 GLRO(dl_profile
) = &envline
[8];
2722 /* Do we bind early? */
2723 if (memcmp (envline
, "BIND_NOW", 8) == 0)
2725 GLRO(dl_lazy
) = envline
[9] == '\0';
2728 if (memcmp (envline
, "BIND_NOT", 8) == 0)
2729 GLRO(dl_bind_not
) = envline
[9] != '\0';
2733 /* Test whether we want to see the content of the auxiliary
2734 array passed up from the kernel. */
2735 if (!__libc_enable_secure
2736 && memcmp (envline
, "SHOW_AUXV", 9) == 0)
2742 /* Mask for the important hardware capabilities. */
2743 if (!__libc_enable_secure
2744 && memcmp (envline
, "HWCAP_MASK", 10) == 0)
2745 GLRO(dl_hwcap_mask
) = _dl_strtoul (&envline
[11], NULL
);
2750 /* Path where the binary is found. */
2751 if (!__libc_enable_secure
2752 && memcmp (envline
, "ORIGIN_PATH", 11) == 0)
2753 GLRO(dl_origin_path
) = &envline
[12];
2757 /* The library search path. */
2758 if (!__libc_enable_secure
2759 && memcmp (envline
, "LIBRARY_PATH", 12) == 0)
2761 state
->library_path
= &envline
[13];
2762 state
->library_path_source
= "LD_LIBRARY_PATH";
2766 /* Where to place the profiling data file. */
2767 if (memcmp (envline
, "DEBUG_OUTPUT", 12) == 0)
2769 debug_output
= &envline
[13];
2773 if (!__libc_enable_secure
2774 && memcmp (envline
, "DYNAMIC_WEAK", 12) == 0)
2775 GLRO(dl_dynamic_weak
) = 1;
2779 /* We might have some extra environment variable with length 13
2781 #ifdef EXTRA_LD_ENVVARS_13
2784 if (!__libc_enable_secure
2785 && memcmp (envline
, "USE_LOAD_BIAS", 13) == 0)
2787 GLRO(dl_use_load_bias
) = envline
[14] == '1' ? -1 : 0;
2793 /* Where to place the profiling data file. */
2794 if (!__libc_enable_secure
2795 && memcmp (envline
, "PROFILE_OUTPUT", 14) == 0
2796 && envline
[15] != '\0')
2797 GLRO(dl_profile_output
) = &envline
[15];
2801 /* The mode of the dynamic linker can be set. */
2802 if (memcmp (envline
, "TRACE_PRELINKING", 16) == 0)
2804 state
->mode
= rtld_mode_trace
;
2805 GLRO(dl_verbose
) = 1;
2806 GLRO(dl_debug_mask
) |= DL_DEBUG_PRELINK
;
2807 GLRO(dl_trace_prelink
) = &envline
[17];
2812 /* The mode of the dynamic linker can be set. */
2813 if (memcmp (envline
, "TRACE_LOADED_OBJECTS", 20) == 0)
2814 state
->mode
= rtld_mode_trace
;
2817 /* We might have some extra environment variable to handle. This
2818 is tricky due to the pre-processing of the length of the name
2819 in the switch statement here. The code here assumes that added
2820 environment variables have a different length. */
2821 #ifdef EXTRA_LD_ENVVARS
2827 /* Extra security for SUID binaries. Remove all dangerous environment
2829 if (__builtin_expect (__libc_enable_secure
, 0))
2831 static const char unsecure_envvars
[] =
2832 #ifdef EXTRA_UNSECURE_ENVVARS
2833 EXTRA_UNSECURE_ENVVARS
2838 nextp
= unsecure_envvars
;
2842 /* We could use rawmemchr but this need not be fast. */
2843 nextp
= (char *) (strchr
) (nextp
, '\0') + 1;
2845 while (*nextp
!= '\0');
2847 if (__access ("/etc/suid-debug", F_OK
) != 0)
2850 unsetenv ("MALLOC_CHECK_");
2852 GLRO(dl_debug_mask
) = 0;
2855 if (state
->mode
!= rtld_mode_normal
)
2858 /* If we have to run the dynamic linker in debugging mode and the
2859 LD_DEBUG_OUTPUT environment variable is given, we write the debug
2860 messages to this file. */
2861 else if (state
->any_debug
&& debug_output
!= NULL
)
2863 const int flags
= O_WRONLY
| O_APPEND
| O_CREAT
| O_NOFOLLOW
;
2864 size_t name_len
= strlen (debug_output
);
2865 char buf
[name_len
+ 12];
2868 buf
[name_len
+ 11] = '\0';
2869 startp
= _itoa (__getpid (), &buf
[name_len
+ 11], 10, 0);
2871 startp
= memcpy (startp
- name_len
, debug_output
, name_len
);
2873 GLRO(dl_debug_fd
) = __open64_nocancel (startp
, flags
, DEFFILEMODE
);
2874 if (GLRO(dl_debug_fd
) == -1)
2875 /* We use standard output if opening the file failed. */
2876 GLRO(dl_debug_fd
) = STDOUT_FILENO
;
2880 #if HP_TIMING_INLINE
2882 print_statistics_item (const char *title
, hp_timing_t time
,
2885 char cycles
[HP_TIMING_PRINT_SIZE
];
2886 HP_TIMING_PRINT (cycles
, sizeof (cycles
), time
);
2888 char relative
[3 * sizeof (hp_timing_t
) + 2];
2889 char *cp
= _itoa ((1000ULL * time
) / total
, relative
+ sizeof (relative
),
2891 /* Sets the decimal point. */
2892 char *wp
= relative
;
2893 switch (relative
+ sizeof (relative
) - cp
)
2906 _dl_debug_printf ("%s: %s cycles (%s%%)\n", title
, cycles
, relative
);
2910 /* Print the various times we collected. */
2912 __attribute ((noinline
))
2913 print_statistics (const hp_timing_t
*rtld_total_timep
)
2915 #if HP_TIMING_INLINE
2917 char cycles
[HP_TIMING_PRINT_SIZE
];
2918 HP_TIMING_PRINT (cycles
, sizeof (cycles
), *rtld_total_timep
);
2919 _dl_debug_printf ("\nruntime linker statistics:\n"
2920 " total startup time in dynamic loader: %s cycles\n",
2922 print_statistics_item (" time needed for relocation",
2923 relocate_time
, *rtld_total_timep
);
2927 unsigned long int num_relative_relocations
= 0;
2928 for (Lmid_t ns
= 0; ns
< GL(dl_nns
); ++ns
)
2930 if (GL(dl_ns
)[ns
]._ns_loaded
== NULL
)
2933 struct r_scope_elem
*scope
= &GL(dl_ns
)[ns
]._ns_loaded
->l_searchlist
;
2935 for (unsigned int i
= 0; i
< scope
->r_nlist
; i
++)
2937 struct link_map
*l
= scope
->r_list
[i
];
2939 if (l
->l_addr
!= 0 && l
->l_info
[VERSYMIDX (DT_RELCOUNT
)])
2940 num_relative_relocations
2941 += l
->l_info
[VERSYMIDX (DT_RELCOUNT
)]->d_un
.d_val
;
2942 #ifndef ELF_MACHINE_REL_RELATIVE
2943 /* Relative relocations are processed on these architectures if
2944 library is loaded to different address than p_vaddr or
2945 if not prelinked. */
2946 if ((l
->l_addr
!= 0 || !l
->l_info
[VALIDX(DT_GNU_PRELINKED
)])
2947 && l
->l_info
[VERSYMIDX (DT_RELACOUNT
)])
2949 /* On e.g. IA-64 or Alpha, relative relocations are processed
2950 only if library is loaded to different address than p_vaddr. */
2951 if (l
->l_addr
!= 0 && l
->l_info
[VERSYMIDX (DT_RELACOUNT
)])
2953 num_relative_relocations
2954 += l
->l_info
[VERSYMIDX (DT_RELACOUNT
)]->d_un
.d_val
;
2958 _dl_debug_printf (" number of relocations: %lu\n"
2959 " number of relocations from cache: %lu\n"
2960 " number of relative relocations: %lu\n",
2961 GL(dl_num_relocations
),
2962 GL(dl_num_cache_relocations
),
2963 num_relative_relocations
);
2965 #if HP_TIMING_INLINE
2966 print_statistics_item (" time needed to load objects",
2967 load_time
, *rtld_total_timep
);