1 /* Run time dynamic linker.
2 Copyright (C) 1995-2006, 2007, 2008 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, write to the Free
17 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
27 #include <sys/mman.h> /* Check if MAP_ANON is defined. */
28 #include <sys/param.h>
31 #include <stdio-common/_itoa.h>
33 #include <fpu_control.h>
34 #include <hp-timing.h>
35 #include <bits/libc-lock.h>
36 #include "dynamic-link.h"
37 #include <dl-librecon.h>
38 #include <unsecvars.h>
40 #include <dl-osinfo.h>
41 #include <dl-procinfo.h>
46 /* Avoid PLT use for our local calls at startup. */
47 extern __typeof (__mempcpy
) __mempcpy attribute_hidden
;
49 /* GCC has mental blocks about _exit. */
50 extern __typeof (_exit
) exit_internal
asm ("_exit") attribute_hidden
;
51 #define _exit exit_internal
53 /* Helper function to handle errors while resolving symbols. */
54 static void print_unresolved (int errcode
, const char *objname
,
55 const char *errsting
);
57 /* Helper function to handle errors when a version is missing. */
58 static void print_missing_version (int errcode
, const char *objname
,
59 const char *errsting
);
61 /* Print the various times we collected. */
62 static void print_statistics (hp_timing_t
*total_timep
);
64 /* Add audit objects. */
65 static void process_dl_audit (char *str
);
67 /* This is a list of all the modes the dynamic loader can be in. */
68 enum mode
{ normal
, list
, verify
, trace
};
70 /* Process all environments variables the dynamic linker must recognize.
71 Since all of them start with `LD_' we are a bit smarter while finding
73 static void process_envvars (enum mode
*modep
);
75 #ifdef DL_ARGV_NOT_RELRO
76 int _dl_argc attribute_hidden
;
77 char **_dl_argv
= NULL
;
78 /* Nonzero if we were run directly. */
79 unsigned int _dl_skip_args attribute_hidden
;
81 int _dl_argc attribute_relro attribute_hidden
;
82 char **_dl_argv attribute_relro
= NULL
;
83 unsigned int _dl_skip_args attribute_relro attribute_hidden
;
87 #ifndef THREAD_SET_STACK_GUARD
88 /* Only exported for architectures that don't store the stack guard canary
89 in thread local area. */
90 uintptr_t __stack_chk_guard attribute_relro
;
93 /* Only exported for architectures that don't store the pointer guard
94 value in thread local area. */
95 uintptr_t __pointer_chk_guard_local
96 attribute_relro attribute_hidden
__attribute__ ((nocommon
));
97 #ifndef THREAD_SET_POINTER_GUARD
98 strong_alias (__pointer_chk_guard_local
, __pointer_chk_guard
)
102 /* List of auditing DSOs. */
103 static struct audit_list
106 struct audit_list
*next
;
109 #ifndef HAVE_INLINED_SYSCALLS
110 /* Set nonzero during loading and initialization of executable and
111 libraries, cleared before the executable's entry point runs. This
112 must not be initialized to nonzero, because the unused dynamic
113 linker loaded in for libc.so's "ld.so.1" dep will provide the
114 definition seen by libc.so's initializer; that value must be zero,
115 and will be since that dynamic linker's _dl_start and dl_main will
117 int _dl_starting_up
= 0;
118 INTVARDEF(_dl_starting_up
)
121 /* This is the structure which defines all variables global to ld.so
122 (except those which cannot be added for some reason). */
123 struct rtld_global _rtld_global
=
125 /* Default presumption without further information is executable stack. */
126 ._dl_stack_flags
= PF_R
|PF_W
|PF_X
,
127 #ifdef _LIBC_REENTRANT
128 ._dl_load_lock
= _RTLD_LOCK_RECURSIVE_INITIALIZER
131 /* If we would use strong_alias here the compiler would see a
132 non-hidden definition. This would undo the effect of the previous
133 declaration. So spell out was strong_alias does plus add the
134 visibility attribute. */
135 extern struct rtld_global _rtld_local
136 __attribute__ ((alias ("_rtld_global"), visibility ("hidden")));
139 /* This variable is similar to _rtld_local, but all values are
140 read-only after relocation. */
141 struct rtld_global_ro _rtld_global_ro attribute_relro
=
143 /* Get architecture specific initializer. */
144 #include <dl-procinfo.c>
145 #ifdef NEED_DL_SYSINFO
146 ._dl_sysinfo
= DL_SYSINFO_DEFAULT
,
148 ._dl_debug_fd
= STDERR_FILENO
,
149 ._dl_use_load_bias
= -2,
150 ._dl_correct_cache_id
= _DL_CACHE_DEFAULT_ID
,
151 ._dl_hwcap_mask
= HWCAP_IMPORTANT
,
153 ._dl_fpu_control
= _FPU_DEFAULT
,
154 ._dl_pointer_guard
= 1,
156 /* Function pointers. */
157 ._dl_debug_printf
= _dl_debug_printf
,
158 ._dl_catch_error
= _dl_catch_error
,
159 ._dl_signal_error
= _dl_signal_error
,
160 ._dl_mcount
= _dl_mcount_internal
,
161 ._dl_lookup_symbol_x
= _dl_lookup_symbol_x
,
162 ._dl_check_caller
= _dl_check_caller
,
163 ._dl_open
= _dl_open
,
164 ._dl_close
= _dl_close
,
165 ._dl_tls_get_addr_soft
= _dl_tls_get_addr_soft
167 /* If we would use strong_alias here the compiler would see a
168 non-hidden definition. This would undo the effect of the previous
169 declaration. So spell out was strong_alias does plus add the
170 visibility attribute. */
171 extern struct rtld_global_ro _rtld_local_ro
172 __attribute__ ((alias ("_rtld_global_ro"), visibility ("hidden")));
175 static void dl_main (const ElfW(Phdr
) *phdr
, ElfW(Word
) phnum
,
176 ElfW(Addr
) *user_entry
);
178 /* These two variables cannot be moved into .data.rel.ro. */
179 static struct libname_list _dl_rtld_libname
;
180 static struct libname_list _dl_rtld_libname2
;
182 /* We expect less than a second for relocation. */
183 #ifdef HP_SMALL_TIMING_AVAIL
184 # undef HP_TIMING_AVAIL
185 # define HP_TIMING_AVAIL HP_SMALL_TIMING_AVAIL
188 /* Variable for statistics. */
189 #ifndef HP_TIMING_NONAVAIL
190 static hp_timing_t relocate_time
;
191 static hp_timing_t load_time attribute_relro
;
192 static hp_timing_t start_time attribute_relro
;
195 /* Additional definitions needed by TLS initialization. */
196 #ifdef TLS_INIT_HELPER
200 /* Helper function for syscall implementation. */
201 #ifdef DL_SYSINFO_IMPLEMENTATION
202 DL_SYSINFO_IMPLEMENTATION
205 /* Before ld.so is relocated we must not access variables which need
206 relocations. This means variables which are exported. Variables
207 declared as static are fine. If we can mark a variable hidden this
208 is fine, too. The latter is important here. We can avoid setting
209 up a temporary link map for ld.so if we can mark _rtld_global as
211 #ifdef PI_STATIC_AND_HIDDEN
212 # define DONT_USE_BOOTSTRAP_MAP 1
215 #ifdef DONT_USE_BOOTSTRAP_MAP
216 static ElfW(Addr
) _dl_start_final (void *arg
);
218 struct dl_start_final_info
221 #if !defined HP_TIMING_NONAVAIL && HP_TIMING_INLINE
222 hp_timing_t start_time
;
225 static ElfW(Addr
) _dl_start_final (void *arg
,
226 struct dl_start_final_info
*info
);
229 /* These defined magically in the linker script. */
230 extern char _begin
[] attribute_hidden
;
231 extern char _etext
[] attribute_hidden
;
232 extern char _end
[] attribute_hidden
;
238 # error "sysdeps/MACHINE/dl-machine.h fails to define RTLD_START"
242 # define VALIDX(tag) (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM \
243 + DT_EXTRANUM + DT_VALTAGIDX (tag))
246 # define ADDRIDX(tag) (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM \
247 + DT_EXTRANUM + DT_VALNUM + DT_ADDRTAGIDX (tag))
250 /* This is the second half of _dl_start (below). It can be inlined safely
251 under DONT_USE_BOOTSTRAP_MAP, where it is careful not to make any GOT
252 references. When the tools don't permit us to avoid using a GOT entry
253 for _dl_rtld_global (no attribute_hidden support), we must make sure
254 this function is not inlined (see below). */
256 #ifdef DONT_USE_BOOTSTRAP_MAP
257 static inline ElfW(Addr
) __attribute__ ((always_inline
))
258 _dl_start_final (void *arg
)
260 static ElfW(Addr
) __attribute__ ((noinline
))
261 _dl_start_final (void *arg
, struct dl_start_final_info
*info
)
264 ElfW(Addr
) start_addr
;
268 /* If it hasn't happen yet record the startup time. */
269 if (! HP_TIMING_INLINE
)
270 HP_TIMING_NOW (start_time
);
271 #if !defined DONT_USE_BOOTSTRAP_MAP && !defined HP_TIMING_NONAVAIL
273 start_time
= info
->start_time
;
276 /* Initialize the timing functions. */
277 HP_TIMING_DIFF_INIT ();
280 /* Transfer data about ourselves to the permanent link_map structure. */
281 #ifndef DONT_USE_BOOTSTRAP_MAP
282 GL(dl_rtld_map
).l_addr
= info
->l
.l_addr
;
283 GL(dl_rtld_map
).l_ld
= info
->l
.l_ld
;
284 memcpy (GL(dl_rtld_map
).l_info
, info
->l
.l_info
,
285 sizeof GL(dl_rtld_map
).l_info
);
286 GL(dl_rtld_map
).l_mach
= info
->l
.l_mach
;
287 GL(dl_rtld_map
).l_relocated
= 1;
289 _dl_setup_hash (&GL(dl_rtld_map
));
290 GL(dl_rtld_map
).l_real
= &GL(dl_rtld_map
);
291 GL(dl_rtld_map
).l_map_start
= (ElfW(Addr
)) _begin
;
292 GL(dl_rtld_map
).l_map_end
= (ElfW(Addr
)) _end
;
293 GL(dl_rtld_map
).l_text_end
= (ElfW(Addr
)) _etext
;
294 /* Copy the TLS related data if necessary. */
295 #ifndef DONT_USE_BOOTSTRAP_MAP
297 assert (info
->l
.l_tls_modid
!= 0);
298 GL(dl_rtld_map
).l_tls_blocksize
= info
->l
.l_tls_blocksize
;
299 GL(dl_rtld_map
).l_tls_align
= info
->l
.l_tls_align
;
300 GL(dl_rtld_map
).l_tls_firstbyte_offset
= info
->l
.l_tls_firstbyte_offset
;
301 GL(dl_rtld_map
).l_tls_initimage_size
= info
->l
.l_tls_initimage_size
;
302 GL(dl_rtld_map
).l_tls_initimage
= info
->l
.l_tls_initimage
;
303 GL(dl_rtld_map
).l_tls_offset
= info
->l
.l_tls_offset
;
304 GL(dl_rtld_map
).l_tls_modid
= 1;
306 # if NO_TLS_OFFSET != 0
307 GL(dl_rtld_map
).l_tls_offset
= NO_TLS_OFFSET
;
314 HP_TIMING_NOW (GL(dl_cpuclock_offset
));
317 /* Initialize the stack end variable. */
318 __libc_stack_end
= __builtin_frame_address (0);
320 /* Call the OS-dependent function to set up life so we can do things like
321 file access. It will call `dl_main' (below) to do all the real work
322 of the dynamic linker, and then unwind our frame and run the user
323 entry point on the same stack we entered on. */
324 start_addr
= _dl_sysdep_start (arg
, &dl_main
);
326 #ifndef HP_TIMING_NONAVAIL
327 hp_timing_t rtld_total_time
;
330 hp_timing_t end_time
;
332 /* Get the current time. */
333 HP_TIMING_NOW (end_time
);
335 /* Compute the difference. */
336 HP_TIMING_DIFF (rtld_total_time
, start_time
, end_time
);
340 if (__builtin_expect (GLRO(dl_debug_mask
) & DL_DEBUG_STATISTICS
, 0))
342 #ifndef HP_TIMING_NONAVAIL
343 print_statistics (&rtld_total_time
);
345 print_statistics (NULL
);
352 static ElfW(Addr
) __attribute_used__ internal_function
353 _dl_start (void *arg
)
355 #ifdef DONT_USE_BOOTSTRAP_MAP
356 # define bootstrap_map GL(dl_rtld_map)
358 struct dl_start_final_info info
;
359 # define bootstrap_map info.l
362 /* This #define produces dynamic linking inline functions for
363 bootstrap relocation instead of general-purpose relocation.
364 Since ld.so must not have any undefined symbols the result
365 is trivial: always the map of ld.so itself. */
366 #define RTLD_BOOTSTRAP
367 #define RESOLVE_MAP(sym, version, flags) (&bootstrap_map)
368 #include "dynamic-link.h"
370 if (HP_TIMING_INLINE
&& HP_TIMING_AVAIL
)
371 #ifdef DONT_USE_BOOTSTRAP_MAP
372 HP_TIMING_NOW (start_time
);
374 HP_TIMING_NOW (info
.start_time
);
377 /* Partly clean the `bootstrap_map' structure up. Don't use
378 `memset' since it might not be built in or inlined and we cannot
379 make function calls at this point. Use '__builtin_memset' if we
380 know it is available. We do not have to clear the memory if we
381 do not have to use the temporary bootstrap_map. Global variables
382 are initialized to zero by default. */
383 #ifndef DONT_USE_BOOTSTRAP_MAP
384 # ifdef HAVE_BUILTIN_MEMSET
385 __builtin_memset (bootstrap_map
.l_info
, '\0', sizeof (bootstrap_map
.l_info
));
388 cnt
< sizeof (bootstrap_map
.l_info
) / sizeof (bootstrap_map
.l_info
[0]);
390 bootstrap_map
.l_info
[cnt
] = 0;
393 bootstrap_map
.l_tls_modid
= 0;
397 /* Figure out the run-time load address of the dynamic linker itself. */
398 bootstrap_map
.l_addr
= elf_machine_load_address ();
400 /* Read our own dynamic section and fill in the info array. */
401 bootstrap_map
.l_ld
= (void *) bootstrap_map
.l_addr
+ elf_machine_dynamic ();
402 elf_get_dynamic_info (&bootstrap_map
, NULL
);
404 #if NO_TLS_OFFSET != 0
405 bootstrap_map
.l_tls_offset
= NO_TLS_OFFSET
;
408 /* Get the dynamic linker's own program header. First we need the ELF
409 file header. The `_begin' symbol created by the linker script points
410 to it. When we have something like GOTOFF relocs, we can use a plain
411 reference to find the runtime address. Without that, we have to rely
412 on the `l_addr' value, which is not the value we want when prelinked. */
416 # ifdef DONT_USE_BOOTSTRAP_MAP
417 = (ElfW(Ehdr
) *) &_begin
;
419 # error This will not work with prelink.
420 = (ElfW(Ehdr
) *) bootstrap_map
.l_addr
;
422 ElfW(Phdr
) *phdr
= (ElfW(Phdr
) *) ((void *) ehdr
+ ehdr
->e_phoff
);
423 size_t cnt
= ehdr
->e_phnum
; /* PT_TLS is usually the last phdr. */
425 if (phdr
[cnt
].p_type
== PT_TLS
)
428 size_t max_align
= MAX (TLS_INIT_TCB_ALIGN
, phdr
[cnt
].p_align
);
431 bootstrap_map
.l_tls_blocksize
= phdr
[cnt
].p_memsz
;
432 bootstrap_map
.l_tls_align
= phdr
[cnt
].p_align
;
433 if (phdr
[cnt
].p_align
== 0)
434 bootstrap_map
.l_tls_firstbyte_offset
= 0;
436 bootstrap_map
.l_tls_firstbyte_offset
= (phdr
[cnt
].p_vaddr
437 & (phdr
[cnt
].p_align
- 1));
438 assert (bootstrap_map
.l_tls_blocksize
!= 0);
439 bootstrap_map
.l_tls_initimage_size
= phdr
[cnt
].p_filesz
;
440 bootstrap_map
.l_tls_initimage
= (void *) (bootstrap_map
.l_addr
441 + phdr
[cnt
].p_vaddr
);
443 /* We can now allocate the initial TLS block. This can happen
444 on the stack. We'll get the final memory later when we
445 know all about the various objects loaded at startup
448 tlsblock
= alloca (roundup (bootstrap_map
.l_tls_blocksize
,
453 tlsblock
= alloca (roundup (TLS_INIT_TCB_SIZE
,
454 bootstrap_map
.l_tls_align
)
455 + bootstrap_map
.l_tls_blocksize
458 /* In case a model with a different layout for the TCB and DTV
459 is defined add another #elif here and in the following #ifs. */
460 # error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
462 /* Align the TLS block. */
463 tlsblock
= (void *) (((uintptr_t) tlsblock
+ max_align
- 1)
466 /* Initialize the dtv. [0] is the length, [1] the generation
468 initdtv
[0].counter
= 1;
469 initdtv
[1].counter
= 0;
471 /* Initialize the TLS block. */
473 initdtv
[2].pointer
= tlsblock
;
475 bootstrap_map
.l_tls_offset
= roundup (TLS_INIT_TCB_SIZE
,
476 bootstrap_map
.l_tls_align
);
477 initdtv
[2].pointer
= (char *) tlsblock
+ bootstrap_map
.l_tls_offset
;
479 # error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
481 p
= __mempcpy (initdtv
[2].pointer
, bootstrap_map
.l_tls_initimage
,
482 bootstrap_map
.l_tls_initimage_size
);
483 # ifdef HAVE_BUILTIN_MEMSET
484 __builtin_memset (p
, '\0', (bootstrap_map
.l_tls_blocksize
485 - bootstrap_map
.l_tls_initimage_size
));
488 size_t remaining
= (bootstrap_map
.l_tls_blocksize
489 - bootstrap_map
.l_tls_initimage_size
);
490 while (remaining
-- > 0)
495 /* Install the pointer to the dtv. */
497 /* Initialize the thread pointer. */
499 bootstrap_map
.l_tls_offset
500 = roundup (bootstrap_map
.l_tls_blocksize
, TLS_INIT_TCB_ALIGN
);
502 INSTALL_DTV ((char *) tlsblock
+ bootstrap_map
.l_tls_offset
,
505 const char *lossage
= TLS_INIT_TP ((char *) tlsblock
506 + bootstrap_map
.l_tls_offset
, 0);
508 INSTALL_DTV (tlsblock
, initdtv
);
509 const char *lossage
= TLS_INIT_TP (tlsblock
, 0);
511 # error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
513 if (__builtin_expect (lossage
!= NULL
, 0))
514 _dl_fatal_printf ("cannot set up thread-local storage: %s\n",
517 /* So far this is module number one. */
518 bootstrap_map
.l_tls_modid
= 1;
520 /* There can only be one PT_TLS entry. */
523 #endif /* USE___THREAD */
525 #ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
526 ELF_MACHINE_BEFORE_RTLD_RELOC (bootstrap_map
.l_info
);
529 if (bootstrap_map
.l_addr
|| ! bootstrap_map
.l_info
[VALIDX(DT_GNU_PRELINKED
)])
531 /* Relocate ourselves so we can do normal function calls and
532 data access using the global offset table. */
534 ELF_DYNAMIC_RELOCATE (&bootstrap_map
, 0, 0);
536 bootstrap_map
.l_relocated
= 1;
538 /* Please note that we don't allow profiling of this object and
539 therefore need not test whether we have to allocate the array
540 for the relocation results (as done in dl-reloc.c). */
542 /* Now life is sane; we can call functions and access global data.
543 Set up to use the operating system facilities, and find out from
544 the operating system's program loader where to find the program
545 header table in core. Put the rest of _dl_start into a separate
546 function, that way the compiler cannot put accesses to the GOT
547 before ELF_DYNAMIC_RELOCATE. */
549 #ifdef DONT_USE_BOOTSTRAP_MAP
550 ElfW(Addr
) entry
= _dl_start_final (arg
);
552 ElfW(Addr
) entry
= _dl_start_final (arg
, &info
);
555 #ifndef ELF_MACHINE_START_ADDRESS
556 # define ELF_MACHINE_START_ADDRESS(map, start) (start)
559 return ELF_MACHINE_START_ADDRESS (GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
, entry
);
565 /* Now life is peachy; we can do all normal operations.
566 On to the real work. */
568 /* Some helper functions. */
570 /* Arguments to relocate_doit. */
579 /* Argument to map_doit. */
581 struct link_map
*loader
;
584 /* Return value of map_doit. */
585 struct link_map
*map
;
591 struct link_map
*map
;
597 struct link_map
*map
;
601 /* Arguments to version_check_doit. */
602 struct version_check_args
609 relocate_doit (void *a
)
611 struct relocate_args
*args
= (struct relocate_args
*) a
;
613 _dl_relocate_object (args
->l
, args
->l
->l_scope
, args
->lazy
, 0);
619 struct map_args
*args
= (struct map_args
*) a
;
620 args
->map
= _dl_map_object (args
->loader
, args
->str
,
621 args
->is_preloaded
, lt_library
, 0, args
->mode
,
626 dlmopen_doit (void *a
)
628 struct dlmopen_args
*args
= (struct dlmopen_args
*) a
;
629 args
->map
= _dl_open (args
->fname
, RTLD_LAZY
| __RTLD_DLOPEN
| __RTLD_AUDIT
,
630 dl_main
, LM_ID_NEWLM
, _dl_argc
, INTUSE(_dl_argv
),
635 lookup_doit (void *a
)
637 struct lookup_args
*args
= (struct lookup_args
*) a
;
638 const ElfW(Sym
) *ref
= NULL
;
640 lookup_t l
= _dl_lookup_symbol_x (args
->name
, args
->map
, &ref
,
641 args
->map
->l_local_scope
, NULL
, 0,
642 DL_LOOKUP_RETURN_NEWEST
, NULL
);
644 args
->result
= DL_SYMBOL_ADDRESS (l
, ref
);
648 version_check_doit (void *a
)
650 struct version_check_args
*args
= (struct version_check_args
*) a
;
651 if (_dl_check_all_versions (GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
, 1,
652 args
->dotrace
) && args
->doexit
)
653 /* We cannot start the application. Abort now. */
658 static inline struct link_map
*
659 find_needed (const char *name
)
661 struct r_scope_elem
*scope
= &GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
->l_searchlist
;
662 unsigned int n
= scope
->r_nlist
;
665 if (_dl_name_match_p (name
, scope
->r_list
[n
]))
666 return scope
->r_list
[n
];
668 /* Should never happen. */
673 match_version (const char *string
, struct link_map
*map
)
675 const char *strtab
= (const void *) D_PTR (map
, l_info
[DT_STRTAB
]);
678 #define VERDEFTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERDEF))
679 if (map
->l_info
[VERDEFTAG
] == NULL
)
680 /* The file has no symbol versioning. */
683 def
= (ElfW(Verdef
) *) ((char *) map
->l_addr
684 + map
->l_info
[VERDEFTAG
]->d_un
.d_ptr
);
687 ElfW(Verdaux
) *aux
= (ElfW(Verdaux
) *) ((char *) def
+ def
->vd_aux
);
689 /* Compare the version strings. */
690 if (strcmp (string
, strtab
+ aux
->vda_name
) == 0)
694 /* If no more definitions we failed to find what we want. */
695 if (def
->vd_next
== 0)
698 /* Next definition. */
699 def
= (ElfW(Verdef
) *) ((char *) def
+ def
->vd_next
);
705 static bool tls_init_tp_called
;
710 /* Number of elements in the static TLS block. */
711 GL(dl_tls_static_nelem
) = GL(dl_tls_max_dtv_idx
);
713 /* Do not do this twice. The audit interface might have required
714 the DTV interfaces to be set up early. */
715 if (GL(dl_initial_dtv
) != NULL
)
718 /* Allocate the array which contains the information about the
719 dtv slots. We allocate a few entries more than needed to
720 avoid the need for reallocation. */
721 size_t nelem
= GL(dl_tls_max_dtv_idx
) + 1 + TLS_SLOTINFO_SURPLUS
;
724 GL(dl_tls_dtv_slotinfo_list
) = (struct dtv_slotinfo_list
*)
725 calloc (sizeof (struct dtv_slotinfo_list
)
726 + nelem
* sizeof (struct dtv_slotinfo
), 1);
727 /* No need to check the return value. If memory allocation failed
728 the program would have been terminated. */
730 struct dtv_slotinfo
*slotinfo
= GL(dl_tls_dtv_slotinfo_list
)->slotinfo
;
731 GL(dl_tls_dtv_slotinfo_list
)->len
= nelem
;
732 GL(dl_tls_dtv_slotinfo_list
)->next
= NULL
;
734 /* Fill in the information from the loaded modules. No namespace
735 but the base one can be filled at this time. */
736 assert (GL(dl_ns
)[LM_ID_BASE
+ 1]._ns_loaded
== NULL
);
738 for (struct link_map
*l
= GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
; l
!= NULL
;
740 if (l
->l_tls_blocksize
!= 0)
742 /* This is a module with TLS data. Store the map reference.
743 The generation counter is zero. */
745 /* slotinfo[i].gen = 0; */
748 assert (i
== GL(dl_tls_max_dtv_idx
));
750 /* Compute the TLS offsets for the various blocks. */
751 _dl_determine_tlsoffset ();
753 /* Construct the static TLS block and the dtv for the initial
754 thread. For some platforms this will include allocating memory
755 for the thread descriptor. The memory for the TLS block will
756 never be freed. It should be allocated accordingly. The dtv
757 array can be changed if dynamic loading requires it. */
758 void *tcbp
= _dl_allocate_tls_storage ();
761 cannot allocate TLS data structures for initial thread");
763 /* Store for detection of the special case by __tls_get_addr
764 so it knows not to pass this dtv to the normal realloc. */
765 GL(dl_initial_dtv
) = GET_DTV (tcbp
);
767 /* And finally install it for the main thread. If ld.so itself uses
768 TLS we know the thread pointer was initialized earlier. */
769 const char *lossage
= TLS_INIT_TP (tcbp
, USE___THREAD
);
770 if (__builtin_expect (lossage
!= NULL
, 0))
771 _dl_fatal_printf ("cannot set up thread-local storage: %s\n", lossage
);
772 tls_init_tp_called
= true;
777 #ifdef _LIBC_REENTRANT
778 /* _dl_error_catch_tsd points to this for the single-threaded case.
779 It's reset by the thread library for multithreaded programs. */
780 void ** __attribute__ ((const))
781 _dl_initial_error_catch_tsd (void)
790 do_preload (char *fname
, struct link_map
*main_map
, const char *where
)
793 const char *err_str
= NULL
;
794 struct map_args args
;
798 args
.loader
= main_map
;
799 args
.is_preloaded
= 1;
802 unsigned int old_nloaded
= GL(dl_ns
)[LM_ID_BASE
]._ns_nloaded
;
804 (void) _dl_catch_error (&objname
, &err_str
, &malloced
, map_doit
, &args
);
805 if (__builtin_expect (err_str
!= NULL
, 0))
808 ERROR: ld.so: object '%s' from %s cannot be preloaded: ignored.\n",
810 /* No need to call free, this is still before
811 the libc's malloc is used. */
813 else if (GL(dl_ns
)[LM_ID_BASE
]._ns_nloaded
!= old_nloaded
)
814 /* It is no duplicate. */
817 /* Nothing loaded. */
821 #if defined SHARED && defined _LIBC_REENTRANT \
822 && defined __rtld_lock_default_lock_recursive
824 rtld_lock_default_lock_recursive (void *lock
)
826 __rtld_lock_default_lock_recursive (lock
);
830 rtld_lock_default_unlock_recursive (void *lock
)
832 __rtld_lock_default_unlock_recursive (lock
);
840 /* Set up the stack checker's canary. */
841 uintptr_t stack_chk_guard
= _dl_setup_stack_chk_guard ();
842 #ifdef THREAD_SET_STACK_GUARD
843 THREAD_SET_STACK_GUARD (stack_chk_guard
);
845 __stack_chk_guard
= stack_chk_guard
;
848 /* Set up the pointer guard as well, if necessary. */
849 if (GLRO(dl_pointer_guard
))
851 // XXX If it is cheap, we should use a separate value.
852 uintptr_t pointer_chk_guard
= stack_chk_guard
;
853 #ifndef HP_TIMING_NONAVAIL
856 pointer_chk_guard
^= now
;
858 #ifdef THREAD_SET_POINTER_GUARD
859 THREAD_SET_POINTER_GUARD (pointer_chk_guard
);
861 __pointer_chk_guard_local
= pointer_chk_guard
;
866 /* The library search path. */
867 static const char *library_path attribute_relro
;
868 /* The list preloaded objects. */
869 static const char *preloadlist attribute_relro
;
870 /* Nonzero if information about versions has to be printed. */
871 static int version_info attribute_relro
;
874 dl_main (const ElfW(Phdr
) *phdr
,
876 ElfW(Addr
) *user_entry
)
878 const ElfW(Phdr
) *ph
;
880 struct link_map
*main_map
;
883 bool has_interp
= false;
885 bool prelinked
= false;
886 bool rtld_is_main
= false;
887 #ifndef HP_TIMING_NONAVAIL
894 #ifdef _LIBC_REENTRANT
895 /* Explicit initialization since the reloc would just be more work. */
896 GL(dl_error_catch_tsd
) = &_dl_initial_error_catch_tsd
;
899 GL(dl_init_static_tls
) = &_dl_nothread_init_static_tls
;
901 #if defined SHARED && defined _LIBC_REENTRANT \
902 && defined __rtld_lock_default_lock_recursive
903 GL(dl_rtld_lock_recursive
) = rtld_lock_default_lock_recursive
;
904 GL(dl_rtld_unlock_recursive
) = rtld_lock_default_unlock_recursive
;
907 /* The explicit initialization here is cheaper than processing the reloc
908 in the _rtld_local definition's initializer. */
909 GL(dl_make_stack_executable_hook
) = &_dl_make_stack_executable
;
911 /* Process the environment variable which control the behaviour. */
912 process_envvars (&mode
);
914 #ifndef HAVE_INLINED_SYSCALLS
915 /* Set up a flag which tells we are just starting. */
916 INTUSE(_dl_starting_up
) = 1;
919 if (*user_entry
== (ElfW(Addr
)) ENTRY_POINT
)
921 /* Ho ho. We are not the program interpreter! We are the program
922 itself! This means someone ran ld.so as a command. Well, that
923 might be convenient to do sometimes. We support it by
924 interpreting the args like this:
926 ld.so PROGRAM ARGS...
928 The first argument is the name of a file containing an ELF
929 executable we will load and run with the following arguments.
930 To simplify life here, PROGRAM is searched for using the
931 normal rules for shared objects, rather than $PATH or anything
932 like that. We just load it and use its entry point; we don't
933 pay attention to its PT_INTERP command (we are the interpreter
934 ourselves). This is an easy way to test a new ld.so before
938 /* Note the place where the dynamic linker actually came from. */
939 GL(dl_rtld_map
).l_name
= rtld_progname
;
942 if (! strcmp (INTUSE(_dl_argv
)[1], "--list"))
945 GLRO(dl_lazy
) = -1; /* This means do no dependency analysis. */
951 else if (! strcmp (INTUSE(_dl_argv
)[1], "--verify"))
959 else if (! strcmp (INTUSE(_dl_argv
)[1], "--library-path")
962 library_path
= INTUSE(_dl_argv
)[2];
966 INTUSE(_dl_argv
) += 2;
968 else if (! strcmp (INTUSE(_dl_argv
)[1], "--inhibit-rpath")
971 GLRO(dl_inhibit_rpath
) = INTUSE(_dl_argv
)[2];
975 INTUSE(_dl_argv
) += 2;
977 else if (! strcmp (INTUSE(_dl_argv
)[1], "--audit") && _dl_argc
> 2)
979 process_dl_audit (INTUSE(_dl_argv
)[2]);
983 INTUSE(_dl_argv
) += 2;
988 /* If we have no further argument the program was called incorrectly.
989 Grant the user some education. */
992 Usage: ld.so [OPTION]... EXECUTABLE-FILE [ARGS-FOR-PROGRAM...]\n\
993 You have invoked `ld.so', the helper program for shared library executables.\n\
994 This program usually lives in the file `/lib/ld.so', and special directives\n\
995 in executable files using ELF shared libraries tell the system's program\n\
996 loader to load the helper program from this file. This helper program loads\n\
997 the shared libraries needed by the program executable, prepares the program\n\
998 to run, and runs it. You may invoke this helper program directly from the\n\
999 command line to load and run an ELF executable file; this is like executing\n\
1000 that file itself, but always uses this helper program from the file you\n\
1001 specified, instead of the helper program file specified in the executable\n\
1002 file you run. This is mostly of use for maintainers to test new versions\n\
1003 of this helper program; chances are you did not intend to run this program.\n\
1005 --list list all dependencies and how they are resolved\n\
1006 --verify verify that given object really is a dynamically linked\n\
1007 object we can handle\n\
1008 --library-path PATH use given PATH instead of content of the environment\n\
1009 variable LD_LIBRARY_PATH\n\
1010 --inhibit-rpath LIST ignore RUNPATH and RPATH information in object names\n\
1017 /* The initialization of _dl_stack_flags done below assumes the
1018 executable's PT_GNU_STACK may have been honored by the kernel, and
1019 so a PT_GNU_STACK with PF_X set means the stack started out with
1020 execute permission. However, this is not really true if the
1021 dynamic linker is the executable the kernel loaded. For this
1022 case, we must reinitialize _dl_stack_flags to match the dynamic
1023 linker itself. If the dynamic linker was built with a
1024 PT_GNU_STACK, then the kernel may have loaded us with a
1025 nonexecutable stack that we will have to make executable when we
1026 load the program below unless it has a PT_GNU_STACK indicating
1027 nonexecutable stack is ok. */
1029 for (ph
= phdr
; ph
< &phdr
[phnum
]; ++ph
)
1030 if (ph
->p_type
== PT_GNU_STACK
)
1032 GL(dl_stack_flags
) = ph
->p_flags
;
1036 if (__builtin_expect (mode
, normal
) == verify
)
1038 const char *objname
;
1039 const char *err_str
= NULL
;
1040 struct map_args args
;
1043 args
.str
= rtld_progname
;
1045 args
.is_preloaded
= 0;
1046 args
.mode
= __RTLD_OPENEXEC
;
1047 (void) _dl_catch_error (&objname
, &err_str
, &malloced
, map_doit
,
1049 if (__builtin_expect (err_str
!= NULL
, 0))
1050 /* We don't free the returned string, the programs stops
1052 _exit (EXIT_FAILURE
);
1056 HP_TIMING_NOW (start
);
1057 _dl_map_object (NULL
, rtld_progname
, 0, lt_library
, 0,
1058 __RTLD_OPENEXEC
, LM_ID_BASE
);
1059 HP_TIMING_NOW (stop
);
1061 HP_TIMING_DIFF (load_time
, start
, stop
);
1064 /* Now the map for the main executable is available. */
1065 main_map
= GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
;
1067 phdr
= main_map
->l_phdr
;
1068 phnum
= main_map
->l_phnum
;
1069 /* We overwrite here a pointer to a malloc()ed string. But since
1070 the malloc() implementation used at this point is the dummy
1071 implementations which has no real free() function it does not
1072 makes sense to free the old string first. */
1073 main_map
->l_name
= (char *) "";
1074 *user_entry
= main_map
->l_entry
;
1078 /* Create a link_map for the executable itself.
1079 This will be what dlopen on "" returns. */
1080 main_map
= _dl_new_object ((char *) "", "", lt_executable
, NULL
,
1081 __RTLD_OPENEXEC
, LM_ID_BASE
);
1082 assert (main_map
!= NULL
);
1083 assert (main_map
== GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
);
1084 main_map
->l_phdr
= phdr
;
1085 main_map
->l_phnum
= phnum
;
1086 main_map
->l_entry
= *user_entry
;
1088 /* At this point we are in a bit of trouble. We would have to
1089 fill in the values for l_dev and l_ino. But in general we
1090 do not know where the file is. We also do not handle AT_EXECFD
1091 even if it would be passed up.
1093 We leave the values here defined to 0. This is normally no
1094 problem as the program code itself is normally no shared
1095 object and therefore cannot be loaded dynamically. Nothing
1096 prevent the use of dynamic binaries and in these situations
1097 we might get problems. We might not be able to find out
1098 whether the object is already loaded. But since there is no
1099 easy way out and because the dynamic binary must also not
1100 have an SONAME we ignore this program for now. If it becomes
1101 a problem we can force people using SONAMEs. */
1103 /* We delay initializing the path structure until we got the dynamic
1104 information for the program. */
1107 main_map
->l_map_end
= 0;
1108 main_map
->l_text_end
= 0;
1109 /* Perhaps the executable has no PT_LOAD header entries at all. */
1110 main_map
->l_map_start
= ~0;
1111 /* And it was opened directly. */
1112 ++main_map
->l_direct_opencount
;
1114 /* Scan the program header table for the dynamic section. */
1115 for (ph
= phdr
; ph
< &phdr
[phnum
]; ++ph
)
1119 /* Find out the load address. */
1120 main_map
->l_addr
= (ElfW(Addr
)) phdr
- ph
->p_vaddr
;
1123 /* This tells us where to find the dynamic section,
1124 which tells us everything we need to do. */
1125 main_map
->l_ld
= (void *) main_map
->l_addr
+ ph
->p_vaddr
;
1128 /* This "interpreter segment" was used by the program loader to
1129 find the program interpreter, which is this program itself, the
1130 dynamic linker. We note what name finds us, so that a future
1131 dlopen call or DT_NEEDED entry, for something that wants to link
1132 against the dynamic linker as a shared library, will know that
1133 the shared object is already loaded. */
1134 _dl_rtld_libname
.name
= ((const char *) main_map
->l_addr
1136 /* _dl_rtld_libname.next = NULL; Already zero. */
1137 GL(dl_rtld_map
).l_libname
= &_dl_rtld_libname
;
1139 /* Ordinarilly, we would get additional names for the loader from
1140 our DT_SONAME. This can't happen if we were actually linked as
1141 a static executable (detect this case when we have no DYNAMIC).
1142 If so, assume the filename component of the interpreter path to
1143 be our SONAME, and add it to our name list. */
1144 if (GL(dl_rtld_map
).l_ld
== NULL
)
1146 const char *p
= NULL
;
1147 const char *cp
= _dl_rtld_libname
.name
;
1149 /* Find the filename part of the path. */
1156 _dl_rtld_libname2
.name
= p
;
1157 /* _dl_rtld_libname2.next = NULL; Already zero. */
1158 _dl_rtld_libname
.next
= &_dl_rtld_libname2
;
1166 ElfW(Addr
) mapstart
;
1167 ElfW(Addr
) allocend
;
1169 /* Remember where the main program starts in memory. */
1170 mapstart
= (main_map
->l_addr
1171 + (ph
->p_vaddr
& ~(GLRO(dl_pagesize
) - 1)));
1172 if (main_map
->l_map_start
> mapstart
)
1173 main_map
->l_map_start
= mapstart
;
1175 /* Also where it ends. */
1176 allocend
= main_map
->l_addr
+ ph
->p_vaddr
+ ph
->p_memsz
;
1177 if (main_map
->l_map_end
< allocend
)
1178 main_map
->l_map_end
= allocend
;
1179 if ((ph
->p_flags
& PF_X
) && allocend
> main_map
->l_text_end
)
1180 main_map
->l_text_end
= allocend
;
1185 if (ph
->p_memsz
> 0)
1187 /* Note that in the case the dynamic linker we duplicate work
1188 here since we read the PT_TLS entry already in
1189 _dl_start_final. But the result is repeatable so do not
1190 check for this special but unimportant case. */
1191 main_map
->l_tls_blocksize
= ph
->p_memsz
;
1192 main_map
->l_tls_align
= ph
->p_align
;
1193 if (ph
->p_align
== 0)
1194 main_map
->l_tls_firstbyte_offset
= 0;
1196 main_map
->l_tls_firstbyte_offset
= (ph
->p_vaddr
1197 & (ph
->p_align
- 1));
1198 main_map
->l_tls_initimage_size
= ph
->p_filesz
;
1199 main_map
->l_tls_initimage
= (void *) ph
->p_vaddr
;
1201 /* This image gets the ID one. */
1202 GL(dl_tls_max_dtv_idx
) = main_map
->l_tls_modid
= 1;
1207 GL(dl_stack_flags
) = ph
->p_flags
;
1211 main_map
->l_relro_addr
= ph
->p_vaddr
;
1212 main_map
->l_relro_size
= ph
->p_memsz
;
1216 /* Adjust the address of the TLS initialization image in case
1217 the executable is actually an ET_DYN object. */
1218 if (main_map
->l_tls_initimage
!= NULL
)
1219 main_map
->l_tls_initimage
1220 = (char *) main_map
->l_tls_initimage
+ main_map
->l_addr
;
1221 if (! main_map
->l_map_end
)
1222 main_map
->l_map_end
= ~0;
1223 if (! main_map
->l_text_end
)
1224 main_map
->l_text_end
= ~0;
1225 if (! GL(dl_rtld_map
).l_libname
&& GL(dl_rtld_map
).l_name
)
1227 /* We were invoked directly, so the program might not have a
1229 _dl_rtld_libname
.name
= GL(dl_rtld_map
).l_name
;
1230 /* _dl_rtld_libname.next = NULL; Already zero. */
1231 GL(dl_rtld_map
).l_libname
= &_dl_rtld_libname
;
1234 assert (GL(dl_rtld_map
).l_libname
); /* How else did we get here? */
1236 /* If the current libname is different from the SONAME, add the
1238 if (GL(dl_rtld_map
).l_info
[DT_SONAME
] != NULL
1239 && strcmp (GL(dl_rtld_map
).l_libname
->name
,
1240 (const char *) D_PTR (&GL(dl_rtld_map
), l_info
[DT_STRTAB
])
1241 + GL(dl_rtld_map
).l_info
[DT_SONAME
]->d_un
.d_val
) != 0)
1243 static struct libname_list newname
;
1244 newname
.name
= ((char *) D_PTR (&GL(dl_rtld_map
), l_info
[DT_STRTAB
])
1245 + GL(dl_rtld_map
).l_info
[DT_SONAME
]->d_un
.d_ptr
);
1246 newname
.next
= NULL
;
1247 newname
.dont_free
= 1;
1249 assert (GL(dl_rtld_map
).l_libname
->next
== NULL
);
1250 GL(dl_rtld_map
).l_libname
->next
= &newname
;
1252 /* The ld.so must be relocated since otherwise loading audit modules
1253 will fail since they reuse the very same ld.so. */
1254 assert (GL(dl_rtld_map
).l_relocated
);
1258 /* Extract the contents of the dynamic section for easy access. */
1259 elf_get_dynamic_info (main_map
, NULL
);
1260 /* Set up our cache of pointers into the hash table. */
1261 _dl_setup_hash (main_map
);
1264 if (__builtin_expect (mode
, normal
) == verify
)
1266 /* We were called just to verify that this is a dynamic
1267 executable using us as the program interpreter. Exit with an
1268 error if we were not able to load the binary or no interpreter
1269 is specified (i.e., this is no dynamically linked binary. */
1270 if (main_map
->l_ld
== NULL
)
1273 /* We allow here some platform specific code. */
1274 #ifdef DISTINGUISH_LIB_VERSIONS
1275 DISTINGUISH_LIB_VERSIONS
;
1277 _exit (has_interp
? 0 : 2);
1280 struct link_map
**first_preload
= &GL(dl_rtld_map
).l_next
;
1281 #if defined NEED_DL_SYSINFO || defined NEED_DL_SYSINFO_DSO
1282 /* Set up the data structures for the system-supplied DSO early,
1283 so they can influence _dl_init_paths. */
1284 if (GLRO(dl_sysinfo_dso
) != NULL
)
1286 /* Do an abridged version of the work _dl_map_object_from_fd would do
1287 to map in the object. It's already mapped and prelinked (and
1288 better be, since it's read-only and so we couldn't relocate it).
1289 We just want our data structures to describe it as if we had just
1290 mapped and relocated it normally. */
1291 struct link_map
*l
= _dl_new_object ((char *) "", "", lt_library
, NULL
,
1293 if (__builtin_expect (l
!= NULL
, 1))
1295 static ElfW(Dyn
) dyn_temp
[DL_RO_DYN_TEMP_CNT
] attribute_relro
;
1297 l
->l_phdr
= ((const void *) GLRO(dl_sysinfo_dso
)
1298 + GLRO(dl_sysinfo_dso
)->e_phoff
);
1299 l
->l_phnum
= GLRO(dl_sysinfo_dso
)->e_phnum
;
1300 for (uint_fast16_t i
= 0; i
< l
->l_phnum
; ++i
)
1302 const ElfW(Phdr
) *const ph
= &l
->l_phdr
[i
];
1303 if (ph
->p_type
== PT_DYNAMIC
)
1305 l
->l_ld
= (void *) ph
->p_vaddr
;
1306 l
->l_ldnum
= ph
->p_memsz
/ sizeof (ElfW(Dyn
));
1308 else if (ph
->p_type
== PT_LOAD
)
1311 l
->l_addr
= ph
->p_vaddr
;
1312 if (ph
->p_vaddr
+ ph
->p_memsz
>= l
->l_map_end
)
1313 l
->l_map_end
= ph
->p_vaddr
+ ph
->p_memsz
;
1314 if ((ph
->p_flags
& PF_X
)
1315 && ph
->p_vaddr
+ ph
->p_memsz
>= l
->l_text_end
)
1316 l
->l_text_end
= ph
->p_vaddr
+ ph
->p_memsz
;
1319 /* There must be no TLS segment. */
1320 assert (ph
->p_type
!= PT_TLS
);
1322 l
->l_map_start
= (ElfW(Addr
)) GLRO(dl_sysinfo_dso
);
1323 l
->l_addr
= l
->l_map_start
- l
->l_addr
;
1324 l
->l_map_end
+= l
->l_addr
;
1325 l
->l_text_end
+= l
->l_addr
;
1326 l
->l_ld
= (void *) ((ElfW(Addr
)) l
->l_ld
+ l
->l_addr
);
1327 elf_get_dynamic_info (l
, dyn_temp
);
1331 /* Initialize l_local_scope to contain just this map. This allows
1332 the use of dl_lookup_symbol_x to resolve symbols within the vdso.
1333 So we create a single entry list pointing to l_real as its only
1335 l
->l_local_scope
[0]->r_nlist
= 1;
1336 l
->l_local_scope
[0]->r_list
= &l
->l_real
;
1338 /* Now that we have the info handy, use the DSO image's soname
1339 so this object can be looked up by name. Note that we do not
1340 set l_name here. That field gives the file name of the DSO,
1341 and this DSO is not associated with any file. */
1342 if (l
->l_info
[DT_SONAME
] != NULL
)
1344 /* Work around a kernel problem. The kernel cannot handle
1345 addresses in the vsyscall DSO pages in writev() calls. */
1346 const char *dsoname
= ((char *) D_PTR (l
, l_info
[DT_STRTAB
])
1347 + l
->l_info
[DT_SONAME
]->d_un
.d_val
);
1348 size_t len
= strlen (dsoname
);
1349 char *copy
= malloc (len
);
1351 _dl_fatal_printf ("out of memory\n");
1352 l
->l_libname
->name
= memcpy (copy
, dsoname
, len
);
1355 /* Rearrange the list so this DSO appears after rtld_map. */
1356 assert (l
->l_next
== NULL
);
1357 assert (l
->l_prev
== main_map
);
1358 GL(dl_rtld_map
).l_next
= l
;
1359 l
->l_prev
= &GL(dl_rtld_map
);
1360 first_preload
= &l
->l_next
;
1362 /* We have a prelinked DSO preloaded by the system. */
1363 GLRO(dl_sysinfo_map
) = l
;
1364 # ifdef NEED_DL_SYSINFO
1365 if (GLRO(dl_sysinfo
) == DL_SYSINFO_DEFAULT
)
1366 GLRO(dl_sysinfo
) = GLRO(dl_sysinfo_dso
)->e_entry
+ l
->l_addr
;
1372 #ifdef DL_SYSDEP_OSCHECK
1373 DL_SYSDEP_OSCHECK (dl_fatal
);
1376 /* Initialize the data structures for the search paths for shared
1378 _dl_init_paths (library_path
);
1380 /* Initialize _r_debug. */
1381 struct r_debug
*r
= _dl_debug_initialize (GL(dl_rtld_map
).l_addr
,
1383 r
->r_state
= RT_CONSISTENT
;
1385 /* Put the link_map for ourselves on the chain so it can be found by
1386 name. Note that at this point the global chain of link maps contains
1387 exactly one element, which is pointed to by dl_loaded. */
1388 if (! GL(dl_rtld_map
).l_name
)
1389 /* If not invoked directly, the dynamic linker shared object file was
1390 found by the PT_INTERP name. */
1391 GL(dl_rtld_map
).l_name
= (char *) GL(dl_rtld_map
).l_libname
->name
;
1392 GL(dl_rtld_map
).l_type
= lt_library
;
1393 main_map
->l_next
= &GL(dl_rtld_map
);
1394 GL(dl_rtld_map
).l_prev
= main_map
;
1395 ++GL(dl_ns
)[LM_ID_BASE
]._ns_nloaded
;
1398 /* If LD_USE_LOAD_BIAS env variable has not been seen, default
1399 to not using bias for non-prelinked PIEs and libraries
1400 and using it for executables or prelinked PIEs or libraries. */
1401 if (GLRO(dl_use_load_bias
) == (ElfW(Addr
)) -2)
1402 GLRO(dl_use_load_bias
) = main_map
->l_addr
== 0 ? -1 : 0;
1404 /* Set up the program header information for the dynamic linker
1405 itself. It is needed in the dl_iterate_phdr() callbacks. */
1406 ElfW(Ehdr
) *rtld_ehdr
= (ElfW(Ehdr
) *) GL(dl_rtld_map
).l_map_start
;
1407 ElfW(Phdr
) *rtld_phdr
= (ElfW(Phdr
) *) (GL(dl_rtld_map
).l_map_start
1408 + rtld_ehdr
->e_phoff
);
1409 GL(dl_rtld_map
).l_phdr
= rtld_phdr
;
1410 GL(dl_rtld_map
).l_phnum
= rtld_ehdr
->e_phnum
;
1413 /* PT_GNU_RELRO is usually the last phdr. */
1414 size_t cnt
= rtld_ehdr
->e_phnum
;
1416 if (rtld_phdr
[cnt
].p_type
== PT_GNU_RELRO
)
1418 GL(dl_rtld_map
).l_relro_addr
= rtld_phdr
[cnt
].p_vaddr
;
1419 GL(dl_rtld_map
).l_relro_size
= rtld_phdr
[cnt
].p_memsz
;
1423 /* Add the dynamic linker to the TLS list if it also uses TLS. */
1424 if (GL(dl_rtld_map
).l_tls_blocksize
!= 0)
1425 /* Assign a module ID. Do this before loading any audit modules. */
1426 GL(dl_rtld_map
).l_tls_modid
= _dl_next_tls_modid ();
1428 /* If we have auditing DSOs to load, do it now. */
1429 if (__builtin_expect (audit_list
!= NULL
, 0))
1431 /* Iterate over all entries in the list. The order is important. */
1432 struct audit_ifaces
*last_audit
= NULL
;
1433 struct audit_list
*al
= audit_list
->next
;
1435 /* Since we start using the auditing DSOs right away we need to
1436 initialize the data structures now. */
1439 /* Initialize security features. We need to do it this early
1440 since otherwise the constructors of the audit libraries will
1441 use different values (especially the pointer guard) and will
1447 int tls_idx
= GL(dl_tls_max_dtv_idx
);
1449 /* Now it is time to determine the layout of the static TLS
1450 block and allocate it for the initial thread. Note that we
1451 always allocate the static block, we never defer it even if
1452 no DF_STATIC_TLS bit is set. The reason is that we know
1453 glibc will use the static model. */
1454 struct dlmopen_args dlmargs
;
1455 dlmargs
.fname
= al
->name
;
1458 const char *objname
;
1459 const char *err_str
= NULL
;
1461 (void) _dl_catch_error (&objname
, &err_str
, &malloced
, dlmopen_doit
,
1463 if (__builtin_expect (err_str
!= NULL
, 0))
1466 _dl_error_printf ("\
1467 ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n",
1470 free ((char *) err_str
);
1474 struct lookup_args largs
;
1475 largs
.name
= "la_version";
1476 largs
.map
= dlmargs
.map
;
1478 /* Check whether the interface version matches. */
1479 (void) _dl_catch_error (&objname
, &err_str
, &malloced
,
1480 lookup_doit
, &largs
);
1482 unsigned int (*laversion
) (unsigned int);
1485 && (laversion
= largs
.result
) != NULL
1486 && (lav
= laversion (LAV_CURRENT
)) > 0
1487 && lav
<= LAV_CURRENT
)
1489 /* Allocate structure for the callback function pointers.
1490 This call can never fail. */
1493 struct audit_ifaces ifaces
;
1494 #define naudit_ifaces 8
1495 void (*fptr
[naudit_ifaces
]) (void);
1496 } *newp
= malloc (sizeof (*newp
));
1498 /* Names of the auditing interfaces. All in one
1500 static const char audit_iface_names
[] =
1505 #if __ELF_NATIVE_CLASS == 32
1507 #elif __ELF_NATIVE_CLASS == 64
1510 # error "__ELF_NATIVE_CLASS must be defined"
1512 #define STRING(s) __STRING (s)
1513 "la_" STRING (ARCH_LA_PLTENTER
) "\0"
1514 "la_" STRING (ARCH_LA_PLTEXIT
) "\0"
1516 unsigned int cnt
= 0;
1517 const char *cp
= audit_iface_names
;
1521 (void) _dl_catch_error (&objname
, &err_str
, &malloced
,
1522 lookup_doit
, &largs
);
1524 /* Store the pointer. */
1525 if (err_str
== NULL
&& largs
.result
!= NULL
)
1527 newp
->fptr
[cnt
] = largs
.result
;
1529 /* The dynamic linker link map is statically
1530 allocated, initialize the data now. */
1531 GL(dl_rtld_map
).l_audit
[cnt
].cookie
1532 = (intptr_t) &GL(dl_rtld_map
);
1535 newp
->fptr
[cnt
] = NULL
;
1538 cp
= (char *) rawmemchr (cp
, '\0') + 1;
1540 while (*cp
!= '\0');
1541 assert (cnt
== naudit_ifaces
);
1543 /* Now append the new auditing interface to the list. */
1544 newp
->ifaces
.next
= NULL
;
1545 if (last_audit
== NULL
)
1546 last_audit
= GLRO(dl_audit
) = &newp
->ifaces
;
1548 last_audit
= last_audit
->next
= &newp
->ifaces
;
1551 /* Mark the DSO as being used for auditing. */
1552 dlmargs
.map
->l_auditing
= 1;
1556 /* We cannot use the DSO, it does not have the
1557 appropriate interfaces or it expects something
1560 Lmid_t ns
= dlmargs
.map
->l_ns
;
1562 _dl_close (dlmargs
.map
);
1564 /* Make sure the namespace has been cleared entirely. */
1565 assert (GL(dl_ns
)[ns
]._ns_loaded
== NULL
);
1566 assert (GL(dl_ns
)[ns
]._ns_nloaded
== 0);
1568 GL(dl_tls_max_dtv_idx
) = tls_idx
;
1575 while (al
!= audit_list
->next
);
1577 /* If we have any auditing modules, announce that we already
1578 have two objects loaded. */
1579 if (__builtin_expect (GLRO(dl_naudit
) > 0, 0))
1581 struct link_map
*ls
[2] = { main_map
, &GL(dl_rtld_map
) };
1583 for (unsigned int outer
= 0; outer
< 2; ++outer
)
1585 struct audit_ifaces
*afct
= GLRO(dl_audit
);
1586 for (unsigned int cnt
= 0; cnt
< GLRO(dl_naudit
); ++cnt
)
1588 if (afct
->objopen
!= NULL
)
1590 ls
[outer
]->l_audit
[cnt
].bindflags
1591 = afct
->objopen (ls
[outer
], LM_ID_BASE
,
1592 &ls
[outer
]->l_audit
[cnt
].cookie
);
1594 ls
[outer
]->l_audit_any_plt
1595 |= ls
[outer
]->l_audit
[cnt
].bindflags
!= 0;
1604 /* Set up debugging before the debugger is notified for the first time. */
1605 #ifdef ELF_MACHINE_DEBUG_SETUP
1606 /* Some machines (e.g. MIPS) don't use DT_DEBUG in this way. */
1607 ELF_MACHINE_DEBUG_SETUP (main_map
, r
);
1608 ELF_MACHINE_DEBUG_SETUP (&GL(dl_rtld_map
), r
);
1610 if (main_map
->l_info
[DT_DEBUG
] != NULL
)
1611 /* There is a DT_DEBUG entry in the dynamic section. Fill it in
1612 with the run-time address of the r_debug structure */
1613 main_map
->l_info
[DT_DEBUG
]->d_un
.d_ptr
= (ElfW(Addr
)) r
;
1615 /* Fill in the pointer in the dynamic linker's own dynamic section, in
1616 case you run gdb on the dynamic linker directly. */
1617 if (GL(dl_rtld_map
).l_info
[DT_DEBUG
] != NULL
)
1618 GL(dl_rtld_map
).l_info
[DT_DEBUG
]->d_un
.d_ptr
= (ElfW(Addr
)) r
;
1621 /* We start adding objects. */
1622 r
->r_state
= RT_ADD
;
1625 /* Auditing checkpoint: we are ready to signal that the initial map
1626 is being constructed. */
1627 if (__builtin_expect (GLRO(dl_naudit
) > 0, 0))
1629 struct audit_ifaces
*afct
= GLRO(dl_audit
);
1630 for (unsigned int cnt
= 0; cnt
< GLRO(dl_naudit
); ++cnt
)
1632 if (afct
->activity
!= NULL
)
1633 afct
->activity (&main_map
->l_audit
[cnt
].cookie
, LA_ACT_ADD
);
1639 /* We have two ways to specify objects to preload: via environment
1640 variable and via the file /etc/ld.so.preload. The latter can also
1641 be used when security is enabled. */
1642 assert (*first_preload
== NULL
);
1643 struct link_map
**preloads
= NULL
;
1644 unsigned int npreloads
= 0;
1646 if (__builtin_expect (preloadlist
!= NULL
, 0))
1648 /* The LD_PRELOAD environment variable gives list of libraries
1649 separated by white space or colons that are loaded before the
1650 executable's dependencies and prepended to the global scope
1651 list. If the binary is running setuid all elements
1652 containing a '/' are ignored since it is insecure. */
1653 char *list
= strdupa (preloadlist
);
1656 HP_TIMING_NOW (start
);
1658 /* Prevent optimizing strsep. Speed is not important here. */
1659 while ((p
= (strsep
) (&list
, " :")) != NULL
)
1661 && (__builtin_expect (! INTUSE(__libc_enable_secure
), 1)
1662 || strchr (p
, '/') == NULL
))
1663 npreloads
+= do_preload (p
, main_map
, "LD_PRELOAD");
1665 HP_TIMING_NOW (stop
);
1666 HP_TIMING_DIFF (diff
, start
, stop
);
1667 HP_TIMING_ACCUM_NT (load_time
, diff
);
1670 /* There usually is no ld.so.preload file, it should only be used
1671 for emergencies and testing. So the open call etc should usually
1672 fail. Using access() on a non-existing file is faster than using
1673 open(). So we do this first. If it succeeds we do almost twice
1674 the work but this does not matter, since it is not for production
1676 static const char preload_file
[] = "/etc/ld.so.preload";
1677 if (__builtin_expect (__access (preload_file
, R_OK
) == 0, 0))
1679 /* Read the contents of the file. */
1680 file
= _dl_sysdep_read_whole_file (preload_file
, &file_size
,
1681 PROT_READ
| PROT_WRITE
);
1682 if (__builtin_expect (file
!= MAP_FAILED
, 0))
1684 /* Parse the file. It contains names of libraries to be loaded,
1685 separated by white spaces or `:'. It may also contain
1686 comments introduced by `#'. */
1691 /* Eliminate comments. */
1696 char *comment
= memchr (runp
, '#', rest
);
1697 if (comment
== NULL
)
1700 rest
-= comment
- runp
;
1703 while (--rest
> 0 && *++comment
!= '\n');
1706 /* We have one problematic case: if we have a name at the end of
1707 the file without a trailing terminating characters, we cannot
1708 place the \0. Handle the case separately. */
1709 if (file
[file_size
- 1] != ' ' && file
[file_size
- 1] != '\t'
1710 && file
[file_size
- 1] != '\n' && file
[file_size
- 1] != ':')
1712 problem
= &file
[file_size
];
1713 while (problem
> file
&& problem
[-1] != ' '
1714 && problem
[-1] != '\t'
1715 && problem
[-1] != '\n' && problem
[-1] != ':')
1724 file
[file_size
- 1] = '\0';
1727 HP_TIMING_NOW (start
);
1729 if (file
!= problem
)
1733 while ((p
= strsep (&runp
, ": \t\n")) != NULL
)
1735 npreloads
+= do_preload (p
, main_map
, preload_file
);
1738 if (problem
!= NULL
)
1740 char *p
= strndupa (problem
, file_size
- (problem
- file
));
1742 npreloads
+= do_preload (p
, main_map
, preload_file
);
1745 HP_TIMING_NOW (stop
);
1746 HP_TIMING_DIFF (diff
, start
, stop
);
1747 HP_TIMING_ACCUM_NT (load_time
, diff
);
1749 /* We don't need the file anymore. */
1750 __munmap (file
, file_size
);
1754 if (__builtin_expect (*first_preload
!= NULL
, 0))
1756 /* Set up PRELOADS with a vector of the preloaded libraries. */
1757 struct link_map
*l
= *first_preload
;
1758 preloads
= __alloca (npreloads
* sizeof preloads
[0]);
1765 assert (i
== npreloads
);
1768 /* Load all the libraries specified by DT_NEEDED entries. If LD_PRELOAD
1769 specified some libraries to load, these are inserted before the actual
1770 dependencies in the executable's searchlist for symbol resolution. */
1771 HP_TIMING_NOW (start
);
1772 _dl_map_object_deps (main_map
, preloads
, npreloads
, mode
== trace
, 0);
1773 HP_TIMING_NOW (stop
);
1774 HP_TIMING_DIFF (diff
, start
, stop
);
1775 HP_TIMING_ACCUM_NT (load_time
, diff
);
1777 /* Mark all objects as being in the global scope. */
1778 for (i
= main_map
->l_searchlist
.r_nlist
; i
> 0; )
1779 main_map
->l_searchlist
.r_list
[--i
]->l_global
= 1;
1782 /* We are done mapping things, so close the zero-fill descriptor. */
1783 __close (_dl_zerofd
);
1787 /* Remove _dl_rtld_map from the chain. */
1788 GL(dl_rtld_map
).l_prev
->l_next
= GL(dl_rtld_map
).l_next
;
1789 if (GL(dl_rtld_map
).l_next
!= NULL
)
1790 GL(dl_rtld_map
).l_next
->l_prev
= GL(dl_rtld_map
).l_prev
;
1792 for (i
= 1; i
< main_map
->l_searchlist
.r_nlist
; ++i
)
1793 if (main_map
->l_searchlist
.r_list
[i
] == &GL(dl_rtld_map
))
1796 bool rtld_multiple_ref
= false;
1797 if (__builtin_expect (i
< main_map
->l_searchlist
.r_nlist
, 1))
1799 /* Some DT_NEEDED entry referred to the interpreter object itself, so
1800 put it back in the list of visible objects. We insert it into the
1801 chain in symbol search order because gdb uses the chain's order as
1802 its symbol search order. */
1803 rtld_multiple_ref
= true;
1805 GL(dl_rtld_map
).l_prev
= main_map
->l_searchlist
.r_list
[i
- 1];
1806 if (__builtin_expect (mode
, normal
) == normal
)
1808 GL(dl_rtld_map
).l_next
= (i
+ 1 < main_map
->l_searchlist
.r_nlist
1809 ? main_map
->l_searchlist
.r_list
[i
+ 1]
1811 #if defined NEED_DL_SYSINFO || defined NEED_DL_SYSINFO_DSO
1812 if (GLRO(dl_sysinfo_map
) != NULL
1813 && GL(dl_rtld_map
).l_prev
->l_next
== GLRO(dl_sysinfo_map
)
1814 && GL(dl_rtld_map
).l_next
!= GLRO(dl_sysinfo_map
))
1815 GL(dl_rtld_map
).l_prev
= GLRO(dl_sysinfo_map
);
1819 /* In trace mode there might be an invisible object (which we
1820 could not find) after the previous one in the search list.
1821 In this case it doesn't matter much where we put the
1822 interpreter object, so we just initialize the list pointer so
1823 that the assertion below holds. */
1824 GL(dl_rtld_map
).l_next
= GL(dl_rtld_map
).l_prev
->l_next
;
1826 assert (GL(dl_rtld_map
).l_prev
->l_next
== GL(dl_rtld_map
).l_next
);
1827 GL(dl_rtld_map
).l_prev
->l_next
= &GL(dl_rtld_map
);
1828 if (GL(dl_rtld_map
).l_next
!= NULL
)
1830 assert (GL(dl_rtld_map
).l_next
->l_prev
== GL(dl_rtld_map
).l_prev
);
1831 GL(dl_rtld_map
).l_next
->l_prev
= &GL(dl_rtld_map
);
1835 /* Now let us see whether all libraries are available in the
1836 versions we need. */
1838 struct version_check_args args
;
1839 args
.doexit
= mode
== normal
;
1840 args
.dotrace
= mode
== trace
;
1841 _dl_receive_error (print_missing_version
, version_check_doit
, &args
);
1844 /* We do not initialize any of the TLS functionality unless any of the
1845 initial modules uses TLS. This makes dynamic loading of modules with
1846 TLS impossible, but to support it requires either eagerly doing setup
1847 now or lazily doing it later. Doing it now makes us incompatible with
1848 an old kernel that can't perform TLS_INIT_TP, even if no TLS is ever
1849 used. Trying to do it lazily is too hairy to try when there could be
1850 multiple threads (from a non-TLS-using libpthread). */
1851 bool was_tls_init_tp_called
= tls_init_tp_called
;
1855 if (__builtin_expect (audit_list
== NULL
, 1))
1856 /* Initialize security features. But only if we have not done it
1860 if (__builtin_expect (mode
, normal
) != normal
)
1862 /* We were run just to list the shared libraries. It is
1863 important that we do this before real relocation, because the
1864 functions we call below for output may no longer work properly
1865 after relocation. */
1868 if (GLRO(dl_debug_mask
) & DL_DEBUG_PRELINK
)
1870 struct r_scope_elem
*scope
= &main_map
->l_searchlist
;
1872 for (i
= 0; i
< scope
->r_nlist
; i
++)
1874 l
= scope
->r_list
[i
];
1877 _dl_printf ("\t%s => not found\n", l
->l_libname
->name
);
1880 if (_dl_name_match_p (GLRO(dl_trace_prelink
), l
))
1881 GLRO(dl_trace_prelink_map
) = l
;
1882 _dl_printf ("\t%s => %s (0x%0*Zx, 0x%0*Zx)",
1883 l
->l_libname
->name
[0] ? l
->l_libname
->name
1884 : rtld_progname
?: "<main program>",
1885 l
->l_name
[0] ? l
->l_name
1886 : rtld_progname
?: "<main program>",
1887 (int) sizeof l
->l_map_start
* 2,
1888 (size_t) l
->l_map_start
,
1889 (int) sizeof l
->l_addr
* 2,
1890 (size_t) l
->l_addr
);
1893 _dl_printf (" TLS(0x%Zx, 0x%0*Zx)\n", l
->l_tls_modid
,
1894 (int) sizeof l
->l_tls_offset
* 2,
1895 (size_t) l
->l_tls_offset
);
1900 else if (GLRO(dl_debug_mask
) & DL_DEBUG_UNUSED
)
1902 /* Look through the dependencies of the main executable
1903 and determine which of them is not actually
1905 struct link_map
*l
= main_map
;
1907 /* Relocate the main executable. */
1908 struct relocate_args args
= { .l
= l
, .lazy
= GLRO(dl_lazy
) };
1909 _dl_receive_error (print_unresolved
, relocate_doit
, &args
);
1911 /* This loop depends on the dependencies of the executable to
1912 correspond in number and order to the DT_NEEDED entries. */
1913 ElfW(Dyn
) *dyn
= main_map
->l_ld
;
1915 while (dyn
->d_tag
!= DT_NULL
)
1917 if (dyn
->d_tag
== DT_NEEDED
)
1925 _dl_printf ("Unused direct dependencies:\n");
1929 _dl_printf ("\t%s\n", l
->l_name
);
1936 _exit (first
!= true);
1938 else if (! main_map
->l_info
[DT_NEEDED
])
1939 _dl_printf ("\tstatically linked\n");
1942 for (l
= main_map
->l_next
; l
; l
= l
->l_next
)
1944 /* The library was not found. */
1945 _dl_printf ("\t%s => not found\n", l
->l_libname
->name
);
1946 else if (strcmp (l
->l_libname
->name
, l
->l_name
) == 0)
1947 _dl_printf ("\t%s (0x%0*Zx)\n", l
->l_libname
->name
,
1948 (int) sizeof l
->l_map_start
* 2,
1949 (size_t) l
->l_map_start
);
1951 _dl_printf ("\t%s => %s (0x%0*Zx)\n", l
->l_libname
->name
,
1952 l
->l_name
, (int) sizeof l
->l_map_start
* 2,
1953 (size_t) l
->l_map_start
);
1956 if (__builtin_expect (mode
, trace
) != trace
)
1957 for (i
= 1; i
< (unsigned int) _dl_argc
; ++i
)
1959 const ElfW(Sym
) *ref
= NULL
;
1960 ElfW(Addr
) loadbase
;
1963 result
= _dl_lookup_symbol_x (INTUSE(_dl_argv
)[i
], main_map
,
1964 &ref
, main_map
->l_scope
,
1965 NULL
, ELF_RTYPE_CLASS_PLT
,
1966 DL_LOOKUP_ADD_DEPENDENCY
, NULL
);
1968 loadbase
= LOOKUP_VALUE_ADDRESS (result
);
1970 _dl_printf ("%s found at 0x%0*Zd in object at 0x%0*Zd\n",
1971 INTUSE(_dl_argv
)[i
],
1972 (int) sizeof ref
->st_value
* 2,
1973 (size_t) ref
->st_value
,
1974 (int) sizeof loadbase
* 2, (size_t) loadbase
);
1978 /* If LD_WARN is set, warn about undefined symbols. */
1979 if (GLRO(dl_lazy
) >= 0 && GLRO(dl_verbose
))
1981 /* We have to do symbol dependency testing. */
1982 struct relocate_args args
;
1985 args
.lazy
= GLRO(dl_lazy
);
1988 while (l
->l_next
!= NULL
)
1992 if (l
!= &GL(dl_rtld_map
) && ! l
->l_faked
)
1995 _dl_receive_error (print_unresolved
, relocate_doit
,
2002 if ((GLRO(dl_debug_mask
) & DL_DEBUG_PRELINK
)
2003 && rtld_multiple_ref
)
2005 /* Mark the link map as not yet relocated again. */
2006 GL(dl_rtld_map
).l_relocated
= 0;
2007 _dl_relocate_object (&GL(dl_rtld_map
),
2008 main_map
->l_scope
, 0, 0);
2011 #define VERNEEDTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERNEED))
2014 /* Print more information. This means here, print information
2015 about the versions needed. */
2017 struct link_map
*map
;
2019 for (map
= main_map
; map
!= NULL
; map
= map
->l_next
)
2022 ElfW(Dyn
) *dyn
= map
->l_info
[VERNEEDTAG
];
2028 strtab
= (const void *) D_PTR (map
, l_info
[DT_STRTAB
]);
2029 ent
= (ElfW(Verneed
) *) (map
->l_addr
+ dyn
->d_un
.d_ptr
);
2033 _dl_printf ("\n\tVersion information:\n");
2037 _dl_printf ("\t%s:\n",
2038 map
->l_name
[0] ? map
->l_name
: rtld_progname
);
2043 struct link_map
*needed
;
2045 needed
= find_needed (strtab
+ ent
->vn_file
);
2046 aux
= (ElfW(Vernaux
) *) ((char *) ent
+ ent
->vn_aux
);
2050 const char *fname
= NULL
;
2053 && match_version (strtab
+ aux
->vna_name
,
2055 fname
= needed
->l_name
;
2057 _dl_printf ("\t\t%s (%s) %s=> %s\n",
2058 strtab
+ ent
->vn_file
,
2059 strtab
+ aux
->vna_name
,
2060 aux
->vna_flags
& VER_FLG_WEAK
2062 fname
?: "not found");
2064 if (aux
->vna_next
== 0)
2065 /* No more symbols. */
2069 aux
= (ElfW(Vernaux
) *) ((char *) aux
2073 if (ent
->vn_next
== 0)
2074 /* No more dependencies. */
2077 /* Next dependency. */
2078 ent
= (ElfW(Verneed
) *) ((char *) ent
+ ent
->vn_next
);
2087 if (main_map
->l_info
[ADDRIDX (DT_GNU_LIBLIST
)]
2088 && ! __builtin_expect (GLRO(dl_profile
) != NULL
, 0)
2089 && ! __builtin_expect (GLRO(dl_dynamic_weak
), 0))
2091 ElfW(Lib
) *liblist
, *liblistend
;
2092 struct link_map
**r_list
, **r_listend
, *l
;
2093 const char *strtab
= (const void *) D_PTR (main_map
, l_info
[DT_STRTAB
]);
2095 assert (main_map
->l_info
[VALIDX (DT_GNU_LIBLISTSZ
)] != NULL
);
2096 liblist
= (ElfW(Lib
) *)
2097 main_map
->l_info
[ADDRIDX (DT_GNU_LIBLIST
)]->d_un
.d_ptr
;
2098 liblistend
= (ElfW(Lib
) *)
2100 main_map
->l_info
[VALIDX (DT_GNU_LIBLISTSZ
)]->d_un
.d_val
);
2101 r_list
= main_map
->l_searchlist
.r_list
;
2102 r_listend
= r_list
+ main_map
->l_searchlist
.r_nlist
;
2104 for (; r_list
< r_listend
&& liblist
< liblistend
; r_list
++)
2111 /* If the library is not mapped where it should, fail. */
2115 /* Next, check if checksum matches. */
2116 if (l
->l_info
[VALIDX(DT_CHECKSUM
)] == NULL
2117 || l
->l_info
[VALIDX(DT_CHECKSUM
)]->d_un
.d_val
2118 != liblist
->l_checksum
)
2121 if (l
->l_info
[VALIDX(DT_GNU_PRELINKED
)] == NULL
2122 || l
->l_info
[VALIDX(DT_GNU_PRELINKED
)]->d_un
.d_val
2123 != liblist
->l_time_stamp
)
2126 if (! _dl_name_match_p (strtab
+ liblist
->l_name
, l
))
2133 if (r_list
== r_listend
&& liblist
== liblistend
)
2136 if (__builtin_expect (GLRO(dl_debug_mask
) & DL_DEBUG_LIBS
, 0))
2137 _dl_debug_printf ("\nprelink checking: %s\n",
2138 prelinked
? "ok" : "failed");
2142 /* Now set up the variable which helps the assembler startup code. */
2143 GL(dl_ns
)[LM_ID_BASE
]._ns_main_searchlist
= &main_map
->l_searchlist
;
2145 /* Save the information about the original global scope list since
2146 we need it in the memory handling later. */
2147 GLRO(dl_initial_searchlist
) = *GL(dl_ns
)[LM_ID_BASE
]._ns_main_searchlist
;
2151 if (main_map
->l_info
[ADDRIDX (DT_GNU_CONFLICT
)] != NULL
)
2153 ElfW(Rela
) *conflict
, *conflictend
;
2154 #ifndef HP_TIMING_NONAVAIL
2159 HP_TIMING_NOW (start
);
2160 assert (main_map
->l_info
[VALIDX (DT_GNU_CONFLICTSZ
)] != NULL
);
2161 conflict
= (ElfW(Rela
) *)
2162 main_map
->l_info
[ADDRIDX (DT_GNU_CONFLICT
)]->d_un
.d_ptr
;
2163 conflictend
= (ElfW(Rela
) *)
2165 + main_map
->l_info
[VALIDX (DT_GNU_CONFLICTSZ
)]->d_un
.d_val
);
2166 _dl_resolve_conflicts (main_map
, conflict
, conflictend
);
2167 HP_TIMING_NOW (stop
);
2168 HP_TIMING_DIFF (relocate_time
, start
, stop
);
2172 /* Mark all the objects so we know they have been already relocated. */
2173 for (struct link_map
*l
= main_map
; l
!= NULL
; l
= l
->l_next
)
2176 if (l
->l_relro_size
)
2177 _dl_protect_relro (l
);
2179 /* Add object to slot information data if necessasy. */
2180 if (l
->l_tls_blocksize
!= 0 && tls_init_tp_called
)
2181 _dl_add_to_slotinfo (l
);
2184 _dl_sysdep_start_cleanup ();
2188 /* Now we have all the objects loaded. Relocate them all except for
2189 the dynamic linker itself. We do this in reverse order so that copy
2190 relocs of earlier objects overwrite the data written by later
2191 objects. We do not re-relocate the dynamic linker itself in this
2192 loop because that could result in the GOT entries for functions we
2193 call being changed, and that would break us. It is safe to relocate
2194 the dynamic linker out of order because it has no copy relocs (we
2195 know that because it is self-contained). */
2197 int consider_profiling
= GLRO(dl_profile
) != NULL
;
2198 #ifndef HP_TIMING_NONAVAIL
2203 /* If we are profiling we also must do lazy reloaction. */
2204 GLRO(dl_lazy
) |= consider_profiling
;
2206 struct link_map
*l
= main_map
;
2210 HP_TIMING_NOW (start
);
2213 /* While we are at it, help the memory handling a bit. We have to
2214 mark some data structures as allocated with the fake malloc()
2215 implementation in ld.so. */
2216 struct libname_list
*lnp
= l
->l_libname
->next
;
2218 while (__builtin_expect (lnp
!= NULL
, 0))
2224 if (l
!= &GL(dl_rtld_map
))
2225 _dl_relocate_object (l
, l
->l_scope
, GLRO(dl_lazy
),
2226 consider_profiling
);
2228 /* Add object to slot information data if necessasy. */
2229 if (l
->l_tls_blocksize
!= 0 && tls_init_tp_called
)
2230 _dl_add_to_slotinfo (l
);
2235 HP_TIMING_NOW (stop
);
2237 HP_TIMING_DIFF (relocate_time
, start
, stop
);
2239 /* Do any necessary cleanups for the startup OS interface code.
2240 We do these now so that no calls are made after rtld re-relocation
2241 which might be resolved to different functions than we expect.
2242 We cannot do this before relocating the other objects because
2243 _dl_relocate_object might need to call `mprotect' for DT_TEXTREL. */
2244 _dl_sysdep_start_cleanup ();
2246 /* Now enable profiling if needed. Like the previous call,
2247 this has to go here because the calls it makes should use the
2248 rtld versions of the functions (particularly calloc()), but it
2249 needs to have _dl_profile_map set up by the relocator. */
2250 if (__builtin_expect (GL(dl_profile_map
) != NULL
, 0))
2251 /* We must prepare the profiling. */
2252 _dl_start_profile ();
2255 #ifndef NONTLS_INIT_TP
2256 # define NONTLS_INIT_TP do { } while (0)
2259 if (!was_tls_init_tp_called
&& GL(dl_tls_max_dtv_idx
) > 0)
2260 ++GL(dl_tls_generation
);
2262 /* Now that we have completed relocation, the initializer data
2263 for the TLS blocks has its final values and we can copy them
2264 into the main thread's TLS area, which we allocated above. */
2265 _dl_allocate_tls_init (tcbp
);
2267 /* And finally install it for the main thread. If ld.so itself uses
2268 TLS we know the thread pointer was initialized earlier. */
2269 if (! tls_init_tp_called
)
2271 const char *lossage
= TLS_INIT_TP (tcbp
, USE___THREAD
);
2272 if (__builtin_expect (lossage
!= NULL
, 0))
2273 _dl_fatal_printf ("cannot set up thread-local storage: %s\n",
2277 if (! prelinked
&& rtld_multiple_ref
)
2279 /* There was an explicit ref to the dynamic linker as a shared lib.
2280 Re-relocate ourselves with user-controlled symbol definitions.
2282 We must do this after TLS initialization in case after this
2283 re-relocation, we might call a user-supplied function
2284 (e.g. calloc from _dl_relocate_object) that uses TLS data. */
2286 #ifndef HP_TIMING_NONAVAIL
2292 HP_TIMING_NOW (start
);
2293 /* Mark the link map as not yet relocated again. */
2294 GL(dl_rtld_map
).l_relocated
= 0;
2295 _dl_relocate_object (&GL(dl_rtld_map
), main_map
->l_scope
, 0, 0);
2296 HP_TIMING_NOW (stop
);
2297 HP_TIMING_DIFF (add
, start
, stop
);
2298 HP_TIMING_ACCUM_NT (relocate_time
, add
);
2302 /* Auditing checkpoint: we have added all objects. */
2303 if (__builtin_expect (GLRO(dl_naudit
) > 0, 0))
2305 struct link_map
*head
= GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
;
2306 /* Do not call the functions for any auditing object. */
2307 if (head
->l_auditing
== 0)
2309 struct audit_ifaces
*afct
= GLRO(dl_audit
);
2310 for (unsigned int cnt
= 0; cnt
< GLRO(dl_naudit
); ++cnt
)
2312 if (afct
->activity
!= NULL
)
2313 afct
->activity (&head
->l_audit
[cnt
].cookie
, LA_ACT_CONSISTENT
);
2321 /* Notify the debugger all new objects are now ready to go. We must re-get
2322 the address since by now the variable might be in another object. */
2323 r
= _dl_debug_initialize (0, LM_ID_BASE
);
2324 r
->r_state
= RT_CONSISTENT
;
2328 /* We must munmap() the cache file. */
2329 _dl_unload_cache ();
2332 /* Once we return, _dl_sysdep_start will invoke
2333 the DT_INIT functions and then *USER_ENTRY. */
2336 /* This is a little helper function for resolving symbols while
2337 tracing the binary. */
2339 print_unresolved (int errcode
__attribute__ ((unused
)), const char *objname
,
2340 const char *errstring
)
2342 if (objname
[0] == '\0')
2343 objname
= rtld_progname
?: "<main program>";
2344 _dl_error_printf ("%s (%s)\n", errstring
, objname
);
2347 /* This is a little helper function for resolving symbols while
2348 tracing the binary. */
2350 print_missing_version (int errcode
__attribute__ ((unused
)),
2351 const char *objname
, const char *errstring
)
2353 _dl_error_printf ("%s: %s: %s\n", rtld_progname
?: "<program name unknown>",
2354 objname
, errstring
);
2357 /* Nonzero if any of the debugging options is enabled. */
2358 static int any_debug attribute_relro
;
2360 /* Process the string given as the parameter which explains which debugging
2361 options are enabled. */
2363 process_dl_debug (const char *dl_debug
)
2365 /* When adding new entries make sure that the maximal length of a name
2366 is correctly handled in the LD_DEBUG_HELP code below. */
2370 const char name
[10];
2371 const char helptext
[41];
2372 unsigned short int mask
;
2375 #define LEN_AND_STR(str) sizeof (str) - 1, str
2376 { LEN_AND_STR ("libs"), "display library search paths",
2377 DL_DEBUG_LIBS
| DL_DEBUG_IMPCALLS
},
2378 { LEN_AND_STR ("reloc"), "display relocation processing",
2379 DL_DEBUG_RELOC
| DL_DEBUG_IMPCALLS
},
2380 { LEN_AND_STR ("files"), "display progress for input file",
2381 DL_DEBUG_FILES
| DL_DEBUG_IMPCALLS
},
2382 { LEN_AND_STR ("symbols"), "display symbol table processing",
2383 DL_DEBUG_SYMBOLS
| DL_DEBUG_IMPCALLS
},
2384 { LEN_AND_STR ("bindings"), "display information about symbol binding",
2385 DL_DEBUG_BINDINGS
| DL_DEBUG_IMPCALLS
},
2386 { LEN_AND_STR ("versions"), "display version dependencies",
2387 DL_DEBUG_VERSIONS
| DL_DEBUG_IMPCALLS
},
2388 { LEN_AND_STR ("all"), "all previous options combined",
2389 DL_DEBUG_LIBS
| DL_DEBUG_RELOC
| DL_DEBUG_FILES
| DL_DEBUG_SYMBOLS
2390 | DL_DEBUG_BINDINGS
| DL_DEBUG_VERSIONS
| DL_DEBUG_IMPCALLS
},
2391 { LEN_AND_STR ("statistics"), "display relocation statistics",
2392 DL_DEBUG_STATISTICS
},
2393 { LEN_AND_STR ("unused"), "determined unused DSOs",
2395 { LEN_AND_STR ("help"), "display this help message and exit",
2398 #define ndebopts (sizeof (debopts) / sizeof (debopts[0]))
2400 /* Skip separating white spaces and commas. */
2401 while (*dl_debug
!= '\0')
2403 if (*dl_debug
!= ' ' && *dl_debug
!= ',' && *dl_debug
!= ':')
2408 while (dl_debug
[len
] != '\0' && dl_debug
[len
] != ' '
2409 && dl_debug
[len
] != ',' && dl_debug
[len
] != ':')
2412 for (cnt
= 0; cnt
< ndebopts
; ++cnt
)
2413 if (debopts
[cnt
].len
== len
2414 && memcmp (dl_debug
, debopts
[cnt
].name
, len
) == 0)
2416 GLRO(dl_debug_mask
) |= debopts
[cnt
].mask
;
2421 if (cnt
== ndebopts
)
2423 /* Display a warning and skip everything until next
2425 char *copy
= strndupa (dl_debug
, len
);
2426 _dl_error_printf ("\
2427 warning: debug option `%s' unknown; try LD_DEBUG=help\n", copy
);
2437 if (GLRO(dl_debug_mask
) & DL_DEBUG_HELP
)
2442 Valid options for the LD_DEBUG environment variable are:\n\n");
2444 for (cnt
= 0; cnt
< ndebopts
; ++cnt
)
2445 _dl_printf (" %.*s%s%s\n", debopts
[cnt
].len
, debopts
[cnt
].name
,
2446 " " + debopts
[cnt
].len
- 3,
2447 debopts
[cnt
].helptext
);
2450 To direct the debugging output into a file instead of standard output\n\
2451 a filename can be specified using the LD_DEBUG_OUTPUT environment variable.\n");
2457 process_dl_audit (char *str
)
2459 /* The parameter is a colon separated list of DSO names. */
2462 while ((p
= (strsep
) (&str
, ":")) != NULL
)
2464 && (__builtin_expect (! INTUSE(__libc_enable_secure
), 1)
2465 || strchr (p
, '/') == NULL
))
2467 /* This is using the local malloc, not the system malloc. The
2468 memory can never be freed. */
2469 struct audit_list
*newp
= malloc (sizeof (*newp
));
2472 if (audit_list
== NULL
)
2473 audit_list
= newp
->next
= newp
;
2476 newp
->next
= audit_list
->next
;
2477 audit_list
= audit_list
->next
= newp
;
2482 /* Process all environments variables the dynamic linker must recognize.
2483 Since all of them start with `LD_' we are a bit smarter while finding
2485 extern char **_environ attribute_hidden
;
2489 process_envvars (enum mode
*modep
)
2491 char **runp
= _environ
;
2493 enum mode mode
= normal
;
2494 char *debug_output
= NULL
;
2496 /* This is the default place for profiling data file. */
2497 GLRO(dl_profile_output
)
2498 = &"/var/tmp\0/var/profile"[INTUSE(__libc_enable_secure
) ? 9 : 0];
2500 while ((envline
= _dl_next_ld_env_entry (&runp
)) != NULL
)
2504 while (envline
[len
] != '\0' && envline
[len
] != '=')
2507 if (envline
[len
] != '=')
2508 /* This is a "LD_" variable at the end of the string without
2509 a '=' character. Ignore it since otherwise we will access
2510 invalid memory below. */
2516 /* Warning level, verbose or not. */
2517 if (memcmp (envline
, "WARN", 4) == 0)
2518 GLRO(dl_verbose
) = envline
[5] != '\0';
2522 /* Debugging of the dynamic linker? */
2523 if (memcmp (envline
, "DEBUG", 5) == 0)
2525 process_dl_debug (&envline
[6]);
2528 if (memcmp (envline
, "AUDIT", 5) == 0)
2529 process_dl_audit (&envline
[6]);
2533 /* Print information about versions. */
2534 if (memcmp (envline
, "VERBOSE", 7) == 0)
2536 version_info
= envline
[8] != '\0';
2540 /* List of objects to be preloaded. */
2541 if (memcmp (envline
, "PRELOAD", 7) == 0)
2543 preloadlist
= &envline
[8];
2547 /* Which shared object shall be profiled. */
2548 if (memcmp (envline
, "PROFILE", 7) == 0 && envline
[8] != '\0')
2549 GLRO(dl_profile
) = &envline
[8];
2553 /* Do we bind early? */
2554 if (memcmp (envline
, "BIND_NOW", 8) == 0)
2556 GLRO(dl_lazy
) = envline
[9] == '\0';
2559 if (memcmp (envline
, "BIND_NOT", 8) == 0)
2560 GLRO(dl_bind_not
) = envline
[9] != '\0';
2564 /* Test whether we want to see the content of the auxiliary
2565 array passed up from the kernel. */
2566 if (!INTUSE(__libc_enable_secure
)
2567 && memcmp (envline
, "SHOW_AUXV", 9) == 0)
2572 /* Mask for the important hardware capabilities. */
2573 if (memcmp (envline
, "HWCAP_MASK", 10) == 0)
2574 GLRO(dl_hwcap_mask
) = __strtoul_internal (&envline
[11], NULL
,
2579 /* Path where the binary is found. */
2580 if (!INTUSE(__libc_enable_secure
)
2581 && memcmp (envline
, "ORIGIN_PATH", 11) == 0)
2582 GLRO(dl_origin_path
) = &envline
[12];
2586 /* The library search path. */
2587 if (memcmp (envline
, "LIBRARY_PATH", 12) == 0)
2589 library_path
= &envline
[13];
2593 /* Where to place the profiling data file. */
2594 if (memcmp (envline
, "DEBUG_OUTPUT", 12) == 0)
2596 debug_output
= &envline
[13];
2600 if (!INTUSE(__libc_enable_secure
)
2601 && memcmp (envline
, "DYNAMIC_WEAK", 12) == 0)
2602 GLRO(dl_dynamic_weak
) = 1;
2606 /* We might have some extra environment variable with length 13
2608 #ifdef EXTRA_LD_ENVVARS_13
2611 if (!INTUSE(__libc_enable_secure
)
2612 && memcmp (envline
, "USE_LOAD_BIAS", 13) == 0)
2614 GLRO(dl_use_load_bias
) = envline
[14] == '1' ? -1 : 0;
2618 if (memcmp (envline
, "POINTER_GUARD", 13) == 0)
2619 GLRO(dl_pointer_guard
) = envline
[14] != '0';
2623 /* Where to place the profiling data file. */
2624 if (!INTUSE(__libc_enable_secure
)
2625 && memcmp (envline
, "PROFILE_OUTPUT", 14) == 0
2626 && envline
[15] != '\0')
2627 GLRO(dl_profile_output
) = &envline
[15];
2631 /* The mode of the dynamic linker can be set. */
2632 if (memcmp (envline
, "TRACE_PRELINKING", 16) == 0)
2635 GLRO(dl_verbose
) = 1;
2636 GLRO(dl_debug_mask
) |= DL_DEBUG_PRELINK
;
2637 GLRO(dl_trace_prelink
) = &envline
[17];
2642 /* The mode of the dynamic linker can be set. */
2643 if (memcmp (envline
, "TRACE_LOADED_OBJECTS", 20) == 0)
2647 /* We might have some extra environment variable to handle. This
2648 is tricky due to the pre-processing of the length of the name
2649 in the switch statement here. The code here assumes that added
2650 environment variables have a different length. */
2651 #ifdef EXTRA_LD_ENVVARS
2657 /* The caller wants this information. */
2660 /* Extra security for SUID binaries. Remove all dangerous environment
2662 if (__builtin_expect (INTUSE(__libc_enable_secure
), 0))
2664 static const char unsecure_envvars
[] =
2665 #ifdef EXTRA_UNSECURE_ENVVARS
2666 EXTRA_UNSECURE_ENVVARS
2671 nextp
= unsecure_envvars
;
2675 /* We could use rawmemchr but this need not be fast. */
2676 nextp
= (char *) (strchr
) (nextp
, '\0') + 1;
2678 while (*nextp
!= '\0');
2680 if (__access ("/etc/suid-debug", F_OK
) != 0)
2682 unsetenv ("MALLOC_CHECK_");
2683 GLRO(dl_debug_mask
) = 0;
2689 /* If we have to run the dynamic linker in debugging mode and the
2690 LD_DEBUG_OUTPUT environment variable is given, we write the debug
2691 messages to this file. */
2692 else if (any_debug
&& debug_output
!= NULL
)
2695 const int flags
= O_WRONLY
| O_APPEND
| O_CREAT
| O_NOFOLLOW
;
2697 const int flags
= O_WRONLY
| O_APPEND
| O_CREAT
;
2699 size_t name_len
= strlen (debug_output
);
2700 char buf
[name_len
+ 12];
2703 buf
[name_len
+ 11] = '\0';
2704 startp
= _itoa (__getpid (), &buf
[name_len
+ 11], 10, 0);
2706 startp
= memcpy (startp
- name_len
, debug_output
, name_len
);
2708 GLRO(dl_debug_fd
) = __open (startp
, flags
, DEFFILEMODE
);
2709 if (GLRO(dl_debug_fd
) == -1)
2710 /* We use standard output if opening the file failed. */
2711 GLRO(dl_debug_fd
) = STDOUT_FILENO
;
2716 /* Print the various times we collected. */
2718 __attribute ((noinline
))
2719 print_statistics (hp_timing_t
*rtld_total_timep
)
2721 #ifndef HP_TIMING_NONAVAIL
2726 /* Total time rtld used. */
2727 if (HP_TIMING_AVAIL
)
2729 HP_TIMING_PRINT (buf
, sizeof (buf
), *rtld_total_timep
);
2730 _dl_debug_printf ("\nruntime linker statistics:\n"
2731 " total startup time in dynamic loader: %s\n", buf
);
2733 /* Print relocation statistics. */
2735 HP_TIMING_PRINT (buf
, sizeof (buf
), relocate_time
);
2736 cp
= _itoa ((1000ULL * relocate_time
) / *rtld_total_timep
,
2737 pbuf
+ sizeof (pbuf
), 10, 0);
2739 switch (pbuf
+ sizeof (pbuf
) - cp
)
2750 _dl_debug_printf ("\
2751 time needed for relocation: %s (%s%%)\n", buf
, pbuf
);
2755 unsigned long int num_relative_relocations
= 0;
2756 for (Lmid_t ns
= 0; ns
< DL_NNS
; ++ns
)
2758 if (GL(dl_ns
)[ns
]._ns_loaded
== NULL
)
2761 struct r_scope_elem
*scope
= &GL(dl_ns
)[ns
]._ns_loaded
->l_searchlist
;
2763 for (unsigned int i
= 0; i
< scope
->r_nlist
; i
++)
2765 struct link_map
*l
= scope
->r_list
[i
];
2767 if (l
->l_addr
!= 0 && l
->l_info
[VERSYMIDX (DT_RELCOUNT
)])
2768 num_relative_relocations
2769 += l
->l_info
[VERSYMIDX (DT_RELCOUNT
)]->d_un
.d_val
;
2770 #ifndef ELF_MACHINE_REL_RELATIVE
2771 /* Relative relocations are processed on these architectures if
2772 library is loaded to different address than p_vaddr or
2773 if not prelinked. */
2774 if ((l
->l_addr
!= 0 || !l
->l_info
[VALIDX(DT_GNU_PRELINKED
)])
2775 && l
->l_info
[VERSYMIDX (DT_RELACOUNT
)])
2777 /* On e.g. IA-64 or Alpha, relative relocations are processed
2778 only if library is loaded to different address than p_vaddr. */
2779 if (l
->l_addr
!= 0 && l
->l_info
[VERSYMIDX (DT_RELACOUNT
)])
2781 num_relative_relocations
2782 += l
->l_info
[VERSYMIDX (DT_RELACOUNT
)]->d_un
.d_val
;
2786 _dl_debug_printf (" number of relocations: %lu\n"
2787 " number of relocations from cache: %lu\n"
2788 " number of relative relocations: %lu\n",
2789 GL(dl_num_relocations
),
2790 GL(dl_num_cache_relocations
),
2791 num_relative_relocations
);
2793 #ifndef HP_TIMING_NONAVAIL
2794 /* Time spend while loading the object and the dependencies. */
2795 if (HP_TIMING_AVAIL
)
2798 HP_TIMING_PRINT (buf
, sizeof (buf
), load_time
);
2799 cp
= _itoa ((1000ULL * load_time
) / *rtld_total_timep
,
2800 pbuf
+ sizeof (pbuf
), 10, 0);
2802 switch (pbuf
+ sizeof (pbuf
) - cp
)
2813 _dl_debug_printf ("\
2814 time needed to load objects: %s (%s%%)\n",