1 /* Run time dynamic linker.
2 Copyright (C) 1995-2002, 2003, 2004 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-procinfo.h>
45 /* Avoid PLT use for our local calls at startup. */
46 extern __typeof (__mempcpy
) __mempcpy attribute_hidden
;
48 /* GCC has mental blocks about _exit. */
49 extern __typeof (_exit
) exit_internal
asm ("_exit") attribute_hidden
;
50 #define _exit exit_internal
52 /* Helper function to handle errors while resolving symbols. */
53 static void print_unresolved (int errcode
, const char *objname
,
54 const char *errsting
);
56 /* Helper function to handle errors when a version is missing. */
57 static void print_missing_version (int errcode
, const char *objname
,
58 const char *errsting
);
60 /* Print the various times we collected. */
61 static void print_statistics (hp_timing_t
*total_timep
);
63 /* This is a list of all the modes the dynamic loader can be in. */
64 enum mode
{ normal
, list
, verify
, trace
};
66 /* Process all environments variables the dynamic linker must recognize.
67 Since all of them start with `LD_' we are a bit smarter while finding
69 static void process_envvars (enum mode
*modep
);
71 int _dl_argc attribute_relro attribute_hidden
;
72 #ifdef DL_ARGV_NOT_RELRO
73 char **_dl_argv
= NULL
;
75 char **_dl_argv attribute_relro
= NULL
;
79 /* Nonzero if we were run directly. */
80 unsigned int _dl_skip_args attribute_relro attribute_hidden
;
82 #ifndef HAVE_INLINED_SYSCALLS
83 /* Set nonzero during loading and initialization of executable and
84 libraries, cleared before the executable's entry point runs. This
85 must not be initialized to nonzero, because the unused dynamic
86 linker loaded in for libc.so's "ld.so.1" dep will provide the
87 definition seen by libc.so's initializer; that value must be zero,
88 and will be since that dynamic linker's _dl_start and dl_main will
90 int _dl_starting_up
= 0;
91 INTVARDEF(_dl_starting_up
)
94 /* This is the structure which defines all variables global to ld.so
95 (except those which cannot be added for some reason). */
96 struct rtld_global _rtld_global
=
98 /* Default presumption without further information is executable stack. */
99 ._dl_stack_flags
= PF_R
|PF_W
|PF_X
,
100 #ifdef _LIBC_REENTRANT
101 ._dl_load_lock
= _RTLD_LOCK_RECURSIVE_INITIALIZER
104 /* If we would use strong_alias here the compiler would see a
105 non-hidden definition. This would undo the effect of the previous
106 declaration. So spell out was strong_alias does plus add the
107 visibility attribute. */
108 extern struct rtld_global _rtld_local
109 __attribute__ ((alias ("_rtld_global"), visibility ("hidden")));
112 /* This variable is similar to _rtld_local, but all values are
113 read-only after relocation. */
114 struct rtld_global_ro _rtld_global_ro attribute_relro
=
116 /* Get architecture specific initializer. */
117 #include <dl-procinfo.c>
118 #ifdef NEED_DL_SYSINFO
119 ._dl_sysinfo
= DL_SYSINFO_DEFAULT
,
121 ._dl_debug_fd
= STDERR_FILENO
,
122 ._dl_use_load_bias
= -2,
123 ._dl_correct_cache_id
= _DL_CACHE_DEFAULT_ID
,
124 ._dl_hwcap_mask
= HWCAP_IMPORTANT
,
126 ._dl_fpu_control
= _FPU_DEFAULT
,
128 /* Function pointers. */
129 ._dl_get_origin
= _dl_get_origin
,
130 ._dl_dst_count
= _dl_dst_count
,
131 ._dl_dst_substitute
= _dl_dst_substitute
,
132 ._dl_map_object
= _dl_map_object
,
133 ._dl_map_object_deps
= _dl_map_object_deps
,
134 ._dl_relocate_object
= _dl_relocate_object
,
135 ._dl_check_map_versions
= _dl_check_map_versions
,
136 ._dl_init
= _dl_init
,
137 ._dl_debug_state
= _dl_debug_state
,
139 ._dl_unload_cache
= _dl_unload_cache
,
141 ._dl_debug_printf
= _dl_debug_printf
,
142 ._dl_catch_error
= _dl_catch_error
,
143 ._dl_signal_error
= _dl_signal_error
,
144 ._dl_start_profile
= _dl_start_profile
,
145 ._dl_mcount
= _dl_mcount_internal
,
146 ._dl_lookup_symbol_x
= _dl_lookup_symbol_x
,
147 ._dl_check_caller
= _dl_check_caller
149 /* If we would use strong_alias here the compiler would see a
150 non-hidden definition. This would undo the effect of the previous
151 declaration. So spell out was strong_alias does plus add the
152 visibility attribute. */
153 extern struct rtld_global_ro _rtld_local_ro
154 __attribute__ ((alias ("_rtld_global_ro"), visibility ("hidden")));
157 static void dl_main (const ElfW(Phdr
) *phdr
, ElfW(Word
) phnum
,
158 ElfW(Addr
) *user_entry
);
160 /* These two variables cannot be moved into .data.rel.ro. */
161 static struct libname_list _dl_rtld_libname
;
162 static struct libname_list _dl_rtld_libname2
;
164 /* We expect less than a second for relocation. */
165 #ifdef HP_SMALL_TIMING_AVAIL
166 # undef HP_TIMING_AVAIL
167 # define HP_TIMING_AVAIL HP_SMALL_TIMING_AVAIL
170 /* Variable for statistics. */
171 #ifndef HP_TIMING_NONAVAIL
172 static hp_timing_t relocate_time
;
173 static hp_timing_t load_time attribute_relro
;
174 static hp_timing_t start_time attribute_relro
;
177 /* Additional definitions needed by TLS initialization. */
178 #ifdef TLS_INIT_HELPER
182 /* Helper function for syscall implementation. */
183 #ifdef DL_SYSINFO_IMPLEMENTATION
184 DL_SYSINFO_IMPLEMENTATION
187 /* Before ld.so is relocated we must not access variables which need
188 relocations. This means variables which are exported. Variables
189 declared as static are fine. If we can mark a variable hidden this
190 is fine, too. The latter is important here. We can avoid setting
191 up a temporary link map for ld.so if we can mark _rtld_global as
193 #if defined PI_STATIC_AND_HIDDEN && defined HAVE_HIDDEN \
194 && defined HAVE_VISIBILITY_ATTRIBUTE
195 # define DONT_USE_BOOTSTRAP_MAP 1
198 #ifdef DONT_USE_BOOTSTRAP_MAP
199 static ElfW(Addr
) _dl_start_final (void *arg
);
201 struct dl_start_final_info
204 #if !defined HP_TIMING_NONAVAIL && HP_TIMING_INLINE
205 hp_timing_t start_time
;
208 static ElfW(Addr
) _dl_start_final (void *arg
,
209 struct dl_start_final_info
*info
);
212 /* These defined magically in the linker script. */
213 extern char _begin
[] attribute_hidden
;
214 extern char _etext
[] attribute_hidden
;
215 extern char _end
[] attribute_hidden
;
221 # error "sysdeps/MACHINE/dl-machine.h fails to define RTLD_START"
225 # define VALIDX(tag) (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM \
226 + DT_EXTRANUM + DT_VALTAGIDX (tag))
229 # define ADDRIDX(tag) (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM \
230 + DT_EXTRANUM + DT_VALNUM + DT_ADDRTAGIDX (tag))
233 /* This is the second half of _dl_start (below). It can be inlined safely
234 under DONT_USE_BOOTSTRAP_MAP, where it is careful not to make any GOT
235 references. When the tools don't permit us to avoid using a GOT entry
236 for _dl_rtld_global (no attribute_hidden support), we must make sure
237 this function is not inlined (see below). */
239 #ifdef DONT_USE_BOOTSTRAP_MAP
240 static inline ElfW(Addr
) __attribute__ ((always_inline
))
241 _dl_start_final (void *arg
)
243 static ElfW(Addr
) __attribute__ ((noinline
))
244 _dl_start_final (void *arg
, struct dl_start_final_info
*info
)
247 ElfW(Addr
) start_addr
;
251 /* If it hasn't happen yet record the startup time. */
252 if (! HP_TIMING_INLINE
)
253 HP_TIMING_NOW (start_time
);
254 #if !defined DONT_USE_BOOTSTRAP_MAP && !defined HP_TIMING_NONAVAIL
256 start_time
= info
->start_time
;
259 /* Initialize the timing functions. */
260 HP_TIMING_DIFF_INIT ();
263 /* Transfer data about ourselves to the permanent link_map structure. */
264 #ifndef DONT_USE_BOOTSTRAP_MAP
265 GL(dl_rtld_map
).l_addr
= info
->l
.l_addr
;
266 GL(dl_rtld_map
).l_ld
= info
->l
.l_ld
;
267 memcpy (GL(dl_rtld_map
).l_info
, info
->l
.l_info
,
268 sizeof GL(dl_rtld_map
).l_info
);
269 GL(dl_rtld_map
).l_mach
= info
->l
.l_mach
;
271 _dl_setup_hash (&GL(dl_rtld_map
));
272 GL(dl_rtld_map
).l_opencount
= 1;
273 GL(dl_rtld_map
).l_map_start
= (ElfW(Addr
)) _begin
;
274 GL(dl_rtld_map
).l_map_end
= (ElfW(Addr
)) _end
;
275 GL(dl_rtld_map
).l_text_end
= (ElfW(Addr
)) _etext
;
276 /* Copy the TLS related data if necessary. */
277 #if USE_TLS && !defined DONT_USE_BOOTSTRAP_MAP
279 assert (info
->l
.l_tls_modid
!= 0);
280 GL(dl_rtld_map
).l_tls_blocksize
= info
->l
.l_tls_blocksize
;
281 GL(dl_rtld_map
).l_tls_align
= info
->l
.l_tls_align
;
282 GL(dl_rtld_map
).l_tls_firstbyte_offset
= info
->l
.l_tls_firstbyte_offset
;
283 GL(dl_rtld_map
).l_tls_initimage_size
= info
->l
.l_tls_initimage_size
;
284 GL(dl_rtld_map
).l_tls_initimage
= info
->l
.l_tls_initimage
;
285 GL(dl_rtld_map
).l_tls_offset
= info
->l
.l_tls_offset
;
286 GL(dl_rtld_map
).l_tls_modid
= 1;
288 assert (info
->l
.l_tls_modid
== 0);
289 # if NO_TLS_OFFSET != 0
290 GL(dl_rtld_map
).l_tls_offset
= NO_TLS_OFFSET
;
297 HP_TIMING_NOW (GL(dl_cpuclock_offset
));
300 /* Initialize the stack end variable. */
301 __libc_stack_end
= __builtin_frame_address (0);
303 /* Call the OS-dependent function to set up life so we can do things like
304 file access. It will call `dl_main' (below) to do all the real work
305 of the dynamic linker, and then unwind our frame and run the user
306 entry point on the same stack we entered on. */
307 start_addr
= _dl_sysdep_start (arg
, &dl_main
);
309 #ifndef HP_TIMING_NONAVAIL
310 hp_timing_t rtld_total_time
;
313 hp_timing_t end_time
;
315 /* Get the current time. */
316 HP_TIMING_NOW (end_time
);
318 /* Compute the difference. */
319 HP_TIMING_DIFF (rtld_total_time
, start_time
, end_time
);
323 if (__builtin_expect (GLRO(dl_debug_mask
) & DL_DEBUG_STATISTICS
, 0))
325 #ifndef HP_TIMING_NONAVAIL
326 print_statistics (&rtld_total_time
);
328 print_statistics (NULL
);
335 static ElfW(Addr
) __attribute_used__ internal_function
336 _dl_start (void *arg
)
338 #ifdef DONT_USE_BOOTSTRAP_MAP
339 # define bootstrap_map GL(dl_rtld_map)
341 struct dl_start_final_info info
;
342 # define bootstrap_map info.l
345 /* This #define produces dynamic linking inline functions for
346 bootstrap relocation instead of general-purpose relocation. */
347 #define RTLD_BOOTSTRAP
348 #define RESOLVE_MAP(sym, version, flags) \
349 ((*(sym))->st_shndx == SHN_UNDEF ? 0 : &bootstrap_map)
350 #define RESOLVE(sym, version, flags) \
351 ((*(sym))->st_shndx == SHN_UNDEF ? 0 : bootstrap_map.l_addr)
352 #include "dynamic-link.h"
354 if (HP_TIMING_INLINE
&& HP_TIMING_AVAIL
)
355 #ifdef DONT_USE_BOOTSTRAP_MAP
356 HP_TIMING_NOW (start_time
);
358 HP_TIMING_NOW (info
.start_time
);
361 /* Partly clean the `bootstrap_map' structure up. Don't use
362 `memset' since it might not be built in or inlined and we cannot
363 make function calls at this point. Use '__builtin_memset' if we
364 know it is available. We do not have to clear the memory if we
365 do not have to use the temporary bootstrap_map. Global variables
366 are initialized to zero by default. */
367 #ifndef DONT_USE_BOOTSTRAP_MAP
368 # ifdef HAVE_BUILTIN_MEMSET
369 __builtin_memset (bootstrap_map
.l_info
, '\0', sizeof (bootstrap_map
.l_info
));
372 cnt
< sizeof (bootstrap_map
.l_info
) / sizeof (bootstrap_map
.l_info
[0]);
374 bootstrap_map
.l_info
[cnt
] = 0;
378 /* Figure out the run-time load address of the dynamic linker itself. */
379 bootstrap_map
.l_addr
= elf_machine_load_address ();
381 /* Read our own dynamic section and fill in the info array. */
382 bootstrap_map
.l_ld
= (void *) bootstrap_map
.l_addr
+ elf_machine_dynamic ();
383 elf_get_dynamic_info (&bootstrap_map
, NULL
);
385 #if defined USE_TLS && NO_TLS_OFFSET != 0
386 bootstrap_map
.l_tls_offset
= NO_TLS_OFFSET
;
389 /* Get the dynamic linker's own program header. First we need the ELF
390 file header. The `_begin' symbol created by the linker script points
391 to it. When we have something like GOTOFF relocs, we can use a plain
392 reference to find the runtime address. Without that, we have to rely
393 on the `l_addr' value, which is not the value we want when prelinked. */
397 # ifdef DONT_USE_BOOTSTRAP_MAP
398 = (ElfW(Ehdr
) *) &_begin
;
400 # error This will not work with prelink.
401 = (ElfW(Ehdr
) *) bootstrap_map
.l_addr
;
403 ElfW(Phdr
) *phdr
= (ElfW(Phdr
) *) ((void *) ehdr
+ ehdr
->e_phoff
);
404 size_t cnt
= ehdr
->e_phnum
; /* PT_TLS is usually the last phdr. */
406 if (phdr
[cnt
].p_type
== PT_TLS
)
409 size_t max_align
= MAX (TLS_INIT_TCB_ALIGN
, phdr
[cnt
].p_align
);
412 bootstrap_map
.l_tls_blocksize
= phdr
[cnt
].p_memsz
;
413 bootstrap_map
.l_tls_align
= phdr
[cnt
].p_align
;
414 if (phdr
[cnt
].p_align
== 0)
415 bootstrap_map
.l_tls_firstbyte_offset
= 0;
417 bootstrap_map
.l_tls_firstbyte_offset
= (phdr
[cnt
].p_vaddr
418 & (phdr
[cnt
].p_align
- 1));
419 assert (bootstrap_map
.l_tls_blocksize
!= 0);
420 bootstrap_map
.l_tls_initimage_size
= phdr
[cnt
].p_filesz
;
421 bootstrap_map
.l_tls_initimage
= (void *) (bootstrap_map
.l_addr
422 + phdr
[cnt
].p_vaddr
);
424 /* We can now allocate the initial TLS block. This can happen
425 on the stack. We'll get the final memory later when we
426 know all about the various objects loaded at startup
429 tlsblock
= alloca (roundup (bootstrap_map
.l_tls_blocksize
,
434 tlsblock
= alloca (roundup (TLS_INIT_TCB_SIZE
,
435 bootstrap_map
.l_tls_align
)
436 + bootstrap_map
.l_tls_blocksize
439 /* In case a model with a different layout for the TCB and DTV
440 is defined add another #elif here and in the following #ifs. */
441 # error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
443 /* Align the TLS block. */
444 tlsblock
= (void *) (((uintptr_t) tlsblock
+ max_align
- 1)
447 /* Initialize the dtv. [0] is the length, [1] the generation
449 initdtv
[0].counter
= 1;
450 initdtv
[1].counter
= 0;
452 /* Initialize the TLS block. */
454 initdtv
[2].pointer
= tlsblock
;
456 bootstrap_map
.l_tls_offset
= roundup (TLS_INIT_TCB_SIZE
,
457 bootstrap_map
.l_tls_align
);
458 initdtv
[2].pointer
= (char *) tlsblock
+ bootstrap_map
.l_tls_offset
;
460 # error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
462 p
= __mempcpy (initdtv
[2].pointer
, bootstrap_map
.l_tls_initimage
,
463 bootstrap_map
.l_tls_initimage_size
);
464 # ifdef HAVE_BUILTIN_MEMSET
465 __builtin_memset (p
, '\0', (bootstrap_map
.l_tls_blocksize
466 - bootstrap_map
.l_tls_initimage_size
));
469 size_t remaining
= (bootstrap_map
.l_tls_blocksize
470 - bootstrap_map
.l_tls_initimage_size
);
471 while (remaining
-- > 0)
476 /* Install the pointer to the dtv. */
478 /* Initialize the thread pointer. */
480 bootstrap_map
.l_tls_offset
481 = roundup (bootstrap_map
.l_tls_blocksize
, TLS_INIT_TCB_ALIGN
);
483 INSTALL_DTV ((char *) tlsblock
+ bootstrap_map
.l_tls_offset
,
486 const char *lossage
= TLS_INIT_TP ((char *) tlsblock
487 + bootstrap_map
.l_tls_offset
, 0);
489 INSTALL_DTV (tlsblock
, initdtv
);
490 const char *lossage
= TLS_INIT_TP (tlsblock
, 0);
492 # error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
494 if (__builtin_expect (lossage
!= NULL
, 0))
495 _dl_fatal_printf ("cannot set up thread-local storage: %s\n",
498 /* So far this is module number one. */
499 bootstrap_map
.l_tls_modid
= 1;
501 /* There can only be one PT_TLS entry. */
504 #endif /* USE___THREAD */
506 #ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
507 ELF_MACHINE_BEFORE_RTLD_RELOC (bootstrap_map
.l_info
);
510 if (bootstrap_map
.l_addr
|| ! bootstrap_map
.l_info
[VALIDX(DT_GNU_PRELINKED
)])
512 /* Relocate ourselves so we can do normal function calls and
513 data access using the global offset table. */
515 ELF_DYNAMIC_RELOCATE (&bootstrap_map
, 0, 0);
518 /* Please note that we don't allow profiling of this object and
519 therefore need not test whether we have to allocate the array
520 for the relocation results (as done in dl-reloc.c). */
522 /* Now life is sane; we can call functions and access global data.
523 Set up to use the operating system facilities, and find out from
524 the operating system's program loader where to find the program
525 header table in core. Put the rest of _dl_start into a separate
526 function, that way the compiler cannot put accesses to the GOT
527 before ELF_DYNAMIC_RELOCATE. */
529 #ifdef DONT_USE_BOOTSTRAP_MAP
530 ElfW(Addr
) entry
= _dl_start_final (arg
);
532 ElfW(Addr
) entry
= _dl_start_final (arg
, &info
);
535 #ifndef ELF_MACHINE_START_ADDRESS
536 # define ELF_MACHINE_START_ADDRESS(map, start) (start)
539 return ELF_MACHINE_START_ADDRESS (GL(dl_loaded
), entry
);
545 /* Now life is peachy; we can do all normal operations.
546 On to the real work. */
548 /* Some helper functions. */
550 /* Arguments to relocate_doit. */
559 /* Argument to map_doit. */
561 struct link_map
*loader
;
564 /* Return value of map_doit. */
565 struct link_map
*map
;
568 /* Arguments to version_check_doit. */
569 struct version_check_args
576 relocate_doit (void *a
)
578 struct relocate_args
*args
= (struct relocate_args
*) a
;
580 _dl_relocate_object (args
->l
, args
->l
->l_scope
, args
->lazy
, 0);
586 struct map_args
*args
= (struct map_args
*) a
;
587 args
->map
= _dl_map_object (args
->loader
, args
->str
,
588 args
->is_preloaded
, lt_library
, 0, args
->mode
);
592 version_check_doit (void *a
)
594 struct version_check_args
*args
= (struct version_check_args
*) a
;
595 if (_dl_check_all_versions (GL(dl_loaded
), 1, args
->dotrace
) && args
->doexit
)
596 /* We cannot start the application. Abort now. */
601 static inline struct link_map
*
602 find_needed (const char *name
)
604 unsigned int n
= GL(dl_loaded
)->l_searchlist
.r_nlist
;
607 if (_dl_name_match_p (name
, GL(dl_loaded
)->l_searchlist
.r_list
[n
]))
608 return GL(dl_loaded
)->l_searchlist
.r_list
[n
];
610 /* Should never happen. */
615 match_version (const char *string
, struct link_map
*map
)
617 const char *strtab
= (const void *) D_PTR (map
, l_info
[DT_STRTAB
]);
620 #define VERDEFTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERDEF))
621 if (map
->l_info
[VERDEFTAG
] == NULL
)
622 /* The file has no symbol versioning. */
625 def
= (ElfW(Verdef
) *) ((char *) map
->l_addr
626 + map
->l_info
[VERDEFTAG
]->d_un
.d_ptr
);
629 ElfW(Verdaux
) *aux
= (ElfW(Verdaux
) *) ((char *) def
+ def
->vd_aux
);
631 /* Compare the version strings. */
632 if (strcmp (string
, strtab
+ aux
->vda_name
) == 0)
636 /* If no more definitions we failed to find what we want. */
637 if (def
->vd_next
== 0)
640 /* Next definition. */
641 def
= (ElfW(Verdef
) *) ((char *) def
+ def
->vd_next
);
647 #ifdef _LIBC_REENTRANT
648 /* _dl_error_catch_tsd points to this for the single-threaded case.
649 It's reset by the thread library for multithreaded programs. */
650 void ** __attribute__ ((const))
651 _dl_initial_error_catch_tsd (void)
658 #if defined SHARED && defined _LIBC_REENTRANT \
659 && defined __rtld_lock_default_lock_recursive
660 static void rtld_lock_default_lock_recursive (void *lock
)
662 __rtld_lock_default_lock_recursive (lock
);
665 static void rtld_lock_default_unlock_recursive (void *lock
)
667 __rtld_lock_default_unlock_recursive (lock
);
672 /* The library search path. */
673 static const char *library_path attribute_relro
;
674 /* The list preloaded objects. */
675 static const char *preloadlist attribute_relro
;
676 /* Nonzero if information about versions has to be printed. */
677 static int version_info attribute_relro
;
680 dl_main (const ElfW(Phdr
) *phdr
,
682 ElfW(Addr
) *user_entry
)
684 const ElfW(Phdr
) *ph
;
686 struct link_map
**preloads
;
687 unsigned int npreloads
;
690 bool has_interp
= false;
692 bool prelinked
= false;
693 bool rtld_is_main
= false;
694 #ifndef HP_TIMING_NONAVAIL
703 #ifdef _LIBC_REENTRANT
704 /* Explicit initialization since the reloc would just be more work. */
705 GL(dl_error_catch_tsd
) = &_dl_initial_error_catch_tsd
;
709 GL(dl_init_static_tls
) = &_dl_nothread_init_static_tls
;
712 #if defined SHARED && defined _LIBC_REENTRANT \
713 && defined __rtld_lock_default_lock_recursive
714 GL(dl_rtld_lock_recursive
) = rtld_lock_default_lock_recursive
;
715 GL(dl_rtld_unlock_recursive
) = rtld_lock_default_unlock_recursive
;
718 /* The explicit initialization here is cheaper than processing the reloc
719 in the _rtld_local definition's initializer. */
720 GL(dl_make_stack_executable_hook
) = &_dl_make_stack_executable
;
722 /* Process the environment variable which control the behaviour. */
723 process_envvars (&mode
);
725 #ifndef HAVE_INLINED_SYSCALLS
726 /* Set up a flag which tells we are just starting. */
727 INTUSE(_dl_starting_up
) = 1;
730 if (*user_entry
== (ElfW(Addr
)) ENTRY_POINT
)
732 /* Ho ho. We are not the program interpreter! We are the program
733 itself! This means someone ran ld.so as a command. Well, that
734 might be convenient to do sometimes. We support it by
735 interpreting the args like this:
737 ld.so PROGRAM ARGS...
739 The first argument is the name of a file containing an ELF
740 executable we will load and run with the following arguments.
741 To simplify life here, PROGRAM is searched for using the
742 normal rules for shared objects, rather than $PATH or anything
743 like that. We just load it and use its entry point; we don't
744 pay attention to its PT_INTERP command (we are the interpreter
745 ourselves). This is an easy way to test a new ld.so before
749 /* Note the place where the dynamic linker actually came from. */
750 GL(dl_rtld_map
).l_name
= rtld_progname
;
753 if (! strcmp (INTUSE(_dl_argv
)[1], "--list"))
756 GLRO(dl_lazy
) = -1; /* This means do no dependency analysis. */
762 else if (! strcmp (INTUSE(_dl_argv
)[1], "--verify"))
770 else if (! strcmp (INTUSE(_dl_argv
)[1], "--library-path")
773 library_path
= INTUSE(_dl_argv
)[2];
777 INTUSE(_dl_argv
) += 2;
779 else if (! strcmp (INTUSE(_dl_argv
)[1], "--inhibit-rpath")
782 GLRO(dl_inhibit_rpath
) = INTUSE(_dl_argv
)[2];
786 INTUSE(_dl_argv
) += 2;
791 /* If we have no further argument the program was called incorrectly.
792 Grant the user some education. */
795 Usage: ld.so [OPTION]... EXECUTABLE-FILE [ARGS-FOR-PROGRAM...]\n\
796 You have invoked `ld.so', the helper program for shared library executables.\n\
797 This program usually lives in the file `/lib/ld.so', and special directives\n\
798 in executable files using ELF shared libraries tell the system's program\n\
799 loader to load the helper program from this file. This helper program loads\n\
800 the shared libraries needed by the program executable, prepares the program\n\
801 to run, and runs it. You may invoke this helper program directly from the\n\
802 command line to load and run an ELF executable file; this is like executing\n\
803 that file itself, but always uses this helper program from the file you\n\
804 specified, instead of the helper program file specified in the executable\n\
805 file you run. This is mostly of use for maintainers to test new versions\n\
806 of this helper program; chances are you did not intend to run this program.\n\
808 --list list all dependencies and how they are resolved\n\
809 --verify verify that given object really is a dynamically linked\n\
810 object we can handle\n\
811 --library-path PATH use given PATH instead of content of the environment\n\
812 variable LD_LIBRARY_PATH\n\
813 --inhibit-rpath LIST ignore RUNPATH and RPATH information in object names\n\
820 /* Initialize the data structures for the search paths for shared
822 _dl_init_paths (library_path
);
824 /* The initialization of _dl_stack_flags done below assumes the
825 executable's PT_GNU_STACK may have been honored by the kernel, and
826 so a PT_GNU_STACK with PF_X set means the stack started out with
827 execute permission. However, this is not really true if the
828 dynamic linker is the executable the kernel loaded. For this
829 case, we must reinitialize _dl_stack_flags to match the dynamic
830 linker itself. If the dynamic linker was built with a
831 PT_GNU_STACK, then the kernel may have loaded us with a
832 nonexecutable stack that we will have to make executable when we
833 load the program below unless it has a PT_GNU_STACK indicating
834 nonexecutable stack is ok. */
836 for (ph
= phdr
; ph
< &phdr
[phnum
]; ++ph
)
837 if (ph
->p_type
== PT_GNU_STACK
)
839 GL(dl_stack_flags
) = ph
->p_flags
;
843 if (__builtin_expect (mode
, normal
) == verify
)
846 const char *err_str
= NULL
;
847 struct map_args args
;
849 args
.str
= rtld_progname
;
851 args
.is_preloaded
= 0;
852 args
.mode
= __RTLD_OPENEXEC
;
853 (void) _dl_catch_error (&objname
, &err_str
, map_doit
, &args
);
854 if (__builtin_expect (err_str
!= NULL
, 0))
855 /* We don't free the returned string, the programs stops
857 _exit (EXIT_FAILURE
);
861 HP_TIMING_NOW (start
);
862 _dl_map_object (NULL
, rtld_progname
, 0, lt_library
, 0,
864 HP_TIMING_NOW (stop
);
866 HP_TIMING_DIFF (load_time
, start
, stop
);
869 phdr
= GL(dl_loaded
)->l_phdr
;
870 phnum
= GL(dl_loaded
)->l_phnum
;
871 /* We overwrite here a pointer to a malloc()ed string. But since
872 the malloc() implementation used at this point is the dummy
873 implementations which has no real free() function it does not
874 makes sense to free the old string first. */
875 GL(dl_loaded
)->l_name
= (char *) "";
876 *user_entry
= GL(dl_loaded
)->l_entry
;
880 /* Create a link_map for the executable itself.
881 This will be what dlopen on "" returns. */
882 _dl_new_object ((char *) "", "", lt_executable
, NULL
);
883 if (GL(dl_loaded
) == NULL
)
884 _dl_fatal_printf ("cannot allocate memory for link map\n");
885 GL(dl_loaded
)->l_phdr
= phdr
;
886 GL(dl_loaded
)->l_phnum
= phnum
;
887 GL(dl_loaded
)->l_entry
= *user_entry
;
889 /* At this point we are in a bit of trouble. We would have to
890 fill in the values for l_dev and l_ino. But in general we
891 do not know where the file is. We also do not handle AT_EXECFD
892 even if it would be passed up.
894 We leave the values here defined to 0. This is normally no
895 problem as the program code itself is normally no shared
896 object and therefore cannot be loaded dynamically. Nothing
897 prevent the use of dynamic binaries and in these situations
898 we might get problems. We might not be able to find out
899 whether the object is already loaded. But since there is no
900 easy way out and because the dynamic binary must also not
901 have an SONAME we ignore this program for now. If it becomes
902 a problem we can force people using SONAMEs. */
904 /* We delay initializing the path structure until we got the dynamic
905 information for the program. */
908 GL(dl_loaded
)->l_map_end
= 0;
909 GL(dl_loaded
)->l_text_end
= 0;
910 /* Perhaps the executable has no PT_LOAD header entries at all. */
911 GL(dl_loaded
)->l_map_start
= ~0;
912 /* We opened the file, account for it. */
913 ++GL(dl_loaded
)->l_opencount
;
915 /* Scan the program header table for the dynamic section. */
916 for (ph
= phdr
; ph
< &phdr
[phnum
]; ++ph
)
920 /* Find out the load address. */
921 GL(dl_loaded
)->l_addr
= (ElfW(Addr
)) phdr
- ph
->p_vaddr
;
924 /* This tells us where to find the dynamic section,
925 which tells us everything we need to do. */
926 GL(dl_loaded
)->l_ld
= (void *) GL(dl_loaded
)->l_addr
+ ph
->p_vaddr
;
929 /* This "interpreter segment" was used by the program loader to
930 find the program interpreter, which is this program itself, the
931 dynamic linker. We note what name finds us, so that a future
932 dlopen call or DT_NEEDED entry, for something that wants to link
933 against the dynamic linker as a shared library, will know that
934 the shared object is already loaded. */
935 _dl_rtld_libname
.name
= ((const char *) GL(dl_loaded
)->l_addr
937 /* _dl_rtld_libname.next = NULL; Already zero. */
938 GL(dl_rtld_map
).l_libname
= &_dl_rtld_libname
;
940 /* Ordinarilly, we would get additional names for the loader from
941 our DT_SONAME. This can't happen if we were actually linked as
942 a static executable (detect this case when we have no DYNAMIC).
943 If so, assume the filename component of the interpreter path to
944 be our SONAME, and add it to our name list. */
945 if (GL(dl_rtld_map
).l_ld
== NULL
)
947 const char *p
= NULL
;
948 const char *cp
= _dl_rtld_libname
.name
;
950 /* Find the filename part of the path. */
957 _dl_rtld_libname2
.name
= p
;
958 /* _dl_rtld_libname2.next = NULL; Already zero. */
959 _dl_rtld_libname
.next
= &_dl_rtld_libname2
;
970 /* Remember where the main program starts in memory. */
971 mapstart
= (GL(dl_loaded
)->l_addr
972 + (ph
->p_vaddr
& ~(ph
->p_align
- 1)));
973 if (GL(dl_loaded
)->l_map_start
> mapstart
)
974 GL(dl_loaded
)->l_map_start
= mapstart
;
976 /* Also where it ends. */
977 allocend
= GL(dl_loaded
)->l_addr
+ ph
->p_vaddr
+ ph
->p_memsz
;
978 if (GL(dl_loaded
)->l_map_end
< allocend
)
979 GL(dl_loaded
)->l_map_end
= allocend
;
980 if ((ph
->p_flags
& PF_X
) && allocend
> GL(dl_loaded
)->l_text_end
)
981 GL(dl_loaded
)->l_text_end
= allocend
;
988 /* Note that in the case the dynamic linker we duplicate work
989 here since we read the PT_TLS entry already in
990 _dl_start_final. But the result is repeatable so do not
991 check for this special but unimportant case. */
992 GL(dl_loaded
)->l_tls_blocksize
= ph
->p_memsz
;
993 GL(dl_loaded
)->l_tls_align
= ph
->p_align
;
994 if (ph
->p_align
== 0)
995 GL(dl_loaded
)->l_tls_firstbyte_offset
= 0;
997 GL(dl_loaded
)->l_tls_firstbyte_offset
= (ph
->p_vaddr
998 & (ph
->p_align
- 1));
999 GL(dl_loaded
)->l_tls_initimage_size
= ph
->p_filesz
;
1000 GL(dl_loaded
)->l_tls_initimage
= (void *) ph
->p_vaddr
;
1002 /* This image gets the ID one. */
1003 GL(dl_tls_max_dtv_idx
) = GL(dl_loaded
)->l_tls_modid
= 1;
1008 GL(dl_stack_flags
) = ph
->p_flags
;
1012 GL(dl_loaded
)->l_relro_addr
= ph
->p_vaddr
;
1013 GL(dl_loaded
)->l_relro_size
= ph
->p_memsz
;
1017 /* Adjust the address of the TLS initialization image in case
1018 the executable is actually an ET_DYN object. */
1019 if (GL(dl_loaded
)->l_tls_initimage
!= NULL
)
1020 GL(dl_loaded
)->l_tls_initimage
1021 = (char *) GL(dl_loaded
)->l_tls_initimage
+ GL(dl_loaded
)->l_addr
;
1023 if (! GL(dl_loaded
)->l_map_end
)
1024 GL(dl_loaded
)->l_map_end
= ~0;
1025 if (! GL(dl_loaded
)->l_text_end
)
1026 GL(dl_loaded
)->l_text_end
= ~0;
1027 if (! GL(dl_rtld_map
).l_libname
&& GL(dl_rtld_map
).l_name
)
1029 /* We were invoked directly, so the program might not have a
1031 _dl_rtld_libname
.name
= GL(dl_rtld_map
).l_name
;
1032 /* _dl_rtld_libname.next = NULL; Already zero. */
1033 GL(dl_rtld_map
).l_libname
= &_dl_rtld_libname
;
1036 assert (GL(dl_rtld_map
).l_libname
); /* How else did we get here? */
1040 /* Extract the contents of the dynamic section for easy access. */
1041 elf_get_dynamic_info (GL(dl_loaded
), NULL
);
1042 /* Set up our cache of pointers into the hash table. */
1043 _dl_setup_hash (GL(dl_loaded
));
1046 if (__builtin_expect (mode
, normal
) == verify
)
1048 /* We were called just to verify that this is a dynamic
1049 executable using us as the program interpreter. Exit with an
1050 error if we were not able to load the binary or no interpreter
1051 is specified (i.e., this is no dynamically linked binary. */
1052 if (GL(dl_loaded
)->l_ld
== NULL
)
1055 /* We allow here some platform specific code. */
1056 #ifdef DISTINGUISH_LIB_VERSIONS
1057 DISTINGUISH_LIB_VERSIONS
;
1059 _exit (has_interp
? 0 : 2);
1063 /* Initialize the data structures for the search paths for shared
1065 _dl_init_paths (library_path
);
1067 /* Put the link_map for ourselves on the chain so it can be found by
1068 name. Note that at this point the global chain of link maps contains
1069 exactly one element, which is pointed to by dl_loaded. */
1070 if (! GL(dl_rtld_map
).l_name
)
1071 /* If not invoked directly, the dynamic linker shared object file was
1072 found by the PT_INTERP name. */
1073 GL(dl_rtld_map
).l_name
= (char *) GL(dl_rtld_map
).l_libname
->name
;
1074 GL(dl_rtld_map
).l_type
= lt_library
;
1075 GL(dl_loaded
)->l_next
= &GL(dl_rtld_map
);
1076 GL(dl_rtld_map
).l_prev
= GL(dl_loaded
);
1080 #if defined(__i386__)
1081 /* Force non-TLS libraries for glibc 2.0 binaries
1082 or if a buggy binary references non-TLS errno or h_errno. */
1083 if (__builtin_expect (GL(dl_loaded
)->l_info
[DT_NUM
+ DT_THISPROCNUM
+ DT_VERSIONTAGIDX (DT_VERNEED
)] == NULL
, 0)
1084 && GL(dl_loaded
)->l_info
[DT_DEBUG
])
1085 GLRO(dl_osversion
) = 0x20205;
1086 else if ((__builtin_expect (mode
, normal
) != normal
1087 || GL(dl_loaded
)->l_info
[ADDRIDX (DT_GNU_LIBLIST
)] == NULL
)
1088 /* Only binaries have DT_DEBUG dynamic tags... */
1089 && GL(dl_loaded
)->l_info
[DT_DEBUG
])
1091 /* Workaround for buggy binaries. This doesn't handle buggy
1094 const ElfW(Sym
) *symtab
= (const void *) D_PTR (GL(dl_loaded
), l_info
[DT_SYMTAB
]);
1095 const char *strtab
= (const void *) D_PTR (GL(dl_loaded
), l_info
[DT_STRTAB
]);
1097 for (symidx
= GL(dl_loaded
)->l_buckets
[0x6c994f % GL(dl_loaded
)->l_nbuckets
];
1098 symidx
!= STN_UNDEF
;
1099 symidx
= GL(dl_loaded
)->l_chain
[symidx
])
1101 if (__builtin_expect (strcmp (strtab
+ symtab
[symidx
].st_name
,
1103 && ELFW(ST_TYPE
) (symtab
[symidx
].st_info
) != STT_TLS
)
1106 for (symidx
= GL(dl_loaded
)->l_buckets
[0xe5c992f % GL(dl_loaded
)->l_nbuckets
];
1107 symidx
!= STN_UNDEF
;
1108 symidx
= GL(dl_loaded
)->l_chain
[symidx
])
1110 if (__builtin_expect (strcmp (strtab
+ symtab
[symidx
].st_name
,
1112 && ELFW(ST_TYPE
) (symtab
[symidx
].st_info
) != STT_TLS
)
1115 if (__builtin_expect (buggy
, false) && GLRO(dl_osversion
) > 0x20401)
1117 GLRO(dl_osversion
) = 0x20401;
1118 _dl_error_printf ("Incorrectly built binary which accesses errno or h_errno directly. Needs to be fixed.\n");
1123 /* If LD_USE_LOAD_BIAS env variable has not been seen, default
1124 to not using bias for non-prelinked PIEs and libraries
1125 and using it for executables or prelinked PIEs or libraries. */
1126 if (GLRO(dl_use_load_bias
) == (ElfW(Addr
)) -2)
1127 GLRO(dl_use_load_bias
) = (GL(dl_loaded
)->l_addr
== 0) ? -1 : 0;
1129 /* Set up the program header information for the dynamic linker
1130 itself. It is needed in the dl_iterate_phdr() callbacks. */
1131 ElfW(Ehdr
) *rtld_ehdr
= (ElfW(Ehdr
) *) GL(dl_rtld_map
).l_map_start
;
1132 ElfW(Phdr
) *rtld_phdr
= (ElfW(Phdr
) *) (GL(dl_rtld_map
).l_map_start
1133 + rtld_ehdr
->e_phoff
);
1134 GL(dl_rtld_map
).l_phdr
= rtld_phdr
;
1135 GL(dl_rtld_map
).l_phnum
= rtld_ehdr
->e_phnum
;
1137 /* PT_GNU_RELRO is usually the last phdr. */
1138 size_t cnt
= rtld_ehdr
->e_phnum
;
1140 if (rtld_phdr
[cnt
].p_type
== PT_GNU_RELRO
)
1142 GL(dl_rtld_map
).l_relro_addr
= rtld_phdr
[cnt
].p_vaddr
;
1143 GL(dl_rtld_map
).l_relro_size
= rtld_phdr
[cnt
].p_memsz
;
1147 /* We have two ways to specify objects to preload: via environment
1148 variable and via the file /etc/ld.so.preload. The latter can also
1149 be used when security is enabled. */
1153 if (__builtin_expect (preloadlist
!= NULL
, 0))
1155 /* The LD_PRELOAD environment variable gives list of libraries
1156 separated by white space or colons that are loaded before the
1157 executable's dependencies and prepended to the global scope
1158 list. If the binary is running setuid all elements
1159 containing a '/' are ignored since it is insecure. */
1160 char *list
= strdupa (preloadlist
);
1163 HP_TIMING_NOW (start
);
1165 /* Prevent optimizing strsep. Speed is not important here. */
1166 while ((p
= (strsep
) (&list
, " :")) != NULL
)
1168 && (__builtin_expect (! INTUSE(__libc_enable_secure
), 1)
1169 || strchr (p
, '/') == NULL
))
1171 struct link_map
*new_map
= _dl_map_object (GL(dl_loaded
), p
, 1,
1173 if (++new_map
->l_opencount
== 1)
1174 /* It is no duplicate. */
1178 HP_TIMING_NOW (stop
);
1179 HP_TIMING_DIFF (diff
, start
, stop
);
1180 HP_TIMING_ACCUM_NT (load_time
, diff
);
1183 /* There usually is no ld.so.preload file, it should only be used
1184 for emergencies and testing. So the open call etc should usually
1185 fail. Using access() on a non-existing file is faster than using
1186 open(). So we do this first. If it succeeds we do almost twice
1187 the work but this does not matter, since it is not for production
1189 static const char preload_file
[] = "/etc/ld.so.preload";
1190 if (__builtin_expect (__access (preload_file
, R_OK
) == 0, 0))
1192 /* Read the contents of the file. */
1193 file
= _dl_sysdep_read_whole_file (preload_file
, &file_size
,
1194 PROT_READ
| PROT_WRITE
);
1195 if (__builtin_expect (file
!= MAP_FAILED
, 0))
1197 /* Parse the file. It contains names of libraries to be loaded,
1198 separated by white spaces or `:'. It may also contain
1199 comments introduced by `#'. */
1204 /* Eliminate comments. */
1209 char *comment
= memchr (runp
, '#', rest
);
1210 if (comment
== NULL
)
1213 rest
-= comment
- runp
;
1216 while (--rest
> 0 && *++comment
!= '\n');
1219 /* We have one problematic case: if we have a name at the end of
1220 the file without a trailing terminating characters, we cannot
1221 place the \0. Handle the case separately. */
1222 if (file
[file_size
- 1] != ' ' && file
[file_size
- 1] != '\t'
1223 && file
[file_size
- 1] != '\n' && file
[file_size
- 1] != ':')
1225 problem
= &file
[file_size
];
1226 while (problem
> file
&& problem
[-1] != ' '
1227 && problem
[-1] != '\t'
1228 && problem
[-1] != '\n' && problem
[-1] != ':')
1237 file
[file_size
- 1] = '\0';
1240 HP_TIMING_NOW (start
);
1242 if (file
!= problem
)
1246 while ((p
= strsep (&runp
, ": \t\n")) != NULL
)
1249 const char *objname
;
1250 const char *err_str
= NULL
;
1251 struct map_args args
;
1254 args
.loader
= GL(dl_loaded
);
1255 args
.is_preloaded
= 1;
1258 (void) _dl_catch_error (&objname
, &err_str
, map_doit
,
1260 if (__builtin_expect (err_str
!= NULL
, 0))
1262 _dl_error_printf ("\
1263 ERROR: ld.so: object '%s' from %s cannot be preloaded: ignored.\n",
1265 /* No need to call free, this is still before
1266 the libc's malloc is used. */
1268 else if (++args
.map
->l_opencount
== 1)
1269 /* It is no duplicate. */
1274 if (problem
!= NULL
)
1276 char *p
= strndupa (problem
, file_size
- (problem
- file
));
1277 struct link_map
*new_map
= _dl_map_object (GL(dl_loaded
), p
, 1,
1279 if (++new_map
->l_opencount
== 1)
1280 /* It is no duplicate. */
1284 HP_TIMING_NOW (stop
);
1285 HP_TIMING_DIFF (diff
, start
, stop
);
1286 HP_TIMING_ACCUM_NT (load_time
, diff
);
1288 /* We don't need the file anymore. */
1289 __munmap (file
, file_size
);
1294 #if defined(__i386__) || defined(__alpha__) || (defined(__sparc__) && !defined(__arch64__))
1296 * Modifications by Red Hat Software
1298 * Deal with the broken binaries from the non-versioned ages of glibc.
1299 * If a binary does not have version information enabled, we assume that
1300 * it is a glibc 2.0 binary and we load a compatibility library to try to
1301 * overcome binary incompatibilities.
1302 * Blame: gafton@redhat.com
1304 #define LIB_NOVERSION "/lib/libNoVersion.so.1"
1306 if (__builtin_expect (GL(dl_loaded
)->l_info
[DT_NUM
+ DT_THISPROCNUM
+ DT_VERSIONTAGIDX (DT_VERNEED
)] == NULL
, 0)
1307 && (GL(dl_loaded
)->l_info
[DT_DEBUG
] || !(GLRO(dl_debug_mask
) & DL_DEBUG_PRELINK
)))
1309 struct stat test_st
;
1313 HP_TIMING_NOW (start
);
1315 /* _dl_sysdep_message("Loading compatibility library... ", NULL); */
1318 test_fd
= __open (LIB_NOVERSION
, O_RDONLY
);
1321 /* _dl_sysdep_message(" Can't find " LIB_NOVERSION "\n", NULL); */
1323 if (__fxstat (_STAT_VER
, test_fd
, &test_st
) < 0 || test_st
.st_size
== 0) {
1325 /* _dl_sysdep_message(" Can't stat " LIB_NOVERSION "\n", NULL); */
1329 if (test_fd
>= 0) /* open did no fail.. */
1330 __close(test_fd
); /* avoid fd leaks */
1332 if (can_load
!= 0) {
1333 struct link_map
*new_map
;
1334 new_map
= _dl_map_object (GL(dl_loaded
), LIB_NOVERSION
,
1335 1, lt_library
, 0, 0);
1336 if (++new_map
->l_opencount
== 1) {
1337 /* It is no duplicate. */
1339 /* _dl_sysdep_message(" DONE\n", NULL); */
1341 /* _dl_sysdep_message(" FAILED\n", NULL); */
1345 HP_TIMING_NOW (stop
);
1346 HP_TIMING_DIFF (diff
, start
, stop
);
1347 HP_TIMING_ACCUM_NT (load_time
, diff
);
1351 if (__builtin_expect (npreloads
, 0) != 0)
1353 /* Set up PRELOADS with a vector of the preloaded libraries. */
1355 preloads
= __alloca (npreloads
* sizeof preloads
[0]);
1356 l
= GL(dl_rtld_map
).l_next
; /* End of the chain before preloads. */
1363 assert (i
== npreloads
);
1366 #ifdef NEED_DL_SYSINFO
1367 struct link_map
*sysinfo_map
= NULL
;
1368 if (GLRO(dl_sysinfo_dso
) != NULL
)
1370 /* Do an abridged version of the work _dl_map_object_from_fd would do
1371 to map in the object. It's already mapped and prelinked (and
1372 better be, since it's read-only and so we couldn't relocate it).
1373 We just want our data structures to describe it as if we had just
1374 mapped and relocated it normally. */
1375 struct link_map
*l
= _dl_new_object ((char *) "", "", lt_library
, NULL
);
1376 if (__builtin_expect (l
!= NULL
, 1))
1378 static ElfW(Dyn
) dyn_temp
[DL_RO_DYN_TEMP_CNT
] attribute_relro
;
1380 l
->l_phdr
= ((const void *) GLRO(dl_sysinfo_dso
)
1381 + GLRO(dl_sysinfo_dso
)->e_phoff
);
1382 l
->l_phnum
= GLRO(dl_sysinfo_dso
)->e_phnum
;
1383 for (uint_fast16_t i
= 0; i
< l
->l_phnum
; ++i
)
1385 const ElfW(Phdr
) *const ph
= &l
->l_phdr
[i
];
1386 if (ph
->p_type
== PT_DYNAMIC
)
1388 l
->l_ld
= (void *) ph
->p_vaddr
;
1389 l
->l_ldnum
= ph
->p_memsz
/ sizeof (ElfW(Dyn
));
1391 else if (ph
->p_type
== PT_LOAD
)
1394 l
->l_addr
= ph
->p_vaddr
;
1395 else if (ph
->p_vaddr
+ ph
->p_memsz
>= l
->l_map_end
)
1396 l
->l_map_end
= ph
->p_vaddr
+ ph
->p_memsz
;
1397 else if ((ph
->p_flags
& PF_X
)
1398 && ph
->p_vaddr
+ ph
->p_memsz
>= l
->l_text_end
)
1399 l
->l_text_end
= ph
->p_vaddr
+ ph
->p_memsz
;
1402 l
->l_map_start
= (ElfW(Addr
)) GLRO(dl_sysinfo_dso
);
1403 l
->l_addr
= l
->l_map_start
- l
->l_addr
;
1404 l
->l_map_end
+= l
->l_addr
;
1405 l
->l_text_end
+= l
->l_addr
;
1406 l
->l_ld
= (void *) ((ElfW(Addr
)) l
->l_ld
+ l
->l_addr
);
1407 elf_get_dynamic_info (l
, dyn_temp
);
1411 /* Now that we have the info handy, use the DSO image's soname
1412 so this object can be looked up by name. Note that we do not
1413 set l_name here. That field gives the file name of the DSO,
1414 and this DSO is not associated with any file. */
1415 if (l
->l_info
[DT_SONAME
] != NULL
)
1417 /* Work around a kernel problem. The kernel cannot handle
1418 addresses in the vsyscall DSO pages in writev() calls. */
1419 const char *dsoname
= ((char *) D_PTR (l
, l_info
[DT_STRTAB
])
1420 + l
->l_info
[DT_SONAME
]->d_un
.d_val
);
1421 size_t len
= strlen (dsoname
);
1422 char *copy
= malloc (len
);
1424 _dl_fatal_printf ("out of memory\n");
1425 l
->l_libname
->name
= memcpy (copy
, dsoname
, len
);
1428 /* We have a prelinked DSO preloaded by the system. */
1429 if (GLRO(dl_sysinfo
) == DL_SYSINFO_DEFAULT
)
1430 GLRO(dl_sysinfo
) = GLRO(dl_sysinfo_dso
)->e_entry
+ l
->l_addr
;
1436 /* Load all the libraries specified by DT_NEEDED entries. If LD_PRELOAD
1437 specified some libraries to load, these are inserted before the actual
1438 dependencies in the executable's searchlist for symbol resolution. */
1439 HP_TIMING_NOW (start
);
1440 _dl_map_object_deps (GL(dl_loaded
), preloads
, npreloads
, mode
== trace
, 0);
1441 HP_TIMING_NOW (stop
);
1442 HP_TIMING_DIFF (diff
, start
, stop
);
1443 HP_TIMING_ACCUM_NT (load_time
, diff
);
1445 /* Mark all objects as being in the global scope and set the open
1447 for (i
= GL(dl_loaded
)->l_searchlist
.r_nlist
; i
> 0; )
1450 GL(dl_loaded
)->l_searchlist
.r_list
[i
]->l_global
= 1;
1451 ++GL(dl_loaded
)->l_searchlist
.r_list
[i
]->l_opencount
;
1455 /* We are done mapping things, so close the zero-fill descriptor. */
1456 __close (_dl_zerofd
);
1460 /* Remove _dl_rtld_map from the chain. */
1461 GL(dl_rtld_map
).l_prev
->l_next
= GL(dl_rtld_map
).l_next
;
1462 if (GL(dl_rtld_map
).l_next
)
1463 GL(dl_rtld_map
).l_next
->l_prev
= GL(dl_rtld_map
).l_prev
;
1465 if (__builtin_expect (GL(dl_rtld_map
).l_opencount
> 1, 1))
1467 /* Some DT_NEEDED entry referred to the interpreter object itself, so
1468 put it back in the list of visible objects. We insert it into the
1469 chain in symbol search order because gdb uses the chain's order as
1470 its symbol search order. */
1472 while (GL(dl_loaded
)->l_searchlist
.r_list
[i
] != &GL(dl_rtld_map
))
1474 GL(dl_rtld_map
).l_prev
= GL(dl_loaded
)->l_searchlist
.r_list
[i
- 1];
1475 if (__builtin_expect (mode
, normal
) == normal
)
1477 GL(dl_rtld_map
).l_next
= (i
+ 1 < GL(dl_loaded
)->l_searchlist
.r_nlist
1478 ? GL(dl_loaded
)->l_searchlist
.r_list
[i
+ 1]
1480 #ifdef NEED_DL_SYSINFO
1481 if (sysinfo_map
!= NULL
1482 && GL(dl_rtld_map
).l_prev
->l_next
== sysinfo_map
1483 && GL(dl_rtld_map
).l_next
!= sysinfo_map
)
1484 GL(dl_rtld_map
).l_prev
= sysinfo_map
;
1488 /* In trace mode there might be an invisible object (which we
1489 could not find) after the previous one in the search list.
1490 In this case it doesn't matter much where we put the
1491 interpreter object, so we just initialize the list pointer so
1492 that the assertion below holds. */
1493 GL(dl_rtld_map
).l_next
= GL(dl_rtld_map
).l_prev
->l_next
;
1495 assert (GL(dl_rtld_map
).l_prev
->l_next
== GL(dl_rtld_map
).l_next
);
1496 GL(dl_rtld_map
).l_prev
->l_next
= &GL(dl_rtld_map
);
1497 if (GL(dl_rtld_map
).l_next
!= NULL
)
1499 assert (GL(dl_rtld_map
).l_next
->l_prev
== GL(dl_rtld_map
).l_prev
);
1500 GL(dl_rtld_map
).l_next
->l_prev
= &GL(dl_rtld_map
);
1504 /* Now let us see whether all libraries are available in the
1505 versions we need. */
1507 struct version_check_args args
;
1508 args
.doexit
= mode
== normal
;
1509 args
.dotrace
= mode
== trace
;
1510 _dl_receive_error (print_missing_version
, version_check_doit
, &args
);
1514 /* Now it is time to determine the layout of the static TLS block
1515 and allocate it for the initial thread. Note that we always
1516 allocate the static block, we never defer it even if no
1517 DF_STATIC_TLS bit is set. The reason is that we know glibc will
1518 use the static model. First add the dynamic linker to the list
1519 if it also uses TLS. */
1520 if (GL(dl_rtld_map
).l_tls_blocksize
!= 0)
1521 /* Assign a module ID. */
1522 GL(dl_rtld_map
).l_tls_modid
= _dl_next_tls_modid ();
1524 # ifndef TLS_INIT_TP_EXPENSIVE
1525 # define TLS_INIT_TP_EXPENSIVE 0
1528 /* We do not initialize any of the TLS functionality unless any of the
1529 initial modules uses TLS. This makes dynamic loading of modules with
1530 TLS impossible, but to support it requires either eagerly doing setup
1531 now or lazily doing it later. Doing it now makes us incompatible with
1532 an old kernel that can't perform TLS_INIT_TP, even if no TLS is ever
1533 used. Trying to do it lazily is too hairy to try when there could be
1534 multiple threads (from a non-TLS-using libpthread). */
1535 if (!TLS_INIT_TP_EXPENSIVE
|| GL(dl_tls_max_dtv_idx
) > 0)
1539 struct dtv_slotinfo
*slotinfo
;
1541 /* Number of elements in the static TLS block. */
1542 GL(dl_tls_static_nelem
) = GL(dl_tls_max_dtv_idx
);
1544 /* Allocate the array which contains the information about the
1545 dtv slots. We allocate a few entries more than needed to
1546 avoid the need for reallocation. */
1547 nelem
= GL(dl_tls_max_dtv_idx
) + 1 + TLS_SLOTINFO_SURPLUS
;
1550 GL(dl_tls_dtv_slotinfo_list
) = (struct dtv_slotinfo_list
*)
1551 malloc (sizeof (struct dtv_slotinfo_list
)
1552 + nelem
* sizeof (struct dtv_slotinfo
));
1553 /* No need to check the return value. If memory allocation failed
1554 the program would have been terminated. */
1556 slotinfo
= memset (GL(dl_tls_dtv_slotinfo_list
)->slotinfo
, '\0',
1557 nelem
* sizeof (struct dtv_slotinfo
));
1558 GL(dl_tls_dtv_slotinfo_list
)->len
= nelem
;
1559 GL(dl_tls_dtv_slotinfo_list
)->next
= NULL
;
1561 /* Fill in the information from the loaded modules. */
1562 for (l
= GL(dl_loaded
), i
= 0; l
!= NULL
; l
= l
->l_next
)
1563 if (l
->l_tls_blocksize
!= 0)
1564 /* This is a module with TLS data. Store the map reference.
1565 The generation counter is zero. */
1566 slotinfo
[++i
].map
= l
;
1567 assert (i
== GL(dl_tls_max_dtv_idx
));
1569 /* Compute the TLS offsets for the various blocks. */
1570 _dl_determine_tlsoffset ();
1572 /* Construct the static TLS block and the dtv for the initial
1573 thread. For some platforms this will include allocating memory
1574 for the thread descriptor. The memory for the TLS block will
1575 never be freed. It should be allocated accordingly. The dtv
1576 array can be changed if dynamic loading requires it. */
1577 tcbp
= _dl_allocate_tls_storage ();
1579 _dl_fatal_printf ("\
1580 cannot allocate TLS data structures for initial thread");
1582 /* Store for detection of the special case by __tls_get_addr
1583 so it knows not to pass this dtv to the normal realloc. */
1584 GL(dl_initial_dtv
) = GET_DTV (tcbp
);
1588 if (__builtin_expect (mode
, normal
) != normal
)
1590 /* We were run just to list the shared libraries. It is
1591 important that we do this before real relocation, because the
1592 functions we call below for output may no longer work properly
1593 after relocation. */
1596 if (GLRO(dl_debug_mask
) & DL_DEBUG_PRELINK
)
1598 struct r_scope_elem
*scope
= &GL(dl_loaded
)->l_searchlist
;
1600 for (i
= 0; i
< scope
->r_nlist
; i
++)
1602 l
= scope
->r_list
[i
];
1605 _dl_printf ("\t%s => not found\n", l
->l_libname
->name
);
1608 if (_dl_name_match_p (GLRO(dl_trace_prelink
), l
))
1609 GLRO(dl_trace_prelink_map
) = l
;
1610 _dl_printf ("\t%s => %s (0x%0*Zx, 0x%0*Zx)",
1611 l
->l_libname
->name
[0] ? l
->l_libname
->name
1612 : rtld_progname
?: "<main program>",
1613 l
->l_name
[0] ? l
->l_name
1614 : rtld_progname
?: "<main program>",
1615 (int) sizeof l
->l_map_start
* 2,
1616 (size_t) l
->l_map_start
,
1617 (int) sizeof l
->l_addr
* 2,
1618 (size_t) l
->l_addr
);
1621 _dl_printf (" TLS(0x%Zx, 0x%0*Zx)\n", l
->l_tls_modid
,
1622 (int) sizeof l
->l_tls_offset
* 2,
1623 (size_t) l
->l_tls_offset
);
1629 else if (GLRO(dl_debug_mask
) & DL_DEBUG_UNUSED
)
1631 /* Look through the dependencies of the main executable
1632 and determine which of them is not actually
1634 struct link_map
*l
= GL(dl_loaded
);
1636 /* Relocate the main executable. */
1637 struct relocate_args args
= { .l
= l
, .lazy
= GLRO(dl_lazy
) };
1638 _dl_receive_error (print_unresolved
, relocate_doit
, &args
);
1640 /* This loop depends on the dependencies of the executable to
1641 correspond in number and order to the DT_NEEDED entries. */
1642 ElfW(Dyn
) *dyn
= GL(dl_loaded
)->l_ld
;
1644 while (dyn
->d_tag
!= DT_NULL
)
1646 if (dyn
->d_tag
== DT_NEEDED
)
1654 _dl_printf ("Unused direct dependencies:\n");
1658 _dl_printf ("\t%s\n", l
->l_name
);
1665 _exit (first
!= true);
1667 else if (! GL(dl_loaded
)->l_info
[DT_NEEDED
])
1668 _dl_printf ("\tstatically linked\n");
1671 for (l
= GL(dl_loaded
)->l_next
; l
; l
= l
->l_next
)
1673 /* The library was not found. */
1674 _dl_printf ("\t%s => not found\n", l
->l_libname
->name
);
1675 else if (l
->l_libname
->name
[0] == '/')
1676 _dl_printf ("\t%s (0x%0*Zx)\n", l
->l_libname
->name
,
1677 (int) sizeof l
->l_map_start
* 2,
1678 (size_t) l
->l_map_start
);
1680 _dl_printf ("\t%s => %s (0x%0*Zx)\n", l
->l_libname
->name
,
1681 l
->l_name
, (int) sizeof l
->l_map_start
* 2,
1682 (size_t) l
->l_map_start
);
1685 if (__builtin_expect (mode
, trace
) != trace
)
1686 for (i
= 1; i
< (unsigned int) _dl_argc
; ++i
)
1688 const ElfW(Sym
) *ref
= NULL
;
1689 ElfW(Addr
) loadbase
;
1692 result
= _dl_lookup_symbol_x (INTUSE(_dl_argv
)[i
], GL(dl_loaded
),
1693 &ref
, GL(dl_loaded
)->l_scope
, NULL
,
1694 ELF_RTYPE_CLASS_PLT
,
1695 DL_LOOKUP_ADD_DEPENDENCY
, NULL
);
1697 loadbase
= LOOKUP_VALUE_ADDRESS (result
);
1699 _dl_printf ("%s found at 0x%0*Zd in object at 0x%0*Zd\n",
1700 INTUSE(_dl_argv
)[i
],
1701 (int) sizeof ref
->st_value
* 2,
1702 (size_t) ref
->st_value
,
1703 (int) sizeof loadbase
* 2, (size_t) loadbase
);
1707 /* If LD_WARN is set warn about undefined symbols. */
1708 if (GLRO(dl_lazy
) >= 0 && GLRO(dl_verbose
))
1710 /* We have to do symbol dependency testing. */
1711 struct relocate_args args
;
1714 args
.lazy
= GLRO(dl_lazy
);
1721 if (l
!= &GL(dl_rtld_map
) && ! l
->l_faked
)
1724 _dl_receive_error (print_unresolved
, relocate_doit
,
1730 if ((GLRO(dl_debug_mask
) & DL_DEBUG_PRELINK
)
1731 && GL(dl_rtld_map
).l_opencount
> 1)
1732 _dl_relocate_object (&GL(dl_rtld_map
), GL(dl_loaded
)->l_scope
,
1736 #define VERNEEDTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERNEED))
1739 /* Print more information. This means here, print information
1740 about the versions needed. */
1742 struct link_map
*map
= GL(dl_loaded
);
1744 for (map
= GL(dl_loaded
); map
!= NULL
; map
= map
->l_next
)
1747 ElfW(Dyn
) *dyn
= map
->l_info
[VERNEEDTAG
];
1753 strtab
= (const void *) D_PTR (map
, l_info
[DT_STRTAB
]);
1754 ent
= (ElfW(Verneed
) *) (map
->l_addr
+ dyn
->d_un
.d_ptr
);
1758 _dl_printf ("\n\tVersion information:\n");
1762 _dl_printf ("\t%s:\n",
1763 map
->l_name
[0] ? map
->l_name
: rtld_progname
);
1768 struct link_map
*needed
;
1770 needed
= find_needed (strtab
+ ent
->vn_file
);
1771 aux
= (ElfW(Vernaux
) *) ((char *) ent
+ ent
->vn_aux
);
1775 const char *fname
= NULL
;
1778 && match_version (strtab
+ aux
->vna_name
,
1780 fname
= needed
->l_name
;
1782 _dl_printf ("\t\t%s (%s) %s=> %s\n",
1783 strtab
+ ent
->vn_file
,
1784 strtab
+ aux
->vna_name
,
1785 aux
->vna_flags
& VER_FLG_WEAK
1787 fname
?: "not found");
1789 if (aux
->vna_next
== 0)
1790 /* No more symbols. */
1794 aux
= (ElfW(Vernaux
) *) ((char *) aux
1798 if (ent
->vn_next
== 0)
1799 /* No more dependencies. */
1802 /* Next dependency. */
1803 ent
= (ElfW(Verneed
) *) ((char *) ent
+ ent
->vn_next
);
1812 if (GL(dl_loaded
)->l_info
[ADDRIDX (DT_GNU_LIBLIST
)]
1813 && ! __builtin_expect (GLRO(dl_profile
) != NULL
, 0))
1815 ElfW(Lib
) *liblist
, *liblistend
;
1816 struct link_map
**r_list
, **r_listend
, *l
;
1817 const char *strtab
= (const void *) D_PTR (GL(dl_loaded
),
1820 assert (GL(dl_loaded
)->l_info
[VALIDX (DT_GNU_LIBLISTSZ
)] != NULL
);
1821 liblist
= (ElfW(Lib
) *)
1822 GL(dl_loaded
)->l_info
[ADDRIDX (DT_GNU_LIBLIST
)]->d_un
.d_ptr
;
1823 liblistend
= (ElfW(Lib
) *)
1825 + GL(dl_loaded
)->l_info
[VALIDX (DT_GNU_LIBLISTSZ
)]->d_un
.d_val
);
1826 r_list
= GL(dl_loaded
)->l_searchlist
.r_list
;
1827 r_listend
= r_list
+ GL(dl_loaded
)->l_searchlist
.r_nlist
;
1829 for (; r_list
< r_listend
&& liblist
< liblistend
; r_list
++)
1833 if (l
== GL(dl_loaded
))
1836 /* If the library is not mapped where it should, fail. */
1840 /* Next, check if checksum matches. */
1841 if (l
->l_info
[VALIDX(DT_CHECKSUM
)] == NULL
1842 || l
->l_info
[VALIDX(DT_CHECKSUM
)]->d_un
.d_val
1843 != liblist
->l_checksum
)
1846 if (l
->l_info
[VALIDX(DT_GNU_PRELINKED
)] == NULL
1847 || l
->l_info
[VALIDX(DT_GNU_PRELINKED
)]->d_un
.d_val
1848 != liblist
->l_time_stamp
)
1851 if (! _dl_name_match_p (strtab
+ liblist
->l_name
, l
))
1858 if (r_list
== r_listend
&& liblist
== liblistend
)
1861 if (__builtin_expect (GLRO(dl_debug_mask
) & DL_DEBUG_LIBS
, 0))
1862 _dl_printf ("\nprelink checking: %s\n", prelinked
? "ok" : "failed");
1866 /* Initialize _r_debug. */
1867 struct r_debug
*r
= _dl_debug_initialize (GL(dl_rtld_map
).l_addr
);
1873 #ifdef ELF_MACHINE_DEBUG_SETUP
1875 /* Some machines (e.g. MIPS) don't use DT_DEBUG in this way. */
1877 ELF_MACHINE_DEBUG_SETUP (l
, r
);
1878 ELF_MACHINE_DEBUG_SETUP (&GL(dl_rtld_map
), r
);
1882 if (l
->l_info
[DT_DEBUG
] != NULL
)
1883 /* There is a DT_DEBUG entry in the dynamic section. Fill it in
1884 with the run-time address of the r_debug structure */
1885 l
->l_info
[DT_DEBUG
]->d_un
.d_ptr
= (ElfW(Addr
)) r
;
1887 /* Fill in the pointer in the dynamic linker's own dynamic section, in
1888 case you run gdb on the dynamic linker directly. */
1889 if (GL(dl_rtld_map
).l_info
[DT_DEBUG
] != NULL
)
1890 GL(dl_rtld_map
).l_info
[DT_DEBUG
]->d_un
.d_ptr
= (ElfW(Addr
)) r
;
1894 /* Now set up the variable which helps the assembler startup code. */
1895 GL(dl_main_searchlist
) = &GL(dl_loaded
)->l_searchlist
;
1896 GL(dl_global_scope
)[0] = &GL(dl_loaded
)->l_searchlist
;
1898 /* Save the information about the original global scope list since
1899 we need it in the memory handling later. */
1900 GLRO(dl_initial_searchlist
) = *GL(dl_main_searchlist
);
1906 if (GL(dl_loaded
)->l_info
[ADDRIDX (DT_GNU_CONFLICT
)] != NULL
)
1908 ElfW(Rela
) *conflict
, *conflictend
;
1909 #ifndef HP_TIMING_NONAVAIL
1914 HP_TIMING_NOW (start
);
1915 assert (GL(dl_loaded
)->l_info
[VALIDX (DT_GNU_CONFLICTSZ
)] != NULL
);
1916 conflict
= (ElfW(Rela
) *)
1917 GL(dl_loaded
)->l_info
[ADDRIDX (DT_GNU_CONFLICT
)]->d_un
.d_ptr
;
1918 conflictend
= (ElfW(Rela
) *)
1920 + GL(dl_loaded
)->l_info
[VALIDX (DT_GNU_CONFLICTSZ
)]->d_un
.d_val
);
1921 _dl_resolve_conflicts (GL(dl_loaded
), conflict
, conflictend
);
1922 HP_TIMING_NOW (stop
);
1923 HP_TIMING_DIFF (relocate_time
, start
, stop
);
1927 /* Mark all the objects so we know they have been already relocated. */
1928 for (l
= GL(dl_loaded
); l
!= NULL
; l
= l
->l_next
)
1931 if (l
->l_relro_size
)
1932 _dl_protect_relro (l
);
1935 _dl_sysdep_start_cleanup ();
1939 /* Now we have all the objects loaded. Relocate them all except for
1940 the dynamic linker itself. We do this in reverse order so that copy
1941 relocs of earlier objects overwrite the data written by later
1942 objects. We do not re-relocate the dynamic linker itself in this
1943 loop because that could result in the GOT entries for functions we
1944 call being changed, and that would break us. It is safe to relocate
1945 the dynamic linker out of order because it has no copy relocs (we
1946 know that because it is self-contained). */
1949 int consider_profiling
= GLRO(dl_profile
) != NULL
;
1950 #ifndef HP_TIMING_NONAVAIL
1956 /* If we are profiling we also must do lazy reloaction. */
1957 GLRO(dl_lazy
) |= consider_profiling
;
1963 HP_TIMING_NOW (start
);
1966 /* While we are at it, help the memory handling a bit. We have to
1967 mark some data structures as allocated with the fake malloc()
1968 implementation in ld.so. */
1969 struct libname_list
*lnp
= l
->l_libname
->next
;
1971 while (__builtin_expect (lnp
!= NULL
, 0))
1977 if (l
!= &GL(dl_rtld_map
))
1978 _dl_relocate_object (l
, l
->l_scope
, GLRO(dl_lazy
),
1979 consider_profiling
);
1984 HP_TIMING_NOW (stop
);
1986 HP_TIMING_DIFF (relocate_time
, start
, stop
);
1988 /* Do any necessary cleanups for the startup OS interface code.
1989 We do these now so that no calls are made after rtld re-relocation
1990 which might be resolved to different functions than we expect.
1991 We cannot do this before relocating the other objects because
1992 _dl_relocate_object might need to call `mprotect' for DT_TEXTREL. */
1993 _dl_sysdep_start_cleanup ();
1995 /* Now enable profiling if needed. Like the previous call,
1996 this has to go here because the calls it makes should use the
1997 rtld versions of the functions (particularly calloc()), but it
1998 needs to have _dl_profile_map set up by the relocator. */
1999 if (__builtin_expect (GL(dl_profile_map
) != NULL
, 0))
2000 /* We must prepare the profiling. */
2001 _dl_start_profile ();
2003 if (GL(dl_rtld_map
).l_opencount
> 1)
2005 /* There was an explicit ref to the dynamic linker as a shared lib.
2006 Re-relocate ourselves with user-controlled symbol definitions. */
2007 HP_TIMING_NOW (start
);
2008 _dl_relocate_object (&GL(dl_rtld_map
), GL(dl_loaded
)->l_scope
, 0, 0);
2009 HP_TIMING_NOW (stop
);
2010 HP_TIMING_DIFF (add
, start
, stop
);
2011 HP_TIMING_ACCUM_NT (relocate_time
, add
);
2015 #ifndef NONTLS_INIT_TP
2016 # define NONTLS_INIT_TP do { } while (0)
2020 if (GL(dl_tls_max_dtv_idx
) > 0 || USE___THREAD
|| !TLS_INIT_TP_EXPENSIVE
)
2022 /* Now that we have completed relocation, the initializer data
2023 for the TLS blocks has its final values and we can copy them
2024 into the main thread's TLS area, which we allocated above. */
2025 _dl_allocate_tls_init (tcbp
);
2027 /* And finally install it for the main thread. If ld.so itself uses
2028 TLS we know the thread pointer was initialized earlier. */
2029 const char *lossage
= TLS_INIT_TP (tcbp
, USE___THREAD
);
2030 if (__builtin_expect (lossage
!= NULL
, 0))
2031 _dl_fatal_printf ("cannot set up thread-local storage: %s\n", lossage
);
2037 /* Notify the debugger that all objects are now mapped in. */
2038 r
->r_state
= RT_ADD
;
2042 /* We must munmap() the cache file. */
2043 _dl_unload_cache ();
2046 /* Once we return, _dl_sysdep_start will invoke
2047 the DT_INIT functions and then *USER_ENTRY. */
2050 /* This is a little helper function for resolving symbols while
2051 tracing the binary. */
2053 print_unresolved (int errcode
__attribute__ ((unused
)), const char *objname
,
2054 const char *errstring
)
2056 if (objname
[0] == '\0')
2057 objname
= rtld_progname
?: "<main program>";
2058 _dl_error_printf ("%s (%s)\n", errstring
, objname
);
2061 /* This is a little helper function for resolving symbols while
2062 tracing the binary. */
2064 print_missing_version (int errcode
__attribute__ ((unused
)),
2065 const char *objname
, const char *errstring
)
2067 _dl_error_printf ("%s: %s: %s\n", rtld_progname
?: "<program name unknown>",
2068 objname
, errstring
);
2071 /* Nonzero if any of the debugging options is enabled. */
2072 static int any_debug attribute_relro
;
2074 /* Process the string given as the parameter which explains which debugging
2075 options are enabled. */
2077 process_dl_debug (const char *dl_debug
)
2079 /* When adding new entries make sure that the maximal length of a name
2080 is correctly handled in the LD_DEBUG_HELP code below. */
2084 const char name
[10];
2085 const char helptext
[41];
2086 unsigned short int mask
;
2089 #define LEN_AND_STR(str) sizeof (str) - 1, str
2090 { LEN_AND_STR ("libs"), "display library search paths",
2091 DL_DEBUG_LIBS
| DL_DEBUG_IMPCALLS
},
2092 { LEN_AND_STR ("reloc"), "display relocation processing",
2093 DL_DEBUG_RELOC
| DL_DEBUG_IMPCALLS
},
2094 { LEN_AND_STR ("files"), "display progress for input file",
2095 DL_DEBUG_FILES
| DL_DEBUG_IMPCALLS
},
2096 { LEN_AND_STR ("symbols"), "display symbol table processing",
2097 DL_DEBUG_SYMBOLS
| DL_DEBUG_IMPCALLS
},
2098 { LEN_AND_STR ("bindings"), "display information about symbol binding",
2099 DL_DEBUG_BINDINGS
| DL_DEBUG_IMPCALLS
},
2100 { LEN_AND_STR ("versions"), "display version dependencies",
2101 DL_DEBUG_VERSIONS
| DL_DEBUG_IMPCALLS
},
2102 { LEN_AND_STR ("all"), "all previous options combined",
2103 DL_DEBUG_LIBS
| DL_DEBUG_RELOC
| DL_DEBUG_FILES
| DL_DEBUG_SYMBOLS
2104 | DL_DEBUG_BINDINGS
| DL_DEBUG_VERSIONS
| DL_DEBUG_IMPCALLS
},
2105 { LEN_AND_STR ("statistics"), "display relocation statistics",
2106 DL_DEBUG_STATISTICS
},
2107 { LEN_AND_STR ("unused"), "determined unused DSOs",
2109 { LEN_AND_STR ("help"), "display this help message and exit",
2112 #define ndebopts (sizeof (debopts) / sizeof (debopts[0]))
2114 /* Skip separating white spaces and commas. */
2115 while (*dl_debug
!= '\0')
2117 if (*dl_debug
!= ' ' && *dl_debug
!= ',' && *dl_debug
!= ':')
2122 while (dl_debug
[len
] != '\0' && dl_debug
[len
] != ' '
2123 && dl_debug
[len
] != ',' && dl_debug
[len
] != ':')
2126 for (cnt
= 0; cnt
< ndebopts
; ++cnt
)
2127 if (debopts
[cnt
].len
== len
2128 && memcmp (dl_debug
, debopts
[cnt
].name
, len
) == 0)
2130 GLRO(dl_debug_mask
) |= debopts
[cnt
].mask
;
2135 if (cnt
== ndebopts
)
2137 /* Display a warning and skip everything until next
2139 char *copy
= strndupa (dl_debug
, len
);
2140 _dl_error_printf ("\
2141 warning: debug option `%s' unknown; try LD_DEBUG=help\n", copy
);
2151 if (GLRO(dl_debug_mask
) & DL_DEBUG_HELP
)
2156 Valid options for the LD_DEBUG environment variable are:\n\n");
2158 for (cnt
= 0; cnt
< ndebopts
; ++cnt
)
2159 _dl_printf (" %.*s%s%s\n", debopts
[cnt
].len
, debopts
[cnt
].name
,
2160 " " + debopts
[cnt
].len
- 3,
2161 debopts
[cnt
].helptext
);
2164 To direct the debugging output into a file instead of standard output\n\
2165 a filename can be specified using the LD_DEBUG_OUTPUT environment variable.\n");
2170 /* Process all environments variables the dynamic linker must recognize.
2171 Since all of them start with `LD_' we are a bit smarter while finding
2173 extern char **_environ attribute_hidden
;
2177 process_envvars (enum mode
*modep
)
2179 char **runp
= _environ
;
2181 enum mode mode
= normal
;
2182 char *debug_output
= NULL
;
2184 /* This is the default place for profiling data file. */
2185 GLRO(dl_profile_output
)
2186 = &"/var/tmp\0/var/profile"[INTUSE(__libc_enable_secure
) ? 9 : 0];
2188 while ((envline
= _dl_next_ld_env_entry (&runp
)) != NULL
)
2192 while (envline
[len
] != '\0' && envline
[len
] != '=')
2195 if (envline
[len
] != '=')
2196 /* This is a "LD_" variable at the end of the string without
2197 a '=' character. Ignore it since otherwise we will access
2198 invalid memory below. */
2204 /* Warning level, verbose or not. */
2205 if (memcmp (envline
, "WARN", 4) == 0)
2206 GLRO(dl_verbose
) = envline
[5] != '\0';
2210 /* Debugging of the dynamic linker? */
2211 if (memcmp (envline
, "DEBUG", 5) == 0)
2212 process_dl_debug (&envline
[6]);
2216 /* Print information about versions. */
2217 if (memcmp (envline
, "VERBOSE", 7) == 0)
2219 version_info
= envline
[8] != '\0';
2223 /* List of objects to be preloaded. */
2224 if (memcmp (envline
, "PRELOAD", 7) == 0)
2226 preloadlist
= &envline
[8];
2230 /* Which shared object shall be profiled. */
2231 if (memcmp (envline
, "PROFILE", 7) == 0 && envline
[8] != '\0')
2232 GLRO(dl_profile
) = &envline
[8];
2236 /* Do we bind early? */
2237 if (memcmp (envline
, "BIND_NOW", 8) == 0)
2239 GLRO(dl_lazy
) = envline
[9] == '\0';
2242 if (memcmp (envline
, "BIND_NOT", 8) == 0)
2243 GLRO(dl_bind_not
) = envline
[9] != '\0';
2247 /* Test whether we want to see the content of the auxiliary
2248 array passed up from the kernel. */
2249 if (memcmp (envline
, "SHOW_AUXV", 9) == 0)
2254 /* Mask for the important hardware capabilities. */
2255 if (memcmp (envline
, "HWCAP_MASK", 10) == 0)
2256 GLRO(dl_hwcap_mask
) = __strtoul_internal (&envline
[11], NULL
,
2261 /* Path where the binary is found. */
2262 if (!INTUSE(__libc_enable_secure
)
2263 && memcmp (envline
, "ORIGIN_PATH", 11) == 0)
2264 GLRO(dl_origin_path
) = &envline
[12];
2268 /* The library search path. */
2269 if (memcmp (envline
, "LIBRARY_PATH", 12) == 0)
2271 library_path
= &envline
[13];
2275 /* Where to place the profiling data file. */
2276 if (memcmp (envline
, "DEBUG_OUTPUT", 12) == 0)
2278 debug_output
= &envline
[13];
2282 if (memcmp (envline
, "DYNAMIC_WEAK", 12) == 0)
2283 GLRO(dl_dynamic_weak
) = 1;
2287 /* We might have some extra environment variable with length 13
2289 #ifdef EXTRA_LD_ENVVARS_13
2292 if (!INTUSE(__libc_enable_secure
)
2293 && memcmp (envline
, "USE_LOAD_BIAS", 13) == 0)
2294 GLRO(dl_use_load_bias
) = envline
[14] == '1' ? -1 : 0;
2298 /* Where to place the profiling data file. */
2299 if (!INTUSE(__libc_enable_secure
)
2300 && memcmp (envline
, "PROFILE_OUTPUT", 14) == 0
2301 && envline
[15] != '\0')
2302 GLRO(dl_profile_output
) = &envline
[15];
2306 /* The mode of the dynamic linker can be set. */
2307 if (memcmp (envline
, "TRACE_PRELINKING", 16) == 0)
2310 GLRO(dl_verbose
) = 1;
2311 GLRO(dl_debug_mask
) |= DL_DEBUG_PRELINK
;
2312 GLRO(dl_trace_prelink
) = &envline
[17];
2317 /* The mode of the dynamic linker can be set. */
2318 if (memcmp (envline
, "TRACE_LOADED_OBJECTS", 20) == 0)
2322 /* We might have some extra environment variable to handle. This
2323 is tricky due to the pre-processing of the length of the name
2324 in the switch statement here. The code here assumes that added
2325 environment variables have a different length. */
2326 #ifdef EXTRA_LD_ENVVARS
2332 /* The caller wants this information. */
2335 /* Extra security for SUID binaries. Remove all dangerous environment
2337 if (__builtin_expect (INTUSE(__libc_enable_secure
), 0))
2339 static const char unsecure_envvars
[] =
2340 #ifdef EXTRA_UNSECURE_ENVVARS
2341 EXTRA_UNSECURE_ENVVARS
2346 nextp
= unsecure_envvars
;
2350 /* We could use rawmemchr but this need not be fast. */
2351 nextp
= (char *) (strchr
) (nextp
, '\0') + 1;
2353 while (*nextp
!= '\0');
2355 if (__access ("/etc/suid-debug", F_OK
) != 0)
2356 unsetenv ("MALLOC_CHECK_");
2358 /* If we have to run the dynamic linker in debugging mode and the
2359 LD_DEBUG_OUTPUT environment variable is given, we write the debug
2360 messages to this file. */
2361 else if (any_debug
&& debug_output
!= NULL
)
2364 const int flags
= O_WRONLY
| O_APPEND
| O_CREAT
| O_NOFOLLOW
;
2366 const int flags
= O_WRONLY
| O_APPEND
| O_CREAT
;
2368 size_t name_len
= strlen (debug_output
);
2369 char buf
[name_len
+ 12];
2372 buf
[name_len
+ 11] = '\0';
2373 startp
= _itoa (__getpid (), &buf
[name_len
+ 11], 10, 0);
2375 startp
= memcpy (startp
- name_len
, debug_output
, name_len
);
2377 GLRO(dl_debug_fd
) = __open (startp
, flags
, DEFFILEMODE
);
2378 if (GLRO(dl_debug_fd
) == -1)
2379 /* We use standard output if opening the file failed. */
2380 GLRO(dl_debug_fd
) = STDOUT_FILENO
;
2385 /* Print the various times we collected. */
2387 __attribute ((noinline
))
2388 print_statistics (hp_timing_t
*rtld_total_timep
)
2390 #ifndef HP_TIMING_NONAVAIL
2395 /* Total time rtld used. */
2396 if (HP_TIMING_AVAIL
)
2398 HP_TIMING_PRINT (buf
, sizeof (buf
), *rtld_total_timep
);
2399 _dl_debug_printf ("\nruntime linker statistics:\n"
2400 " total startup time in dynamic loader: %s\n", buf
);
2402 /* Print relocation statistics. */
2404 HP_TIMING_PRINT (buf
, sizeof (buf
), relocate_time
);
2405 cp
= _itoa ((1000ULL * relocate_time
) / *rtld_total_timep
,
2406 pbuf
+ sizeof (pbuf
), 10, 0);
2408 switch (pbuf
+ sizeof (pbuf
) - cp
)
2419 _dl_debug_printf ("\
2420 time needed for relocation: %s (%s%%)\n", buf
, pbuf
);
2424 unsigned long int num_relative_relocations
= 0;
2425 struct r_scope_elem
*scope
= &GL(dl_loaded
)->l_searchlist
;
2428 for (i
= 0; i
< scope
->r_nlist
; i
++)
2430 struct link_map
*l
= scope
->r_list
[i
];
2435 if (l
->l_info
[VERSYMIDX (DT_RELCOUNT
)])
2436 num_relative_relocations
+= l
->l_info
[VERSYMIDX (DT_RELCOUNT
)]->d_un
.d_val
;
2437 if (l
->l_info
[VERSYMIDX (DT_RELACOUNT
)])
2438 num_relative_relocations
+= l
->l_info
[VERSYMIDX (DT_RELACOUNT
)]->d_un
.d_val
;
2441 _dl_debug_printf (" number of relocations: %lu\n"
2442 " number of relocations from cache: %lu\n"
2443 " number of relative relocations: %lu\n",
2444 GL(dl_num_relocations
),
2445 GL(dl_num_cache_relocations
),
2446 num_relative_relocations
);
2448 #ifndef HP_TIMING_NONAVAIL
2449 /* Time spend while loading the object and the dependencies. */
2450 if (HP_TIMING_AVAIL
)
2453 HP_TIMING_PRINT (buf
, sizeof (buf
), load_time
);
2454 cp
= _itoa ((1000ULL * load_time
) / *rtld_total_timep
,
2455 pbuf
+ sizeof (pbuf
), 10, 0);
2457 switch (pbuf
+ sizeof (pbuf
) - cp
)
2468 _dl_debug_printf ("\
2469 time needed to load objects: %s (%s%%)\n",