1 /* Run time dynamic linker.
2 Copyright (C) 1995-2002, 2003 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
26 #include <sys/mman.h> /* Check if MAP_ANON is defined. */
27 #include <sys/param.h>
30 #include <stdio-common/_itoa.h>
32 #include <fpu_control.h>
33 #include <hp-timing.h>
34 #include <bits/libc-lock.h>
35 #include "dynamic-link.h"
36 #include "dl-librecon.h"
37 #include <unsecvars.h>
39 #include <dl-procinfo.h>
44 /* Avoid PLT use for our local calls at startup. */
45 extern __typeof (__mempcpy
) __mempcpy attribute_hidden
;
47 /* GCC has mental blocks about _exit. */
48 extern __typeof (_exit
) exit_internal
asm ("_exit") attribute_hidden
;
49 #define _exit exit_internal
51 /* Helper function to handle errors while resolving symbols. */
52 static void print_unresolved (int errcode
, const char *objname
,
53 const char *errsting
);
55 /* Helper function to handle errors when a version is missing. */
56 static void print_missing_version (int errcode
, const char *objname
,
57 const char *errsting
);
59 /* Print the various times we collected. */
60 static void print_statistics (void);
62 /* This is a list of all the modes the dynamic loader can be in. */
63 enum mode
{ normal
, list
, verify
, trace
};
65 /* Process all environments variables the dynamic linker must recognize.
66 Since all of them start with `LD_' we are a bit smarter while finding
68 static void process_envvars (enum mode
*modep
);
70 int _dl_argc attribute_hidden
;
71 char **_dl_argv
= NULL
;
74 /* Nonzero if we were run directly. */
75 unsigned int _dl_skip_args attribute_hidden
;
77 /* Set nonzero during loading and initialization of executable and
78 libraries, cleared before the executable's entry point runs. This
79 must not be initialized to nonzero, because the unused dynamic
80 linker loaded in for libc.so's "ld.so.1" dep will provide the
81 definition seen by libc.so's initializer; that value must be zero,
82 and will be since that dynamic linker's _dl_start and dl_main will
84 int _dl_starting_up
= 0;
85 INTVARDEF(_dl_starting_up
)
87 /* This is the structure which defines all variables global to ld.so
88 (except those which cannot be added for some reason). */
89 struct rtld_global _rtld_global
=
91 /* Get architecture specific initializer. */
92 #include <dl-procinfo.c>
93 ._dl_debug_fd
= STDERR_FILENO
,
94 #ifdef NEED_DL_SYSINFO
95 ._dl_sysinfo
= DL_SYSINFO_DEFAULT
,
98 ._dl_fpu_control
= _FPU_DEFAULT
,
99 ._dl_correct_cache_id
= _DL_CACHE_DEFAULT_ID
,
100 ._dl_hwcap_mask
= HWCAP_IMPORTANT
,
101 #ifdef _LIBC_REENTRANT
102 ._dl_load_lock
= _RTLD_LOCK_RECURSIVE_INITIALIZER
105 strong_alias (_rtld_global
, _rtld_local
);
107 static void dl_main (const ElfW(Phdr
) *phdr
, ElfW(Word
) phnum
,
108 ElfW(Addr
) *user_entry
);
110 static struct libname_list _dl_rtld_libname
;
111 static struct libname_list _dl_rtld_libname2
;
113 /* We expect less than a second for relocation. */
114 #ifdef HP_SMALL_TIMING_AVAIL
115 # undef HP_TIMING_AVAIL
116 # define HP_TIMING_AVAIL HP_SMALL_TIMING_AVAIL
119 /* Variable for statistics. */
120 #ifndef HP_TIMING_NONAVAIL
121 static hp_timing_t rtld_total_time
;
122 static hp_timing_t relocate_time
;
123 static hp_timing_t load_time
;
124 static hp_timing_t start_time
;
127 /* Additional definitions needed by TLS initialization. */
128 #ifdef TLS_INIT_HELPER
132 /* Helper function for syscall implementation. */
133 #ifdef DL_SYSINFO_IMPLEMENTATION
134 DL_SYSINFO_IMPLEMENTATION
137 /* Before ld.so is relocated we must not access variables which need
138 relocations. This means variables which are exported. Variables
139 declared as static are fine. If we can mark a variable hidden this
140 is fine, too. The latter is impotant here. We can avoid setting
141 up a temporary link map for ld.so if we can mark _rtld_global as
143 #if defined PI_STATIC_AND_HIDDEN && defined HAVE_HIDDEN \
144 && defined HAVE_VISIBILITY_ATTRIBUTE
145 # define DONT_USE_BOOTSTRAP_MAP 1
148 #ifdef DONT_USE_BOOTSTRAP_MAP
149 static ElfW(Addr
) _dl_start_final (void *arg
);
151 struct dl_start_final_info
154 #if !defined HP_TIMING_NONAVAIL && HP_TIMING_INLINE
155 hp_timing_t start_time
;
158 static ElfW(Addr
) _dl_start_final (void *arg
,
159 struct dl_start_final_info
*info
);
162 /* These defined magically in the linker script. */
163 extern char _begin
[] attribute_hidden
;
164 extern char _end
[] attribute_hidden
;
170 # error "sysdeps/MACHINE/dl-machine.h fails to define RTLD_START"
174 # define VALIDX(tag) (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM \
175 + DT_EXTRANUM + DT_VALTAGIDX (tag))
178 # define ADDRIDX(tag) (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM \
179 + DT_EXTRANUM + DT_VALNUM + DT_ADDRTAGIDX (tag))
182 /* This is the second half of _dl_start (below). It can be inlined safely
183 under DONT_USE_BOOTSTRAP_MAP, where it is careful not to make any GOT
184 references. When the tools don't permit us to avoid using a GOT entry
185 for _dl_rtld_global (no attribute_hidden support), we must make sure
186 this function is not inlined (see below). */
188 #ifdef DONT_USE_BOOTSTRAP_MAP
189 static inline ElfW(Addr
) __attribute__ ((always_inline
))
190 _dl_start_final (void *arg
)
192 static ElfW(Addr
) __attribute__ ((noinline
))
193 _dl_start_final (void *arg
, struct dl_start_final_info
*info
)
196 ElfW(Addr
) start_addr
;
200 /* If it hasn't happen yet record the startup time. */
201 if (! HP_TIMING_INLINE
)
202 HP_TIMING_NOW (start_time
);
203 #if !defined DONT_USE_BOOTSTRAP_MAP && !defined HP_TIMING_NONAVAIL
205 start_time
= info
->start_time
;
208 /* Initialize the timing functions. */
209 HP_TIMING_DIFF_INIT ();
212 /* Transfer data about ourselves to the permanent link_map structure. */
213 #ifndef DONT_USE_BOOTSTRAP_MAP
214 GL(dl_rtld_map
).l_addr
= info
->l
.l_addr
;
215 GL(dl_rtld_map
).l_ld
= info
->l
.l_ld
;
216 memcpy (GL(dl_rtld_map
).l_info
, info
->l
.l_info
,
217 sizeof GL(dl_rtld_map
).l_info
);
218 GL(dl_rtld_map
).l_mach
= info
->l
.l_mach
;
220 _dl_setup_hash (&GL(dl_rtld_map
));
221 GL(dl_rtld_map
).l_opencount
= 1;
222 GL(dl_rtld_map
).l_map_start
= (ElfW(Addr
)) _begin
;
223 GL(dl_rtld_map
).l_map_end
= (ElfW(Addr
)) _end
;
224 /* Copy the TLS related data if necessary. */
225 #if USE_TLS && !defined DONT_USE_BOOTSTRAP_MAP
227 assert (info
->l
.l_tls_modid
!= 0);
228 GL(dl_rtld_map
).l_tls_blocksize
= info
->l
.l_tls_blocksize
;
229 GL(dl_rtld_map
).l_tls_align
= info
->l
.l_tls_align
;
230 GL(dl_rtld_map
).l_tls_initimage_size
= info
->l
.l_tls_initimage_size
;
231 GL(dl_rtld_map
).l_tls_initimage
= info
->l
.l_tls_initimage
;
232 GL(dl_rtld_map
).l_tls_offset
= info
->l
.l_tls_offset
;
233 GL(dl_rtld_map
).l_tls_modid
= 1;
235 assert (info
->l
.l_tls_modid
== 0);
241 HP_TIMING_NOW (GL(dl_cpuclock_offset
));
244 /* Call the OS-dependent function to set up life so we can do things like
245 file access. It will call `dl_main' (below) to do all the real work
246 of the dynamic linker, and then unwind our frame and run the user
247 entry point on the same stack we entered on. */
248 start_addr
= _dl_sysdep_start (arg
, &dl_main
);
250 #ifndef HP_TIMING_NONAVAIL
253 hp_timing_t end_time
;
255 /* Get the current time. */
256 HP_TIMING_NOW (end_time
);
258 /* Compute the difference. */
259 HP_TIMING_DIFF (rtld_total_time
, start_time
, end_time
);
263 if (__builtin_expect (GL(dl_debug_mask
) & DL_DEBUG_STATISTICS
, 0))
269 static ElfW(Addr
) __attribute_used__ internal_function
270 _dl_start (void *arg
)
272 #ifdef DONT_USE_BOOTSTRAP_MAP
273 # define bootstrap_map GL(dl_rtld_map)
275 struct dl_start_final_info info
;
276 # define bootstrap_map info.l
279 /* This #define produces dynamic linking inline functions for
280 bootstrap relocation instead of general-purpose relocation. */
281 #define RTLD_BOOTSTRAP
282 #define RESOLVE_MAP(sym, version, flags) \
283 ((*(sym))->st_shndx == SHN_UNDEF ? 0 : &bootstrap_map)
284 #define RESOLVE(sym, version, flags) \
285 ((*(sym))->st_shndx == SHN_UNDEF ? 0 : bootstrap_map.l_addr)
286 #include "dynamic-link.h"
288 if (HP_TIMING_INLINE
&& HP_TIMING_AVAIL
)
289 #ifdef DONT_USE_BOOTSTRAP_MAP
290 HP_TIMING_NOW (start_time
);
292 HP_TIMING_NOW (info
.start_time
);
295 /* Partly clean the `bootstrap_map' structure up. Don't use
296 `memset' since it might not be built in or inlined and we cannot
297 make function calls at this point. Use '__builtin_memset' if we
298 know it is available. We do not have to clear the memory if we
299 do not have to use the temporary bootstrap_map. Global variables
300 are initialized to zero by default. */
301 #ifndef DONT_USE_BOOTSTRAP_MAP
302 # ifdef HAVE_BUILTIN_MEMSET
303 __builtin_memset (bootstrap_map
.l_info
, '\0', sizeof (bootstrap_map
.l_info
));
306 cnt
< sizeof (bootstrap_map
.l_info
) / sizeof (bootstrap_map
.l_info
[0]);
308 bootstrap_map
.l_info
[cnt
] = 0;
312 /* Figure out the run-time load address of the dynamic linker itself. */
313 bootstrap_map
.l_addr
= elf_machine_load_address ();
315 /* Read our own dynamic section and fill in the info array. */
316 bootstrap_map
.l_ld
= (void *) bootstrap_map
.l_addr
+ elf_machine_dynamic ();
317 elf_get_dynamic_info (&bootstrap_map
);
320 /* Get the dynamic linker's own program header. First we need the ELF
321 file header. The `_begin' symbol created by the linker script points
322 to it. When we have something like GOTOFF relocs, we can use a plain
323 reference to find the runtime address. Without that, we have to rely
324 on the `l_addr' value, which is not the value we want when prelinked. */
327 # ifdef DONT_USE_BOOTSTRAP_MAP
328 = (ElfW(Ehdr
) *) &_begin
;
330 = (ElfW(Ehdr
) *) bootstrap_map
.l_addr
;
332 ElfW(Phdr
) *phdr
= (ElfW(Phdr
) *) ((void *) ehdr
+ ehdr
->e_phoff
);
333 size_t cnt
= ehdr
->e_phnum
; /* PT_TLS is usually the last phdr. */
335 if (phdr
[cnt
].p_type
== PT_TLS
)
338 size_t max_align
= MAX (TLS_INIT_TCB_ALIGN
, phdr
[cnt
].p_align
);
341 bootstrap_map
.l_tls_blocksize
= phdr
[cnt
].p_memsz
;
342 bootstrap_map
.l_tls_align
= phdr
[cnt
].p_align
;
343 assert (bootstrap_map
.l_tls_blocksize
!= 0);
344 bootstrap_map
.l_tls_initimage_size
= phdr
[cnt
].p_filesz
;
345 bootstrap_map
.l_tls_initimage
= (void *) (bootstrap_map
.l_addr
346 + phdr
[cnt
].p_vaddr
);
348 /* We can now allocate the initial TLS block. This can happen
349 on the stack. We'll get the final memory later when we
350 know all about the various objects loaded at startup
353 tlsblock
= alloca (roundup (bootstrap_map
.l_tls_blocksize
,
358 tlsblock
= alloca (roundup (TLS_INIT_TCB_SIZE
,
359 bootstrap_map
.l_tls_align
)
360 + bootstrap_map
.l_tls_blocksize
363 /* In case a model with a different layout for the TCB and DTV
364 is defined add another #elif here and in the following #ifs. */
365 # error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
367 /* Align the TLS block. */
368 tlsblock
= (void *) (((uintptr_t) tlsblock
+ max_align
- 1)
371 /* Initialize the dtv. [0] is the length, [1] the generation
373 initdtv
[0].counter
= 1;
374 initdtv
[1].counter
= 0;
376 /* Initialize the TLS block. */
378 initdtv
[2].pointer
= tlsblock
;
380 bootstrap_map
.l_tls_offset
= roundup (TLS_INIT_TCB_SIZE
,
381 bootstrap_map
.l_tls_align
);
382 initdtv
[2].pointer
= (char *) tlsblock
+ bootstrap_map
.l_tls_offset
;
384 # error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
386 p
= __mempcpy (initdtv
[2].pointer
, bootstrap_map
.l_tls_initimage
,
387 bootstrap_map
.l_tls_initimage_size
);
388 # ifdef HAVE_BUILTIN_MEMSET
389 __builtin_memset (p
, '\0', (bootstrap_map
.l_tls_blocksize
390 - bootstrap_map
.l_tls_initimage_size
));
393 size_t remaining
= (bootstrap_map
.l_tls_blocksize
394 - bootstrap_map
.l_tls_initimage_size
);
395 while (remaining
-- > 0)
400 /* Install the pointer to the dtv. */
402 /* Initialize the thread pointer. */
404 bootstrap_map
.l_tls_offset
405 = roundup (bootstrap_map
.l_tls_blocksize
, TLS_INIT_TCB_ALIGN
);
407 INSTALL_DTV ((char *) tlsblock
+ bootstrap_map
.l_tls_offset
,
410 const char *lossage
= TLS_INIT_TP ((char *) tlsblock
411 + bootstrap_map
.l_tls_offset
, 0);
413 INSTALL_DTV (tlsblock
, initdtv
);
414 const char *lossage
= TLS_INIT_TP (tlsblock
, 0);
416 # error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
418 if (__builtin_expect (lossage
!= NULL
, 0))
419 _dl_fatal_printf ("cannot set up thread-local storage: %s\n",
422 /* So far this is module number one. */
423 bootstrap_map
.l_tls_modid
= 1;
425 /* There can only be one PT_TLS entry. */
428 #endif /* USE___THREAD */
430 #ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
431 ELF_MACHINE_BEFORE_RTLD_RELOC (bootstrap_map
.l_info
);
434 if (bootstrap_map
.l_addr
|| ! bootstrap_map
.l_info
[VALIDX(DT_GNU_PRELINKED
)])
436 /* Relocate ourselves so we can do normal function calls and
437 data access using the global offset table. */
439 ELF_DYNAMIC_RELOCATE (&bootstrap_map
, 0, 0);
442 /* Please note that we don't allow profiling of this object and
443 therefore need not test whether we have to allocate the array
444 for the relocation results (as done in dl-reloc.c). */
446 /* Now life is sane; we can call functions and access global data.
447 Set up to use the operating system facilities, and find out from
448 the operating system's program loader where to find the program
449 header table in core. Put the rest of _dl_start into a separate
450 function, that way the compiler cannot put accesses to the GOT
451 before ELF_DYNAMIC_RELOCATE. */
453 #ifdef DONT_USE_BOOTSTRAP_MAP
454 ElfW(Addr
) entry
= _dl_start_final (arg
);
456 ElfW(Addr
) entry
= _dl_start_final (arg
, &info
);
459 #ifndef ELF_MACHINE_START_ADDRESS
460 # define ELF_MACHINE_START_ADDRESS(map, start) (start)
463 return ELF_MACHINE_START_ADDRESS (GL(dl_loaded
), entry
);
469 /* Now life is peachy; we can do all normal operations.
470 On to the real work. */
472 /* Some helper functions. */
474 /* Arguments to relocate_doit. */
483 /* Argument to map_doit. */
485 /* Return value of map_doit. */
486 struct link_map
*main_map
;
489 /* Arguments to version_check_doit. */
490 struct version_check_args
497 relocate_doit (void *a
)
499 struct relocate_args
*args
= (struct relocate_args
*) a
;
501 INTUSE(_dl_relocate_object
) (args
->l
, args
->l
->l_scope
, args
->lazy
, 0);
507 struct map_args
*args
= (struct map_args
*) a
;
508 args
->main_map
= INTUSE(_dl_map_object
) (NULL
, args
->str
, 0, lt_library
, 0, 0);
512 version_check_doit (void *a
)
514 struct version_check_args
*args
= (struct version_check_args
*) a
;
515 if (_dl_check_all_versions (GL(dl_loaded
), 1, args
->dotrace
) && args
->doexit
)
516 /* We cannot start the application. Abort now. */
521 static inline struct link_map
*
522 find_needed (const char *name
)
524 unsigned int n
= GL(dl_loaded
)->l_searchlist
.r_nlist
;
527 if (_dl_name_match_p (name
, GL(dl_loaded
)->l_searchlist
.r_list
[n
]))
528 return GL(dl_loaded
)->l_searchlist
.r_list
[n
];
530 /* Should never happen. */
535 match_version (const char *string
, struct link_map
*map
)
537 const char *strtab
= (const void *) D_PTR (map
, l_info
[DT_STRTAB
]);
540 #define VERDEFTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERDEF))
541 if (map
->l_info
[VERDEFTAG
] == NULL
)
542 /* The file has no symbol versioning. */
545 def
= (ElfW(Verdef
) *) ((char *) map
->l_addr
546 + map
->l_info
[VERDEFTAG
]->d_un
.d_ptr
);
549 ElfW(Verdaux
) *aux
= (ElfW(Verdaux
) *) ((char *) def
+ def
->vd_aux
);
551 /* Compare the version strings. */
552 if (strcmp (string
, strtab
+ aux
->vda_name
) == 0)
556 /* If no more definitions we failed to find what we want. */
557 if (def
->vd_next
== 0)
560 /* Next definition. */
561 def
= (ElfW(Verdef
) *) ((char *) def
+ def
->vd_next
);
567 #ifdef _LIBC_REENTRANT
568 /* _dl_error_catch_tsd points to this for the single-threaded case.
569 It's reset by the thread library for multithreaded programs. */
570 void ** __attribute__ ((const))
571 _dl_initial_error_catch_tsd (void)
578 static const char *library_path
; /* The library search path. */
579 static const char *preloadlist
; /* The list preloaded objects. */
580 static int version_info
; /* Nonzero if information about
581 versions has to be printed. */
584 dl_main (const ElfW(Phdr
) *phdr
,
586 ElfW(Addr
) *user_entry
)
588 const ElfW(Phdr
) *ph
;
590 struct link_map
**preloads
;
591 unsigned int npreloads
;
594 bool has_interp
= false;
596 bool prelinked
= false;
597 bool rtld_is_main
= false;
598 #ifndef HP_TIMING_NONAVAIL
607 #ifdef _LIBC_REENTRANT
608 /* Explicit initialization since the reloc would just be more work. */
609 GL(dl_error_catch_tsd
) = &_dl_initial_error_catch_tsd
;
612 /* Process the environment variable which control the behaviour. */
613 process_envvars (&mode
);
615 /* Set up a flag which tells we are just starting. */
616 INTUSE(_dl_starting_up
) = 1;
618 if (*user_entry
== (ElfW(Addr
)) ENTRY_POINT
)
620 /* Ho ho. We are not the program interpreter! We are the program
621 itself! This means someone ran ld.so as a command. Well, that
622 might be convenient to do sometimes. We support it by
623 interpreting the args like this:
625 ld.so PROGRAM ARGS...
627 The first argument is the name of a file containing an ELF
628 executable we will load and run with the following arguments.
629 To simplify life here, PROGRAM is searched for using the
630 normal rules for shared objects, rather than $PATH or anything
631 like that. We just load it and use its entry point; we don't
632 pay attention to its PT_INTERP command (we are the interpreter
633 ourselves). This is an easy way to test a new ld.so before
637 /* Note the place where the dynamic linker actually came from. */
638 GL(dl_rtld_map
).l_name
= rtld_progname
;
641 if (! strcmp (INTUSE(_dl_argv
)[1], "--list"))
644 GL(dl_lazy
) = -1; /* This means do no dependency analysis. */
650 else if (! strcmp (INTUSE(_dl_argv
)[1], "--verify"))
658 else if (! strcmp (INTUSE(_dl_argv
)[1], "--library-path")
661 library_path
= INTUSE(_dl_argv
)[2];
665 INTUSE(_dl_argv
) += 2;
667 else if (! strcmp (INTUSE(_dl_argv
)[1], "--inhibit-rpath")
670 GL(dl_inhibit_rpath
) = INTUSE(_dl_argv
)[2];
674 INTUSE(_dl_argv
) += 2;
679 /* If we have no further argument the program was called incorrectly.
680 Grant the user some education. */
683 Usage: ld.so [OPTION]... EXECUTABLE-FILE [ARGS-FOR-PROGRAM...]\n\
684 You have invoked `ld.so', the helper program for shared library executables.\n\
685 This program usually lives in the file `/lib/ld.so', and special directives\n\
686 in executable files using ELF shared libraries tell the system's program\n\
687 loader to load the helper program from this file. This helper program loads\n\
688 the shared libraries needed by the program executable, prepares the program\n\
689 to run, and runs it. You may invoke this helper program directly from the\n\
690 command line to load and run an ELF executable file; this is like executing\n\
691 that file itself, but always uses this helper program from the file you\n\
692 specified, instead of the helper program file specified in the executable\n\
693 file you run. This is mostly of use for maintainers to test new versions\n\
694 of this helper program; chances are you did not intend to run this program.\n\
696 --list list all dependencies and how they are resolved\n\
697 --verify verify that given object really is a dynamically linked\n\
698 object we can handle\n\
699 --library-path PATH use given PATH instead of content of the environment\n\
700 variable LD_LIBRARY_PATH\n\
701 --inhibit-rpath LIST ignore RUNPATH and RPATH information in object names\n\
708 /* Initialize the data structures for the search paths for shared
710 _dl_init_paths (library_path
);
712 if (__builtin_expect (mode
, normal
) == verify
)
715 const char *err_str
= NULL
;
716 struct map_args args
;
718 args
.str
= rtld_progname
;
719 (void) INTUSE(_dl_catch_error
) (&objname
, &err_str
, map_doit
, &args
);
720 if (__builtin_expect (err_str
!= NULL
, 0))
721 /* We don't free the returned string, the programs stops
723 _exit (EXIT_FAILURE
);
727 HP_TIMING_NOW (start
);
728 INTUSE(_dl_map_object
) (NULL
, rtld_progname
, 0, lt_library
, 0, 0);
729 HP_TIMING_NOW (stop
);
731 HP_TIMING_DIFF (load_time
, start
, stop
);
734 phdr
= GL(dl_loaded
)->l_phdr
;
735 phnum
= GL(dl_loaded
)->l_phnum
;
736 /* We overwrite here a pointer to a malloc()ed string. But since
737 the malloc() implementation used at this point is the dummy
738 implementations which has no real free() function it does not
739 makes sense to free the old string first. */
740 GL(dl_loaded
)->l_name
= (char *) "";
741 *user_entry
= GL(dl_loaded
)->l_entry
;
745 /* Create a link_map for the executable itself.
746 This will be what dlopen on "" returns. */
747 _dl_new_object ((char *) "", "", lt_executable
, NULL
);
748 if (GL(dl_loaded
) == NULL
)
749 _dl_fatal_printf ("cannot allocate memory for link map\n");
750 GL(dl_loaded
)->l_phdr
= phdr
;
751 GL(dl_loaded
)->l_phnum
= phnum
;
752 GL(dl_loaded
)->l_entry
= *user_entry
;
754 /* At this point we are in a bit of trouble. We would have to
755 fill in the values for l_dev and l_ino. But in general we
756 do not know where the file is. We also do not handle AT_EXECFD
757 even if it would be passed up.
759 We leave the values here defined to 0. This is normally no
760 problem as the program code itself is normally no shared
761 object and therefore cannot be loaded dynamically. Nothing
762 prevent the use of dynamic binaries and in these situations
763 we might get problems. We might not be able to find out
764 whether the object is already loaded. But since there is no
765 easy way out and because the dynamic binary must also not
766 have an SONAME we ignore this program for now. If it becomes
767 a problem we can force people using SONAMEs. */
769 /* We delay initializing the path structure until we got the dynamic
770 information for the program. */
773 GL(dl_loaded
)->l_map_end
= 0;
774 /* Perhaps the executable has no PT_LOAD header entries at all. */
775 GL(dl_loaded
)->l_map_start
= ~0;
776 /* We opened the file, account for it. */
777 ++GL(dl_loaded
)->l_opencount
;
779 /* Scan the program header table for the dynamic section. */
780 for (ph
= phdr
; ph
< &phdr
[phnum
]; ++ph
)
784 /* Find out the load address. */
785 GL(dl_loaded
)->l_addr
= (ElfW(Addr
)) phdr
- ph
->p_vaddr
;
788 /* This tells us where to find the dynamic section,
789 which tells us everything we need to do. */
790 GL(dl_loaded
)->l_ld
= (void *) GL(dl_loaded
)->l_addr
+ ph
->p_vaddr
;
793 /* This "interpreter segment" was used by the program loader to
794 find the program interpreter, which is this program itself, the
795 dynamic linker. We note what name finds us, so that a future
796 dlopen call or DT_NEEDED entry, for something that wants to link
797 against the dynamic linker as a shared library, will know that
798 the shared object is already loaded. */
799 _dl_rtld_libname
.name
= ((const char *) GL(dl_loaded
)->l_addr
801 /* _dl_rtld_libname.next = NULL; Already zero. */
802 GL(dl_rtld_map
).l_libname
= &_dl_rtld_libname
;
804 /* Ordinarilly, we would get additional names for the loader from
805 our DT_SONAME. This can't happen if we were actually linked as
806 a static executable (detect this case when we have no DYNAMIC).
807 If so, assume the filename component of the interpreter path to
808 be our SONAME, and add it to our name list. */
809 if (GL(dl_rtld_map
).l_ld
== NULL
)
811 const char *p
= NULL
;
812 const char *cp
= _dl_rtld_libname
.name
;
814 /* Find the filename part of the path. */
821 _dl_rtld_libname2
.name
= p
;
822 /* _dl_rtld_libname2.next = NULL; Already zero. */
823 _dl_rtld_libname
.next
= &_dl_rtld_libname2
;
834 /* Remember where the main program starts in memory. */
835 mapstart
= (GL(dl_loaded
)->l_addr
836 + (ph
->p_vaddr
& ~(ph
->p_align
- 1)));
837 if (GL(dl_loaded
)->l_map_start
> mapstart
)
838 GL(dl_loaded
)->l_map_start
= mapstart
;
840 /* Also where it ends. */
841 allocend
= GL(dl_loaded
)->l_addr
+ ph
->p_vaddr
+ ph
->p_memsz
;
842 if (GL(dl_loaded
)->l_map_end
< allocend
)
843 GL(dl_loaded
)->l_map_end
= allocend
;
850 /* Note that in the case the dynamic linker we duplicate work
851 here since we read the PT_TLS entry already in
852 _dl_start_final. But the result is repeatable so do not
853 check for this special but unimportant case. */
854 GL(dl_loaded
)->l_tls_blocksize
= ph
->p_memsz
;
855 GL(dl_loaded
)->l_tls_align
= ph
->p_align
;
856 GL(dl_loaded
)->l_tls_initimage_size
= ph
->p_filesz
;
857 GL(dl_loaded
)->l_tls_initimage
= (void *) ph
->p_vaddr
;
859 /* This image gets the ID one. */
860 GL(dl_tls_max_dtv_idx
) = GL(dl_loaded
)->l_tls_modid
= 1;
866 /* Adjust the address of the TLS initialization image in case
867 the executable is actually an ET_DYN object. */
868 if (GL(dl_loaded
)->l_tls_initimage
!= NULL
)
869 GL(dl_loaded
)->l_tls_initimage
870 = (char *) GL(dl_loaded
)->l_tls_initimage
+ GL(dl_loaded
)->l_addr
;
872 if (! GL(dl_loaded
)->l_map_end
)
873 GL(dl_loaded
)->l_map_end
= ~0;
874 if (! GL(dl_rtld_map
).l_libname
&& GL(dl_rtld_map
).l_name
)
876 /* We were invoked directly, so the program might not have a
878 _dl_rtld_libname
.name
= GL(dl_rtld_map
).l_name
;
879 /* _dl_rtld_libname.next = NULL; Already zero. */
880 GL(dl_rtld_map
).l_libname
= &_dl_rtld_libname
;
883 assert (GL(dl_rtld_map
).l_libname
); /* How else did we get here? */
887 /* Extract the contents of the dynamic section for easy access. */
888 elf_get_dynamic_info (GL(dl_loaded
));
889 if (GL(dl_loaded
)->l_info
[DT_HASH
])
890 /* Set up our cache of pointers into the hash table. */
891 _dl_setup_hash (GL(dl_loaded
));
894 if (__builtin_expect (mode
, normal
) == verify
)
896 /* We were called just to verify that this is a dynamic
897 executable using us as the program interpreter. Exit with an
898 error if we were not able to load the binary or no interpreter
899 is specified (i.e., this is no dynamically linked binary. */
900 if (GL(dl_loaded
)->l_ld
== NULL
)
903 /* We allow here some platform specific code. */
904 #ifdef DISTINGUISH_LIB_VERSIONS
905 DISTINGUISH_LIB_VERSIONS
;
907 _exit (has_interp
? 0 : 2);
911 /* Initialize the data structures for the search paths for shared
913 _dl_init_paths (library_path
);
915 /* Put the link_map for ourselves on the chain so it can be found by
916 name. Note that at this point the global chain of link maps contains
917 exactly one element, which is pointed to by dl_loaded. */
918 if (! GL(dl_rtld_map
).l_name
)
919 /* If not invoked directly, the dynamic linker shared object file was
920 found by the PT_INTERP name. */
921 GL(dl_rtld_map
).l_name
= (char *) GL(dl_rtld_map
).l_libname
->name
;
922 GL(dl_rtld_map
).l_type
= lt_library
;
923 GL(dl_loaded
)->l_next
= &GL(dl_rtld_map
);
924 GL(dl_rtld_map
).l_prev
= GL(dl_loaded
);
927 /* We have two ways to specify objects to preload: via environment
928 variable and via the file /etc/ld.so.preload. The latter can also
929 be used when security is enabled. */
933 if (__builtin_expect (preloadlist
!= NULL
, 0))
935 /* The LD_PRELOAD environment variable gives list of libraries
936 separated by white space or colons that are loaded before the
937 executable's dependencies and prepended to the global scope
938 list. If the binary is running setuid all elements
939 containing a '/' are ignored since it is insecure. */
940 char *list
= strdupa (preloadlist
);
943 HP_TIMING_NOW (start
);
945 /* Prevent optimizing strsep. Speed is not important here. */
946 while ((p
= (strsep
) (&list
, " :")) != NULL
)
948 && (__builtin_expect (! INTUSE(__libc_enable_secure
), 1)
949 || strchr (p
, '/') == NULL
))
951 struct link_map
*new_map
= INTUSE(_dl_map_object
) (GL(dl_loaded
),
955 if (++new_map
->l_opencount
== 1)
956 /* It is no duplicate. */
960 HP_TIMING_NOW (stop
);
961 HP_TIMING_DIFF (diff
, start
, stop
);
962 HP_TIMING_ACCUM_NT (load_time
, diff
);
965 /* Read the contents of the file. */
966 file
= _dl_sysdep_read_whole_file ("/etc/ld.so.preload", &file_size
,
967 PROT_READ
| PROT_WRITE
);
968 if (__builtin_expect (file
!= MAP_FAILED
, 0))
970 /* Parse the file. It contains names of libraries to be loaded,
971 separated by white spaces or `:'. It may also contain
972 comments introduced by `#'. */
977 /* Eliminate comments. */
982 char *comment
= memchr (runp
, '#', rest
);
986 rest
-= comment
- runp
;
989 while (--rest
> 0 && *++comment
!= '\n');
992 /* We have one problematic case: if we have a name at the end of
993 the file without a trailing terminating characters, we cannot
994 place the \0. Handle the case separately. */
995 if (file
[file_size
- 1] != ' ' && file
[file_size
- 1] != '\t'
996 && file
[file_size
- 1] != '\n' && file
[file_size
- 1] != ':')
998 problem
= &file
[file_size
];
999 while (problem
> file
&& problem
[-1] != ' ' && problem
[-1] != '\t'
1000 && problem
[-1] != '\n' && problem
[-1] != ':')
1009 file
[file_size
- 1] = '\0';
1012 HP_TIMING_NOW (start
);
1014 if (file
!= problem
)
1018 while ((p
= strsep (&runp
, ": \t\n")) != NULL
)
1021 struct link_map
*new_map
= INTUSE(_dl_map_object
) (GL(dl_loaded
),
1025 if (++new_map
->l_opencount
== 1)
1026 /* It is no duplicate. */
1031 if (problem
!= NULL
)
1033 char *p
= strndupa (problem
, file_size
- (problem
- file
));
1034 struct link_map
*new_map
= INTUSE(_dl_map_object
) (GL(dl_loaded
), p
,
1037 if (++new_map
->l_opencount
== 1)
1038 /* It is no duplicate. */
1042 HP_TIMING_NOW (stop
);
1043 HP_TIMING_DIFF (diff
, start
, stop
);
1044 HP_TIMING_ACCUM_NT (load_time
, diff
);
1046 /* We don't need the file anymore. */
1047 __munmap (file
, file_size
);
1050 if (__builtin_expect (npreloads
, 0) != 0)
1052 /* Set up PRELOADS with a vector of the preloaded libraries. */
1054 preloads
= __alloca (npreloads
* sizeof preloads
[0]);
1055 l
= GL(dl_rtld_map
).l_next
; /* End of the chain before preloads. */
1062 assert (i
== npreloads
);
1065 /* Load all the libraries specified by DT_NEEDED entries. If LD_PRELOAD
1066 specified some libraries to load, these are inserted before the actual
1067 dependencies in the executable's searchlist for symbol resolution. */
1068 HP_TIMING_NOW (start
);
1069 INTUSE(_dl_map_object_deps
) (GL(dl_loaded
), preloads
, npreloads
,
1071 HP_TIMING_NOW (stop
);
1072 HP_TIMING_DIFF (diff
, start
, stop
);
1073 HP_TIMING_ACCUM_NT (load_time
, diff
);
1075 /* Mark all objects as being in the global scope and set the open
1077 for (i
= GL(dl_loaded
)->l_searchlist
.r_nlist
; i
> 0; )
1080 GL(dl_loaded
)->l_searchlist
.r_list
[i
]->l_global
= 1;
1081 ++GL(dl_loaded
)->l_searchlist
.r_list
[i
]->l_opencount
;
1085 /* We are done mapping things, so close the zero-fill descriptor. */
1086 __close (_dl_zerofd
);
1090 /* Remove _dl_rtld_map from the chain. */
1091 GL(dl_rtld_map
).l_prev
->l_next
= GL(dl_rtld_map
).l_next
;
1092 if (GL(dl_rtld_map
).l_next
)
1093 GL(dl_rtld_map
).l_next
->l_prev
= GL(dl_rtld_map
).l_prev
;
1095 if (__builtin_expect (GL(dl_rtld_map
).l_opencount
> 1, 1))
1097 /* Some DT_NEEDED entry referred to the interpreter object itself, so
1098 put it back in the list of visible objects. We insert it into the
1099 chain in symbol search order because gdb uses the chain's order as
1100 its symbol search order. */
1102 while (GL(dl_loaded
)->l_searchlist
.r_list
[i
] != &GL(dl_rtld_map
))
1104 GL(dl_rtld_map
).l_prev
= GL(dl_loaded
)->l_searchlist
.r_list
[i
- 1];
1105 if (__builtin_expect (mode
, normal
) == normal
)
1106 GL(dl_rtld_map
).l_next
= (i
+ 1 < GL(dl_loaded
)->l_searchlist
.r_nlist
1107 ? GL(dl_loaded
)->l_searchlist
.r_list
[i
+ 1]
1110 /* In trace mode there might be an invisible object (which we
1111 could not find) after the previous one in the search list.
1112 In this case it doesn't matter much where we put the
1113 interpreter object, so we just initialize the list pointer so
1114 that the assertion below holds. */
1115 GL(dl_rtld_map
).l_next
= GL(dl_rtld_map
).l_prev
->l_next
;
1117 assert (GL(dl_rtld_map
).l_prev
->l_next
== GL(dl_rtld_map
).l_next
);
1118 GL(dl_rtld_map
).l_prev
->l_next
= &GL(dl_rtld_map
);
1119 if (GL(dl_rtld_map
).l_next
!= NULL
)
1121 assert (GL(dl_rtld_map
).l_next
->l_prev
== GL(dl_rtld_map
).l_prev
);
1122 GL(dl_rtld_map
).l_next
->l_prev
= &GL(dl_rtld_map
);
1126 /* Now let us see whether all libraries are available in the
1127 versions we need. */
1129 struct version_check_args args
;
1130 args
.doexit
= mode
== normal
;
1131 args
.dotrace
= mode
== trace
;
1132 _dl_receive_error (print_missing_version
, version_check_doit
, &args
);
1136 /* Now it is time to determine the layout of the static TLS block
1137 and allocate it for the initial thread. Note that we always
1138 allocate the static block, we never defer it even if no
1139 DF_STATIC_TLS bit is set. The reason is that we know glibc will
1140 use the static model. First add the dynamic linker to the list
1141 if it also uses TLS. */
1142 if (GL(dl_rtld_map
).l_tls_blocksize
!= 0)
1143 /* Assign a module ID. */
1144 GL(dl_rtld_map
).l_tls_modid
= _dl_next_tls_modid ();
1146 # ifndef TLS_INIT_TP_EXPENSIVE
1147 # define TLS_INIT_TP_EXPENSIVE 0
1150 /* We do not initialize any of the TLS functionality unless any of the
1151 initial modules uses TLS. This makes dynamic loading of modules with
1152 TLS impossible, but to support it requires either eagerly doing setup
1153 now or lazily doing it later. Doing it now makes us incompatible with
1154 an old kernel that can't perform TLS_INIT_TP, even if no TLS is ever
1155 used. Trying to do it lazily is too hairy to try when there could be
1156 multiple threads (from a non-TLS-using libpthread). */
1157 if (GL(dl_tls_max_dtv_idx
) > 0 || !TLS_INIT_TP_EXPENSIVE
)
1161 struct dtv_slotinfo
*slotinfo
;
1163 /* Number of elements in the static TLS block. */
1164 GL(dl_tls_static_nelem
) = GL(dl_tls_max_dtv_idx
);
1166 /* Allocate the array which contains the information about the
1167 dtv slots. We allocate a few entries more than needed to
1168 avoid the need for reallocation. */
1169 nelem
= GL(dl_tls_max_dtv_idx
) + 1 + TLS_SLOTINFO_SURPLUS
;
1172 GL(dl_tls_dtv_slotinfo_list
) = (struct dtv_slotinfo_list
*)
1173 malloc (sizeof (struct dtv_slotinfo_list
)
1174 + nelem
* sizeof (struct dtv_slotinfo
));
1175 /* No need to check the return value. If memory allocation failed
1176 the program would have been terminated. */
1178 slotinfo
= memset (GL(dl_tls_dtv_slotinfo_list
)->slotinfo
, '\0',
1179 nelem
* sizeof (struct dtv_slotinfo
));
1180 GL(dl_tls_dtv_slotinfo_list
)->len
= nelem
;
1181 GL(dl_tls_dtv_slotinfo_list
)->next
= NULL
;
1183 /* Fill in the information from the loaded modules. */
1184 for (l
= GL(dl_loaded
), i
= 0; l
!= NULL
; l
= l
->l_next
)
1185 if (l
->l_tls_blocksize
!= 0)
1186 /* This is a module with TLS data. Store the map reference.
1187 The generation counter is zero. */
1188 slotinfo
[++i
].map
= l
;
1189 assert (i
== GL(dl_tls_max_dtv_idx
));
1191 /* Compute the TLS offsets for the various blocks. */
1192 _dl_determine_tlsoffset ();
1194 /* Construct the static TLS block and the dtv for the initial
1195 thread. For some platforms this will include allocating memory
1196 for the thread descriptor. The memory for the TLS block will
1197 never be freed. It should be allocated accordingly. The dtv
1198 array can be changed if dynamic loading requires it. */
1199 tcbp
= _dl_allocate_tls_storage ();
1201 _dl_fatal_printf ("\
1202 cannot allocate TLS data structures for initial thread");
1204 /* Store for detection of the special case by __tls_get_addr
1205 so it knows not to pass this dtv to the normal realloc. */
1206 GL(dl_initial_dtv
) = GET_DTV (tcbp
);
1210 if (__builtin_expect (mode
, normal
) != normal
)
1212 /* We were run just to list the shared libraries. It is
1213 important that we do this before real relocation, because the
1214 functions we call below for output may no longer work properly
1215 after relocation. */
1216 if (! GL(dl_loaded
)->l_info
[DT_NEEDED
])
1217 _dl_printf ("\tstatically linked\n");
1222 if (GL(dl_debug_mask
) & DL_DEBUG_PRELINK
)
1224 struct r_scope_elem
*scope
= &GL(dl_loaded
)->l_searchlist
;
1226 for (i
= 0; i
< scope
->r_nlist
; i
++)
1228 l
= scope
->r_list
[i
];
1231 _dl_printf ("\t%s => not found\n", l
->l_libname
->name
);
1234 if (_dl_name_match_p (GL(dl_trace_prelink
), l
))
1235 GL(dl_trace_prelink_map
) = l
;
1236 _dl_printf ("\t%s => %s (0x%0*Zx, 0x%0*Zx)",
1237 l
->l_libname
->name
[0] ? l
->l_libname
->name
1238 : rtld_progname
?: "<main program>",
1239 l
->l_name
[0] ? l
->l_name
1240 : rtld_progname
?: "<main program>",
1241 (int) sizeof l
->l_map_start
* 2,
1243 (int) sizeof l
->l_addr
* 2,
1247 _dl_printf (" TLS(0x%Zx, 0x%0*Zx)\n", l
->l_tls_modid
,
1248 (int) sizeof l
->l_tls_offset
* 2,
1257 for (l
= GL(dl_loaded
)->l_next
; l
; l
= l
->l_next
)
1259 /* The library was not found. */
1260 _dl_printf ("\t%s => not found\n", l
->l_libname
->name
);
1262 _dl_printf ("\t%s => %s (0x%0*Zx)\n", l
->l_libname
->name
,
1263 l
->l_name
, (int) sizeof l
->l_map_start
* 2,
1268 if (__builtin_expect (mode
, trace
) != trace
)
1269 for (i
= 1; i
< (unsigned int) _dl_argc
; ++i
)
1271 const ElfW(Sym
) *ref
= NULL
;
1272 ElfW(Addr
) loadbase
;
1275 result
= INTUSE(_dl_lookup_symbol
) (INTUSE(_dl_argv
)[i
],
1277 &ref
, GL(dl_loaded
)->l_scope
,
1278 ELF_RTYPE_CLASS_PLT
, 1);
1280 loadbase
= LOOKUP_VALUE_ADDRESS (result
);
1282 _dl_printf ("%s found at 0x%0*Zd in object at 0x%0*Zd\n",
1283 INTUSE(_dl_argv
)[i
],
1284 (int) sizeof ref
->st_value
* 2, ref
->st_value
,
1285 (int) sizeof loadbase
* 2, loadbase
);
1289 /* If LD_WARN is set warn about undefined symbols. */
1290 if (GL(dl_lazy
) >= 0 && GL(dl_verbose
))
1292 /* We have to do symbol dependency testing. */
1293 struct relocate_args args
;
1296 args
.lazy
= GL(dl_lazy
);
1303 if (l
!= &GL(dl_rtld_map
) && ! l
->l_faked
)
1306 _dl_receive_error (print_unresolved
, relocate_doit
,
1312 if ((GL(dl_debug_mask
) & DL_DEBUG_PRELINK
)
1313 && GL(dl_rtld_map
).l_opencount
> 1)
1314 INTUSE(_dl_relocate_object
) (&GL(dl_rtld_map
),
1315 GL(dl_loaded
)->l_scope
, 0, 0);
1318 #define VERNEEDTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERNEED))
1321 /* Print more information. This means here, print information
1322 about the versions needed. */
1324 struct link_map
*map
= GL(dl_loaded
);
1326 for (map
= GL(dl_loaded
); map
!= NULL
; map
= map
->l_next
)
1329 ElfW(Dyn
) *dyn
= map
->l_info
[VERNEEDTAG
];
1335 strtab
= (const void *) D_PTR (map
, l_info
[DT_STRTAB
]);
1336 ent
= (ElfW(Verneed
) *) (map
->l_addr
+ dyn
->d_un
.d_ptr
);
1340 _dl_printf ("\n\tVersion information:\n");
1344 _dl_printf ("\t%s:\n",
1345 map
->l_name
[0] ? map
->l_name
: rtld_progname
);
1350 struct link_map
*needed
;
1352 needed
= find_needed (strtab
+ ent
->vn_file
);
1353 aux
= (ElfW(Vernaux
) *) ((char *) ent
+ ent
->vn_aux
);
1357 const char *fname
= NULL
;
1360 && match_version (strtab
+ aux
->vna_name
,
1362 fname
= needed
->l_name
;
1364 _dl_printf ("\t\t%s (%s) %s=> %s\n",
1365 strtab
+ ent
->vn_file
,
1366 strtab
+ aux
->vna_name
,
1367 aux
->vna_flags
& VER_FLG_WEAK
1369 fname
?: "not found");
1371 if (aux
->vna_next
== 0)
1372 /* No more symbols. */
1376 aux
= (ElfW(Vernaux
) *) ((char *) aux
1380 if (ent
->vn_next
== 0)
1381 /* No more dependencies. */
1384 /* Next dependency. */
1385 ent
= (ElfW(Verneed
) *) ((char *) ent
+ ent
->vn_next
);
1394 if (GL(dl_loaded
)->l_info
[ADDRIDX (DT_GNU_LIBLIST
)]
1395 && ! __builtin_expect (GL(dl_profile
) != NULL
, 0))
1397 ElfW(Lib
) *liblist
, *liblistend
;
1398 struct link_map
**r_list
, **r_listend
, *l
;
1399 const char *strtab
= (const void *) D_PTR (GL(dl_loaded
),
1402 assert (GL(dl_loaded
)->l_info
[VALIDX (DT_GNU_LIBLISTSZ
)] != NULL
);
1403 liblist
= (ElfW(Lib
) *)
1404 GL(dl_loaded
)->l_info
[ADDRIDX (DT_GNU_LIBLIST
)]->d_un
.d_ptr
;
1405 liblistend
= (ElfW(Lib
) *)
1407 + GL(dl_loaded
)->l_info
[VALIDX (DT_GNU_LIBLISTSZ
)]->d_un
.d_val
);
1408 r_list
= GL(dl_loaded
)->l_searchlist
.r_list
;
1409 r_listend
= r_list
+ GL(dl_loaded
)->l_searchlist
.r_nlist
;
1411 for (; r_list
< r_listend
&& liblist
< liblistend
; r_list
++)
1415 if (l
== GL(dl_loaded
))
1418 /* If the library is not mapped where it should, fail. */
1422 /* Next, check if checksum matches. */
1423 if (l
->l_info
[VALIDX(DT_CHECKSUM
)] == NULL
1424 || l
->l_info
[VALIDX(DT_CHECKSUM
)]->d_un
.d_val
1425 != liblist
->l_checksum
)
1428 if (l
->l_info
[VALIDX(DT_GNU_PRELINKED
)] == NULL
1429 || l
->l_info
[VALIDX(DT_GNU_PRELINKED
)]->d_un
.d_val
1430 != liblist
->l_time_stamp
)
1433 if (! _dl_name_match_p (strtab
+ liblist
->l_name
, l
))
1440 if (r_list
== r_listend
&& liblist
== liblistend
)
1443 if (__builtin_expect (GL(dl_debug_mask
) & DL_DEBUG_LIBS
, 0))
1444 _dl_printf ("\nprelink checking: %s\n", prelinked
? "ok" : "failed");
1451 if (GL(dl_loaded
)->l_info
[ADDRIDX (DT_GNU_CONFLICT
)] != NULL
)
1453 ElfW(Rela
) *conflict
, *conflictend
;
1454 #ifndef HP_TIMING_NONAVAIL
1459 HP_TIMING_NOW (start
);
1460 assert (GL(dl_loaded
)->l_info
[VALIDX (DT_GNU_CONFLICTSZ
)] != NULL
);
1461 conflict
= (ElfW(Rela
) *)
1462 GL(dl_loaded
)->l_info
[ADDRIDX (DT_GNU_CONFLICT
)]->d_un
.d_ptr
;
1463 conflictend
= (ElfW(Rela
) *)
1465 + GL(dl_loaded
)->l_info
[VALIDX (DT_GNU_CONFLICTSZ
)]->d_un
.d_val
);
1466 _dl_resolve_conflicts (GL(dl_loaded
), conflict
, conflictend
);
1467 HP_TIMING_NOW (stop
);
1468 HP_TIMING_DIFF (relocate_time
, start
, stop
);
1472 /* Mark all the objects so we know they have been already relocated. */
1473 for (l
= GL(dl_loaded
); l
!= NULL
; l
= l
->l_next
)
1476 _dl_sysdep_start_cleanup ();
1480 /* Now we have all the objects loaded. Relocate them all except for
1481 the dynamic linker itself. We do this in reverse order so that copy
1482 relocs of earlier objects overwrite the data written by later
1483 objects. We do not re-relocate the dynamic linker itself in this
1484 loop because that could result in the GOT entries for functions we
1485 call being changed, and that would break us. It is safe to relocate
1486 the dynamic linker out of order because it has no copy relocs (we
1487 know that because it is self-contained). */
1490 int consider_profiling
= GL(dl_profile
) != NULL
;
1491 #ifndef HP_TIMING_NONAVAIL
1497 /* If we are profiling we also must do lazy reloaction. */
1498 GL(dl_lazy
) |= consider_profiling
;
1504 HP_TIMING_NOW (start
);
1507 /* While we are at it, help the memory handling a bit. We have to
1508 mark some data structures as allocated with the fake malloc()
1509 implementation in ld.so. */
1510 struct libname_list
*lnp
= l
->l_libname
->next
;
1512 while (__builtin_expect (lnp
!= NULL
, 0))
1518 if (l
!= &GL(dl_rtld_map
))
1519 INTUSE(_dl_relocate_object
) (l
, l
->l_scope
, GL(dl_lazy
),
1520 consider_profiling
);
1525 HP_TIMING_NOW (stop
);
1527 HP_TIMING_DIFF (relocate_time
, start
, stop
);
1529 /* Do any necessary cleanups for the startup OS interface code.
1530 We do these now so that no calls are made after rtld re-relocation
1531 which might be resolved to different functions than we expect.
1532 We cannot do this before relocating the other objects because
1533 _dl_relocate_object might need to call `mprotect' for DT_TEXTREL. */
1534 _dl_sysdep_start_cleanup ();
1536 /* Now enable profiling if needed. Like the previous call,
1537 this has to go here because the calls it makes should use the
1538 rtld versions of the functions (particularly calloc()), but it
1539 needs to have _dl_profile_map set up by the relocator. */
1540 if (__builtin_expect (GL(dl_profile_map
) != NULL
, 0))
1541 /* We must prepare the profiling. */
1542 INTUSE(_dl_start_profile
) (GL(dl_profile_map
), GL(dl_profile_output
));
1544 if (GL(dl_rtld_map
).l_opencount
> 1)
1546 /* There was an explicit ref to the dynamic linker as a shared lib.
1547 Re-relocate ourselves with user-controlled symbol definitions. */
1548 HP_TIMING_NOW (start
);
1549 INTUSE(_dl_relocate_object
) (&GL(dl_rtld_map
), GL(dl_loaded
)->l_scope
,
1551 HP_TIMING_NOW (stop
);
1552 HP_TIMING_DIFF (add
, start
, stop
);
1553 HP_TIMING_ACCUM_NT (relocate_time
, add
);
1557 /* Now set up the variable which helps the assembler startup code. */
1558 GL(dl_main_searchlist
) = &GL(dl_loaded
)->l_searchlist
;
1559 GL(dl_global_scope
)[0] = &GL(dl_loaded
)->l_searchlist
;
1561 /* Save the information about the original global scope list since
1562 we need it in the memory handling later. */
1563 GL(dl_initial_searchlist
) = *GL(dl_main_searchlist
);
1565 #ifndef NONTLS_INIT_TP
1566 # define NONTLS_INIT_TP do { } while (0)
1570 if (GL(dl_tls_max_dtv_idx
) > 0 || USE___THREAD
|| !TLS_INIT_TP_EXPENSIVE
)
1572 /* Now that we have completed relocation, the initializer data
1573 for the TLS blocks has its final values and we can copy them
1574 into the main thread's TLS area, which we allocated above. */
1575 _dl_allocate_tls_init (tcbp
);
1577 /* And finally install it for the main thread. If ld.so itself uses
1578 TLS we know the thread pointer was initialized earlier. */
1579 const char *lossage
= TLS_INIT_TP (tcbp
, USE___THREAD
);
1580 if (__builtin_expect (lossage
!= NULL
, 0))
1581 _dl_fatal_printf ("cannot set up thread-local storage: %s\n", lossage
);
1588 /* Initialize _r_debug. */
1589 struct r_debug
*r
= _dl_debug_initialize (GL(dl_rtld_map
).l_addr
);
1594 #ifdef ELF_MACHINE_DEBUG_SETUP
1596 /* Some machines (e.g. MIPS) don't use DT_DEBUG in this way. */
1598 ELF_MACHINE_DEBUG_SETUP (l
, r
);
1599 ELF_MACHINE_DEBUG_SETUP (&GL(dl_rtld_map
), r
);
1603 if (l
->l_info
[DT_DEBUG
] != NULL
)
1604 /* There is a DT_DEBUG entry in the dynamic section. Fill it in
1605 with the run-time address of the r_debug structure */
1606 l
->l_info
[DT_DEBUG
]->d_un
.d_ptr
= (ElfW(Addr
)) r
;
1608 /* Fill in the pointer in the dynamic linker's own dynamic section, in
1609 case you run gdb on the dynamic linker directly. */
1610 if (GL(dl_rtld_map
).l_info
[DT_DEBUG
] != NULL
)
1611 GL(dl_rtld_map
).l_info
[DT_DEBUG
]->d_un
.d_ptr
= (ElfW(Addr
)) r
;
1615 /* Notify the debugger that all objects are now mapped in. */
1616 r
->r_state
= RT_ADD
;
1617 INTUSE(_dl_debug_state
) ();
1621 /* We must munmap() the cache file. */
1622 INTUSE(_dl_unload_cache
) ();
1625 /* Once we return, _dl_sysdep_start will invoke
1626 the DT_INIT functions and then *USER_ENTRY. */
1629 /* This is a little helper function for resolving symbols while
1630 tracing the binary. */
1632 print_unresolved (int errcode
__attribute__ ((unused
)), const char *objname
,
1633 const char *errstring
)
1635 if (objname
[0] == '\0')
1636 objname
= rtld_progname
?: "<main program>";
1637 _dl_error_printf ("%s (%s)\n", errstring
, objname
);
1640 /* This is a little helper function for resolving symbols while
1641 tracing the binary. */
1643 print_missing_version (int errcode
__attribute__ ((unused
)),
1644 const char *objname
, const char *errstring
)
1646 _dl_error_printf ("%s: %s: %s\n", rtld_progname
?: "<program name unknown>",
1647 objname
, errstring
);
1650 /* Nonzero if any of the debugging options is enabled. */
1651 static int any_debug
;
1653 /* Process the string given as the parameter which explains which debugging
1654 options are enabled. */
1656 process_dl_debug (const char *dl_debug
)
1658 /* When adding new entries make sure that the maximal length of a name
1659 is correctly handled in the LD_DEBUG_HELP code below. */
1663 const char name
[10];
1664 const char helptext
[41];
1665 unsigned short int mask
;
1668 #define LEN_AND_STR(str) sizeof (str) - 1, str
1669 { LEN_AND_STR ("libs"), "display library search paths",
1670 DL_DEBUG_LIBS
| DL_DEBUG_IMPCALLS
},
1671 { LEN_AND_STR ("reloc"), "display relocation processing",
1672 DL_DEBUG_RELOC
| DL_DEBUG_IMPCALLS
},
1673 { LEN_AND_STR ("files"), "display progress for input file",
1674 DL_DEBUG_FILES
| DL_DEBUG_IMPCALLS
},
1675 { LEN_AND_STR ("symbols"), "display symbol table processing",
1676 DL_DEBUG_SYMBOLS
| DL_DEBUG_IMPCALLS
},
1677 { LEN_AND_STR ("bindings"), "display information about symbol binding",
1678 DL_DEBUG_BINDINGS
| DL_DEBUG_IMPCALLS
},
1679 { LEN_AND_STR ("versions"), "display version dependencies",
1680 DL_DEBUG_VERSIONS
| DL_DEBUG_IMPCALLS
},
1681 { LEN_AND_STR ("all"), "all previous options combined",
1682 DL_DEBUG_LIBS
| DL_DEBUG_RELOC
| DL_DEBUG_FILES
| DL_DEBUG_SYMBOLS
1683 | DL_DEBUG_BINDINGS
| DL_DEBUG_VERSIONS
| DL_DEBUG_IMPCALLS
},
1684 { LEN_AND_STR ("statistics"), "display relocation statistics",
1685 DL_DEBUG_STATISTICS
},
1686 { LEN_AND_STR ("help"), "display this help message and exit",
1689 #define ndebopts (sizeof (debopts) / sizeof (debopts[0]))
1691 /* Skip separating white spaces and commas. */
1692 while (*dl_debug
!= '\0')
1694 if (*dl_debug
!= ' ' && *dl_debug
!= ',' && *dl_debug
!= ':')
1699 while (dl_debug
[len
] != '\0' && dl_debug
[len
] != ' '
1700 && dl_debug
[len
] != ',' && dl_debug
[len
] != ':')
1703 for (cnt
= 0; cnt
< ndebopts
; ++cnt
)
1704 if (debopts
[cnt
].len
== len
1705 && memcmp (dl_debug
, debopts
[cnt
].name
, len
) == 0)
1707 GL(dl_debug_mask
) |= debopts
[cnt
].mask
;
1712 if (cnt
== ndebopts
)
1714 /* Display a warning and skip everything until next
1716 char *copy
= strndupa (dl_debug
, len
);
1717 _dl_error_printf ("\
1718 warning: debug option `%s' unknown; try LD_DEBUG=help\n", copy
);
1728 if (GL(dl_debug_mask
) & DL_DEBUG_HELP
)
1733 Valid options for the LD_DEBUG environment variable are:\n\n");
1735 for (cnt
= 0; cnt
< ndebopts
; ++cnt
)
1736 _dl_printf (" %.*s%s%s\n", debopts
[cnt
].len
, debopts
[cnt
].name
,
1737 " " + debopts
[cnt
].len
- 3,
1738 debopts
[cnt
].helptext
);
1741 To direct the debugging output into a file instead of standard output\n\
1742 a filename can be specified using the LD_DEBUG_OUTPUT environment variable.\n");
1747 /* Process all environments variables the dynamic linker must recognize.
1748 Since all of them start with `LD_' we are a bit smarter while finding
1750 extern char **_environ attribute_hidden
;
1754 process_envvars (enum mode
*modep
)
1756 char **runp
= _environ
;
1758 enum mode mode
= normal
;
1759 char *debug_output
= NULL
;
1761 /* This is the default place for profiling data file. */
1762 GL(dl_profile_output
)
1763 = &"/var/tmp\0/var/profile"[INTUSE(__libc_enable_secure
) ? 9 : 0];
1765 while ((envline
= _dl_next_ld_env_entry (&runp
)) != NULL
)
1769 while (envline
[len
] != '\0' && envline
[len
] != '=')
1772 if (envline
[len
] != '=')
1773 /* This is a "LD_" variable at the end of the string without
1774 a '=' character. Ignore it since otherwise we will access
1775 invalid memory below. */
1781 /* Warning level, verbose or not. */
1782 if (memcmp (envline
, "WARN", 4) == 0)
1783 GL(dl_verbose
) = envline
[5] != '\0';
1787 /* Debugging of the dynamic linker? */
1788 if (memcmp (envline
, "DEBUG", 5) == 0)
1789 process_dl_debug (&envline
[6]);
1793 /* Print information about versions. */
1794 if (memcmp (envline
, "VERBOSE", 7) == 0)
1796 version_info
= envline
[8] != '\0';
1800 /* List of objects to be preloaded. */
1801 if (memcmp (envline
, "PRELOAD", 7) == 0)
1803 preloadlist
= &envline
[8];
1807 /* Which shared object shall be profiled. */
1808 if (memcmp (envline
, "PROFILE", 7) == 0 && envline
[8] != '\0')
1809 GL(dl_profile
) = &envline
[8];
1813 /* Do we bind early? */
1814 if (memcmp (envline
, "BIND_NOW", 8) == 0)
1816 GL(dl_lazy
) = envline
[9] == '\0';
1819 if (memcmp (envline
, "BIND_NOT", 8) == 0)
1820 GL(dl_bind_not
) = envline
[9] != '\0';
1824 /* Test whether we want to see the content of the auxiliary
1825 array passed up from the kernel. */
1826 if (memcmp (envline
, "SHOW_AUXV", 9) == 0)
1831 /* Mask for the important hardware capabilities. */
1832 if (memcmp (envline
, "HWCAP_MASK", 10) == 0)
1833 GL(dl_hwcap_mask
) = __strtoul_internal (&envline
[11], NULL
, 0, 0);
1837 /* Path where the binary is found. */
1838 if (!INTUSE(__libc_enable_secure
)
1839 && memcmp (envline
, "ORIGIN_PATH", 11) == 0)
1840 GL(dl_origin_path
) = &envline
[12];
1844 /* The library search path. */
1845 if (memcmp (envline
, "LIBRARY_PATH", 12) == 0)
1847 library_path
= &envline
[13];
1851 /* Where to place the profiling data file. */
1852 if (memcmp (envline
, "DEBUG_OUTPUT", 12) == 0)
1854 debug_output
= &envline
[13];
1858 if (memcmp (envline
, "DYNAMIC_WEAK", 12) == 0)
1859 GL(dl_dynamic_weak
) = 1;
1863 /* Where to place the profiling data file. */
1864 if (!INTUSE(__libc_enable_secure
)
1865 && memcmp (envline
, "PROFILE_OUTPUT", 14) == 0
1866 && envline
[15] != '\0')
1867 GL(dl_profile_output
) = &envline
[15];
1871 /* The mode of the dynamic linker can be set. */
1872 if (memcmp (envline
, "TRACE_PRELINKING", 16) == 0)
1876 GL(dl_debug_mask
) |= DL_DEBUG_PRELINK
;
1877 GL(dl_trace_prelink
) = &envline
[17];
1882 /* The mode of the dynamic linker can be set. */
1883 if (memcmp (envline
, "TRACE_LOADED_OBJECTS", 20) == 0)
1887 /* We might have some extra environment variable to handle. This
1888 is tricky due to the pre-processing of the length of the name
1889 in the switch statement here. The code here assumes that added
1890 environment variables have a different length. */
1891 #ifdef EXTRA_LD_ENVVARS
1897 /* The caller wants this information. */
1900 /* Extra security for SUID binaries. Remove all dangerous environment
1902 if (__builtin_expect (INTUSE(__libc_enable_secure
), 0))
1904 static const char unsecure_envvars
[] =
1905 #ifdef EXTRA_UNSECURE_ENVVARS
1906 EXTRA_UNSECURE_ENVVARS
1911 nextp
= unsecure_envvars
;
1915 /* We could use rawmemchr but this need not be fast. */
1916 nextp
= (char *) (strchr
) (nextp
, '\0') + 1;
1918 while (*nextp
!= '\0');
1920 if (__access ("/etc/suid-debug", F_OK
) != 0)
1921 unsetenv ("MALLOC_CHECK_");
1923 /* If we have to run the dynamic linker in debugging mode and the
1924 LD_DEBUG_OUTPUT environment variable is given, we write the debug
1925 messages to this file. */
1926 else if (any_debug
&& debug_output
!= NULL
)
1929 const int flags
= O_WRONLY
| O_APPEND
| O_CREAT
| O_NOFOLLOW
;
1931 const int flags
= O_WRONLY
| O_APPEND
| O_CREAT
;
1933 size_t name_len
= strlen (debug_output
);
1934 char buf
[name_len
+ 12];
1937 buf
[name_len
+ 11] = '\0';
1938 startp
= _itoa (__getpid (), &buf
[name_len
+ 11], 10, 0);
1940 startp
= memcpy (startp
- name_len
, debug_output
, name_len
);
1942 GL(dl_debug_fd
) = __open (startp
, flags
, DEFFILEMODE
);
1943 if (GL(dl_debug_fd
) == -1)
1944 /* We use standard output if opening the file failed. */
1945 GL(dl_debug_fd
) = STDOUT_FILENO
;
1950 /* Print the various times we collected. */
1952 print_statistics (void)
1954 #ifndef HP_TIMING_NONAVAIL
1959 /* Total time rtld used. */
1960 if (HP_TIMING_AVAIL
)
1962 HP_TIMING_PRINT (buf
, sizeof (buf
), rtld_total_time
);
1963 INTUSE(_dl_debug_printf
) ("\nruntime linker statistics:\n"
1964 " total startup time in dynamic loader: %s\n",
1968 /* Print relocation statistics. */
1969 if (HP_TIMING_AVAIL
)
1972 HP_TIMING_PRINT (buf
, sizeof (buf
), relocate_time
);
1973 cp
= _itoa ((1000ULL * relocate_time
) / rtld_total_time
,
1974 pbuf
+ sizeof (pbuf
), 10, 0);
1976 switch (pbuf
+ sizeof (pbuf
) - cp
)
1987 INTUSE(_dl_debug_printf
) ("\
1988 time needed for relocation: %s (%s%%)\n",
1992 INTUSE(_dl_debug_printf
) (" number of relocations: %lu\n",
1993 GL(dl_num_relocations
));
1994 INTUSE(_dl_debug_printf
) (" number of relocations from cache: %lu\n",
1995 GL(dl_num_cache_relocations
));
1997 #ifndef HP_TIMING_NONAVAIL
1998 /* Time spend while loading the object and the dependencies. */
1999 if (HP_TIMING_AVAIL
)
2002 HP_TIMING_PRINT (buf
, sizeof (buf
), load_time
);
2003 cp
= _itoa ((1000ULL * load_time
) / rtld_total_time
,
2004 pbuf
+ sizeof (pbuf
), 10, 0);
2006 switch (pbuf
+ sizeof (pbuf
) - cp
)
2017 INTUSE(_dl_debug_printf
) ("\
2018 time needed to load objects: %s (%s%%)\n",