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_real
= &GL(dl_rtld_map
);
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_ns
)[LM_ID_BASE
]._ns_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
,
593 version_check_doit (void *a
)
595 struct version_check_args
*args
= (struct version_check_args
*) a
;
596 if (_dl_check_all_versions (GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
, 1,
597 args
->dotrace
) && args
->doexit
)
598 /* We cannot start the application. Abort now. */
603 static inline struct link_map
*
604 find_needed (const char *name
)
606 struct r_scope_elem
*scope
= &GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
->l_searchlist
;
607 unsigned int n
= scope
->r_nlist
;
610 if (_dl_name_match_p (name
, scope
->r_list
[n
]))
611 return scope
->r_list
[n
];
613 /* Should never happen. */
618 match_version (const char *string
, struct link_map
*map
)
620 const char *strtab
= (const void *) D_PTR (map
, l_info
[DT_STRTAB
]);
623 #define VERDEFTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERDEF))
624 if (map
->l_info
[VERDEFTAG
] == NULL
)
625 /* The file has no symbol versioning. */
628 def
= (ElfW(Verdef
) *) ((char *) map
->l_addr
629 + map
->l_info
[VERDEFTAG
]->d_un
.d_ptr
);
632 ElfW(Verdaux
) *aux
= (ElfW(Verdaux
) *) ((char *) def
+ def
->vd_aux
);
634 /* Compare the version strings. */
635 if (strcmp (string
, strtab
+ aux
->vda_name
) == 0)
639 /* If no more definitions we failed to find what we want. */
640 if (def
->vd_next
== 0)
643 /* Next definition. */
644 def
= (ElfW(Verdef
) *) ((char *) def
+ def
->vd_next
);
650 #ifdef _LIBC_REENTRANT
651 /* _dl_error_catch_tsd points to this for the single-threaded case.
652 It's reset by the thread library for multithreaded programs. */
653 void ** __attribute__ ((const))
654 _dl_initial_error_catch_tsd (void)
663 do_preload (char *fname
, struct link_map
*main_map
, const char *where
)
666 const char *err_str
= NULL
;
667 struct map_args args
;
670 args
.loader
= main_map
;
671 args
.is_preloaded
= 1;
674 unsigned int old_nloaded
= GL(dl_ns
)[LM_ID_BASE
]._ns_nloaded
;
676 (void) _dl_catch_error (&objname
, &err_str
, map_doit
, &args
);
677 if (__builtin_expect (err_str
!= NULL
, 0))
680 ERROR: ld.so: object '%s' from %s cannot be preloaded: ignored.\n",
682 /* No need to call free, this is still before
683 the libc's malloc is used. */
685 else if (GL(dl_ns
)[LM_ID_BASE
]._ns_nloaded
!= old_nloaded
)
686 /* It is no duplicate. */
689 /* Nothing loaded. */
693 #if defined SHARED && defined _LIBC_REENTRANT \
694 && defined __rtld_lock_default_lock_recursive
696 rtld_lock_default_lock_recursive (void *lock
)
698 __rtld_lock_default_lock_recursive (lock
);
702 rtld_lock_default_unlock_recursive (void *lock
)
704 __rtld_lock_default_unlock_recursive (lock
);
709 /* The library search path. */
710 static const char *library_path attribute_relro
;
711 /* The list preloaded objects. */
712 static const char *preloadlist attribute_relro
;
713 /* Nonzero if information about versions has to be printed. */
714 static int version_info attribute_relro
;
717 dl_main (const ElfW(Phdr
) *phdr
,
719 ElfW(Addr
) *user_entry
)
721 const ElfW(Phdr
) *ph
;
723 struct link_map
*main_map
;
726 bool has_interp
= false;
728 bool prelinked
= false;
729 bool rtld_is_main
= false;
730 #ifndef HP_TIMING_NONAVAIL
739 #ifdef _LIBC_REENTRANT
740 /* Explicit initialization since the reloc would just be more work. */
741 GL(dl_error_catch_tsd
) = &_dl_initial_error_catch_tsd
;
745 GL(dl_init_static_tls
) = &_dl_nothread_init_static_tls
;
748 #if defined SHARED && defined _LIBC_REENTRANT \
749 && defined __rtld_lock_default_lock_recursive
750 GL(dl_rtld_lock_recursive
) = rtld_lock_default_lock_recursive
;
751 GL(dl_rtld_unlock_recursive
) = rtld_lock_default_unlock_recursive
;
754 /* The explicit initialization here is cheaper than processing the reloc
755 in the _rtld_local definition's initializer. */
756 GL(dl_make_stack_executable_hook
) = &_dl_make_stack_executable
;
758 /* Process the environment variable which control the behaviour. */
759 process_envvars (&mode
);
761 #ifndef HAVE_INLINED_SYSCALLS
762 /* Set up a flag which tells we are just starting. */
763 INTUSE(_dl_starting_up
) = 1;
766 if (*user_entry
== (ElfW(Addr
)) ENTRY_POINT
)
768 /* Ho ho. We are not the program interpreter! We are the program
769 itself! This means someone ran ld.so as a command. Well, that
770 might be convenient to do sometimes. We support it by
771 interpreting the args like this:
773 ld.so PROGRAM ARGS...
775 The first argument is the name of a file containing an ELF
776 executable we will load and run with the following arguments.
777 To simplify life here, PROGRAM is searched for using the
778 normal rules for shared objects, rather than $PATH or anything
779 like that. We just load it and use its entry point; we don't
780 pay attention to its PT_INTERP command (we are the interpreter
781 ourselves). This is an easy way to test a new ld.so before
785 /* Note the place where the dynamic linker actually came from. */
786 GL(dl_rtld_map
).l_name
= rtld_progname
;
789 if (! strcmp (INTUSE(_dl_argv
)[1], "--list"))
792 GLRO(dl_lazy
) = -1; /* This means do no dependency analysis. */
798 else if (! strcmp (INTUSE(_dl_argv
)[1], "--verify"))
806 else if (! strcmp (INTUSE(_dl_argv
)[1], "--library-path")
809 library_path
= INTUSE(_dl_argv
)[2];
813 INTUSE(_dl_argv
) += 2;
815 else if (! strcmp (INTUSE(_dl_argv
)[1], "--inhibit-rpath")
818 GLRO(dl_inhibit_rpath
) = INTUSE(_dl_argv
)[2];
822 INTUSE(_dl_argv
) += 2;
827 /* If we have no further argument the program was called incorrectly.
828 Grant the user some education. */
831 Usage: ld.so [OPTION]... EXECUTABLE-FILE [ARGS-FOR-PROGRAM...]\n\
832 You have invoked `ld.so', the helper program for shared library executables.\n\
833 This program usually lives in the file `/lib/ld.so', and special directives\n\
834 in executable files using ELF shared libraries tell the system's program\n\
835 loader to load the helper program from this file. This helper program loads\n\
836 the shared libraries needed by the program executable, prepares the program\n\
837 to run, and runs it. You may invoke this helper program directly from the\n\
838 command line to load and run an ELF executable file; this is like executing\n\
839 that file itself, but always uses this helper program from the file you\n\
840 specified, instead of the helper program file specified in the executable\n\
841 file you run. This is mostly of use for maintainers to test new versions\n\
842 of this helper program; chances are you did not intend to run this program.\n\
844 --list list all dependencies and how they are resolved\n\
845 --verify verify that given object really is a dynamically linked\n\
846 object we can handle\n\
847 --library-path PATH use given PATH instead of content of the environment\n\
848 variable LD_LIBRARY_PATH\n\
849 --inhibit-rpath LIST ignore RUNPATH and RPATH information in object names\n\
856 /* Initialize the data structures for the search paths for shared
858 _dl_init_paths (library_path
);
860 /* The initialization of _dl_stack_flags done below assumes the
861 executable's PT_GNU_STACK may have been honored by the kernel, and
862 so a PT_GNU_STACK with PF_X set means the stack started out with
863 execute permission. However, this is not really true if the
864 dynamic linker is the executable the kernel loaded. For this
865 case, we must reinitialize _dl_stack_flags to match the dynamic
866 linker itself. If the dynamic linker was built with a
867 PT_GNU_STACK, then the kernel may have loaded us with a
868 nonexecutable stack that we will have to make executable when we
869 load the program below unless it has a PT_GNU_STACK indicating
870 nonexecutable stack is ok. */
872 for (ph
= phdr
; ph
< &phdr
[phnum
]; ++ph
)
873 if (ph
->p_type
== PT_GNU_STACK
)
875 GL(dl_stack_flags
) = ph
->p_flags
;
879 if (__builtin_expect (mode
, normal
) == verify
)
882 const char *err_str
= NULL
;
883 struct map_args args
;
885 args
.str
= rtld_progname
;
887 args
.is_preloaded
= 0;
888 args
.mode
= __RTLD_OPENEXEC
;
889 (void) _dl_catch_error (&objname
, &err_str
, map_doit
, &args
);
890 if (__builtin_expect (err_str
!= NULL
, 0))
891 /* We don't free the returned string, the programs stops
893 _exit (EXIT_FAILURE
);
897 HP_TIMING_NOW (start
);
898 _dl_map_object (NULL
, rtld_progname
, 0, lt_library
, 0,
899 __RTLD_OPENEXEC
, LM_ID_BASE
);
900 HP_TIMING_NOW (stop
);
902 HP_TIMING_DIFF (load_time
, start
, stop
);
905 /* Now the map for the main executable is available. */
906 main_map
= GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
;
908 phdr
= main_map
->l_phdr
;
909 phnum
= main_map
->l_phnum
;
910 /* We overwrite here a pointer to a malloc()ed string. But since
911 the malloc() implementation used at this point is the dummy
912 implementations which has no real free() function it does not
913 makes sense to free the old string first. */
914 main_map
->l_name
= (char *) "";
915 *user_entry
= main_map
->l_entry
;
919 /* Create a link_map for the executable itself.
920 This will be what dlopen on "" returns. */
921 _dl_new_object ((char *) "", "", lt_executable
, NULL
, 0, LM_ID_BASE
);
922 main_map
= GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
;
923 if (main_map
== NULL
)
924 _dl_fatal_printf ("cannot allocate memory for link map\n");
925 main_map
->l_phdr
= phdr
;
926 main_map
->l_phnum
= phnum
;
927 main_map
->l_entry
= *user_entry
;
929 /* At this point we are in a bit of trouble. We would have to
930 fill in the values for l_dev and l_ino. But in general we
931 do not know where the file is. We also do not handle AT_EXECFD
932 even if it would be passed up.
934 We leave the values here defined to 0. This is normally no
935 problem as the program code itself is normally no shared
936 object and therefore cannot be loaded dynamically. Nothing
937 prevent the use of dynamic binaries and in these situations
938 we might get problems. We might not be able to find out
939 whether the object is already loaded. But since there is no
940 easy way out and because the dynamic binary must also not
941 have an SONAME we ignore this program for now. If it becomes
942 a problem we can force people using SONAMEs. */
944 /* We delay initializing the path structure until we got the dynamic
945 information for the program. */
948 main_map
->l_map_end
= 0;
949 main_map
->l_text_end
= 0;
950 /* Perhaps the executable has no PT_LOAD header entries at all. */
951 main_map
->l_map_start
= ~0;
952 /* And it was opened directly. */
953 ++main_map
->l_direct_opencount
;
955 /* Scan the program header table for the dynamic section. */
956 for (ph
= phdr
; ph
< &phdr
[phnum
]; ++ph
)
960 /* Find out the load address. */
961 main_map
->l_addr
= (ElfW(Addr
)) phdr
- ph
->p_vaddr
;
964 /* This tells us where to find the dynamic section,
965 which tells us everything we need to do. */
966 main_map
->l_ld
= (void *) main_map
->l_addr
+ ph
->p_vaddr
;
969 /* This "interpreter segment" was used by the program loader to
970 find the program interpreter, which is this program itself, the
971 dynamic linker. We note what name finds us, so that a future
972 dlopen call or DT_NEEDED entry, for something that wants to link
973 against the dynamic linker as a shared library, will know that
974 the shared object is already loaded. */
975 _dl_rtld_libname
.name
= ((const char *) main_map
->l_addr
977 /* _dl_rtld_libname.next = NULL; Already zero. */
978 GL(dl_rtld_map
).l_libname
= &_dl_rtld_libname
;
980 /* Ordinarilly, we would get additional names for the loader from
981 our DT_SONAME. This can't happen if we were actually linked as
982 a static executable (detect this case when we have no DYNAMIC).
983 If so, assume the filename component of the interpreter path to
984 be our SONAME, and add it to our name list. */
985 if (GL(dl_rtld_map
).l_ld
== NULL
)
987 const char *p
= NULL
;
988 const char *cp
= _dl_rtld_libname
.name
;
990 /* Find the filename part of the path. */
997 _dl_rtld_libname2
.name
= p
;
998 /* _dl_rtld_libname2.next = NULL; Already zero. */
999 _dl_rtld_libname
.next
= &_dl_rtld_libname2
;
1007 ElfW(Addr
) mapstart
;
1008 ElfW(Addr
) allocend
;
1010 /* Remember where the main program starts in memory. */
1011 mapstart
= (main_map
->l_addr
+ (ph
->p_vaddr
& ~(ph
->p_align
- 1)));
1012 if (main_map
->l_map_start
> mapstart
)
1013 main_map
->l_map_start
= mapstart
;
1015 /* Also where it ends. */
1016 allocend
= main_map
->l_addr
+ ph
->p_vaddr
+ ph
->p_memsz
;
1017 if (main_map
->l_map_end
< allocend
)
1018 main_map
->l_map_end
= allocend
;
1019 if ((ph
->p_flags
& PF_X
) && allocend
> main_map
->l_text_end
)
1020 main_map
->l_text_end
= allocend
;
1025 if (ph
->p_memsz
> 0)
1027 /* Note that in the case the dynamic linker we duplicate work
1028 here since we read the PT_TLS entry already in
1029 _dl_start_final. But the result is repeatable so do not
1030 check for this special but unimportant case. */
1031 main_map
->l_tls_blocksize
= ph
->p_memsz
;
1032 main_map
->l_tls_align
= ph
->p_align
;
1033 if (ph
->p_align
== 0)
1034 main_map
->l_tls_firstbyte_offset
= 0;
1036 main_map
->l_tls_firstbyte_offset
= (ph
->p_vaddr
1037 & (ph
->p_align
- 1));
1038 main_map
->l_tls_initimage_size
= ph
->p_filesz
;
1039 main_map
->l_tls_initimage
= (void *) ph
->p_vaddr
;
1041 /* This image gets the ID one. */
1042 GL(dl_tls_max_dtv_idx
) = main_map
->l_tls_modid
= 1;
1047 GL(dl_stack_flags
) = ph
->p_flags
;
1051 main_map
->l_relro_addr
= ph
->p_vaddr
;
1052 main_map
->l_relro_size
= ph
->p_memsz
;
1056 /* Adjust the address of the TLS initialization image in case
1057 the executable is actually an ET_DYN object. */
1058 if (main_map
->l_tls_initimage
!= NULL
)
1059 main_map
->l_tls_initimage
1060 = (char *) main_map
->l_tls_initimage
+ main_map
->l_addr
;
1062 if (! main_map
->l_map_end
)
1063 main_map
->l_map_end
= ~0;
1064 if (! main_map
->l_text_end
)
1065 main_map
->l_text_end
= ~0;
1066 if (! GL(dl_rtld_map
).l_libname
&& GL(dl_rtld_map
).l_name
)
1068 /* We were invoked directly, so the program might not have a
1070 _dl_rtld_libname
.name
= GL(dl_rtld_map
).l_name
;
1071 /* _dl_rtld_libname.next = NULL; Already zero. */
1072 GL(dl_rtld_map
).l_libname
= &_dl_rtld_libname
;
1075 assert (GL(dl_rtld_map
).l_libname
); /* How else did we get here? */
1079 /* Extract the contents of the dynamic section for easy access. */
1080 elf_get_dynamic_info (main_map
, NULL
);
1081 /* Set up our cache of pointers into the hash table. */
1082 _dl_setup_hash (main_map
);
1085 if (__builtin_expect (mode
, normal
) == verify
)
1087 /* We were called just to verify that this is a dynamic
1088 executable using us as the program interpreter. Exit with an
1089 error if we were not able to load the binary or no interpreter
1090 is specified (i.e., this is no dynamically linked binary. */
1091 if (main_map
->l_ld
== NULL
)
1094 /* We allow here some platform specific code. */
1095 #ifdef DISTINGUISH_LIB_VERSIONS
1096 DISTINGUISH_LIB_VERSIONS
;
1098 _exit (has_interp
? 0 : 2);
1102 /* Initialize the data structures for the search paths for shared
1104 _dl_init_paths (library_path
);
1106 /* Put the link_map for ourselves on the chain so it can be found by
1107 name. Note that at this point the global chain of link maps contains
1108 exactly one element, which is pointed to by dl_loaded. */
1109 if (! GL(dl_rtld_map
).l_name
)
1110 /* If not invoked directly, the dynamic linker shared object file was
1111 found by the PT_INTERP name. */
1112 GL(dl_rtld_map
).l_name
= (char *) GL(dl_rtld_map
).l_libname
->name
;
1113 GL(dl_rtld_map
).l_type
= lt_library
;
1114 main_map
->l_next
= &GL(dl_rtld_map
);
1115 GL(dl_rtld_map
).l_prev
= main_map
;
1116 ++GL(dl_ns
)[LM_ID_BASE
]._ns_nloaded
;
1119 #if defined(__i386__)
1120 /* Force non-TLS libraries for glibc 2.0 binaries
1121 or if a buggy binary references non-TLS errno or h_errno. */
1122 if (__builtin_expect (main_map
->l_info
[DT_NUM
+ DT_THISPROCNUM
1123 + DT_VERSIONTAGIDX (DT_VERNEED
)]
1125 && main_map
->l_info
[DT_DEBUG
])
1126 GLRO(dl_osversion
) = 0x20205;
1127 else if ((__builtin_expect (mode
, normal
) != normal
1128 || main_map
->l_info
[ADDRIDX (DT_GNU_LIBLIST
)] == NULL
)
1129 /* Only binaries have DT_DEBUG dynamic tags... */
1130 && main_map
->l_info
[DT_DEBUG
])
1132 /* Workaround for buggy binaries. This doesn't handle buggy
1135 const ElfW(Sym
) *symtab
= (const void *) D_PTR (main_map
,
1137 const char *strtab
= (const void *) D_PTR (main_map
,
1140 for (symidx
= main_map
->l_buckets
[0x6c994f % main_map
->l_nbuckets
];
1141 symidx
!= STN_UNDEF
;
1142 symidx
= main_map
->l_chain
[symidx
])
1144 if (__builtin_expect (strcmp (strtab
+ symtab
[symidx
].st_name
,
1146 && ELFW(ST_TYPE
) (symtab
[symidx
].st_info
) != STT_TLS
)
1149 for (symidx
= main_map
->l_buckets
[0xe5c992f % main_map
->l_nbuckets
];
1150 symidx
!= STN_UNDEF
;
1151 symidx
= main_map
->l_chain
[symidx
])
1153 if (__builtin_expect (strcmp (strtab
+ symtab
[symidx
].st_name
,
1155 && ELFW(ST_TYPE
) (symtab
[symidx
].st_info
) != STT_TLS
)
1158 if (__builtin_expect (buggy
, false) && GLRO(dl_osversion
) > 0x20401)
1160 GLRO(dl_osversion
) = 0x20401;
1161 _dl_error_printf ("Incorrectly built binary which accesses errno or h_errno directly. Needs to be fixed.\n");
1166 /* If LD_USE_LOAD_BIAS env variable has not been seen, default
1167 to not using bias for non-prelinked PIEs and libraries
1168 and using it for executables or prelinked PIEs or libraries. */
1169 if (GLRO(dl_use_load_bias
) == (ElfW(Addr
)) -2)
1170 GLRO(dl_use_load_bias
) = main_map
->l_addr
== 0 ? -1 : 0;
1172 /* Set up the program header information for the dynamic linker
1173 itself. It is needed in the dl_iterate_phdr() callbacks. */
1174 ElfW(Ehdr
) *rtld_ehdr
= (ElfW(Ehdr
) *) GL(dl_rtld_map
).l_map_start
;
1175 ElfW(Phdr
) *rtld_phdr
= (ElfW(Phdr
) *) (GL(dl_rtld_map
).l_map_start
1176 + rtld_ehdr
->e_phoff
);
1177 GL(dl_rtld_map
).l_phdr
= rtld_phdr
;
1178 GL(dl_rtld_map
).l_phnum
= rtld_ehdr
->e_phnum
;
1180 /* PT_GNU_RELRO is usually the last phdr. */
1181 size_t cnt
= rtld_ehdr
->e_phnum
;
1183 if (rtld_phdr
[cnt
].p_type
== PT_GNU_RELRO
)
1185 GL(dl_rtld_map
).l_relro_addr
= rtld_phdr
[cnt
].p_vaddr
;
1186 GL(dl_rtld_map
).l_relro_size
= rtld_phdr
[cnt
].p_memsz
;
1190 /* We have two ways to specify objects to preload: via environment
1191 variable and via the file /etc/ld.so.preload. The latter can also
1192 be used when security is enabled. */
1193 assert (GL(dl_rtld_map
).l_next
== NULL
);
1194 struct link_map
**preloads
= NULL
;
1195 unsigned int npreloads
= 0;
1197 if (__builtin_expect (preloadlist
!= NULL
, 0))
1199 /* The LD_PRELOAD environment variable gives list of libraries
1200 separated by white space or colons that are loaded before the
1201 executable's dependencies and prepended to the global scope
1202 list. If the binary is running setuid all elements
1203 containing a '/' are ignored since it is insecure. */
1204 char *list
= strdupa (preloadlist
);
1207 HP_TIMING_NOW (start
);
1209 /* Prevent optimizing strsep. Speed is not important here. */
1210 while ((p
= (strsep
) (&list
, " :")) != NULL
)
1212 && (__builtin_expect (! INTUSE(__libc_enable_secure
), 1)
1213 || strchr (p
, '/') == NULL
))
1214 npreloads
+= do_preload (p
, main_map
, "LD_PRELOAD");
1216 HP_TIMING_NOW (stop
);
1217 HP_TIMING_DIFF (diff
, start
, stop
);
1218 HP_TIMING_ACCUM_NT (load_time
, diff
);
1221 /* There usually is no ld.so.preload file, it should only be used
1222 for emergencies and testing. So the open call etc should usually
1223 fail. Using access() on a non-existing file is faster than using
1224 open(). So we do this first. If it succeeds we do almost twice
1225 the work but this does not matter, since it is not for production
1227 static const char preload_file
[] = "/etc/ld.so.preload";
1228 if (__builtin_expect (__access (preload_file
, R_OK
) == 0, 0))
1230 /* Read the contents of the file. */
1231 file
= _dl_sysdep_read_whole_file (preload_file
, &file_size
,
1232 PROT_READ
| PROT_WRITE
);
1233 if (__builtin_expect (file
!= MAP_FAILED
, 0))
1235 /* Parse the file. It contains names of libraries to be loaded,
1236 separated by white spaces or `:'. It may also contain
1237 comments introduced by `#'. */
1242 /* Eliminate comments. */
1247 char *comment
= memchr (runp
, '#', rest
);
1248 if (comment
== NULL
)
1251 rest
-= comment
- runp
;
1254 while (--rest
> 0 && *++comment
!= '\n');
1257 /* We have one problematic case: if we have a name at the end of
1258 the file without a trailing terminating characters, we cannot
1259 place the \0. Handle the case separately. */
1260 if (file
[file_size
- 1] != ' ' && file
[file_size
- 1] != '\t'
1261 && file
[file_size
- 1] != '\n' && file
[file_size
- 1] != ':')
1263 problem
= &file
[file_size
];
1264 while (problem
> file
&& problem
[-1] != ' '
1265 && problem
[-1] != '\t'
1266 && problem
[-1] != '\n' && problem
[-1] != ':')
1275 file
[file_size
- 1] = '\0';
1278 HP_TIMING_NOW (start
);
1280 if (file
!= problem
)
1284 while ((p
= strsep (&runp
, ": \t\n")) != NULL
)
1286 npreloads
+= do_preload (p
, main_map
, preload_file
);
1289 if (problem
!= NULL
)
1291 char *p
= strndupa (problem
, file_size
- (problem
- file
));
1293 npreloads
+= do_preload (p
, main_map
, preload_file
);
1296 HP_TIMING_NOW (stop
);
1297 HP_TIMING_DIFF (diff
, start
, stop
);
1298 HP_TIMING_ACCUM_NT (load_time
, diff
);
1300 /* We don't need the file anymore. */
1301 __munmap (file
, file_size
);
1306 #if defined(__i386__) || defined(__alpha__) || (defined(__sparc__) && !defined(__arch64__))
1308 * Modifications by Red Hat Software
1310 * Deal with the broken binaries from the non-versioned ages of glibc.
1311 * If a binary does not have version information enabled, we assume that
1312 * it is a glibc 2.0 binary and we load a compatibility library to try to
1313 * overcome binary incompatibilities.
1314 * Blame: gafton@redhat.com
1316 #define LIB_NOVERSION "/lib/libNoVersion.so.1"
1318 if (__builtin_expect (main_map
->l_info
[DT_NUM
+ DT_THISPROCNUM
1319 + DT_VERSIONTAGIDX (DT_VERNEED
)]
1321 && (main_map
->l_info
[DT_DEBUG
]
1322 || !(GLRO(dl_debug_mask
) & DL_DEBUG_PRELINK
)))
1324 struct stat test_st
;
1328 HP_TIMING_NOW (start
);
1330 /* _dl_sysdep_message("Loading compatibility library... ", NULL); */
1333 test_fd
= __open (LIB_NOVERSION
, O_RDONLY
);
1336 /* _dl_sysdep_message(" Can't find " LIB_NOVERSION "\n", NULL); */
1338 if (__fxstat (_STAT_VER
, test_fd
, &test_st
) < 0 || test_st
.st_size
== 0) {
1340 /* _dl_sysdep_message(" Can't stat " LIB_NOVERSION "\n", NULL); */
1344 if (test_fd
>= 0) /* open did no fail.. */
1345 __close(test_fd
); /* avoid fd leaks */
1348 npreloads
+= do_preload (LIB_NOVERSION
, main_map
,
1349 "nonversioned binary");
1351 HP_TIMING_NOW (stop
);
1352 HP_TIMING_DIFF (diff
, start
, stop
);
1353 HP_TIMING_ACCUM_NT (load_time
, diff
);
1357 if (__builtin_expect (GL(dl_rtld_map
).l_next
!= NULL
, 0))
1359 /* Set up PRELOADS with a vector of the preloaded libraries. */
1361 preloads
= __alloca (npreloads
* sizeof preloads
[0]);
1362 l
= GL(dl_rtld_map
).l_next
; /* End of the chain before preloads. */
1369 assert (i
== npreloads
);
1372 #if defined NEED_DL_SYSINFO || defined NEED_DL_SYSINFO_DSO
1373 struct link_map
*sysinfo_map
= NULL
;
1374 if (GLRO(dl_sysinfo_dso
) != NULL
)
1376 /* Do an abridged version of the work _dl_map_object_from_fd would do
1377 to map in the object. It's already mapped and prelinked (and
1378 better be, since it's read-only and so we couldn't relocate it).
1379 We just want our data structures to describe it as if we had just
1380 mapped and relocated it normally. */
1381 struct link_map
*l
= _dl_new_object ((char *) "", "", lt_library
, NULL
,
1383 if (__builtin_expect (l
!= NULL
, 1))
1385 static ElfW(Dyn
) dyn_temp
[DL_RO_DYN_TEMP_CNT
] attribute_relro
;
1387 l
->l_phdr
= ((const void *) GLRO(dl_sysinfo_dso
)
1388 + GLRO(dl_sysinfo_dso
)->e_phoff
);
1389 l
->l_phnum
= GLRO(dl_sysinfo_dso
)->e_phnum
;
1390 for (uint_fast16_t i
= 0; i
< l
->l_phnum
; ++i
)
1392 const ElfW(Phdr
) *const ph
= &l
->l_phdr
[i
];
1393 if (ph
->p_type
== PT_DYNAMIC
)
1395 l
->l_ld
= (void *) ph
->p_vaddr
;
1396 l
->l_ldnum
= ph
->p_memsz
/ sizeof (ElfW(Dyn
));
1398 else if (ph
->p_type
== PT_LOAD
)
1401 l
->l_addr
= ph
->p_vaddr
;
1402 if (ph
->p_vaddr
+ ph
->p_memsz
>= l
->l_map_end
)
1403 l
->l_map_end
= ph
->p_vaddr
+ ph
->p_memsz
;
1404 if ((ph
->p_flags
& PF_X
)
1405 && ph
->p_vaddr
+ ph
->p_memsz
>= l
->l_text_end
)
1406 l
->l_text_end
= ph
->p_vaddr
+ ph
->p_memsz
;
1409 l
->l_map_start
= (ElfW(Addr
)) GLRO(dl_sysinfo_dso
);
1410 l
->l_addr
= l
->l_map_start
- l
->l_addr
;
1411 l
->l_map_end
+= l
->l_addr
;
1412 l
->l_text_end
+= l
->l_addr
;
1413 l
->l_ld
= (void *) ((ElfW(Addr
)) l
->l_ld
+ l
->l_addr
);
1414 elf_get_dynamic_info (l
, dyn_temp
);
1418 /* Now that we have the info handy, use the DSO image's soname
1419 so this object can be looked up by name. Note that we do not
1420 set l_name here. That field gives the file name of the DSO,
1421 and this DSO is not associated with any file. */
1422 if (l
->l_info
[DT_SONAME
] != NULL
)
1424 /* Work around a kernel problem. The kernel cannot handle
1425 addresses in the vsyscall DSO pages in writev() calls. */
1426 const char *dsoname
= ((char *) D_PTR (l
, l_info
[DT_STRTAB
])
1427 + l
->l_info
[DT_SONAME
]->d_un
.d_val
);
1428 size_t len
= strlen (dsoname
);
1429 char *copy
= malloc (len
);
1431 _dl_fatal_printf ("out of memory\n");
1432 l
->l_libname
->name
= memcpy (copy
, dsoname
, len
);
1435 /* We have a prelinked DSO preloaded by the system. */
1437 # ifdef NEED_DL_SYSINFO
1438 if (GLRO(dl_sysinfo
) == DL_SYSINFO_DEFAULT
)
1439 GLRO(dl_sysinfo
) = GLRO(dl_sysinfo_dso
)->e_entry
+ l
->l_addr
;
1445 /* Load all the libraries specified by DT_NEEDED entries. If LD_PRELOAD
1446 specified some libraries to load, these are inserted before the actual
1447 dependencies in the executable's searchlist for symbol resolution. */
1448 HP_TIMING_NOW (start
);
1449 _dl_map_object_deps (main_map
, preloads
, npreloads
, mode
== trace
, 0);
1450 HP_TIMING_NOW (stop
);
1451 HP_TIMING_DIFF (diff
, start
, stop
);
1452 HP_TIMING_ACCUM_NT (load_time
, diff
);
1454 /* Mark all objects as being in the global scope. */
1455 for (i
= main_map
->l_searchlist
.r_nlist
; i
> 0; )
1456 main_map
->l_searchlist
.r_list
[--i
]->l_global
= 1;
1459 /* We are done mapping things, so close the zero-fill descriptor. */
1460 __close (_dl_zerofd
);
1464 /* Remove _dl_rtld_map from the chain. */
1465 GL(dl_rtld_map
).l_prev
->l_next
= GL(dl_rtld_map
).l_next
;
1466 if (GL(dl_rtld_map
).l_next
!= NULL
)
1467 GL(dl_rtld_map
).l_next
->l_prev
= GL(dl_rtld_map
).l_prev
;
1469 for (i
= 1; i
< main_map
->l_searchlist
.r_nlist
; ++i
)
1470 if (main_map
->l_searchlist
.r_list
[i
] == &GL(dl_rtld_map
))
1473 bool rtld_multiple_ref
= false;
1474 if (__builtin_expect (i
< main_map
->l_searchlist
.r_nlist
, 1))
1476 /* Some DT_NEEDED entry referred to the interpreter object itself, so
1477 put it back in the list of visible objects. We insert it into the
1478 chain in symbol search order because gdb uses the chain's order as
1479 its symbol search order. */
1480 rtld_multiple_ref
= true;
1482 GL(dl_rtld_map
).l_prev
= main_map
->l_searchlist
.r_list
[i
- 1];
1483 if (__builtin_expect (mode
, normal
) == normal
)
1485 GL(dl_rtld_map
).l_next
= (i
+ 1 < main_map
->l_searchlist
.r_nlist
1486 ? main_map
->l_searchlist
.r_list
[i
+ 1]
1488 #if defined NEED_DL_SYSINFO || defined NEED_DL_SYSINFO_DSO
1489 if (sysinfo_map
!= NULL
1490 && GL(dl_rtld_map
).l_prev
->l_next
== sysinfo_map
1491 && GL(dl_rtld_map
).l_next
!= sysinfo_map
)
1492 GL(dl_rtld_map
).l_prev
= sysinfo_map
;
1496 /* In trace mode there might be an invisible object (which we
1497 could not find) after the previous one in the search list.
1498 In this case it doesn't matter much where we put the
1499 interpreter object, so we just initialize the list pointer so
1500 that the assertion below holds. */
1501 GL(dl_rtld_map
).l_next
= GL(dl_rtld_map
).l_prev
->l_next
;
1503 assert (GL(dl_rtld_map
).l_prev
->l_next
== GL(dl_rtld_map
).l_next
);
1504 GL(dl_rtld_map
).l_prev
->l_next
= &GL(dl_rtld_map
);
1505 if (GL(dl_rtld_map
).l_next
!= NULL
)
1507 assert (GL(dl_rtld_map
).l_next
->l_prev
== GL(dl_rtld_map
).l_prev
);
1508 GL(dl_rtld_map
).l_next
->l_prev
= &GL(dl_rtld_map
);
1512 /* Now let us see whether all libraries are available in the
1513 versions we need. */
1515 struct version_check_args args
;
1516 args
.doexit
= mode
== normal
;
1517 args
.dotrace
= mode
== trace
;
1518 _dl_receive_error (print_missing_version
, version_check_doit
, &args
);
1522 /* Now it is time to determine the layout of the static TLS block
1523 and allocate it for the initial thread. Note that we always
1524 allocate the static block, we never defer it even if no
1525 DF_STATIC_TLS bit is set. The reason is that we know glibc will
1526 use the static model. First add the dynamic linker to the list
1527 if it also uses TLS. */
1528 if (GL(dl_rtld_map
).l_tls_blocksize
!= 0)
1529 /* Assign a module ID. */
1530 GL(dl_rtld_map
).l_tls_modid
= _dl_next_tls_modid ();
1532 # ifndef TLS_INIT_TP_EXPENSIVE
1533 # define TLS_INIT_TP_EXPENSIVE 0
1536 /* We do not initialize any of the TLS functionality unless any of the
1537 initial modules uses TLS. This makes dynamic loading of modules with
1538 TLS impossible, but to support it requires either eagerly doing setup
1539 now or lazily doing it later. Doing it now makes us incompatible with
1540 an old kernel that can't perform TLS_INIT_TP, even if no TLS is ever
1541 used. Trying to do it lazily is too hairy to try when there could be
1542 multiple threads (from a non-TLS-using libpthread). */
1543 if (!TLS_INIT_TP_EXPENSIVE
|| GL(dl_tls_max_dtv_idx
) > 0)
1547 struct dtv_slotinfo
*slotinfo
;
1549 /* Number of elements in the static TLS block. */
1550 GL(dl_tls_static_nelem
) = GL(dl_tls_max_dtv_idx
);
1552 /* Allocate the array which contains the information about the
1553 dtv slots. We allocate a few entries more than needed to
1554 avoid the need for reallocation. */
1555 nelem
= GL(dl_tls_max_dtv_idx
) + 1 + TLS_SLOTINFO_SURPLUS
;
1558 GL(dl_tls_dtv_slotinfo_list
) = (struct dtv_slotinfo_list
*)
1559 malloc (sizeof (struct dtv_slotinfo_list
)
1560 + nelem
* sizeof (struct dtv_slotinfo
));
1561 /* No need to check the return value. If memory allocation failed
1562 the program would have been terminated. */
1564 slotinfo
= memset (GL(dl_tls_dtv_slotinfo_list
)->slotinfo
, '\0',
1565 nelem
* sizeof (struct dtv_slotinfo
));
1566 GL(dl_tls_dtv_slotinfo_list
)->len
= nelem
;
1567 GL(dl_tls_dtv_slotinfo_list
)->next
= NULL
;
1569 /* Fill in the information from the loaded modules. */
1570 for (l
= main_map
, i
= 0; l
!= NULL
; l
= l
->l_next
)
1571 if (l
->l_tls_blocksize
!= 0)
1572 /* This is a module with TLS data. Store the map reference.
1573 The generation counter is zero. */
1574 slotinfo
[++i
].map
= l
;
1575 assert (i
== GL(dl_tls_max_dtv_idx
));
1577 /* Compute the TLS offsets for the various blocks. */
1578 _dl_determine_tlsoffset ();
1580 /* Construct the static TLS block and the dtv for the initial
1581 thread. For some platforms this will include allocating memory
1582 for the thread descriptor. The memory for the TLS block will
1583 never be freed. It should be allocated accordingly. The dtv
1584 array can be changed if dynamic loading requires it. */
1585 tcbp
= _dl_allocate_tls_storage ();
1587 _dl_fatal_printf ("\
1588 cannot allocate TLS data structures for initial thread");
1590 /* Store for detection of the special case by __tls_get_addr
1591 so it knows not to pass this dtv to the normal realloc. */
1592 GL(dl_initial_dtv
) = GET_DTV (tcbp
);
1596 if (__builtin_expect (mode
, normal
) != normal
)
1598 /* We were run just to list the shared libraries. It is
1599 important that we do this before real relocation, because the
1600 functions we call below for output may no longer work properly
1601 after relocation. */
1604 if (GLRO(dl_debug_mask
) & DL_DEBUG_PRELINK
)
1606 struct r_scope_elem
*scope
= &main_map
->l_searchlist
;
1608 for (i
= 0; i
< scope
->r_nlist
; i
++)
1610 l
= scope
->r_list
[i
];
1613 _dl_printf ("\t%s => not found\n", l
->l_libname
->name
);
1616 if (_dl_name_match_p (GLRO(dl_trace_prelink
), l
))
1617 GLRO(dl_trace_prelink_map
) = l
;
1618 _dl_printf ("\t%s => %s (0x%0*Zx, 0x%0*Zx)",
1619 l
->l_libname
->name
[0] ? l
->l_libname
->name
1620 : rtld_progname
?: "<main program>",
1621 l
->l_name
[0] ? l
->l_name
1622 : rtld_progname
?: "<main program>",
1623 (int) sizeof l
->l_map_start
* 2,
1624 (size_t) l
->l_map_start
,
1625 (int) sizeof l
->l_addr
* 2,
1626 (size_t) l
->l_addr
);
1629 _dl_printf (" TLS(0x%Zx, 0x%0*Zx)\n", l
->l_tls_modid
,
1630 (int) sizeof l
->l_tls_offset
* 2,
1631 (size_t) l
->l_tls_offset
);
1637 else if (GLRO(dl_debug_mask
) & DL_DEBUG_UNUSED
)
1639 /* Look through the dependencies of the main executable
1640 and determine which of them is not actually
1642 struct link_map
*l
= main_map
;
1644 /* Relocate the main executable. */
1645 struct relocate_args args
= { .l
= l
, .lazy
= GLRO(dl_lazy
) };
1646 _dl_receive_error (print_unresolved
, relocate_doit
, &args
);
1648 /* This loop depends on the dependencies of the executable to
1649 correspond in number and order to the DT_NEEDED entries. */
1650 ElfW(Dyn
) *dyn
= main_map
->l_ld
;
1652 while (dyn
->d_tag
!= DT_NULL
)
1654 if (dyn
->d_tag
== DT_NEEDED
)
1662 _dl_printf ("Unused direct dependencies:\n");
1666 _dl_printf ("\t%s\n", l
->l_name
);
1673 _exit (first
!= true);
1675 else if (! main_map
->l_info
[DT_NEEDED
])
1676 _dl_printf ("\tstatically linked\n");
1679 for (l
= main_map
->l_next
; l
; l
= l
->l_next
)
1681 /* The library was not found. */
1682 _dl_printf ("\t%s => not found\n", l
->l_libname
->name
);
1683 else if (strcmp (l
->l_libname
->name
, l
->l_name
) == 0)
1684 _dl_printf ("\t%s (0x%0*Zx)\n", l
->l_libname
->name
,
1685 (int) sizeof l
->l_map_start
* 2,
1686 (size_t) l
->l_map_start
);
1688 _dl_printf ("\t%s => %s (0x%0*Zx)\n", l
->l_libname
->name
,
1689 l
->l_name
, (int) sizeof l
->l_map_start
* 2,
1690 (size_t) l
->l_map_start
);
1693 if (__builtin_expect (mode
, trace
) != trace
)
1694 for (i
= 1; i
< (unsigned int) _dl_argc
; ++i
)
1696 const ElfW(Sym
) *ref
= NULL
;
1697 ElfW(Addr
) loadbase
;
1700 result
= _dl_lookup_symbol_x (INTUSE(_dl_argv
)[i
], main_map
,
1701 &ref
, main_map
->l_scope
, NULL
,
1702 ELF_RTYPE_CLASS_PLT
,
1703 DL_LOOKUP_ADD_DEPENDENCY
, NULL
);
1705 loadbase
= LOOKUP_VALUE_ADDRESS (result
);
1707 _dl_printf ("%s found at 0x%0*Zd in object at 0x%0*Zd\n",
1708 INTUSE(_dl_argv
)[i
],
1709 (int) sizeof ref
->st_value
* 2,
1710 (size_t) ref
->st_value
,
1711 (int) sizeof loadbase
* 2, (size_t) loadbase
);
1715 /* If LD_WARN is set, warn about undefined symbols. */
1716 if (GLRO(dl_lazy
) >= 0 && GLRO(dl_verbose
))
1718 /* We have to do symbol dependency testing. */
1719 struct relocate_args args
;
1722 args
.lazy
= GLRO(dl_lazy
);
1725 while (l
->l_next
!= NULL
)
1729 if (l
!= &GL(dl_rtld_map
) && ! l
->l_faked
)
1732 _dl_receive_error (print_unresolved
, relocate_doit
,
1739 if ((GLRO(dl_debug_mask
) & DL_DEBUG_PRELINK
)
1740 && rtld_multiple_ref
)
1741 _dl_relocate_object (&GL(dl_rtld_map
), main_map
->l_scope
,
1745 #define VERNEEDTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERNEED))
1748 /* Print more information. This means here, print information
1749 about the versions needed. */
1751 struct link_map
*map
;
1753 for (map
= main_map
; map
!= NULL
; map
= map
->l_next
)
1756 ElfW(Dyn
) *dyn
= map
->l_info
[VERNEEDTAG
];
1762 strtab
= (const void *) D_PTR (map
, l_info
[DT_STRTAB
]);
1763 ent
= (ElfW(Verneed
) *) (map
->l_addr
+ dyn
->d_un
.d_ptr
);
1767 _dl_printf ("\n\tVersion information:\n");
1771 _dl_printf ("\t%s:\n",
1772 map
->l_name
[0] ? map
->l_name
: rtld_progname
);
1777 struct link_map
*needed
;
1779 needed
= find_needed (strtab
+ ent
->vn_file
);
1780 aux
= (ElfW(Vernaux
) *) ((char *) ent
+ ent
->vn_aux
);
1784 const char *fname
= NULL
;
1787 && match_version (strtab
+ aux
->vna_name
,
1789 fname
= needed
->l_name
;
1791 _dl_printf ("\t\t%s (%s) %s=> %s\n",
1792 strtab
+ ent
->vn_file
,
1793 strtab
+ aux
->vna_name
,
1794 aux
->vna_flags
& VER_FLG_WEAK
1796 fname
?: "not found");
1798 if (aux
->vna_next
== 0)
1799 /* No more symbols. */
1803 aux
= (ElfW(Vernaux
) *) ((char *) aux
1807 if (ent
->vn_next
== 0)
1808 /* No more dependencies. */
1811 /* Next dependency. */
1812 ent
= (ElfW(Verneed
) *) ((char *) ent
+ ent
->vn_next
);
1821 if (main_map
->l_info
[ADDRIDX (DT_GNU_LIBLIST
)]
1822 && ! __builtin_expect (GLRO(dl_profile
) != NULL
, 0))
1824 ElfW(Lib
) *liblist
, *liblistend
;
1825 struct link_map
**r_list
, **r_listend
, *l
;
1826 const char *strtab
= (const void *) D_PTR (main_map
, l_info
[DT_STRTAB
]);
1828 assert (main_map
->l_info
[VALIDX (DT_GNU_LIBLISTSZ
)] != NULL
);
1829 liblist
= (ElfW(Lib
) *)
1830 main_map
->l_info
[ADDRIDX (DT_GNU_LIBLIST
)]->d_un
.d_ptr
;
1831 liblistend
= (ElfW(Lib
) *)
1833 main_map
->l_info
[VALIDX (DT_GNU_LIBLISTSZ
)]->d_un
.d_val
);
1834 r_list
= main_map
->l_searchlist
.r_list
;
1835 r_listend
= r_list
+ main_map
->l_searchlist
.r_nlist
;
1837 for (; r_list
< r_listend
&& liblist
< liblistend
; r_list
++)
1844 /* If the library is not mapped where it should, fail. */
1848 /* Next, check if checksum matches. */
1849 if (l
->l_info
[VALIDX(DT_CHECKSUM
)] == NULL
1850 || l
->l_info
[VALIDX(DT_CHECKSUM
)]->d_un
.d_val
1851 != liblist
->l_checksum
)
1854 if (l
->l_info
[VALIDX(DT_GNU_PRELINKED
)] == NULL
1855 || l
->l_info
[VALIDX(DT_GNU_PRELINKED
)]->d_un
.d_val
1856 != liblist
->l_time_stamp
)
1859 if (! _dl_name_match_p (strtab
+ liblist
->l_name
, l
))
1866 if (r_list
== r_listend
&& liblist
== liblistend
)
1869 if (__builtin_expect (GLRO(dl_debug_mask
) & DL_DEBUG_LIBS
, 0))
1870 _dl_debug_printf ("\nprelink checking: %s\n",
1871 prelinked
? "ok" : "failed");
1875 /* Initialize _r_debug. */
1876 struct r_debug
*r
= _dl_debug_initialize (GL(dl_rtld_map
).l_addr
);
1878 struct link_map
*l
= main_map
;
1880 #ifdef ELF_MACHINE_DEBUG_SETUP
1882 /* Some machines (e.g. MIPS) don't use DT_DEBUG in this way. */
1884 ELF_MACHINE_DEBUG_SETUP (l
, r
);
1885 ELF_MACHINE_DEBUG_SETUP (&GL(dl_rtld_map
), r
);
1889 if (l
->l_info
[DT_DEBUG
] != NULL
)
1890 /* There is a DT_DEBUG entry in the dynamic section. Fill it in
1891 with the run-time address of the r_debug structure */
1892 l
->l_info
[DT_DEBUG
]->d_un
.d_ptr
= (ElfW(Addr
)) r
;
1894 /* Fill in the pointer in the dynamic linker's own dynamic section, in
1895 case you run gdb on the dynamic linker directly. */
1896 if (GL(dl_rtld_map
).l_info
[DT_DEBUG
] != NULL
)
1897 GL(dl_rtld_map
).l_info
[DT_DEBUG
]->d_un
.d_ptr
= (ElfW(Addr
)) r
;
1901 /* Now set up the variable which helps the assembler startup code. */
1902 GL(dl_ns
)[LM_ID_BASE
]._ns_main_searchlist
= &main_map
->l_searchlist
;
1903 GL(dl_ns
)[LM_ID_BASE
]._ns_global_scope
[0] = &main_map
->l_searchlist
;
1905 /* Save the information about the original global scope list since
1906 we need it in the memory handling later. */
1907 GLRO(dl_initial_searchlist
) = *GL(dl_ns
)[LM_ID_BASE
]._ns_main_searchlist
;
1913 if (main_map
->l_info
[ADDRIDX (DT_GNU_CONFLICT
)] != NULL
)
1915 ElfW(Rela
) *conflict
, *conflictend
;
1916 #ifndef HP_TIMING_NONAVAIL
1921 HP_TIMING_NOW (start
);
1922 assert (main_map
->l_info
[VALIDX (DT_GNU_CONFLICTSZ
)] != NULL
);
1923 conflict
= (ElfW(Rela
) *)
1924 main_map
->l_info
[ADDRIDX (DT_GNU_CONFLICT
)]->d_un
.d_ptr
;
1925 conflictend
= (ElfW(Rela
) *)
1927 + main_map
->l_info
[VALIDX (DT_GNU_CONFLICTSZ
)]->d_un
.d_val
);
1928 _dl_resolve_conflicts (main_map
, conflict
, conflictend
);
1929 HP_TIMING_NOW (stop
);
1930 HP_TIMING_DIFF (relocate_time
, start
, stop
);
1934 /* Mark all the objects so we know they have been already relocated. */
1935 for (l
= main_map
; l
!= NULL
; l
= l
->l_next
)
1938 if (l
->l_relro_size
)
1939 _dl_protect_relro (l
);
1942 _dl_sysdep_start_cleanup ();
1946 /* Now we have all the objects loaded. Relocate them all except for
1947 the dynamic linker itself. We do this in reverse order so that copy
1948 relocs of earlier objects overwrite the data written by later
1949 objects. We do not re-relocate the dynamic linker itself in this
1950 loop because that could result in the GOT entries for functions we
1951 call being changed, and that would break us. It is safe to relocate
1952 the dynamic linker out of order because it has no copy relocs (we
1953 know that because it is self-contained). */
1956 int consider_profiling
= GLRO(dl_profile
) != NULL
;
1957 #ifndef HP_TIMING_NONAVAIL
1963 /* If we are profiling we also must do lazy reloaction. */
1964 GLRO(dl_lazy
) |= consider_profiling
;
1970 HP_TIMING_NOW (start
);
1973 /* While we are at it, help the memory handling a bit. We have to
1974 mark some data structures as allocated with the fake malloc()
1975 implementation in ld.so. */
1976 struct libname_list
*lnp
= l
->l_libname
->next
;
1978 while (__builtin_expect (lnp
!= NULL
, 0))
1984 if (l
!= &GL(dl_rtld_map
))
1985 _dl_relocate_object (l
, l
->l_scope
, GLRO(dl_lazy
),
1986 consider_profiling
);
1991 HP_TIMING_NOW (stop
);
1993 HP_TIMING_DIFF (relocate_time
, start
, stop
);
1995 /* Do any necessary cleanups for the startup OS interface code.
1996 We do these now so that no calls are made after rtld re-relocation
1997 which might be resolved to different functions than we expect.
1998 We cannot do this before relocating the other objects because
1999 _dl_relocate_object might need to call `mprotect' for DT_TEXTREL. */
2000 _dl_sysdep_start_cleanup ();
2002 /* Now enable profiling if needed. Like the previous call,
2003 this has to go here because the calls it makes should use the
2004 rtld versions of the functions (particularly calloc()), but it
2005 needs to have _dl_profile_map set up by the relocator. */
2006 if (__builtin_expect (GL(dl_profile_map
) != NULL
, 0))
2007 /* We must prepare the profiling. */
2008 _dl_start_profile ();
2010 if (rtld_multiple_ref
)
2012 /* There was an explicit ref to the dynamic linker as a shared lib.
2013 Re-relocate ourselves with user-controlled symbol definitions. */
2014 HP_TIMING_NOW (start
);
2015 _dl_relocate_object (&GL(dl_rtld_map
), main_map
->l_scope
, 0, 0);
2016 HP_TIMING_NOW (stop
);
2017 HP_TIMING_DIFF (add
, start
, stop
);
2018 HP_TIMING_ACCUM_NT (relocate_time
, add
);
2022 #ifndef NONTLS_INIT_TP
2023 # define NONTLS_INIT_TP do { } while (0)
2027 if (GL(dl_tls_max_dtv_idx
) > 0 || USE___THREAD
|| !TLS_INIT_TP_EXPENSIVE
)
2029 /* Now that we have completed relocation, the initializer data
2030 for the TLS blocks has its final values and we can copy them
2031 into the main thread's TLS area, which we allocated above. */
2032 _dl_allocate_tls_init (tcbp
);
2034 /* And finally install it for the main thread. If ld.so itself uses
2035 TLS we know the thread pointer was initialized earlier. */
2036 const char *lossage
= TLS_INIT_TP (tcbp
, USE___THREAD
);
2037 if (__builtin_expect (lossage
!= NULL
, 0))
2038 _dl_fatal_printf ("cannot set up thread-local storage: %s\n", lossage
);
2044 /* Notify the debugger that all objects are now mapped in. */
2045 r
->r_state
= RT_ADD
;
2049 /* We must munmap() the cache file. */
2050 _dl_unload_cache ();
2053 /* Once we return, _dl_sysdep_start will invoke
2054 the DT_INIT functions and then *USER_ENTRY. */
2057 /* This is a little helper function for resolving symbols while
2058 tracing the binary. */
2060 print_unresolved (int errcode
__attribute__ ((unused
)), const char *objname
,
2061 const char *errstring
)
2063 if (objname
[0] == '\0')
2064 objname
= rtld_progname
?: "<main program>";
2065 _dl_error_printf ("%s (%s)\n", errstring
, objname
);
2068 /* This is a little helper function for resolving symbols while
2069 tracing the binary. */
2071 print_missing_version (int errcode
__attribute__ ((unused
)),
2072 const char *objname
, const char *errstring
)
2074 _dl_error_printf ("%s: %s: %s\n", rtld_progname
?: "<program name unknown>",
2075 objname
, errstring
);
2078 /* Nonzero if any of the debugging options is enabled. */
2079 static int any_debug attribute_relro
;
2081 /* Process the string given as the parameter which explains which debugging
2082 options are enabled. */
2084 process_dl_debug (const char *dl_debug
)
2086 /* When adding new entries make sure that the maximal length of a name
2087 is correctly handled in the LD_DEBUG_HELP code below. */
2091 const char name
[10];
2092 const char helptext
[41];
2093 unsigned short int mask
;
2096 #define LEN_AND_STR(str) sizeof (str) - 1, str
2097 { LEN_AND_STR ("libs"), "display library search paths",
2098 DL_DEBUG_LIBS
| DL_DEBUG_IMPCALLS
},
2099 { LEN_AND_STR ("reloc"), "display relocation processing",
2100 DL_DEBUG_RELOC
| DL_DEBUG_IMPCALLS
},
2101 { LEN_AND_STR ("files"), "display progress for input file",
2102 DL_DEBUG_FILES
| DL_DEBUG_IMPCALLS
},
2103 { LEN_AND_STR ("symbols"), "display symbol table processing",
2104 DL_DEBUG_SYMBOLS
| DL_DEBUG_IMPCALLS
},
2105 { LEN_AND_STR ("bindings"), "display information about symbol binding",
2106 DL_DEBUG_BINDINGS
| DL_DEBUG_IMPCALLS
},
2107 { LEN_AND_STR ("versions"), "display version dependencies",
2108 DL_DEBUG_VERSIONS
| DL_DEBUG_IMPCALLS
},
2109 { LEN_AND_STR ("all"), "all previous options combined",
2110 DL_DEBUG_LIBS
| DL_DEBUG_RELOC
| DL_DEBUG_FILES
| DL_DEBUG_SYMBOLS
2111 | DL_DEBUG_BINDINGS
| DL_DEBUG_VERSIONS
| DL_DEBUG_IMPCALLS
},
2112 { LEN_AND_STR ("statistics"), "display relocation statistics",
2113 DL_DEBUG_STATISTICS
},
2114 { LEN_AND_STR ("unused"), "determined unused DSOs",
2116 { LEN_AND_STR ("help"), "display this help message and exit",
2119 #define ndebopts (sizeof (debopts) / sizeof (debopts[0]))
2121 /* Skip separating white spaces and commas. */
2122 while (*dl_debug
!= '\0')
2124 if (*dl_debug
!= ' ' && *dl_debug
!= ',' && *dl_debug
!= ':')
2129 while (dl_debug
[len
] != '\0' && dl_debug
[len
] != ' '
2130 && dl_debug
[len
] != ',' && dl_debug
[len
] != ':')
2133 for (cnt
= 0; cnt
< ndebopts
; ++cnt
)
2134 if (debopts
[cnt
].len
== len
2135 && memcmp (dl_debug
, debopts
[cnt
].name
, len
) == 0)
2137 GLRO(dl_debug_mask
) |= debopts
[cnt
].mask
;
2142 if (cnt
== ndebopts
)
2144 /* Display a warning and skip everything until next
2146 char *copy
= strndupa (dl_debug
, len
);
2147 _dl_error_printf ("\
2148 warning: debug option `%s' unknown; try LD_DEBUG=help\n", copy
);
2158 if (GLRO(dl_debug_mask
) & DL_DEBUG_HELP
)
2163 Valid options for the LD_DEBUG environment variable are:\n\n");
2165 for (cnt
= 0; cnt
< ndebopts
; ++cnt
)
2166 _dl_printf (" %.*s%s%s\n", debopts
[cnt
].len
, debopts
[cnt
].name
,
2167 " " + debopts
[cnt
].len
- 3,
2168 debopts
[cnt
].helptext
);
2171 To direct the debugging output into a file instead of standard output\n\
2172 a filename can be specified using the LD_DEBUG_OUTPUT environment variable.\n");
2177 /* Process all environments variables the dynamic linker must recognize.
2178 Since all of them start with `LD_' we are a bit smarter while finding
2180 extern char **_environ attribute_hidden
;
2184 process_envvars (enum mode
*modep
)
2186 char **runp
= _environ
;
2188 enum mode mode
= normal
;
2189 char *debug_output
= NULL
;
2191 /* This is the default place for profiling data file. */
2192 GLRO(dl_profile_output
)
2193 = &"/var/tmp\0/var/profile"[INTUSE(__libc_enable_secure
) ? 9 : 0];
2195 while ((envline
= _dl_next_ld_env_entry (&runp
)) != NULL
)
2199 while (envline
[len
] != '\0' && envline
[len
] != '=')
2202 if (envline
[len
] != '=')
2203 /* This is a "LD_" variable at the end of the string without
2204 a '=' character. Ignore it since otherwise we will access
2205 invalid memory below. */
2211 /* Warning level, verbose or not. */
2212 if (memcmp (envline
, "WARN", 4) == 0)
2213 GLRO(dl_verbose
) = envline
[5] != '\0';
2217 /* Debugging of the dynamic linker? */
2218 if (memcmp (envline
, "DEBUG", 5) == 0)
2219 process_dl_debug (&envline
[6]);
2223 /* Print information about versions. */
2224 if (memcmp (envline
, "VERBOSE", 7) == 0)
2226 version_info
= envline
[8] != '\0';
2230 /* List of objects to be preloaded. */
2231 if (memcmp (envline
, "PRELOAD", 7) == 0)
2233 preloadlist
= &envline
[8];
2237 /* Which shared object shall be profiled. */
2238 if (memcmp (envline
, "PROFILE", 7) == 0 && envline
[8] != '\0')
2239 GLRO(dl_profile
) = &envline
[8];
2243 /* Do we bind early? */
2244 if (memcmp (envline
, "BIND_NOW", 8) == 0)
2246 GLRO(dl_lazy
) = envline
[9] == '\0';
2249 if (memcmp (envline
, "BIND_NOT", 8) == 0)
2250 GLRO(dl_bind_not
) = envline
[9] != '\0';
2254 /* Test whether we want to see the content of the auxiliary
2255 array passed up from the kernel. */
2256 if (!INTUSE(__libc_enable_secure
)
2257 && memcmp (envline
, "SHOW_AUXV", 9) == 0)
2262 /* Mask for the important hardware capabilities. */
2263 if (memcmp (envline
, "HWCAP_MASK", 10) == 0)
2264 GLRO(dl_hwcap_mask
) = __strtoul_internal (&envline
[11], NULL
,
2269 /* Path where the binary is found. */
2270 if (!INTUSE(__libc_enable_secure
)
2271 && memcmp (envline
, "ORIGIN_PATH", 11) == 0)
2272 GLRO(dl_origin_path
) = &envline
[12];
2276 /* The library search path. */
2277 if (memcmp (envline
, "LIBRARY_PATH", 12) == 0)
2279 library_path
= &envline
[13];
2283 /* Where to place the profiling data file. */
2284 if (memcmp (envline
, "DEBUG_OUTPUT", 12) == 0)
2286 debug_output
= &envline
[13];
2290 if (!INTUSE(__libc_enable_secure
)
2291 && memcmp (envline
, "DYNAMIC_WEAK", 12) == 0)
2292 GLRO(dl_dynamic_weak
) = 1;
2296 /* We might have some extra environment variable with length 13
2298 #ifdef EXTRA_LD_ENVVARS_13
2301 if (!INTUSE(__libc_enable_secure
)
2302 && memcmp (envline
, "USE_LOAD_BIAS", 13) == 0)
2303 GLRO(dl_use_load_bias
) = envline
[14] == '1' ? -1 : 0;
2307 /* Where to place the profiling data file. */
2308 if (!INTUSE(__libc_enable_secure
)
2309 && memcmp (envline
, "PROFILE_OUTPUT", 14) == 0
2310 && envline
[15] != '\0')
2311 GLRO(dl_profile_output
) = &envline
[15];
2315 /* The mode of the dynamic linker can be set. */
2316 if (memcmp (envline
, "TRACE_PRELINKING", 16) == 0)
2319 GLRO(dl_verbose
) = 1;
2320 GLRO(dl_debug_mask
) |= DL_DEBUG_PRELINK
;
2321 GLRO(dl_trace_prelink
) = &envline
[17];
2326 /* The mode of the dynamic linker can be set. */
2327 if (memcmp (envline
, "TRACE_LOADED_OBJECTS", 20) == 0)
2331 /* We might have some extra environment variable to handle. This
2332 is tricky due to the pre-processing of the length of the name
2333 in the switch statement here. The code here assumes that added
2334 environment variables have a different length. */
2335 #ifdef EXTRA_LD_ENVVARS
2341 /* The caller wants this information. */
2344 /* Extra security for SUID binaries. Remove all dangerous environment
2346 if (__builtin_expect (INTUSE(__libc_enable_secure
), 0))
2348 static const char unsecure_envvars
[] =
2349 #ifdef EXTRA_UNSECURE_ENVVARS
2350 EXTRA_UNSECURE_ENVVARS
2355 nextp
= unsecure_envvars
;
2359 /* We could use rawmemchr but this need not be fast. */
2360 nextp
= (char *) (strchr
) (nextp
, '\0') + 1;
2362 while (*nextp
!= '\0');
2364 if (__access ("/etc/suid-debug", F_OK
) != 0)
2366 unsetenv ("MALLOC_CHECK_");
2367 GLRO(dl_debug_mask
) = 0;
2373 /* If we have to run the dynamic linker in debugging mode and the
2374 LD_DEBUG_OUTPUT environment variable is given, we write the debug
2375 messages to this file. */
2376 else if (any_debug
&& debug_output
!= NULL
)
2379 const int flags
= O_WRONLY
| O_APPEND
| O_CREAT
| O_NOFOLLOW
;
2381 const int flags
= O_WRONLY
| O_APPEND
| O_CREAT
;
2383 size_t name_len
= strlen (debug_output
);
2384 char buf
[name_len
+ 12];
2387 buf
[name_len
+ 11] = '\0';
2388 startp
= _itoa (__getpid (), &buf
[name_len
+ 11], 10, 0);
2390 startp
= memcpy (startp
- name_len
, debug_output
, name_len
);
2392 GLRO(dl_debug_fd
) = __open (startp
, flags
, DEFFILEMODE
);
2393 if (GLRO(dl_debug_fd
) == -1)
2394 /* We use standard output if opening the file failed. */
2395 GLRO(dl_debug_fd
) = STDOUT_FILENO
;
2400 /* Print the various times we collected. */
2402 __attribute ((noinline
))
2403 print_statistics (hp_timing_t
*rtld_total_timep
)
2405 #ifndef HP_TIMING_NONAVAIL
2410 /* Total time rtld used. */
2411 if (HP_TIMING_AVAIL
)
2413 HP_TIMING_PRINT (buf
, sizeof (buf
), *rtld_total_timep
);
2414 _dl_debug_printf ("\nruntime linker statistics:\n"
2415 " total startup time in dynamic loader: %s\n", buf
);
2417 /* Print relocation statistics. */
2419 HP_TIMING_PRINT (buf
, sizeof (buf
), relocate_time
);
2420 cp
= _itoa ((1000ULL * relocate_time
) / *rtld_total_timep
,
2421 pbuf
+ sizeof (pbuf
), 10, 0);
2423 switch (pbuf
+ sizeof (pbuf
) - cp
)
2434 _dl_debug_printf ("\
2435 time needed for relocation: %s (%s%%)\n", buf
, pbuf
);
2439 unsigned long int num_relative_relocations
= 0;
2440 for (Lmid_t ns
= 0; ns
< DL_NNS
; ++ns
)
2442 if (GL(dl_ns
)[ns
]._ns_loaded
== NULL
)
2445 struct r_scope_elem
*scope
= &GL(dl_ns
)[ns
]._ns_loaded
->l_searchlist
;
2447 for (unsigned int i
= 0; i
< scope
->r_nlist
; i
++)
2449 struct link_map
*l
= scope
->r_list
[i
];
2451 if (l
->l_addr
!= 0 && l
->l_info
[VERSYMIDX (DT_RELCOUNT
)])
2452 num_relative_relocations
2453 += l
->l_info
[VERSYMIDX (DT_RELCOUNT
)]->d_un
.d_val
;
2454 #ifndef ELF_MACHINE_REL_RELATIVE
2455 /* Relative relocations are processed on these architectures if
2456 library is loaded to different address than p_vaddr or
2457 if not prelinked. */
2458 if ((l
->l_addr
!= 0 || !l
->l_info
[VALIDX(DT_GNU_PRELINKED
)])
2459 && l
->l_info
[VERSYMIDX (DT_RELACOUNT
)])
2461 /* On e.g. IA-64 or Alpha, relative relocations are processed
2462 only if library is loaded to different address than p_vaddr. */
2463 if (l
->l_addr
!= 0 && l
->l_info
[VERSYMIDX (DT_RELACOUNT
)])
2465 num_relative_relocations
2466 += l
->l_info
[VERSYMIDX (DT_RELACOUNT
)]->d_un
.d_val
;
2470 _dl_debug_printf (" number of relocations: %lu\n"
2471 " number of relocations from cache: %lu\n"
2472 " number of relative relocations: %lu\n",
2473 GL(dl_num_relocations
),
2474 GL(dl_num_cache_relocations
),
2475 num_relative_relocations
);
2477 #ifndef HP_TIMING_NONAVAIL
2478 /* Time spend while loading the object and the dependencies. */
2479 if (HP_TIMING_AVAIL
)
2482 HP_TIMING_PRINT (buf
, sizeof (buf
), load_time
);
2483 cp
= _itoa ((1000ULL * load_time
) / *rtld_total_timep
,
2484 pbuf
+ sizeof (pbuf
), 10, 0);
2486 switch (pbuf
+ sizeof (pbuf
) - cp
)
2497 _dl_debug_printf ("\
2498 time needed to load objects: %s (%s%%)\n",