1 /* Run time dynamic linker.
2 Copyright (C) 1995-2006, 2007 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
166 /* If we would use strong_alias here the compiler would see a
167 non-hidden definition. This would undo the effect of the previous
168 declaration. So spell out was strong_alias does plus add the
169 visibility attribute. */
170 extern struct rtld_global_ro _rtld_local_ro
171 __attribute__ ((alias ("_rtld_global_ro"), visibility ("hidden")));
174 static void dl_main (const ElfW(Phdr
) *phdr
, ElfW(Word
) phnum
,
175 ElfW(Addr
) *user_entry
);
177 /* These two variables cannot be moved into .data.rel.ro. */
178 static struct libname_list _dl_rtld_libname
;
179 static struct libname_list _dl_rtld_libname2
;
181 /* We expect less than a second for relocation. */
182 #ifdef HP_SMALL_TIMING_AVAIL
183 # undef HP_TIMING_AVAIL
184 # define HP_TIMING_AVAIL HP_SMALL_TIMING_AVAIL
187 /* Variable for statistics. */
188 #ifndef HP_TIMING_NONAVAIL
189 static hp_timing_t relocate_time
;
190 static hp_timing_t load_time attribute_relro
;
191 static hp_timing_t start_time attribute_relro
;
194 /* Additional definitions needed by TLS initialization. */
195 #ifdef TLS_INIT_HELPER
199 /* Helper function for syscall implementation. */
200 #ifdef DL_SYSINFO_IMPLEMENTATION
201 DL_SYSINFO_IMPLEMENTATION
204 /* Before ld.so is relocated we must not access variables which need
205 relocations. This means variables which are exported. Variables
206 declared as static are fine. If we can mark a variable hidden this
207 is fine, too. The latter is important here. We can avoid setting
208 up a temporary link map for ld.so if we can mark _rtld_global as
210 #if defined PI_STATIC_AND_HIDDEN && defined HAVE_HIDDEN \
211 && defined HAVE_VISIBILITY_ATTRIBUTE
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 #if USE_TLS && !defined 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 #define RTLD_BOOTSTRAP
365 #define RESOLVE_MAP(sym, version, flags) \
366 ((*(sym))->st_shndx == SHN_UNDEF ? 0 : &bootstrap_map)
367 #include "dynamic-link.h"
369 if (HP_TIMING_INLINE
&& HP_TIMING_AVAIL
)
370 #ifdef DONT_USE_BOOTSTRAP_MAP
371 HP_TIMING_NOW (start_time
);
373 HP_TIMING_NOW (info
.start_time
);
376 /* Partly clean the `bootstrap_map' structure up. Don't use
377 `memset' since it might not be built in or inlined and we cannot
378 make function calls at this point. Use '__builtin_memset' if we
379 know it is available. We do not have to clear the memory if we
380 do not have to use the temporary bootstrap_map. Global variables
381 are initialized to zero by default. */
382 #ifndef DONT_USE_BOOTSTRAP_MAP
383 # ifdef HAVE_BUILTIN_MEMSET
384 __builtin_memset (bootstrap_map
.l_info
, '\0', sizeof (bootstrap_map
.l_info
));
387 cnt
< sizeof (bootstrap_map
.l_info
) / sizeof (bootstrap_map
.l_info
[0]);
389 bootstrap_map
.l_info
[cnt
] = 0;
392 bootstrap_map
.l_tls_modid
= 0;
396 /* Figure out the run-time load address of the dynamic linker itself. */
397 bootstrap_map
.l_addr
= elf_machine_load_address ();
399 /* Read our own dynamic section and fill in the info array. */
400 bootstrap_map
.l_ld
= (void *) bootstrap_map
.l_addr
+ elf_machine_dynamic ();
401 elf_get_dynamic_info (&bootstrap_map
, NULL
);
403 #if defined USE_TLS && NO_TLS_OFFSET != 0
404 bootstrap_map
.l_tls_offset
= NO_TLS_OFFSET
;
407 /* Get the dynamic linker's own program header. First we need the ELF
408 file header. The `_begin' symbol created by the linker script points
409 to it. When we have something like GOTOFF relocs, we can use a plain
410 reference to find the runtime address. Without that, we have to rely
411 on the `l_addr' value, which is not the value we want when prelinked. */
415 # ifdef DONT_USE_BOOTSTRAP_MAP
416 = (ElfW(Ehdr
) *) &_begin
;
418 # error This will not work with prelink.
419 = (ElfW(Ehdr
) *) bootstrap_map
.l_addr
;
421 ElfW(Phdr
) *phdr
= (ElfW(Phdr
) *) ((void *) ehdr
+ ehdr
->e_phoff
);
422 size_t cnt
= ehdr
->e_phnum
; /* PT_TLS is usually the last phdr. */
424 if (phdr
[cnt
].p_type
== PT_TLS
)
427 size_t max_align
= MAX (TLS_INIT_TCB_ALIGN
, phdr
[cnt
].p_align
);
430 bootstrap_map
.l_tls_blocksize
= phdr
[cnt
].p_memsz
;
431 bootstrap_map
.l_tls_align
= phdr
[cnt
].p_align
;
432 if (phdr
[cnt
].p_align
== 0)
433 bootstrap_map
.l_tls_firstbyte_offset
= 0;
435 bootstrap_map
.l_tls_firstbyte_offset
= (phdr
[cnt
].p_vaddr
436 & (phdr
[cnt
].p_align
- 1));
437 assert (bootstrap_map
.l_tls_blocksize
!= 0);
438 bootstrap_map
.l_tls_initimage_size
= phdr
[cnt
].p_filesz
;
439 bootstrap_map
.l_tls_initimage
= (void *) (bootstrap_map
.l_addr
440 + phdr
[cnt
].p_vaddr
);
442 /* We can now allocate the initial TLS block. This can happen
443 on the stack. We'll get the final memory later when we
444 know all about the various objects loaded at startup
447 tlsblock
= alloca (roundup (bootstrap_map
.l_tls_blocksize
,
452 tlsblock
= alloca (roundup (TLS_INIT_TCB_SIZE
,
453 bootstrap_map
.l_tls_align
)
454 + bootstrap_map
.l_tls_blocksize
457 /* In case a model with a different layout for the TCB and DTV
458 is defined add another #elif here and in the following #ifs. */
459 # error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
461 /* Align the TLS block. */
462 tlsblock
= (void *) (((uintptr_t) tlsblock
+ max_align
- 1)
465 /* Initialize the dtv. [0] is the length, [1] the generation
467 initdtv
[0].counter
= 1;
468 initdtv
[1].counter
= 0;
470 /* Initialize the TLS block. */
472 initdtv
[2].pointer
= tlsblock
;
474 bootstrap_map
.l_tls_offset
= roundup (TLS_INIT_TCB_SIZE
,
475 bootstrap_map
.l_tls_align
);
476 initdtv
[2].pointer
= (char *) tlsblock
+ bootstrap_map
.l_tls_offset
;
478 # error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
480 p
= __mempcpy (initdtv
[2].pointer
, bootstrap_map
.l_tls_initimage
,
481 bootstrap_map
.l_tls_initimage_size
);
482 # ifdef HAVE_BUILTIN_MEMSET
483 __builtin_memset (p
, '\0', (bootstrap_map
.l_tls_blocksize
484 - bootstrap_map
.l_tls_initimage_size
));
487 size_t remaining
= (bootstrap_map
.l_tls_blocksize
488 - bootstrap_map
.l_tls_initimage_size
);
489 while (remaining
-- > 0)
494 /* Install the pointer to the dtv. */
496 /* Initialize the thread pointer. */
498 bootstrap_map
.l_tls_offset
499 = roundup (bootstrap_map
.l_tls_blocksize
, TLS_INIT_TCB_ALIGN
);
501 INSTALL_DTV ((char *) tlsblock
+ bootstrap_map
.l_tls_offset
,
504 const char *lossage
= TLS_INIT_TP ((char *) tlsblock
505 + bootstrap_map
.l_tls_offset
, 0);
507 INSTALL_DTV (tlsblock
, initdtv
);
508 const char *lossage
= TLS_INIT_TP (tlsblock
, 0);
510 # error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
512 if (__builtin_expect (lossage
!= NULL
, 0))
513 _dl_fatal_printf ("cannot set up thread-local storage: %s\n",
516 /* So far this is module number one. */
517 bootstrap_map
.l_tls_modid
= 1;
519 /* There can only be one PT_TLS entry. */
522 #endif /* USE___THREAD */
524 #ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
525 ELF_MACHINE_BEFORE_RTLD_RELOC (bootstrap_map
.l_info
);
528 if (bootstrap_map
.l_addr
|| ! bootstrap_map
.l_info
[VALIDX(DT_GNU_PRELINKED
)])
530 /* Relocate ourselves so we can do normal function calls and
531 data access using the global offset table. */
533 ELF_DYNAMIC_RELOCATE (&bootstrap_map
, 0, 0);
535 bootstrap_map
.l_relocated
= 1;
537 /* Please note that we don't allow profiling of this object and
538 therefore need not test whether we have to allocate the array
539 for the relocation results (as done in dl-reloc.c). */
541 /* Now life is sane; we can call functions and access global data.
542 Set up to use the operating system facilities, and find out from
543 the operating system's program loader where to find the program
544 header table in core. Put the rest of _dl_start into a separate
545 function, that way the compiler cannot put accesses to the GOT
546 before ELF_DYNAMIC_RELOCATE. */
548 #ifdef DONT_USE_BOOTSTRAP_MAP
549 ElfW(Addr
) entry
= _dl_start_final (arg
);
551 ElfW(Addr
) entry
= _dl_start_final (arg
, &info
);
554 #ifndef ELF_MACHINE_START_ADDRESS
555 # define ELF_MACHINE_START_ADDRESS(map, start) (start)
558 return ELF_MACHINE_START_ADDRESS (GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
, entry
);
564 /* Now life is peachy; we can do all normal operations.
565 On to the real work. */
567 /* Some helper functions. */
569 /* Arguments to relocate_doit. */
578 /* Argument to map_doit. */
580 struct link_map
*loader
;
583 /* Return value of map_doit. */
584 struct link_map
*map
;
590 struct link_map
*map
;
596 struct link_map
*map
;
600 /* Arguments to version_check_doit. */
601 struct version_check_args
608 relocate_doit (void *a
)
610 struct relocate_args
*args
= (struct relocate_args
*) a
;
612 _dl_relocate_object (args
->l
, args
->l
->l_scope
, args
->lazy
, 0);
618 struct map_args
*args
= (struct map_args
*) a
;
619 args
->map
= _dl_map_object (args
->loader
, args
->str
,
620 args
->is_preloaded
, lt_library
, 0, args
->mode
,
625 dlmopen_doit (void *a
)
627 struct dlmopen_args
*args
= (struct dlmopen_args
*) a
;
628 args
->map
= _dl_open (args
->fname
, RTLD_LAZY
| __RTLD_DLOPEN
| __RTLD_AUDIT
,
629 dl_main
, LM_ID_NEWLM
, _dl_argc
, INTUSE(_dl_argv
),
634 lookup_doit (void *a
)
636 struct lookup_args
*args
= (struct lookup_args
*) a
;
637 const ElfW(Sym
) *ref
= NULL
;
639 lookup_t l
= _dl_lookup_symbol_x (args
->name
, args
->map
, &ref
,
640 args
->map
->l_local_scope
, NULL
, 0,
641 DL_LOOKUP_RETURN_NEWEST
, NULL
);
643 args
->result
= DL_SYMBOL_ADDRESS (l
, ref
);
647 version_check_doit (void *a
)
649 struct version_check_args
*args
= (struct version_check_args
*) a
;
650 if (_dl_check_all_versions (GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
, 1,
651 args
->dotrace
) && args
->doexit
)
652 /* We cannot start the application. Abort now. */
657 static inline struct link_map
*
658 find_needed (const char *name
)
660 struct r_scope_elem
*scope
= &GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
->l_searchlist
;
661 unsigned int n
= scope
->r_nlist
;
664 if (_dl_name_match_p (name
, scope
->r_list
[n
]))
665 return scope
->r_list
[n
];
667 /* Should never happen. */
672 match_version (const char *string
, struct link_map
*map
)
674 const char *strtab
= (const void *) D_PTR (map
, l_info
[DT_STRTAB
]);
677 #define VERDEFTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERDEF))
678 if (map
->l_info
[VERDEFTAG
] == NULL
)
679 /* The file has no symbol versioning. */
682 def
= (ElfW(Verdef
) *) ((char *) map
->l_addr
683 + map
->l_info
[VERDEFTAG
]->d_un
.d_ptr
);
686 ElfW(Verdaux
) *aux
= (ElfW(Verdaux
) *) ((char *) def
+ def
->vd_aux
);
688 /* Compare the version strings. */
689 if (strcmp (string
, strtab
+ aux
->vda_name
) == 0)
693 /* If no more definitions we failed to find what we want. */
694 if (def
->vd_next
== 0)
697 /* Next definition. */
698 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;
778 #ifdef _LIBC_REENTRANT
779 /* _dl_error_catch_tsd points to this for the single-threaded case.
780 It's reset by the thread library for multithreaded programs. */
781 void ** __attribute__ ((const))
782 _dl_initial_error_catch_tsd (void)
791 do_preload (char *fname
, struct link_map
*main_map
, const char *where
)
794 const char *err_str
= NULL
;
795 struct map_args args
;
799 args
.loader
= main_map
;
800 args
.is_preloaded
= 1;
803 unsigned int old_nloaded
= GL(dl_ns
)[LM_ID_BASE
]._ns_nloaded
;
805 (void) _dl_catch_error (&objname
, &err_str
, &malloced
, map_doit
, &args
);
806 if (__builtin_expect (err_str
!= NULL
, 0))
809 ERROR: ld.so: object '%s' from %s cannot be preloaded: ignored.\n",
811 /* No need to call free, this is still before
812 the libc's malloc is used. */
814 else if (GL(dl_ns
)[LM_ID_BASE
]._ns_nloaded
!= old_nloaded
)
815 /* It is no duplicate. */
818 /* Nothing loaded. */
822 #if defined SHARED && defined _LIBC_REENTRANT \
823 && defined __rtld_lock_default_lock_recursive
825 rtld_lock_default_lock_recursive (void *lock
)
827 __rtld_lock_default_lock_recursive (lock
);
831 rtld_lock_default_unlock_recursive (void *lock
)
833 __rtld_lock_default_unlock_recursive (lock
);
838 /* The library search path. */
839 static const char *library_path attribute_relro
;
840 /* The list preloaded objects. */
841 static const char *preloadlist attribute_relro
;
842 /* Nonzero if information about versions has to be printed. */
843 static int version_info attribute_relro
;
846 dl_main (const ElfW(Phdr
) *phdr
,
848 ElfW(Addr
) *user_entry
)
850 const ElfW(Phdr
) *ph
;
852 struct link_map
*main_map
;
855 bool has_interp
= false;
857 bool prelinked
= false;
858 bool rtld_is_main
= false;
859 #ifndef HP_TIMING_NONAVAIL
868 #ifdef _LIBC_REENTRANT
869 /* Explicit initialization since the reloc would just be more work. */
870 GL(dl_error_catch_tsd
) = &_dl_initial_error_catch_tsd
;
874 GL(dl_init_static_tls
) = &_dl_nothread_init_static_tls
;
877 #if defined SHARED && defined _LIBC_REENTRANT \
878 && defined __rtld_lock_default_lock_recursive
879 GL(dl_rtld_lock_recursive
) = rtld_lock_default_lock_recursive
;
880 GL(dl_rtld_unlock_recursive
) = rtld_lock_default_unlock_recursive
;
883 /* The explicit initialization here is cheaper than processing the reloc
884 in the _rtld_local definition's initializer. */
885 GL(dl_make_stack_executable_hook
) = &_dl_make_stack_executable
;
887 /* Process the environment variable which control the behaviour. */
888 process_envvars (&mode
);
890 #ifndef HAVE_INLINED_SYSCALLS
891 /* Set up a flag which tells we are just starting. */
892 INTUSE(_dl_starting_up
) = 1;
895 if (*user_entry
== (ElfW(Addr
)) ENTRY_POINT
)
897 /* Ho ho. We are not the program interpreter! We are the program
898 itself! This means someone ran ld.so as a command. Well, that
899 might be convenient to do sometimes. We support it by
900 interpreting the args like this:
902 ld.so PROGRAM ARGS...
904 The first argument is the name of a file containing an ELF
905 executable we will load and run with the following arguments.
906 To simplify life here, PROGRAM is searched for using the
907 normal rules for shared objects, rather than $PATH or anything
908 like that. We just load it and use its entry point; we don't
909 pay attention to its PT_INTERP command (we are the interpreter
910 ourselves). This is an easy way to test a new ld.so before
914 /* Note the place where the dynamic linker actually came from. */
915 GL(dl_rtld_map
).l_name
= rtld_progname
;
918 if (! strcmp (INTUSE(_dl_argv
)[1], "--list"))
921 GLRO(dl_lazy
) = -1; /* This means do no dependency analysis. */
927 else if (! strcmp (INTUSE(_dl_argv
)[1], "--verify"))
935 else if (! strcmp (INTUSE(_dl_argv
)[1], "--library-path")
938 library_path
= INTUSE(_dl_argv
)[2];
942 INTUSE(_dl_argv
) += 2;
944 else if (! strcmp (INTUSE(_dl_argv
)[1], "--inhibit-rpath")
947 GLRO(dl_inhibit_rpath
) = INTUSE(_dl_argv
)[2];
951 INTUSE(_dl_argv
) += 2;
953 else if (! strcmp (INTUSE(_dl_argv
)[1], "--audit") && _dl_argc
> 2)
955 process_dl_audit (INTUSE(_dl_argv
)[2]);
959 INTUSE(_dl_argv
) += 2;
964 /* If we have no further argument the program was called incorrectly.
965 Grant the user some education. */
968 Usage: ld.so [OPTION]... EXECUTABLE-FILE [ARGS-FOR-PROGRAM...]\n\
969 You have invoked `ld.so', the helper program for shared library executables.\n\
970 This program usually lives in the file `/lib/ld.so', and special directives\n\
971 in executable files using ELF shared libraries tell the system's program\n\
972 loader to load the helper program from this file. This helper program loads\n\
973 the shared libraries needed by the program executable, prepares the program\n\
974 to run, and runs it. You may invoke this helper program directly from the\n\
975 command line to load and run an ELF executable file; this is like executing\n\
976 that file itself, but always uses this helper program from the file you\n\
977 specified, instead of the helper program file specified in the executable\n\
978 file you run. This is mostly of use for maintainers to test new versions\n\
979 of this helper program; chances are you did not intend to run this program.\n\
981 --list list all dependencies and how they are resolved\n\
982 --verify verify that given object really is a dynamically linked\n\
983 object we can handle\n\
984 --library-path PATH use given PATH instead of content of the environment\n\
985 variable LD_LIBRARY_PATH\n\
986 --inhibit-rpath LIST ignore RUNPATH and RPATH information in object names\n\
993 /* The initialization of _dl_stack_flags done below assumes the
994 executable's PT_GNU_STACK may have been honored by the kernel, and
995 so a PT_GNU_STACK with PF_X set means the stack started out with
996 execute permission. However, this is not really true if the
997 dynamic linker is the executable the kernel loaded. For this
998 case, we must reinitialize _dl_stack_flags to match the dynamic
999 linker itself. If the dynamic linker was built with a
1000 PT_GNU_STACK, then the kernel may have loaded us with a
1001 nonexecutable stack that we will have to make executable when we
1002 load the program below unless it has a PT_GNU_STACK indicating
1003 nonexecutable stack is ok. */
1005 for (ph
= phdr
; ph
< &phdr
[phnum
]; ++ph
)
1006 if (ph
->p_type
== PT_GNU_STACK
)
1008 GL(dl_stack_flags
) = ph
->p_flags
;
1012 if (__builtin_expect (mode
, normal
) == verify
)
1014 const char *objname
;
1015 const char *err_str
= NULL
;
1016 struct map_args args
;
1019 args
.str
= rtld_progname
;
1021 args
.is_preloaded
= 0;
1022 args
.mode
= __RTLD_OPENEXEC
;
1023 (void) _dl_catch_error (&objname
, &err_str
, &malloced
, map_doit
,
1025 if (__builtin_expect (err_str
!= NULL
, 0))
1026 /* We don't free the returned string, the programs stops
1028 _exit (EXIT_FAILURE
);
1032 HP_TIMING_NOW (start
);
1033 _dl_map_object (NULL
, rtld_progname
, 0, lt_library
, 0,
1034 __RTLD_OPENEXEC
, LM_ID_BASE
);
1035 HP_TIMING_NOW (stop
);
1037 HP_TIMING_DIFF (load_time
, start
, stop
);
1040 /* Now the map for the main executable is available. */
1041 main_map
= GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
;
1043 phdr
= main_map
->l_phdr
;
1044 phnum
= main_map
->l_phnum
;
1045 /* We overwrite here a pointer to a malloc()ed string. But since
1046 the malloc() implementation used at this point is the dummy
1047 implementations which has no real free() function it does not
1048 makes sense to free the old string first. */
1049 main_map
->l_name
= (char *) "";
1050 *user_entry
= main_map
->l_entry
;
1054 /* Create a link_map for the executable itself.
1055 This will be what dlopen on "" returns. */
1056 main_map
= _dl_new_object ((char *) "", "", lt_executable
, NULL
,
1057 __RTLD_OPENEXEC
, LM_ID_BASE
);
1058 assert (main_map
!= NULL
);
1059 assert (main_map
== GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
);
1060 main_map
->l_phdr
= phdr
;
1061 main_map
->l_phnum
= phnum
;
1062 main_map
->l_entry
= *user_entry
;
1064 /* At this point we are in a bit of trouble. We would have to
1065 fill in the values for l_dev and l_ino. But in general we
1066 do not know where the file is. We also do not handle AT_EXECFD
1067 even if it would be passed up.
1069 We leave the values here defined to 0. This is normally no
1070 problem as the program code itself is normally no shared
1071 object and therefore cannot be loaded dynamically. Nothing
1072 prevent the use of dynamic binaries and in these situations
1073 we might get problems. We might not be able to find out
1074 whether the object is already loaded. But since there is no
1075 easy way out and because the dynamic binary must also not
1076 have an SONAME we ignore this program for now. If it becomes
1077 a problem we can force people using SONAMEs. */
1079 /* We delay initializing the path structure until we got the dynamic
1080 information for the program. */
1083 main_map
->l_map_end
= 0;
1084 main_map
->l_text_end
= 0;
1085 /* Perhaps the executable has no PT_LOAD header entries at all. */
1086 main_map
->l_map_start
= ~0;
1087 /* And it was opened directly. */
1088 ++main_map
->l_direct_opencount
;
1090 /* Scan the program header table for the dynamic section. */
1091 for (ph
= phdr
; ph
< &phdr
[phnum
]; ++ph
)
1095 /* Find out the load address. */
1096 main_map
->l_addr
= (ElfW(Addr
)) phdr
- ph
->p_vaddr
;
1099 /* This tells us where to find the dynamic section,
1100 which tells us everything we need to do. */
1101 main_map
->l_ld
= (void *) main_map
->l_addr
+ ph
->p_vaddr
;
1104 /* This "interpreter segment" was used by the program loader to
1105 find the program interpreter, which is this program itself, the
1106 dynamic linker. We note what name finds us, so that a future
1107 dlopen call or DT_NEEDED entry, for something that wants to link
1108 against the dynamic linker as a shared library, will know that
1109 the shared object is already loaded. */
1110 _dl_rtld_libname
.name
= ((const char *) main_map
->l_addr
1112 /* _dl_rtld_libname.next = NULL; Already zero. */
1113 GL(dl_rtld_map
).l_libname
= &_dl_rtld_libname
;
1115 /* Ordinarilly, we would get additional names for the loader from
1116 our DT_SONAME. This can't happen if we were actually linked as
1117 a static executable (detect this case when we have no DYNAMIC).
1118 If so, assume the filename component of the interpreter path to
1119 be our SONAME, and add it to our name list. */
1120 if (GL(dl_rtld_map
).l_ld
== NULL
)
1122 const char *p
= NULL
;
1123 const char *cp
= _dl_rtld_libname
.name
;
1125 /* Find the filename part of the path. */
1132 _dl_rtld_libname2
.name
= p
;
1133 /* _dl_rtld_libname2.next = NULL; Already zero. */
1134 _dl_rtld_libname
.next
= &_dl_rtld_libname2
;
1142 ElfW(Addr
) mapstart
;
1143 ElfW(Addr
) allocend
;
1145 /* Remember where the main program starts in memory. */
1146 mapstart
= (main_map
->l_addr
+ (ph
->p_vaddr
& ~(ph
->p_align
- 1)));
1147 if (main_map
->l_map_start
> mapstart
)
1148 main_map
->l_map_start
= mapstart
;
1150 /* Also where it ends. */
1151 allocend
= main_map
->l_addr
+ ph
->p_vaddr
+ ph
->p_memsz
;
1152 if (main_map
->l_map_end
< allocend
)
1153 main_map
->l_map_end
= allocend
;
1154 if ((ph
->p_flags
& PF_X
) && allocend
> main_map
->l_text_end
)
1155 main_map
->l_text_end
= allocend
;
1161 if (ph
->p_memsz
> 0)
1163 /* Note that in the case the dynamic linker we duplicate work
1164 here since we read the PT_TLS entry already in
1165 _dl_start_final. But the result is repeatable so do not
1166 check for this special but unimportant case. */
1167 main_map
->l_tls_blocksize
= ph
->p_memsz
;
1168 main_map
->l_tls_align
= ph
->p_align
;
1169 if (ph
->p_align
== 0)
1170 main_map
->l_tls_firstbyte_offset
= 0;
1172 main_map
->l_tls_firstbyte_offset
= (ph
->p_vaddr
1173 & (ph
->p_align
- 1));
1174 main_map
->l_tls_initimage_size
= ph
->p_filesz
;
1175 main_map
->l_tls_initimage
= (void *) ph
->p_vaddr
;
1177 /* This image gets the ID one. */
1178 GL(dl_tls_max_dtv_idx
) = main_map
->l_tls_modid
= 1;
1181 _dl_fatal_printf ("\
1182 ld.so does not support TLS, but program uses it!\n");
1187 GL(dl_stack_flags
) = ph
->p_flags
;
1191 main_map
->l_relro_addr
= ph
->p_vaddr
;
1192 main_map
->l_relro_size
= ph
->p_memsz
;
1196 /* Adjust the address of the TLS initialization image in case
1197 the executable is actually an ET_DYN object. */
1198 if (main_map
->l_tls_initimage
!= NULL
)
1199 main_map
->l_tls_initimage
1200 = (char *) main_map
->l_tls_initimage
+ main_map
->l_addr
;
1202 if (! main_map
->l_map_end
)
1203 main_map
->l_map_end
= ~0;
1204 if (! main_map
->l_text_end
)
1205 main_map
->l_text_end
= ~0;
1206 if (! GL(dl_rtld_map
).l_libname
&& GL(dl_rtld_map
).l_name
)
1208 /* We were invoked directly, so the program might not have a
1210 _dl_rtld_libname
.name
= GL(dl_rtld_map
).l_name
;
1211 /* _dl_rtld_libname.next = NULL; Already zero. */
1212 GL(dl_rtld_map
).l_libname
= &_dl_rtld_libname
;
1215 assert (GL(dl_rtld_map
).l_libname
); /* How else did we get here? */
1217 /* If the current libname is different from the SONAME, add the
1219 if (GL(dl_rtld_map
).l_info
[DT_SONAME
] != NULL
1220 && strcmp (GL(dl_rtld_map
).l_libname
->name
,
1221 (const char *) D_PTR (&GL(dl_rtld_map
), l_info
[DT_STRTAB
])
1222 + GL(dl_rtld_map
).l_info
[DT_SONAME
]->d_un
.d_val
) != 0)
1224 static struct libname_list newname
;
1225 newname
.name
= ((char *) D_PTR (&GL(dl_rtld_map
), l_info
[DT_STRTAB
])
1226 + GL(dl_rtld_map
).l_info
[DT_SONAME
]->d_un
.d_ptr
);
1227 newname
.next
= NULL
;
1228 newname
.dont_free
= 1;
1230 assert (GL(dl_rtld_map
).l_libname
->next
== NULL
);
1231 GL(dl_rtld_map
).l_libname
->next
= &newname
;
1233 /* The ld.so must be relocated since otherwise loading audit modules
1234 will fail since they reuse the very same ld.so. */
1235 assert (GL(dl_rtld_map
).l_relocated
);
1239 /* Extract the contents of the dynamic section for easy access. */
1240 elf_get_dynamic_info (main_map
, NULL
);
1241 /* Set up our cache of pointers into the hash table. */
1242 _dl_setup_hash (main_map
);
1245 if (__builtin_expect (mode
, normal
) == verify
)
1247 /* We were called just to verify that this is a dynamic
1248 executable using us as the program interpreter. Exit with an
1249 error if we were not able to load the binary or no interpreter
1250 is specified (i.e., this is no dynamically linked binary. */
1251 if (main_map
->l_ld
== NULL
)
1254 /* We allow here some platform specific code. */
1255 #ifdef DISTINGUISH_LIB_VERSIONS
1256 DISTINGUISH_LIB_VERSIONS
;
1258 _exit (has_interp
? 0 : 2);
1261 struct link_map
**first_preload
= &GL(dl_rtld_map
).l_next
;
1262 #if defined NEED_DL_SYSINFO || defined NEED_DL_SYSINFO_DSO
1263 /* Set up the data structures for the system-supplied DSO early,
1264 so they can influence _dl_init_paths. */
1265 if (GLRO(dl_sysinfo_dso
) != NULL
)
1267 /* Do an abridged version of the work _dl_map_object_from_fd would do
1268 to map in the object. It's already mapped and prelinked (and
1269 better be, since it's read-only and so we couldn't relocate it).
1270 We just want our data structures to describe it as if we had just
1271 mapped and relocated it normally. */
1272 struct link_map
*l
= _dl_new_object ((char *) "", "", lt_library
, NULL
,
1274 if (__builtin_expect (l
!= NULL
, 1))
1276 static ElfW(Dyn
) dyn_temp
[DL_RO_DYN_TEMP_CNT
] attribute_relro
;
1278 l
->l_phdr
= ((const void *) GLRO(dl_sysinfo_dso
)
1279 + GLRO(dl_sysinfo_dso
)->e_phoff
);
1280 l
->l_phnum
= GLRO(dl_sysinfo_dso
)->e_phnum
;
1281 for (uint_fast16_t i
= 0; i
< l
->l_phnum
; ++i
)
1283 const ElfW(Phdr
) *const ph
= &l
->l_phdr
[i
];
1284 if (ph
->p_type
== PT_DYNAMIC
)
1286 l
->l_ld
= (void *) ph
->p_vaddr
;
1287 l
->l_ldnum
= ph
->p_memsz
/ sizeof (ElfW(Dyn
));
1289 else if (ph
->p_type
== PT_LOAD
)
1292 l
->l_addr
= ph
->p_vaddr
;
1293 if (ph
->p_vaddr
+ ph
->p_memsz
>= l
->l_map_end
)
1294 l
->l_map_end
= ph
->p_vaddr
+ ph
->p_memsz
;
1295 if ((ph
->p_flags
& PF_X
)
1296 && ph
->p_vaddr
+ ph
->p_memsz
>= l
->l_text_end
)
1297 l
->l_text_end
= ph
->p_vaddr
+ ph
->p_memsz
;
1300 /* There must be no TLS segment. */
1301 assert (ph
->p_type
!= PT_TLS
);
1303 l
->l_map_start
= (ElfW(Addr
)) GLRO(dl_sysinfo_dso
);
1304 l
->l_addr
= l
->l_map_start
- l
->l_addr
;
1305 l
->l_map_end
+= l
->l_addr
;
1306 l
->l_text_end
+= l
->l_addr
;
1307 l
->l_ld
= (void *) ((ElfW(Addr
)) l
->l_ld
+ l
->l_addr
);
1308 elf_get_dynamic_info (l
, dyn_temp
);
1312 /* Initialize l_local_scope to contain just this map. This allows
1313 the use of dl_lookup_symbol_x to resolve symbols within the vdso.
1314 So we create a single entry list pointing to l_real as its only
1316 l
->l_local_scope
[0]->r_nlist
= 1;
1317 l
->l_local_scope
[0]->r_list
= &l
->l_real
;
1319 /* Now that we have the info handy, use the DSO image's soname
1320 so this object can be looked up by name. Note that we do not
1321 set l_name here. That field gives the file name of the DSO,
1322 and this DSO is not associated with any file. */
1323 if (l
->l_info
[DT_SONAME
] != NULL
)
1325 /* Work around a kernel problem. The kernel cannot handle
1326 addresses in the vsyscall DSO pages in writev() calls. */
1327 const char *dsoname
= ((char *) D_PTR (l
, l_info
[DT_STRTAB
])
1328 + l
->l_info
[DT_SONAME
]->d_un
.d_val
);
1329 size_t len
= strlen (dsoname
);
1330 char *copy
= malloc (len
);
1332 _dl_fatal_printf ("out of memory\n");
1333 l
->l_libname
->name
= memcpy (copy
, dsoname
, len
);
1336 /* Rearrange the list so this DSO appears after rtld_map. */
1337 assert (l
->l_next
== NULL
);
1338 assert (l
->l_prev
== main_map
);
1339 GL(dl_rtld_map
).l_next
= l
;
1340 l
->l_prev
= &GL(dl_rtld_map
);
1341 first_preload
= &l
->l_next
;
1343 /* We have a prelinked DSO preloaded by the system. */
1344 GLRO(dl_sysinfo_map
) = l
;
1345 # ifdef NEED_DL_SYSINFO
1346 if (GLRO(dl_sysinfo
) == DL_SYSINFO_DEFAULT
)
1347 GLRO(dl_sysinfo
) = GLRO(dl_sysinfo_dso
)->e_entry
+ l
->l_addr
;
1353 #ifdef DL_SYSDEP_OSCHECK
1354 DL_SYSDEP_OSCHECK (dl_fatal
);
1357 /* Initialize the data structures for the search paths for shared
1359 _dl_init_paths (library_path
);
1361 /* Initialize _r_debug. */
1362 struct r_debug
*r
= _dl_debug_initialize (GL(dl_rtld_map
).l_addr
,
1364 r
->r_state
= RT_CONSISTENT
;
1366 /* Put the link_map for ourselves on the chain so it can be found by
1367 name. Note that at this point the global chain of link maps contains
1368 exactly one element, which is pointed to by dl_loaded. */
1369 if (! GL(dl_rtld_map
).l_name
)
1370 /* If not invoked directly, the dynamic linker shared object file was
1371 found by the PT_INTERP name. */
1372 GL(dl_rtld_map
).l_name
= (char *) GL(dl_rtld_map
).l_libname
->name
;
1373 GL(dl_rtld_map
).l_type
= lt_library
;
1374 main_map
->l_next
= &GL(dl_rtld_map
);
1375 GL(dl_rtld_map
).l_prev
= main_map
;
1376 ++GL(dl_ns
)[LM_ID_BASE
]._ns_nloaded
;
1379 /* If LD_USE_LOAD_BIAS env variable has not been seen, default
1380 to not using bias for non-prelinked PIEs and libraries
1381 and using it for executables or prelinked PIEs or libraries. */
1382 if (GLRO(dl_use_load_bias
) == (ElfW(Addr
)) -2)
1383 GLRO(dl_use_load_bias
) = main_map
->l_addr
== 0 ? -1 : 0;
1385 /* Set up the program header information for the dynamic linker
1386 itself. It is needed in the dl_iterate_phdr() callbacks. */
1387 ElfW(Ehdr
) *rtld_ehdr
= (ElfW(Ehdr
) *) GL(dl_rtld_map
).l_map_start
;
1388 ElfW(Phdr
) *rtld_phdr
= (ElfW(Phdr
) *) (GL(dl_rtld_map
).l_map_start
1389 + rtld_ehdr
->e_phoff
);
1390 GL(dl_rtld_map
).l_phdr
= rtld_phdr
;
1391 GL(dl_rtld_map
).l_phnum
= rtld_ehdr
->e_phnum
;
1394 /* PT_GNU_RELRO is usually the last phdr. */
1395 size_t cnt
= rtld_ehdr
->e_phnum
;
1397 if (rtld_phdr
[cnt
].p_type
== PT_GNU_RELRO
)
1399 GL(dl_rtld_map
).l_relro_addr
= rtld_phdr
[cnt
].p_vaddr
;
1400 GL(dl_rtld_map
).l_relro_size
= rtld_phdr
[cnt
].p_memsz
;
1405 /* Add the dynamic linker to the TLS list if it also uses TLS. */
1406 if (GL(dl_rtld_map
).l_tls_blocksize
!= 0)
1407 /* Assign a module ID. Do this before loading any audit modules. */
1408 GL(dl_rtld_map
).l_tls_modid
= _dl_next_tls_modid ();
1411 /* If we have auditing DSOs to load, do it now. */
1412 if (__builtin_expect (audit_list
!= NULL
, 0))
1414 /* Iterate over all entries in the list. The order is important. */
1415 struct audit_ifaces
*last_audit
= NULL
;
1416 struct audit_list
*al
= audit_list
->next
;
1419 /* Since we start using the auditing DSOs right away we need to
1420 initialize the data structures now. */
1426 int tls_idx
= GL(dl_tls_max_dtv_idx
);
1428 /* Now it is time to determine the layout of the static TLS
1429 block and allocate it for the initial thread. Note that we
1430 always allocate the static block, we never defer it even if
1431 no DF_STATIC_TLS bit is set. The reason is that we know
1432 glibc will use the static model. */
1434 struct dlmopen_args dlmargs
;
1435 dlmargs
.fname
= al
->name
;
1438 const char *objname
;
1439 const char *err_str
= NULL
;
1441 (void) _dl_catch_error (&objname
, &err_str
, &malloced
, dlmopen_doit
,
1443 if (__builtin_expect (err_str
!= NULL
, 0))
1446 _dl_error_printf ("\
1447 ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n",
1450 free ((char *) err_str
);
1454 struct lookup_args largs
;
1455 largs
.name
= "la_version";
1456 largs
.map
= dlmargs
.map
;
1458 /* Check whether the interface version matches. */
1459 (void) _dl_catch_error (&objname
, &err_str
, &malloced
,
1460 lookup_doit
, &largs
);
1462 unsigned int (*laversion
) (unsigned int);
1465 && (laversion
= largs
.result
) != NULL
1466 && (lav
= laversion (LAV_CURRENT
)) > 0
1467 && lav
<= LAV_CURRENT
)
1469 /* Allocate structure for the callback function pointers.
1470 This call can never fail. */
1473 struct audit_ifaces ifaces
;
1474 #define naudit_ifaces 8
1475 void (*fptr
[naudit_ifaces
]) (void);
1476 } *newp
= malloc (sizeof (*newp
));
1478 /* Names of the auditing interfaces. All in one
1480 static const char audit_iface_names
[] =
1485 #if __ELF_NATIVE_CLASS == 32
1487 #elif __ELF_NATIVE_CLASS == 64
1490 # error "__ELF_NATIVE_CLASS must be defined"
1492 #define STRING(s) __STRING (s)
1493 "la_" STRING (ARCH_LA_PLTENTER
) "\0"
1494 "la_" STRING (ARCH_LA_PLTEXIT
) "\0"
1496 unsigned int cnt
= 0;
1497 const char *cp
= audit_iface_names
;
1501 (void) _dl_catch_error (&objname
, &err_str
, &malloced
,
1502 lookup_doit
, &largs
);
1504 /* Store the pointer. */
1505 if (err_str
== NULL
&& largs
.result
!= NULL
)
1507 newp
->fptr
[cnt
] = largs
.result
;
1509 /* The dynamic linker link map is statically
1510 allocated, initialize the data now. */
1511 GL(dl_rtld_map
).l_audit
[cnt
].cookie
1512 = (intptr_t) &GL(dl_rtld_map
);
1515 newp
->fptr
[cnt
] = NULL
;
1518 cp
= (char *) rawmemchr (cp
, '\0') + 1;
1520 while (*cp
!= '\0');
1521 assert (cnt
== naudit_ifaces
);
1523 /* Now append the new auditing interface to the list. */
1524 newp
->ifaces
.next
= NULL
;
1525 if (last_audit
== NULL
)
1526 last_audit
= GLRO(dl_audit
) = &newp
->ifaces
;
1528 last_audit
= last_audit
->next
= &newp
->ifaces
;
1531 /* Mark the DSO as being used for auditing. */
1532 dlmargs
.map
->l_auditing
= 1;
1536 /* We cannot use the DSO, it does not have the
1537 appropriate interfaces or it expects something
1540 Lmid_t ns
= dlmargs
.map
->l_ns
;
1542 _dl_close (dlmargs
.map
);
1544 /* Make sure the namespace has been cleared entirely. */
1545 assert (GL(dl_ns
)[ns
]._ns_loaded
== NULL
);
1546 assert (GL(dl_ns
)[ns
]._ns_nloaded
== 0);
1549 GL(dl_tls_max_dtv_idx
) = tls_idx
;
1557 while (al
!= audit_list
->next
);
1559 /* If we have any auditing modules, announce that we already
1560 have two objects loaded. */
1561 if (__builtin_expect (GLRO(dl_naudit
) > 0, 0))
1563 struct link_map
*ls
[2] = { main_map
, &GL(dl_rtld_map
) };
1565 for (unsigned int outer
= 0; outer
< 2; ++outer
)
1567 struct audit_ifaces
*afct
= GLRO(dl_audit
);
1568 for (unsigned int cnt
= 0; cnt
< GLRO(dl_naudit
); ++cnt
)
1570 if (afct
->objopen
!= NULL
)
1572 ls
[outer
]->l_audit
[cnt
].bindflags
1573 = afct
->objopen (ls
[outer
], LM_ID_BASE
,
1574 &ls
[outer
]->l_audit
[cnt
].cookie
);
1576 ls
[outer
]->l_audit_any_plt
1577 |= ls
[outer
]->l_audit
[cnt
].bindflags
!= 0;
1586 /* Set up debugging before the debugger is notified for the first time. */
1587 #ifdef ELF_MACHINE_DEBUG_SETUP
1588 /* Some machines (e.g. MIPS) don't use DT_DEBUG in this way. */
1589 ELF_MACHINE_DEBUG_SETUP (main_map
, r
);
1590 ELF_MACHINE_DEBUG_SETUP (&GL(dl_rtld_map
), r
);
1592 if (main_map
->l_info
[DT_DEBUG
] != NULL
)
1593 /* There is a DT_DEBUG entry in the dynamic section. Fill it in
1594 with the run-time address of the r_debug structure */
1595 main_map
->l_info
[DT_DEBUG
]->d_un
.d_ptr
= (ElfW(Addr
)) r
;
1597 /* Fill in the pointer in the dynamic linker's own dynamic section, in
1598 case you run gdb on the dynamic linker directly. */
1599 if (GL(dl_rtld_map
).l_info
[DT_DEBUG
] != NULL
)
1600 GL(dl_rtld_map
).l_info
[DT_DEBUG
]->d_un
.d_ptr
= (ElfW(Addr
)) r
;
1603 /* We start adding objects. */
1604 r
->r_state
= RT_ADD
;
1607 /* Auditing checkpoint: we are ready to signal that the initial map
1608 is being constructed. */
1609 if (__builtin_expect (GLRO(dl_naudit
) > 0, 0))
1611 struct audit_ifaces
*afct
= GLRO(dl_audit
);
1612 for (unsigned int cnt
= 0; cnt
< GLRO(dl_naudit
); ++cnt
)
1614 if (afct
->activity
!= NULL
)
1615 afct
->activity (&main_map
->l_audit
[cnt
].cookie
, LA_ACT_ADD
);
1621 /* We have two ways to specify objects to preload: via environment
1622 variable and via the file /etc/ld.so.preload. The latter can also
1623 be used when security is enabled. */
1624 assert (*first_preload
== NULL
);
1625 struct link_map
**preloads
= NULL
;
1626 unsigned int npreloads
= 0;
1628 if (__builtin_expect (preloadlist
!= NULL
, 0))
1630 /* The LD_PRELOAD environment variable gives list of libraries
1631 separated by white space or colons that are loaded before the
1632 executable's dependencies and prepended to the global scope
1633 list. If the binary is running setuid all elements
1634 containing a '/' are ignored since it is insecure. */
1635 char *list
= strdupa (preloadlist
);
1638 HP_TIMING_NOW (start
);
1640 /* Prevent optimizing strsep. Speed is not important here. */
1641 while ((p
= (strsep
) (&list
, " :")) != NULL
)
1643 && (__builtin_expect (! INTUSE(__libc_enable_secure
), 1)
1644 || strchr (p
, '/') == NULL
))
1645 npreloads
+= do_preload (p
, main_map
, "LD_PRELOAD");
1647 HP_TIMING_NOW (stop
);
1648 HP_TIMING_DIFF (diff
, start
, stop
);
1649 HP_TIMING_ACCUM_NT (load_time
, diff
);
1652 /* There usually is no ld.so.preload file, it should only be used
1653 for emergencies and testing. So the open call etc should usually
1654 fail. Using access() on a non-existing file is faster than using
1655 open(). So we do this first. If it succeeds we do almost twice
1656 the work but this does not matter, since it is not for production
1658 static const char preload_file
[] = "/etc/ld.so.preload";
1659 if (__builtin_expect (__access (preload_file
, R_OK
) == 0, 0))
1661 /* Read the contents of the file. */
1662 file
= _dl_sysdep_read_whole_file (preload_file
, &file_size
,
1663 PROT_READ
| PROT_WRITE
);
1664 if (__builtin_expect (file
!= MAP_FAILED
, 0))
1666 /* Parse the file. It contains names of libraries to be loaded,
1667 separated by white spaces or `:'. It may also contain
1668 comments introduced by `#'. */
1673 /* Eliminate comments. */
1678 char *comment
= memchr (runp
, '#', rest
);
1679 if (comment
== NULL
)
1682 rest
-= comment
- runp
;
1685 while (--rest
> 0 && *++comment
!= '\n');
1688 /* We have one problematic case: if we have a name at the end of
1689 the file without a trailing terminating characters, we cannot
1690 place the \0. Handle the case separately. */
1691 if (file
[file_size
- 1] != ' ' && file
[file_size
- 1] != '\t'
1692 && file
[file_size
- 1] != '\n' && file
[file_size
- 1] != ':')
1694 problem
= &file
[file_size
];
1695 while (problem
> file
&& problem
[-1] != ' '
1696 && problem
[-1] != '\t'
1697 && problem
[-1] != '\n' && problem
[-1] != ':')
1706 file
[file_size
- 1] = '\0';
1709 HP_TIMING_NOW (start
);
1711 if (file
!= problem
)
1715 while ((p
= strsep (&runp
, ": \t\n")) != NULL
)
1717 npreloads
+= do_preload (p
, main_map
, preload_file
);
1720 if (problem
!= NULL
)
1722 char *p
= strndupa (problem
, file_size
- (problem
- file
));
1724 npreloads
+= do_preload (p
, main_map
, preload_file
);
1727 HP_TIMING_NOW (stop
);
1728 HP_TIMING_DIFF (diff
, start
, stop
);
1729 HP_TIMING_ACCUM_NT (load_time
, diff
);
1731 /* We don't need the file anymore. */
1732 __munmap (file
, file_size
);
1736 if (__builtin_expect (*first_preload
!= NULL
, 0))
1738 /* Set up PRELOADS with a vector of the preloaded libraries. */
1739 struct link_map
*l
= *first_preload
;
1740 preloads
= __alloca (npreloads
* sizeof preloads
[0]);
1747 assert (i
== npreloads
);
1750 /* Load all the libraries specified by DT_NEEDED entries. If LD_PRELOAD
1751 specified some libraries to load, these are inserted before the actual
1752 dependencies in the executable's searchlist for symbol resolution. */
1753 HP_TIMING_NOW (start
);
1754 _dl_map_object_deps (main_map
, preloads
, npreloads
, mode
== trace
, 0);
1755 HP_TIMING_NOW (stop
);
1756 HP_TIMING_DIFF (diff
, start
, stop
);
1757 HP_TIMING_ACCUM_NT (load_time
, diff
);
1759 /* Mark all objects as being in the global scope. */
1760 for (i
= main_map
->l_searchlist
.r_nlist
; i
> 0; )
1761 main_map
->l_searchlist
.r_list
[--i
]->l_global
= 1;
1764 /* We are done mapping things, so close the zero-fill descriptor. */
1765 __close (_dl_zerofd
);
1769 /* Remove _dl_rtld_map from the chain. */
1770 GL(dl_rtld_map
).l_prev
->l_next
= GL(dl_rtld_map
).l_next
;
1771 if (GL(dl_rtld_map
).l_next
!= NULL
)
1772 GL(dl_rtld_map
).l_next
->l_prev
= GL(dl_rtld_map
).l_prev
;
1774 for (i
= 1; i
< main_map
->l_searchlist
.r_nlist
; ++i
)
1775 if (main_map
->l_searchlist
.r_list
[i
] == &GL(dl_rtld_map
))
1778 bool rtld_multiple_ref
= false;
1779 if (__builtin_expect (i
< main_map
->l_searchlist
.r_nlist
, 1))
1781 /* Some DT_NEEDED entry referred to the interpreter object itself, so
1782 put it back in the list of visible objects. We insert it into the
1783 chain in symbol search order because gdb uses the chain's order as
1784 its symbol search order. */
1785 rtld_multiple_ref
= true;
1787 GL(dl_rtld_map
).l_prev
= main_map
->l_searchlist
.r_list
[i
- 1];
1788 if (__builtin_expect (mode
, normal
) == normal
)
1790 GL(dl_rtld_map
).l_next
= (i
+ 1 < main_map
->l_searchlist
.r_nlist
1791 ? main_map
->l_searchlist
.r_list
[i
+ 1]
1793 #if defined NEED_DL_SYSINFO || defined NEED_DL_SYSINFO_DSO
1794 if (GLRO(dl_sysinfo_map
) != NULL
1795 && GL(dl_rtld_map
).l_prev
->l_next
== GLRO(dl_sysinfo_map
)
1796 && GL(dl_rtld_map
).l_next
!= GLRO(dl_sysinfo_map
))
1797 GL(dl_rtld_map
).l_prev
= GLRO(dl_sysinfo_map
);
1801 /* In trace mode there might be an invisible object (which we
1802 could not find) after the previous one in the search list.
1803 In this case it doesn't matter much where we put the
1804 interpreter object, so we just initialize the list pointer so
1805 that the assertion below holds. */
1806 GL(dl_rtld_map
).l_next
= GL(dl_rtld_map
).l_prev
->l_next
;
1808 assert (GL(dl_rtld_map
).l_prev
->l_next
== GL(dl_rtld_map
).l_next
);
1809 GL(dl_rtld_map
).l_prev
->l_next
= &GL(dl_rtld_map
);
1810 if (GL(dl_rtld_map
).l_next
!= NULL
)
1812 assert (GL(dl_rtld_map
).l_next
->l_prev
== GL(dl_rtld_map
).l_prev
);
1813 GL(dl_rtld_map
).l_next
->l_prev
= &GL(dl_rtld_map
);
1817 /* Now let us see whether all libraries are available in the
1818 versions we need. */
1820 struct version_check_args args
;
1821 args
.doexit
= mode
== normal
;
1822 args
.dotrace
= mode
== trace
;
1823 _dl_receive_error (print_missing_version
, version_check_doit
, &args
);
1827 /* We do not initialize any of the TLS functionality unless any of the
1828 initial modules uses TLS. This makes dynamic loading of modules with
1829 TLS impossible, but to support it requires either eagerly doing setup
1830 now or lazily doing it later. Doing it now makes us incompatible with
1831 an old kernel that can't perform TLS_INIT_TP, even if no TLS is ever
1832 used. Trying to do it lazily is too hairy to try when there could be
1833 multiple threads (from a non-TLS-using libpthread). */
1834 bool was_tls_init_tp_called
= tls_init_tp_called
;
1839 /* Set up the stack checker's canary. */
1840 uintptr_t stack_chk_guard
= _dl_setup_stack_chk_guard ();
1841 #ifdef THREAD_SET_STACK_GUARD
1842 THREAD_SET_STACK_GUARD (stack_chk_guard
);
1844 __stack_chk_guard
= stack_chk_guard
;
1847 /* Set up the pointer guard as well, if necessary. */
1848 if (GLRO(dl_pointer_guard
))
1850 // XXX If it is cheap, we should use a separate value.
1851 uintptr_t pointer_chk_guard
= stack_chk_guard
;
1852 #ifndef HP_TIMING_NONAVAIL
1854 HP_TIMING_NOW (now
);
1855 pointer_chk_guard
^= now
;
1857 #ifdef THREAD_SET_POINTER_GUARD
1858 THREAD_SET_POINTER_GUARD (pointer_chk_guard
);
1860 __pointer_chk_guard_local
= pointer_chk_guard
;
1863 if (__builtin_expect (mode
, normal
) != normal
)
1865 /* We were run just to list the shared libraries. It is
1866 important that we do this before real relocation, because the
1867 functions we call below for output may no longer work properly
1868 after relocation. */
1871 if (GLRO(dl_debug_mask
) & DL_DEBUG_PRELINK
)
1873 struct r_scope_elem
*scope
= &main_map
->l_searchlist
;
1875 for (i
= 0; i
< scope
->r_nlist
; i
++)
1877 l
= scope
->r_list
[i
];
1880 _dl_printf ("\t%s => not found\n", l
->l_libname
->name
);
1883 if (_dl_name_match_p (GLRO(dl_trace_prelink
), l
))
1884 GLRO(dl_trace_prelink_map
) = l
;
1885 _dl_printf ("\t%s => %s (0x%0*Zx, 0x%0*Zx)",
1886 l
->l_libname
->name
[0] ? l
->l_libname
->name
1887 : rtld_progname
?: "<main program>",
1888 l
->l_name
[0] ? l
->l_name
1889 : rtld_progname
?: "<main program>",
1890 (int) sizeof l
->l_map_start
* 2,
1891 (size_t) l
->l_map_start
,
1892 (int) sizeof l
->l_addr
* 2,
1893 (size_t) l
->l_addr
);
1896 _dl_printf (" TLS(0x%Zx, 0x%0*Zx)\n", l
->l_tls_modid
,
1897 (int) sizeof l
->l_tls_offset
* 2,
1898 (size_t) l
->l_tls_offset
);
1904 else if (GLRO(dl_debug_mask
) & DL_DEBUG_UNUSED
)
1906 /* Look through the dependencies of the main executable
1907 and determine which of them is not actually
1909 struct link_map
*l
= main_map
;
1911 /* Relocate the main executable. */
1912 struct relocate_args args
= { .l
= l
, .lazy
= GLRO(dl_lazy
) };
1913 _dl_receive_error (print_unresolved
, relocate_doit
, &args
);
1915 /* This loop depends on the dependencies of the executable to
1916 correspond in number and order to the DT_NEEDED entries. */
1917 ElfW(Dyn
) *dyn
= main_map
->l_ld
;
1919 while (dyn
->d_tag
!= DT_NULL
)
1921 if (dyn
->d_tag
== DT_NEEDED
)
1929 _dl_printf ("Unused direct dependencies:\n");
1933 _dl_printf ("\t%s\n", l
->l_name
);
1940 _exit (first
!= true);
1942 else if (! main_map
->l_info
[DT_NEEDED
])
1943 _dl_printf ("\tstatically linked\n");
1946 for (l
= main_map
->l_next
; l
; l
= l
->l_next
)
1948 /* The library was not found. */
1949 _dl_printf ("\t%s => not found\n", l
->l_libname
->name
);
1950 else if (strcmp (l
->l_libname
->name
, l
->l_name
) == 0)
1951 _dl_printf ("\t%s (0x%0*Zx)\n", l
->l_libname
->name
,
1952 (int) sizeof l
->l_map_start
* 2,
1953 (size_t) l
->l_map_start
);
1955 _dl_printf ("\t%s => %s (0x%0*Zx)\n", l
->l_libname
->name
,
1956 l
->l_name
, (int) sizeof l
->l_map_start
* 2,
1957 (size_t) l
->l_map_start
);
1960 if (__builtin_expect (mode
, trace
) != trace
)
1961 for (i
= 1; i
< (unsigned int) _dl_argc
; ++i
)
1963 const ElfW(Sym
) *ref
= NULL
;
1964 ElfW(Addr
) loadbase
;
1967 result
= _dl_lookup_symbol_x (INTUSE(_dl_argv
)[i
], main_map
,
1968 &ref
, main_map
->l_scope
, NULL
,
1969 ELF_RTYPE_CLASS_PLT
,
1970 DL_LOOKUP_ADD_DEPENDENCY
, NULL
);
1972 loadbase
= LOOKUP_VALUE_ADDRESS (result
);
1974 _dl_printf ("%s found at 0x%0*Zd in object at 0x%0*Zd\n",
1975 INTUSE(_dl_argv
)[i
],
1976 (int) sizeof ref
->st_value
* 2,
1977 (size_t) ref
->st_value
,
1978 (int) sizeof loadbase
* 2, (size_t) loadbase
);
1982 /* If LD_WARN is set, warn about undefined symbols. */
1983 if (GLRO(dl_lazy
) >= 0 && GLRO(dl_verbose
))
1985 /* We have to do symbol dependency testing. */
1986 struct relocate_args args
;
1989 args
.lazy
= GLRO(dl_lazy
);
1992 while (l
->l_next
!= NULL
)
1996 if (l
!= &GL(dl_rtld_map
) && ! l
->l_faked
)
1999 _dl_receive_error (print_unresolved
, relocate_doit
,
2006 if ((GLRO(dl_debug_mask
) & DL_DEBUG_PRELINK
)
2007 && rtld_multiple_ref
)
2009 /* Mark the link map as not yet relocated again. */
2010 GL(dl_rtld_map
).l_relocated
= 0;
2011 _dl_relocate_object (&GL(dl_rtld_map
), main_map
->l_scope
,
2015 #define VERNEEDTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERNEED))
2018 /* Print more information. This means here, print information
2019 about the versions needed. */
2021 struct link_map
*map
;
2023 for (map
= main_map
; map
!= NULL
; map
= map
->l_next
)
2026 ElfW(Dyn
) *dyn
= map
->l_info
[VERNEEDTAG
];
2032 strtab
= (const void *) D_PTR (map
, l_info
[DT_STRTAB
]);
2033 ent
= (ElfW(Verneed
) *) (map
->l_addr
+ dyn
->d_un
.d_ptr
);
2037 _dl_printf ("\n\tVersion information:\n");
2041 _dl_printf ("\t%s:\n",
2042 map
->l_name
[0] ? map
->l_name
: rtld_progname
);
2047 struct link_map
*needed
;
2049 needed
= find_needed (strtab
+ ent
->vn_file
);
2050 aux
= (ElfW(Vernaux
) *) ((char *) ent
+ ent
->vn_aux
);
2054 const char *fname
= NULL
;
2057 && match_version (strtab
+ aux
->vna_name
,
2059 fname
= needed
->l_name
;
2061 _dl_printf ("\t\t%s (%s) %s=> %s\n",
2062 strtab
+ ent
->vn_file
,
2063 strtab
+ aux
->vna_name
,
2064 aux
->vna_flags
& VER_FLG_WEAK
2066 fname
?: "not found");
2068 if (aux
->vna_next
== 0)
2069 /* No more symbols. */
2073 aux
= (ElfW(Vernaux
) *) ((char *) aux
2077 if (ent
->vn_next
== 0)
2078 /* No more dependencies. */
2081 /* Next dependency. */
2082 ent
= (ElfW(Verneed
) *) ((char *) ent
+ ent
->vn_next
);
2091 if (main_map
->l_info
[ADDRIDX (DT_GNU_LIBLIST
)]
2092 && ! __builtin_expect (GLRO(dl_profile
) != NULL
, 0)
2093 && ! __builtin_expect (GLRO(dl_dynamic_weak
), 0))
2095 ElfW(Lib
) *liblist
, *liblistend
;
2096 struct link_map
**r_list
, **r_listend
, *l
;
2097 const char *strtab
= (const void *) D_PTR (main_map
, l_info
[DT_STRTAB
]);
2099 assert (main_map
->l_info
[VALIDX (DT_GNU_LIBLISTSZ
)] != NULL
);
2100 liblist
= (ElfW(Lib
) *)
2101 main_map
->l_info
[ADDRIDX (DT_GNU_LIBLIST
)]->d_un
.d_ptr
;
2102 liblistend
= (ElfW(Lib
) *)
2104 main_map
->l_info
[VALIDX (DT_GNU_LIBLISTSZ
)]->d_un
.d_val
);
2105 r_list
= main_map
->l_searchlist
.r_list
;
2106 r_listend
= r_list
+ main_map
->l_searchlist
.r_nlist
;
2108 for (; r_list
< r_listend
&& liblist
< liblistend
; r_list
++)
2115 /* If the library is not mapped where it should, fail. */
2119 /* Next, check if checksum matches. */
2120 if (l
->l_info
[VALIDX(DT_CHECKSUM
)] == NULL
2121 || l
->l_info
[VALIDX(DT_CHECKSUM
)]->d_un
.d_val
2122 != liblist
->l_checksum
)
2125 if (l
->l_info
[VALIDX(DT_GNU_PRELINKED
)] == NULL
2126 || l
->l_info
[VALIDX(DT_GNU_PRELINKED
)]->d_un
.d_val
2127 != liblist
->l_time_stamp
)
2130 if (! _dl_name_match_p (strtab
+ liblist
->l_name
, l
))
2137 if (r_list
== r_listend
&& liblist
== liblistend
)
2140 if (__builtin_expect (GLRO(dl_debug_mask
) & DL_DEBUG_LIBS
, 0))
2141 _dl_debug_printf ("\nprelink checking: %s\n",
2142 prelinked
? "ok" : "failed");
2146 /* Now set up the variable which helps the assembler startup code. */
2147 GL(dl_ns
)[LM_ID_BASE
]._ns_main_searchlist
= &main_map
->l_searchlist
;
2149 /* Save the information about the original global scope list since
2150 we need it in the memory handling later. */
2151 GLRO(dl_initial_searchlist
) = *GL(dl_ns
)[LM_ID_BASE
]._ns_main_searchlist
;
2155 if (main_map
->l_info
[ADDRIDX (DT_GNU_CONFLICT
)] != NULL
)
2157 ElfW(Rela
) *conflict
, *conflictend
;
2158 #ifndef HP_TIMING_NONAVAIL
2163 HP_TIMING_NOW (start
);
2164 assert (main_map
->l_info
[VALIDX (DT_GNU_CONFLICTSZ
)] != NULL
);
2165 conflict
= (ElfW(Rela
) *)
2166 main_map
->l_info
[ADDRIDX (DT_GNU_CONFLICT
)]->d_un
.d_ptr
;
2167 conflictend
= (ElfW(Rela
) *)
2169 + main_map
->l_info
[VALIDX (DT_GNU_CONFLICTSZ
)]->d_un
.d_val
);
2170 _dl_resolve_conflicts (main_map
, conflict
, conflictend
);
2171 HP_TIMING_NOW (stop
);
2172 HP_TIMING_DIFF (relocate_time
, start
, stop
);
2176 /* Mark all the objects so we know they have been already relocated. */
2177 for (struct link_map
*l
= main_map
; l
!= NULL
; l
= l
->l_next
)
2180 if (l
->l_relro_size
)
2181 _dl_protect_relro (l
);
2184 /* Add object to slot information data if necessasy. */
2185 if (l
->l_tls_blocksize
!= 0 && tls_init_tp_called
)
2186 _dl_add_to_slotinfo (l
);
2190 _dl_sysdep_start_cleanup ();
2194 /* Now we have all the objects loaded. Relocate them all except for
2195 the dynamic linker itself. We do this in reverse order so that copy
2196 relocs of earlier objects overwrite the data written by later
2197 objects. We do not re-relocate the dynamic linker itself in this
2198 loop because that could result in the GOT entries for functions we
2199 call being changed, and that would break us. It is safe to relocate
2200 the dynamic linker out of order because it has no copy relocs (we
2201 know that because it is self-contained). */
2203 int consider_profiling
= GLRO(dl_profile
) != NULL
;
2204 #ifndef HP_TIMING_NONAVAIL
2209 /* If we are profiling we also must do lazy reloaction. */
2210 GLRO(dl_lazy
) |= consider_profiling
;
2212 struct link_map
*l
= main_map
;
2216 HP_TIMING_NOW (start
);
2219 /* While we are at it, help the memory handling a bit. We have to
2220 mark some data structures as allocated with the fake malloc()
2221 implementation in ld.so. */
2222 struct libname_list
*lnp
= l
->l_libname
->next
;
2224 while (__builtin_expect (lnp
!= NULL
, 0))
2230 if (l
!= &GL(dl_rtld_map
))
2231 _dl_relocate_object (l
, l
->l_scope
, GLRO(dl_lazy
),
2232 consider_profiling
);
2235 /* Add object to slot information data if necessasy. */
2236 if (l
->l_tls_blocksize
!= 0 && tls_init_tp_called
)
2237 _dl_add_to_slotinfo (l
);
2243 HP_TIMING_NOW (stop
);
2245 HP_TIMING_DIFF (relocate_time
, start
, stop
);
2247 /* Do any necessary cleanups for the startup OS interface code.
2248 We do these now so that no calls are made after rtld re-relocation
2249 which might be resolved to different functions than we expect.
2250 We cannot do this before relocating the other objects because
2251 _dl_relocate_object might need to call `mprotect' for DT_TEXTREL. */
2252 _dl_sysdep_start_cleanup ();
2254 /* Now enable profiling if needed. Like the previous call,
2255 this has to go here because the calls it makes should use the
2256 rtld versions of the functions (particularly calloc()), but it
2257 needs to have _dl_profile_map set up by the relocator. */
2258 if (__builtin_expect (GL(dl_profile_map
) != NULL
, 0))
2259 /* We must prepare the profiling. */
2260 _dl_start_profile ();
2263 #ifndef NONTLS_INIT_TP
2264 # define NONTLS_INIT_TP do { } while (0)
2268 if (!was_tls_init_tp_called
&& GL(dl_tls_max_dtv_idx
) > 0)
2269 ++GL(dl_tls_generation
);
2271 /* Now that we have completed relocation, the initializer data
2272 for the TLS blocks has its final values and we can copy them
2273 into the main thread's TLS area, which we allocated above. */
2274 _dl_allocate_tls_init (tcbp
);
2276 /* And finally install it for the main thread. If ld.so itself uses
2277 TLS we know the thread pointer was initialized earlier. */
2278 if (! tls_init_tp_called
)
2280 const char *lossage
= TLS_INIT_TP (tcbp
, USE___THREAD
);
2281 if (__builtin_expect (lossage
!= NULL
, 0))
2282 _dl_fatal_printf ("cannot set up thread-local storage: %s\n",
2289 if (! prelinked
&& rtld_multiple_ref
)
2291 /* There was an explicit ref to the dynamic linker as a shared lib.
2292 Re-relocate ourselves with user-controlled symbol definitions.
2294 We must do this after TLS initialization in case after this
2295 re-relocation, we might call a user-supplied function
2296 (e.g. calloc from _dl_relocate_object) that uses TLS data. */
2298 #ifndef HP_TIMING_NONAVAIL
2304 HP_TIMING_NOW (start
);
2305 /* Mark the link map as not yet relocated again. */
2306 GL(dl_rtld_map
).l_relocated
= 0;
2307 _dl_relocate_object (&GL(dl_rtld_map
), main_map
->l_scope
, 0, 0);
2308 HP_TIMING_NOW (stop
);
2309 HP_TIMING_DIFF (add
, start
, stop
);
2310 HP_TIMING_ACCUM_NT (relocate_time
, add
);
2314 /* Auditing checkpoint: we have added all objects. */
2315 if (__builtin_expect (GLRO(dl_naudit
) > 0, 0))
2317 struct link_map
*head
= GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
;
2318 /* Do not call the functions for any auditing object. */
2319 if (head
->l_auditing
== 0)
2321 struct audit_ifaces
*afct
= GLRO(dl_audit
);
2322 for (unsigned int cnt
= 0; cnt
< GLRO(dl_naudit
); ++cnt
)
2324 if (afct
->activity
!= NULL
)
2325 afct
->activity (&head
->l_audit
[cnt
].cookie
, LA_ACT_CONSISTENT
);
2333 /* Notify the debugger all new objects are now ready to go. We must re-get
2334 the address since by now the variable might be in another object. */
2335 r
= _dl_debug_initialize (0, LM_ID_BASE
);
2336 r
->r_state
= RT_CONSISTENT
;
2340 /* We must munmap() the cache file. */
2341 _dl_unload_cache ();
2344 /* Once we return, _dl_sysdep_start will invoke
2345 the DT_INIT functions and then *USER_ENTRY. */
2348 /* This is a little helper function for resolving symbols while
2349 tracing the binary. */
2351 print_unresolved (int errcode
__attribute__ ((unused
)), const char *objname
,
2352 const char *errstring
)
2354 if (objname
[0] == '\0')
2355 objname
= rtld_progname
?: "<main program>";
2356 _dl_error_printf ("%s (%s)\n", errstring
, objname
);
2359 /* This is a little helper function for resolving symbols while
2360 tracing the binary. */
2362 print_missing_version (int errcode
__attribute__ ((unused
)),
2363 const char *objname
, const char *errstring
)
2365 _dl_error_printf ("%s: %s: %s\n", rtld_progname
?: "<program name unknown>",
2366 objname
, errstring
);
2369 /* Nonzero if any of the debugging options is enabled. */
2370 static int any_debug attribute_relro
;
2372 /* Process the string given as the parameter which explains which debugging
2373 options are enabled. */
2375 process_dl_debug (const char *dl_debug
)
2377 /* When adding new entries make sure that the maximal length of a name
2378 is correctly handled in the LD_DEBUG_HELP code below. */
2382 const char name
[10];
2383 const char helptext
[41];
2384 unsigned short int mask
;
2387 #define LEN_AND_STR(str) sizeof (str) - 1, str
2388 { LEN_AND_STR ("libs"), "display library search paths",
2389 DL_DEBUG_LIBS
| DL_DEBUG_IMPCALLS
},
2390 { LEN_AND_STR ("reloc"), "display relocation processing",
2391 DL_DEBUG_RELOC
| DL_DEBUG_IMPCALLS
},
2392 { LEN_AND_STR ("files"), "display progress for input file",
2393 DL_DEBUG_FILES
| DL_DEBUG_IMPCALLS
},
2394 { LEN_AND_STR ("symbols"), "display symbol table processing",
2395 DL_DEBUG_SYMBOLS
| DL_DEBUG_IMPCALLS
},
2396 { LEN_AND_STR ("bindings"), "display information about symbol binding",
2397 DL_DEBUG_BINDINGS
| DL_DEBUG_IMPCALLS
},
2398 { LEN_AND_STR ("versions"), "display version dependencies",
2399 DL_DEBUG_VERSIONS
| DL_DEBUG_IMPCALLS
},
2400 { LEN_AND_STR ("all"), "all previous options combined",
2401 DL_DEBUG_LIBS
| DL_DEBUG_RELOC
| DL_DEBUG_FILES
| DL_DEBUG_SYMBOLS
2402 | DL_DEBUG_BINDINGS
| DL_DEBUG_VERSIONS
| DL_DEBUG_IMPCALLS
},
2403 { LEN_AND_STR ("statistics"), "display relocation statistics",
2404 DL_DEBUG_STATISTICS
},
2405 { LEN_AND_STR ("unused"), "determined unused DSOs",
2407 { LEN_AND_STR ("help"), "display this help message and exit",
2410 #define ndebopts (sizeof (debopts) / sizeof (debopts[0]))
2412 /* Skip separating white spaces and commas. */
2413 while (*dl_debug
!= '\0')
2415 if (*dl_debug
!= ' ' && *dl_debug
!= ',' && *dl_debug
!= ':')
2420 while (dl_debug
[len
] != '\0' && dl_debug
[len
] != ' '
2421 && dl_debug
[len
] != ',' && dl_debug
[len
] != ':')
2424 for (cnt
= 0; cnt
< ndebopts
; ++cnt
)
2425 if (debopts
[cnt
].len
== len
2426 && memcmp (dl_debug
, debopts
[cnt
].name
, len
) == 0)
2428 GLRO(dl_debug_mask
) |= debopts
[cnt
].mask
;
2433 if (cnt
== ndebopts
)
2435 /* Display a warning and skip everything until next
2437 char *copy
= strndupa (dl_debug
, len
);
2438 _dl_error_printf ("\
2439 warning: debug option `%s' unknown; try LD_DEBUG=help\n", copy
);
2449 if (GLRO(dl_debug_mask
) & DL_DEBUG_HELP
)
2454 Valid options for the LD_DEBUG environment variable are:\n\n");
2456 for (cnt
= 0; cnt
< ndebopts
; ++cnt
)
2457 _dl_printf (" %.*s%s%s\n", debopts
[cnt
].len
, debopts
[cnt
].name
,
2458 " " + debopts
[cnt
].len
- 3,
2459 debopts
[cnt
].helptext
);
2462 To direct the debugging output into a file instead of standard output\n\
2463 a filename can be specified using the LD_DEBUG_OUTPUT environment variable.\n");
2469 process_dl_audit (char *str
)
2471 /* The parameter is a colon separated list of DSO names. */
2474 while ((p
= (strsep
) (&str
, ":")) != NULL
)
2476 && (__builtin_expect (! INTUSE(__libc_enable_secure
), 1)
2477 || strchr (p
, '/') == NULL
))
2479 /* This is using the local malloc, not the system malloc. The
2480 memory can never be freed. */
2481 struct audit_list
*newp
= malloc (sizeof (*newp
));
2484 if (audit_list
== NULL
)
2485 audit_list
= newp
->next
= newp
;
2488 newp
->next
= audit_list
->next
;
2489 audit_list
= audit_list
->next
= newp
;
2494 /* Process all environments variables the dynamic linker must recognize.
2495 Since all of them start with `LD_' we are a bit smarter while finding
2497 extern char **_environ attribute_hidden
;
2501 process_envvars (enum mode
*modep
)
2503 char **runp
= _environ
;
2505 enum mode mode
= normal
;
2506 char *debug_output
= NULL
;
2508 /* This is the default place for profiling data file. */
2509 GLRO(dl_profile_output
)
2510 = &"/var/tmp\0/var/profile"[INTUSE(__libc_enable_secure
) ? 9 : 0];
2512 while ((envline
= _dl_next_ld_env_entry (&runp
)) != NULL
)
2516 while (envline
[len
] != '\0' && envline
[len
] != '=')
2519 if (envline
[len
] != '=')
2520 /* This is a "LD_" variable at the end of the string without
2521 a '=' character. Ignore it since otherwise we will access
2522 invalid memory below. */
2528 /* Warning level, verbose or not. */
2529 if (memcmp (envline
, "WARN", 4) == 0)
2530 GLRO(dl_verbose
) = envline
[5] != '\0';
2534 /* Debugging of the dynamic linker? */
2535 if (memcmp (envline
, "DEBUG", 5) == 0)
2537 process_dl_debug (&envline
[6]);
2540 if (memcmp (envline
, "AUDIT", 5) == 0)
2541 process_dl_audit (&envline
[6]);
2545 /* Print information about versions. */
2546 if (memcmp (envline
, "VERBOSE", 7) == 0)
2548 version_info
= envline
[8] != '\0';
2552 /* List of objects to be preloaded. */
2553 if (memcmp (envline
, "PRELOAD", 7) == 0)
2555 preloadlist
= &envline
[8];
2559 /* Which shared object shall be profiled. */
2560 if (memcmp (envline
, "PROFILE", 7) == 0 && envline
[8] != '\0')
2561 GLRO(dl_profile
) = &envline
[8];
2565 /* Do we bind early? */
2566 if (memcmp (envline
, "BIND_NOW", 8) == 0)
2568 GLRO(dl_lazy
) = envline
[9] == '\0';
2571 if (memcmp (envline
, "BIND_NOT", 8) == 0)
2572 GLRO(dl_bind_not
) = envline
[9] != '\0';
2576 /* Test whether we want to see the content of the auxiliary
2577 array passed up from the kernel. */
2578 if (!INTUSE(__libc_enable_secure
)
2579 && memcmp (envline
, "SHOW_AUXV", 9) == 0)
2584 /* Mask for the important hardware capabilities. */
2585 if (memcmp (envline
, "HWCAP_MASK", 10) == 0)
2586 GLRO(dl_hwcap_mask
) = __strtoul_internal (&envline
[11], NULL
,
2591 /* Path where the binary is found. */
2592 if (!INTUSE(__libc_enable_secure
)
2593 && memcmp (envline
, "ORIGIN_PATH", 11) == 0)
2594 GLRO(dl_origin_path
) = &envline
[12];
2598 /* The library search path. */
2599 if (memcmp (envline
, "LIBRARY_PATH", 12) == 0)
2601 library_path
= &envline
[13];
2605 /* Where to place the profiling data file. */
2606 if (memcmp (envline
, "DEBUG_OUTPUT", 12) == 0)
2608 debug_output
= &envline
[13];
2612 if (!INTUSE(__libc_enable_secure
)
2613 && memcmp (envline
, "DYNAMIC_WEAK", 12) == 0)
2614 GLRO(dl_dynamic_weak
) = 1;
2618 /* We might have some extra environment variable with length 13
2620 #ifdef EXTRA_LD_ENVVARS_13
2623 if (!INTUSE(__libc_enable_secure
)
2624 && memcmp (envline
, "USE_LOAD_BIAS", 13) == 0)
2626 GLRO(dl_use_load_bias
) = envline
[14] == '1' ? -1 : 0;
2630 if (memcmp (envline
, "POINTER_GUARD", 13) == 0)
2631 GLRO(dl_pointer_guard
) = envline
[14] != '0';
2635 /* Where to place the profiling data file. */
2636 if (!INTUSE(__libc_enable_secure
)
2637 && memcmp (envline
, "PROFILE_OUTPUT", 14) == 0
2638 && envline
[15] != '\0')
2639 GLRO(dl_profile_output
) = &envline
[15];
2643 /* The mode of the dynamic linker can be set. */
2644 if (memcmp (envline
, "TRACE_PRELINKING", 16) == 0)
2647 GLRO(dl_verbose
) = 1;
2648 GLRO(dl_debug_mask
) |= DL_DEBUG_PRELINK
;
2649 GLRO(dl_trace_prelink
) = &envline
[17];
2654 /* The mode of the dynamic linker can be set. */
2655 if (memcmp (envline
, "TRACE_LOADED_OBJECTS", 20) == 0)
2659 /* We might have some extra environment variable to handle. This
2660 is tricky due to the pre-processing of the length of the name
2661 in the switch statement here. The code here assumes that added
2662 environment variables have a different length. */
2663 #ifdef EXTRA_LD_ENVVARS
2669 /* The caller wants this information. */
2672 /* Extra security for SUID binaries. Remove all dangerous environment
2674 if (__builtin_expect (INTUSE(__libc_enable_secure
), 0))
2676 static const char unsecure_envvars
[] =
2677 #ifdef EXTRA_UNSECURE_ENVVARS
2678 EXTRA_UNSECURE_ENVVARS
2683 nextp
= unsecure_envvars
;
2687 /* We could use rawmemchr but this need not be fast. */
2688 nextp
= (char *) (strchr
) (nextp
, '\0') + 1;
2690 while (*nextp
!= '\0');
2692 if (__access ("/etc/suid-debug", F_OK
) != 0)
2694 unsetenv ("MALLOC_CHECK_");
2695 GLRO(dl_debug_mask
) = 0;
2701 /* If we have to run the dynamic linker in debugging mode and the
2702 LD_DEBUG_OUTPUT environment variable is given, we write the debug
2703 messages to this file. */
2704 else if (any_debug
&& debug_output
!= NULL
)
2707 const int flags
= O_WRONLY
| O_APPEND
| O_CREAT
| O_NOFOLLOW
;
2709 const int flags
= O_WRONLY
| O_APPEND
| O_CREAT
;
2711 size_t name_len
= strlen (debug_output
);
2712 char buf
[name_len
+ 12];
2715 buf
[name_len
+ 11] = '\0';
2716 startp
= _itoa (__getpid (), &buf
[name_len
+ 11], 10, 0);
2718 startp
= memcpy (startp
- name_len
, debug_output
, name_len
);
2720 GLRO(dl_debug_fd
) = __open (startp
, flags
, DEFFILEMODE
);
2721 if (GLRO(dl_debug_fd
) == -1)
2722 /* We use standard output if opening the file failed. */
2723 GLRO(dl_debug_fd
) = STDOUT_FILENO
;
2728 /* Print the various times we collected. */
2730 __attribute ((noinline
))
2731 print_statistics (hp_timing_t
*rtld_total_timep
)
2733 #ifndef HP_TIMING_NONAVAIL
2738 /* Total time rtld used. */
2739 if (HP_TIMING_AVAIL
)
2741 HP_TIMING_PRINT (buf
, sizeof (buf
), *rtld_total_timep
);
2742 _dl_debug_printf ("\nruntime linker statistics:\n"
2743 " total startup time in dynamic loader: %s\n", buf
);
2745 /* Print relocation statistics. */
2747 HP_TIMING_PRINT (buf
, sizeof (buf
), relocate_time
);
2748 cp
= _itoa ((1000ULL * relocate_time
) / *rtld_total_timep
,
2749 pbuf
+ sizeof (pbuf
), 10, 0);
2751 switch (pbuf
+ sizeof (pbuf
) - cp
)
2762 _dl_debug_printf ("\
2763 time needed for relocation: %s (%s%%)\n", buf
, pbuf
);
2767 unsigned long int num_relative_relocations
= 0;
2768 for (Lmid_t ns
= 0; ns
< DL_NNS
; ++ns
)
2770 if (GL(dl_ns
)[ns
]._ns_loaded
== NULL
)
2773 struct r_scope_elem
*scope
= &GL(dl_ns
)[ns
]._ns_loaded
->l_searchlist
;
2775 for (unsigned int i
= 0; i
< scope
->r_nlist
; i
++)
2777 struct link_map
*l
= scope
->r_list
[i
];
2779 if (l
->l_addr
!= 0 && l
->l_info
[VERSYMIDX (DT_RELCOUNT
)])
2780 num_relative_relocations
2781 += l
->l_info
[VERSYMIDX (DT_RELCOUNT
)]->d_un
.d_val
;
2782 #ifndef ELF_MACHINE_REL_RELATIVE
2783 /* Relative relocations are processed on these architectures if
2784 library is loaded to different address than p_vaddr or
2785 if not prelinked. */
2786 if ((l
->l_addr
!= 0 || !l
->l_info
[VALIDX(DT_GNU_PRELINKED
)])
2787 && l
->l_info
[VERSYMIDX (DT_RELACOUNT
)])
2789 /* On e.g. IA-64 or Alpha, relative relocations are processed
2790 only if library is loaded to different address than p_vaddr. */
2791 if (l
->l_addr
!= 0 && l
->l_info
[VERSYMIDX (DT_RELACOUNT
)])
2793 num_relative_relocations
2794 += l
->l_info
[VERSYMIDX (DT_RELACOUNT
)]->d_un
.d_val
;
2798 _dl_debug_printf (" number of relocations: %lu\n"
2799 " number of relocations from cache: %lu\n"
2800 " number of relative relocations: %lu\n",
2801 GL(dl_num_relocations
),
2802 GL(dl_num_cache_relocations
),
2803 num_relative_relocations
);
2805 #ifndef HP_TIMING_NONAVAIL
2806 /* Time spend while loading the object and the dependencies. */
2807 if (HP_TIMING_AVAIL
)
2810 HP_TIMING_PRINT (buf
, sizeof (buf
), load_time
);
2811 cp
= _itoa ((1000ULL * load_time
) / *rtld_total_timep
,
2812 pbuf
+ sizeof (pbuf
), 10, 0);
2814 switch (pbuf
+ sizeof (pbuf
) - cp
)
2825 _dl_debug_printf ("\
2826 time needed to load objects: %s (%s%%)\n",