Fix sign of input to bsloww1 (BZ #16623)
[glibc.git] / elf / rtld.c
blob7f1413af08d9a0b0280c2ba58703e12e36a5266e
1 /* Run time dynamic linker.
2 Copyright (C) 1995-2014 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, see
17 <http://www.gnu.org/licenses/>. */
19 #include <errno.h>
20 #include <dlfcn.h>
21 #include <fcntl.h>
22 #include <stdbool.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <unistd.h>
26 #include <sys/mman.h>
27 #include <sys/param.h>
28 #include <sys/stat.h>
29 #include <ldsodefs.h>
30 #include <_itoa.h>
31 #include <entry.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>
38 #include <dl-cache.h>
39 #include <dl-osinfo.h>
40 #include <dl-procinfo.h>
41 #include <tls.h>
42 #include <stap-probe.h>
43 #include <stackinfo.h>
45 #include <assert.h>
47 /* Avoid PLT use for our local calls at startup. */
48 extern __typeof (__mempcpy) __mempcpy attribute_hidden;
50 /* GCC has mental blocks about _exit. */
51 extern __typeof (_exit) exit_internal asm ("_exit") attribute_hidden;
52 #define _exit exit_internal
54 /* Helper function to handle errors while resolving symbols. */
55 static void print_unresolved (int errcode, const char *objname,
56 const char *errsting);
58 /* Helper function to handle errors when a version is missing. */
59 static void print_missing_version (int errcode, const char *objname,
60 const char *errsting);
62 /* Print the various times we collected. */
63 static void print_statistics (hp_timing_t *total_timep);
65 /* Add audit objects. */
66 static void process_dl_audit (char *str);
68 /* This is a list of all the modes the dynamic loader can be in. */
69 enum mode { normal, list, verify, trace };
71 /* Process all environments variables the dynamic linker must recognize.
72 Since all of them start with `LD_' we are a bit smarter while finding
73 all the entries. */
74 static void process_envvars (enum mode *modep);
76 #ifdef DL_ARGV_NOT_RELRO
77 int _dl_argc attribute_hidden;
78 char **_dl_argv = NULL;
79 /* Nonzero if we were run directly. */
80 unsigned int _dl_skip_args attribute_hidden;
81 #else
82 int _dl_argc attribute_relro attribute_hidden;
83 char **_dl_argv attribute_relro = NULL;
84 unsigned int _dl_skip_args attribute_relro attribute_hidden;
85 #endif
86 INTDEF(_dl_argv)
88 #ifndef THREAD_SET_STACK_GUARD
89 /* Only exported for architectures that don't store the stack guard canary
90 in thread local area. */
91 uintptr_t __stack_chk_guard attribute_relro;
92 #endif
94 /* Only exported for architectures that don't store the pointer guard
95 value in thread local area. */
96 uintptr_t __pointer_chk_guard_local
97 attribute_relro attribute_hidden __attribute__ ((nocommon));
98 #ifndef THREAD_SET_POINTER_GUARD
99 strong_alias (__pointer_chk_guard_local, __pointer_chk_guard)
100 #endif
103 /* List of auditing DSOs. */
104 static struct audit_list
106 const char *name;
107 struct audit_list *next;
108 } *audit_list;
110 #ifndef HAVE_INLINED_SYSCALLS
111 /* Set nonzero during loading and initialization of executable and
112 libraries, cleared before the executable's entry point runs. This
113 must not be initialized to nonzero, because the unused dynamic
114 linker loaded in for libc.so's "ld.so.1" dep will provide the
115 definition seen by libc.so's initializer; that value must be zero,
116 and will be since that dynamic linker's _dl_start and dl_main will
117 never be called. */
118 int _dl_starting_up = 0;
119 INTVARDEF(_dl_starting_up)
120 #endif
122 /* This is the structure which defines all variables global to ld.so
123 (except those which cannot be added for some reason). */
124 struct rtld_global _rtld_global =
126 /* Generally the default presumption without further information is an
127 * executable stack but this is not true for all platforms. */
128 ._dl_stack_flags = DEFAULT_STACK_PERMS,
129 #ifdef _LIBC_REENTRANT
130 ._dl_load_lock = _RTLD_LOCK_RECURSIVE_INITIALIZER,
131 ._dl_load_write_lock = _RTLD_LOCK_RECURSIVE_INITIALIZER,
132 #endif
133 ._dl_nns = 1,
134 ._dl_ns =
136 #ifdef _LIBC_REENTRANT
137 [LM_ID_BASE] = { ._ns_unique_sym_table
138 = { .lock = _RTLD_LOCK_RECURSIVE_INITIALIZER } }
139 #endif
142 /* If we would use strong_alias here the compiler would see a
143 non-hidden definition. This would undo the effect of the previous
144 declaration. So spell out was strong_alias does plus add the
145 visibility attribute. */
146 extern struct rtld_global _rtld_local
147 __attribute__ ((alias ("_rtld_global"), visibility ("hidden")));
150 /* This variable is similar to _rtld_local, but all values are
151 read-only after relocation. */
152 struct rtld_global_ro _rtld_global_ro attribute_relro =
154 /* Get architecture specific initializer. */
155 #include <dl-procinfo.c>
156 #ifdef NEED_DL_SYSINFO
157 ._dl_sysinfo = DL_SYSINFO_DEFAULT,
158 #endif
159 ._dl_debug_fd = STDERR_FILENO,
160 ._dl_use_load_bias = -2,
161 ._dl_correct_cache_id = _DL_CACHE_DEFAULT_ID,
162 ._dl_hwcap_mask = HWCAP_IMPORTANT,
163 ._dl_lazy = 1,
164 ._dl_fpu_control = _FPU_DEFAULT,
165 ._dl_pointer_guard = 1,
166 ._dl_pagesize = EXEC_PAGESIZE,
167 ._dl_inhibit_cache = 0,
169 /* Function pointers. */
170 ._dl_debug_printf = _dl_debug_printf,
171 ._dl_catch_error = _dl_catch_error,
172 ._dl_signal_error = _dl_signal_error,
173 ._dl_mcount = _dl_mcount_internal,
174 ._dl_lookup_symbol_x = _dl_lookup_symbol_x,
175 ._dl_check_caller = _dl_check_caller,
176 ._dl_open = _dl_open,
177 ._dl_close = _dl_close,
178 ._dl_tls_get_addr_soft = _dl_tls_get_addr_soft,
179 #ifdef HAVE_DL_DISCOVER_OSVERSION
180 ._dl_discover_osversion = _dl_discover_osversion
181 #endif
183 /* If we would use strong_alias here the compiler would see a
184 non-hidden definition. This would undo the effect of the previous
185 declaration. So spell out was strong_alias does plus add the
186 visibility attribute. */
187 extern struct rtld_global_ro _rtld_local_ro
188 __attribute__ ((alias ("_rtld_global_ro"), visibility ("hidden")));
191 static void dl_main (const ElfW(Phdr) *phdr, ElfW(Word) phnum,
192 ElfW(Addr) *user_entry, ElfW(auxv_t) *auxv);
194 /* These two variables cannot be moved into .data.rel.ro. */
195 static struct libname_list _dl_rtld_libname;
196 static struct libname_list _dl_rtld_libname2;
198 /* We expect less than a second for relocation. */
199 #ifdef HP_SMALL_TIMING_AVAIL
200 # undef HP_TIMING_AVAIL
201 # define HP_TIMING_AVAIL HP_SMALL_TIMING_AVAIL
202 #endif
204 /* Variable for statistics. */
205 #ifndef HP_TIMING_NONAVAIL
206 static hp_timing_t relocate_time;
207 static hp_timing_t load_time attribute_relro;
208 static hp_timing_t start_time attribute_relro;
209 #endif
211 /* Additional definitions needed by TLS initialization. */
212 #ifdef TLS_INIT_HELPER
213 TLS_INIT_HELPER
214 #endif
216 /* Helper function for syscall implementation. */
217 #ifdef DL_SYSINFO_IMPLEMENTATION
218 DL_SYSINFO_IMPLEMENTATION
219 #endif
221 /* Before ld.so is relocated we must not access variables which need
222 relocations. This means variables which are exported. Variables
223 declared as static are fine. If we can mark a variable hidden this
224 is fine, too. The latter is important here. We can avoid setting
225 up a temporary link map for ld.so if we can mark _rtld_global as
226 hidden. */
227 #ifdef PI_STATIC_AND_HIDDEN
228 # define DONT_USE_BOOTSTRAP_MAP 1
229 #endif
231 #ifdef DONT_USE_BOOTSTRAP_MAP
232 static ElfW(Addr) _dl_start_final (void *arg);
233 #else
234 struct dl_start_final_info
236 struct link_map l;
237 #if !defined HP_TIMING_NONAVAIL && HP_TIMING_INLINE
238 hp_timing_t start_time;
239 #endif
241 static ElfW(Addr) _dl_start_final (void *arg,
242 struct dl_start_final_info *info);
243 #endif
245 /* These defined magically in the linker script. */
246 extern char _begin[] attribute_hidden;
247 extern char _etext[] attribute_hidden;
248 extern char _end[] attribute_hidden;
251 #ifdef RTLD_START
252 RTLD_START
253 #else
254 # error "sysdeps/MACHINE/dl-machine.h fails to define RTLD_START"
255 #endif
257 /* This is the second half of _dl_start (below). It can be inlined safely
258 under DONT_USE_BOOTSTRAP_MAP, where it is careful not to make any GOT
259 references. When the tools don't permit us to avoid using a GOT entry
260 for _dl_rtld_global (no attribute_hidden support), we must make sure
261 this function is not inlined (see below). */
263 #ifdef DONT_USE_BOOTSTRAP_MAP
264 static inline ElfW(Addr) __attribute__ ((always_inline))
265 _dl_start_final (void *arg)
266 #else
267 static ElfW(Addr) __attribute__ ((noinline))
268 _dl_start_final (void *arg, struct dl_start_final_info *info)
269 #endif
271 ElfW(Addr) start_addr;
273 if (HP_TIMING_AVAIL)
275 /* If it hasn't happen yet record the startup time. */
276 if (! HP_TIMING_INLINE)
277 HP_TIMING_NOW (start_time);
278 #if !defined DONT_USE_BOOTSTRAP_MAP && !defined HP_TIMING_NONAVAIL
279 else
280 start_time = info->start_time;
281 #endif
283 /* Initialize the timing functions. */
284 HP_TIMING_DIFF_INIT ();
287 /* Transfer data about ourselves to the permanent link_map structure. */
288 #ifndef DONT_USE_BOOTSTRAP_MAP
289 GL(dl_rtld_map).l_addr = info->l.l_addr;
290 GL(dl_rtld_map).l_ld = info->l.l_ld;
291 memcpy (GL(dl_rtld_map).l_info, info->l.l_info,
292 sizeof GL(dl_rtld_map).l_info);
293 GL(dl_rtld_map).l_mach = info->l.l_mach;
294 GL(dl_rtld_map).l_relocated = 1;
295 #endif
296 _dl_setup_hash (&GL(dl_rtld_map));
297 GL(dl_rtld_map).l_real = &GL(dl_rtld_map);
298 GL(dl_rtld_map).l_map_start = (ElfW(Addr)) _begin;
299 GL(dl_rtld_map).l_map_end = (ElfW(Addr)) _end;
300 GL(dl_rtld_map).l_text_end = (ElfW(Addr)) _etext;
301 /* Copy the TLS related data if necessary. */
302 #ifndef DONT_USE_BOOTSTRAP_MAP
303 # if USE___THREAD
304 assert (info->l.l_tls_modid != 0);
305 GL(dl_rtld_map).l_tls_blocksize = info->l.l_tls_blocksize;
306 GL(dl_rtld_map).l_tls_align = info->l.l_tls_align;
307 GL(dl_rtld_map).l_tls_firstbyte_offset = info->l.l_tls_firstbyte_offset;
308 GL(dl_rtld_map).l_tls_initimage_size = info->l.l_tls_initimage_size;
309 GL(dl_rtld_map).l_tls_initimage = info->l.l_tls_initimage;
310 GL(dl_rtld_map).l_tls_offset = info->l.l_tls_offset;
311 GL(dl_rtld_map).l_tls_modid = 1;
312 # else
313 # if NO_TLS_OFFSET != 0
314 GL(dl_rtld_map).l_tls_offset = NO_TLS_OFFSET;
315 # endif
316 # endif
318 #endif
320 #if HP_TIMING_AVAIL
321 HP_TIMING_NOW (GL(dl_cpuclock_offset));
322 #endif
324 /* Initialize the stack end variable. */
325 __libc_stack_end = __builtin_frame_address (0);
327 /* Call the OS-dependent function to set up life so we can do things like
328 file access. It will call `dl_main' (below) to do all the real work
329 of the dynamic linker, and then unwind our frame and run the user
330 entry point on the same stack we entered on. */
331 start_addr = _dl_sysdep_start (arg, &dl_main);
333 #ifndef HP_TIMING_NONAVAIL
334 hp_timing_t rtld_total_time;
335 if (HP_TIMING_AVAIL)
337 hp_timing_t end_time;
339 /* Get the current time. */
340 HP_TIMING_NOW (end_time);
342 /* Compute the difference. */
343 HP_TIMING_DIFF (rtld_total_time, start_time, end_time);
345 #endif
347 if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_STATISTICS))
349 #ifndef HP_TIMING_NONAVAIL
350 print_statistics (&rtld_total_time);
351 #else
352 print_statistics (NULL);
353 #endif
356 return start_addr;
359 static ElfW(Addr) __attribute_used__ internal_function
360 _dl_start (void *arg)
362 #ifdef DONT_USE_BOOTSTRAP_MAP
363 # define bootstrap_map GL(dl_rtld_map)
364 #else
365 struct dl_start_final_info info;
366 # define bootstrap_map info.l
367 #endif
369 /* This #define produces dynamic linking inline functions for
370 bootstrap relocation instead of general-purpose relocation.
371 Since ld.so must not have any undefined symbols the result
372 is trivial: always the map of ld.so itself. */
373 #define RTLD_BOOTSTRAP
374 #define RESOLVE_MAP(sym, version, flags) (&bootstrap_map)
375 #include "dynamic-link.h"
377 if (HP_TIMING_INLINE && HP_TIMING_AVAIL)
378 #ifdef DONT_USE_BOOTSTRAP_MAP
379 HP_TIMING_NOW (start_time);
380 #else
381 HP_TIMING_NOW (info.start_time);
382 #endif
384 /* Partly clean the `bootstrap_map' structure up. Don't use
385 `memset' since it might not be built in or inlined and we cannot
386 make function calls at this point. Use '__builtin_memset' if we
387 know it is available. We do not have to clear the memory if we
388 do not have to use the temporary bootstrap_map. Global variables
389 are initialized to zero by default. */
390 #ifndef DONT_USE_BOOTSTRAP_MAP
391 # ifdef HAVE_BUILTIN_MEMSET
392 __builtin_memset (bootstrap_map.l_info, '\0', sizeof (bootstrap_map.l_info));
393 # else
394 for (size_t cnt = 0;
395 cnt < sizeof (bootstrap_map.l_info) / sizeof (bootstrap_map.l_info[0]);
396 ++cnt)
397 bootstrap_map.l_info[cnt] = 0;
398 # endif
399 # if USE___THREAD
400 bootstrap_map.l_tls_modid = 0;
401 # endif
402 #endif
404 /* Figure out the run-time load address of the dynamic linker itself. */
405 bootstrap_map.l_addr = elf_machine_load_address ();
407 /* Read our own dynamic section and fill in the info array. */
408 bootstrap_map.l_ld = (void *) bootstrap_map.l_addr + elf_machine_dynamic ();
409 elf_get_dynamic_info (&bootstrap_map, NULL);
411 #if NO_TLS_OFFSET != 0
412 bootstrap_map.l_tls_offset = NO_TLS_OFFSET;
413 #endif
415 /* Get the dynamic linker's own program header. First we need the ELF
416 file header. The `_begin' symbol created by the linker script points
417 to it. When we have something like GOTOFF relocs, we can use a plain
418 reference to find the runtime address. Without that, we have to rely
419 on the `l_addr' value, which is not the value we want when prelinked. */
420 #if USE___THREAD
421 dtv_t initdtv[3];
422 ElfW(Ehdr) *ehdr
423 # ifdef DONT_USE_BOOTSTRAP_MAP
424 = (ElfW(Ehdr) *) &_begin;
425 # else
426 # error This will not work with prelink.
427 = (ElfW(Ehdr) *) bootstrap_map.l_addr;
428 # endif
429 ElfW(Phdr) *phdr = (ElfW(Phdr) *) ((void *) ehdr + ehdr->e_phoff);
430 size_t cnt = ehdr->e_phnum; /* PT_TLS is usually the last phdr. */
431 while (cnt-- > 0)
432 if (phdr[cnt].p_type == PT_TLS)
434 void *tlsblock;
435 size_t max_align = MAX (TLS_INIT_TCB_ALIGN, phdr[cnt].p_align);
436 char *p;
438 bootstrap_map.l_tls_blocksize = phdr[cnt].p_memsz;
439 bootstrap_map.l_tls_align = phdr[cnt].p_align;
440 if (phdr[cnt].p_align == 0)
441 bootstrap_map.l_tls_firstbyte_offset = 0;
442 else
443 bootstrap_map.l_tls_firstbyte_offset = (phdr[cnt].p_vaddr
444 & (phdr[cnt].p_align - 1));
445 assert (bootstrap_map.l_tls_blocksize != 0);
446 bootstrap_map.l_tls_initimage_size = phdr[cnt].p_filesz;
447 bootstrap_map.l_tls_initimage = (void *) (bootstrap_map.l_addr
448 + phdr[cnt].p_vaddr);
450 /* We can now allocate the initial TLS block. This can happen
451 on the stack. We'll get the final memory later when we
452 know all about the various objects loaded at startup
453 time. */
454 # if TLS_TCB_AT_TP
455 tlsblock = alloca (roundup (bootstrap_map.l_tls_blocksize,
456 TLS_INIT_TCB_ALIGN)
457 + TLS_INIT_TCB_SIZE
458 + max_align);
459 # elif TLS_DTV_AT_TP
460 tlsblock = alloca (roundup (TLS_INIT_TCB_SIZE,
461 bootstrap_map.l_tls_align)
462 + bootstrap_map.l_tls_blocksize
463 + max_align);
464 # else
465 /* In case a model with a different layout for the TCB and DTV
466 is defined add another #elif here and in the following #ifs. */
467 # error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
468 # endif
469 /* Align the TLS block. */
470 tlsblock = (void *) (((uintptr_t) tlsblock + max_align - 1)
471 & ~(max_align - 1));
473 /* Initialize the dtv. [0] is the length, [1] the generation
474 counter. */
475 initdtv[0].counter = 1;
476 initdtv[1].counter = 0;
478 /* Initialize the TLS block. */
479 # if TLS_TCB_AT_TP
480 initdtv[2].pointer = tlsblock;
481 # elif TLS_DTV_AT_TP
482 bootstrap_map.l_tls_offset = roundup (TLS_INIT_TCB_SIZE,
483 bootstrap_map.l_tls_align);
484 initdtv[2].pointer = (char *) tlsblock + bootstrap_map.l_tls_offset;
485 # else
486 # error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
487 # endif
488 p = __mempcpy (initdtv[2].pointer, bootstrap_map.l_tls_initimage,
489 bootstrap_map.l_tls_initimage_size);
490 # ifdef HAVE_BUILTIN_MEMSET
491 __builtin_memset (p, '\0', (bootstrap_map.l_tls_blocksize
492 - bootstrap_map.l_tls_initimage_size));
493 # else
495 size_t remaining = (bootstrap_map.l_tls_blocksize
496 - bootstrap_map.l_tls_initimage_size);
497 while (remaining-- > 0)
498 *p++ = '\0';
500 # endif
502 /* Install the pointer to the dtv. */
504 /* Initialize the thread pointer. */
505 # if TLS_TCB_AT_TP
506 bootstrap_map.l_tls_offset
507 = roundup (bootstrap_map.l_tls_blocksize, TLS_INIT_TCB_ALIGN);
509 INSTALL_DTV ((char *) tlsblock + bootstrap_map.l_tls_offset,
510 initdtv);
512 const char *lossage = TLS_INIT_TP ((char *) tlsblock
513 + bootstrap_map.l_tls_offset, 0);
514 # elif TLS_DTV_AT_TP
515 INSTALL_DTV (tlsblock, initdtv);
516 const char *lossage = TLS_INIT_TP (tlsblock, 0);
517 # else
518 # error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
519 # endif
520 if (__glibc_unlikely (lossage != NULL))
521 _dl_fatal_printf ("cannot set up thread-local storage: %s\n",
522 lossage);
524 /* So far this is module number one. */
525 bootstrap_map.l_tls_modid = 1;
527 /* There can only be one PT_TLS entry. */
528 break;
530 #endif /* USE___THREAD */
532 #ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
533 ELF_MACHINE_BEFORE_RTLD_RELOC (bootstrap_map.l_info);
534 #endif
536 if (bootstrap_map.l_addr || ! bootstrap_map.l_info[VALIDX(DT_GNU_PRELINKED)])
538 /* Relocate ourselves so we can do normal function calls and
539 data access using the global offset table. */
541 ELF_DYNAMIC_RELOCATE (&bootstrap_map, 0, 0, 0);
543 bootstrap_map.l_relocated = 1;
545 /* Please note that we don't allow profiling of this object and
546 therefore need not test whether we have to allocate the array
547 for the relocation results (as done in dl-reloc.c). */
549 /* Now life is sane; we can call functions and access global data.
550 Set up to use the operating system facilities, and find out from
551 the operating system's program loader where to find the program
552 header table in core. Put the rest of _dl_start into a separate
553 function, that way the compiler cannot put accesses to the GOT
554 before ELF_DYNAMIC_RELOCATE. */
556 #ifdef DONT_USE_BOOTSTRAP_MAP
557 ElfW(Addr) entry = _dl_start_final (arg);
558 #else
559 ElfW(Addr) entry = _dl_start_final (arg, &info);
560 #endif
562 #ifndef ELF_MACHINE_START_ADDRESS
563 # define ELF_MACHINE_START_ADDRESS(map, start) (start)
564 #endif
566 return ELF_MACHINE_START_ADDRESS (GL(dl_ns)[LM_ID_BASE]._ns_loaded, entry);
572 /* Now life is peachy; we can do all normal operations.
573 On to the real work. */
575 /* Some helper functions. */
577 /* Arguments to relocate_doit. */
578 struct relocate_args
580 struct link_map *l;
581 int reloc_mode;
584 struct map_args
586 /* Argument to map_doit. */
587 char *str;
588 struct link_map *loader;
589 int mode;
590 /* Return value of map_doit. */
591 struct link_map *map;
594 struct dlmopen_args
596 const char *fname;
597 struct link_map *map;
600 struct lookup_args
602 const char *name;
603 struct link_map *map;
604 void *result;
607 /* Arguments to version_check_doit. */
608 struct version_check_args
610 int doexit;
611 int dotrace;
614 static void
615 relocate_doit (void *a)
617 struct relocate_args *args = (struct relocate_args *) a;
619 _dl_relocate_object (args->l, args->l->l_scope, args->reloc_mode, 0);
622 static void
623 map_doit (void *a)
625 struct map_args *args = (struct map_args *) a;
626 args->map = _dl_map_object (args->loader, args->str, lt_library, 0,
627 args->mode, LM_ID_BASE);
630 static void
631 dlmopen_doit (void *a)
633 struct dlmopen_args *args = (struct dlmopen_args *) a;
634 args->map = _dl_open (args->fname,
635 (RTLD_LAZY | __RTLD_DLOPEN | __RTLD_AUDIT
636 | __RTLD_SECURE),
637 dl_main, LM_ID_NEWLM, _dl_argc, INTUSE(_dl_argv),
638 __environ);
641 static void
642 lookup_doit (void *a)
644 struct lookup_args *args = (struct lookup_args *) a;
645 const ElfW(Sym) *ref = NULL;
646 args->result = NULL;
647 lookup_t l = _dl_lookup_symbol_x (args->name, args->map, &ref,
648 args->map->l_local_scope, NULL, 0,
649 DL_LOOKUP_RETURN_NEWEST, NULL);
650 if (ref != NULL)
651 args->result = DL_SYMBOL_ADDRESS (l, ref);
654 static void
655 version_check_doit (void *a)
657 struct version_check_args *args = (struct version_check_args *) a;
658 if (_dl_check_all_versions (GL(dl_ns)[LM_ID_BASE]._ns_loaded, 1,
659 args->dotrace) && args->doexit)
660 /* We cannot start the application. Abort now. */
661 _exit (1);
665 static inline struct link_map *
666 find_needed (const char *name)
668 struct r_scope_elem *scope = &GL(dl_ns)[LM_ID_BASE]._ns_loaded->l_searchlist;
669 unsigned int n = scope->r_nlist;
671 while (n-- > 0)
672 if (_dl_name_match_p (name, scope->r_list[n]))
673 return scope->r_list[n];
675 /* Should never happen. */
676 return NULL;
679 static int
680 match_version (const char *string, struct link_map *map)
682 const char *strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
683 ElfW(Verdef) *def;
685 #define VERDEFTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERDEF))
686 if (map->l_info[VERDEFTAG] == NULL)
687 /* The file has no symbol versioning. */
688 return 0;
690 def = (ElfW(Verdef) *) ((char *) map->l_addr
691 + map->l_info[VERDEFTAG]->d_un.d_ptr);
692 while (1)
694 ElfW(Verdaux) *aux = (ElfW(Verdaux) *) ((char *) def + def->vd_aux);
696 /* Compare the version strings. */
697 if (strcmp (string, strtab + aux->vda_name) == 0)
698 /* Bingo! */
699 return 1;
701 /* If no more definitions we failed to find what we want. */
702 if (def->vd_next == 0)
703 break;
705 /* Next definition. */
706 def = (ElfW(Verdef) *) ((char *) def + def->vd_next);
709 return 0;
712 static bool tls_init_tp_called;
714 static void *
715 init_tls (void)
717 /* Number of elements in the static TLS block. */
718 GL(dl_tls_static_nelem) = GL(dl_tls_max_dtv_idx);
720 /* Do not do this twice. The audit interface might have required
721 the DTV interfaces to be set up early. */
722 if (GL(dl_initial_dtv) != NULL)
723 return NULL;
725 /* Allocate the array which contains the information about the
726 dtv slots. We allocate a few entries more than needed to
727 avoid the need for reallocation. */
728 size_t nelem = GL(dl_tls_max_dtv_idx) + 1 + TLS_SLOTINFO_SURPLUS;
730 /* Allocate. */
731 GL(dl_tls_dtv_slotinfo_list) = (struct dtv_slotinfo_list *)
732 calloc (sizeof (struct dtv_slotinfo_list)
733 + nelem * sizeof (struct dtv_slotinfo), 1);
734 /* No need to check the return value. If memory allocation failed
735 the program would have been terminated. */
737 struct dtv_slotinfo *slotinfo = GL(dl_tls_dtv_slotinfo_list)->slotinfo;
738 GL(dl_tls_dtv_slotinfo_list)->len = nelem;
739 GL(dl_tls_dtv_slotinfo_list)->next = NULL;
741 /* Fill in the information from the loaded modules. No namespace
742 but the base one can be filled at this time. */
743 assert (GL(dl_ns)[LM_ID_BASE + 1]._ns_loaded == NULL);
744 int i = 0;
745 for (struct link_map *l = GL(dl_ns)[LM_ID_BASE]._ns_loaded; l != NULL;
746 l = l->l_next)
747 if (l->l_tls_blocksize != 0)
749 /* This is a module with TLS data. Store the map reference.
750 The generation counter is zero. */
751 slotinfo[i].map = l;
752 /* slotinfo[i].gen = 0; */
753 ++i;
755 assert (i == GL(dl_tls_max_dtv_idx));
757 /* Compute the TLS offsets for the various blocks. */
758 _dl_determine_tlsoffset ();
760 /* Construct the static TLS block and the dtv for the initial
761 thread. For some platforms this will include allocating memory
762 for the thread descriptor. The memory for the TLS block will
763 never be freed. It should be allocated accordingly. The dtv
764 array can be changed if dynamic loading requires it. */
765 void *tcbp = _dl_allocate_tls_storage ();
766 if (tcbp == NULL)
767 _dl_fatal_printf ("\
768 cannot allocate TLS data structures for initial thread");
770 /* Store for detection of the special case by __tls_get_addr
771 so it knows not to pass this dtv to the normal realloc. */
772 GL(dl_initial_dtv) = GET_DTV (tcbp);
774 /* And finally install it for the main thread. If ld.so itself uses
775 TLS we know the thread pointer was initialized earlier. */
776 const char *lossage
777 #ifdef USE___THREAD
778 = TLS_INIT_TP (tcbp, USE___THREAD);
779 #else
780 = TLS_INIT_TP (tcbp, 0);
781 #endif
782 if (__glibc_unlikely (lossage != NULL))
783 _dl_fatal_printf ("cannot set up thread-local storage: %s\n", lossage);
784 tls_init_tp_called = true;
786 return tcbp;
789 #ifdef _LIBC_REENTRANT
790 /* _dl_error_catch_tsd points to this for the single-threaded case.
791 It's reset by the thread library for multithreaded programs. */
792 void ** __attribute__ ((const))
793 _dl_initial_error_catch_tsd (void)
795 static void *data;
796 return &data;
798 #endif
801 static unsigned int
802 do_preload (char *fname, struct link_map *main_map, const char *where)
804 const char *objname;
805 const char *err_str = NULL;
806 struct map_args args;
807 bool malloced;
809 args.str = fname;
810 args.loader = main_map;
811 args.mode = __RTLD_SECURE;
813 unsigned int old_nloaded = GL(dl_ns)[LM_ID_BASE]._ns_nloaded;
815 (void) _dl_catch_error (&objname, &err_str, &malloced, map_doit, &args);
816 if (__glibc_unlikely (err_str != NULL))
818 _dl_error_printf ("\
819 ERROR: ld.so: object '%s' from %s cannot be preloaded (%s): ignored.\n",
820 fname, where, err_str);
821 /* No need to call free, this is still before
822 the libc's malloc is used. */
824 else if (GL(dl_ns)[LM_ID_BASE]._ns_nloaded != old_nloaded)
825 /* It is no duplicate. */
826 return 1;
828 /* Nothing loaded. */
829 return 0;
832 #if defined SHARED && defined _LIBC_REENTRANT \
833 && defined __rtld_lock_default_lock_recursive
834 static void
835 rtld_lock_default_lock_recursive (void *lock)
837 __rtld_lock_default_lock_recursive (lock);
840 static void
841 rtld_lock_default_unlock_recursive (void *lock)
843 __rtld_lock_default_unlock_recursive (lock);
845 #endif
848 static void
849 security_init (void)
851 /* Set up the stack checker's canary. */
852 uintptr_t stack_chk_guard = _dl_setup_stack_chk_guard (_dl_random);
853 #ifdef THREAD_SET_STACK_GUARD
854 THREAD_SET_STACK_GUARD (stack_chk_guard);
855 #else
856 __stack_chk_guard = stack_chk_guard;
857 #endif
859 /* Set up the pointer guard as well, if necessary. */
860 if (GLRO(dl_pointer_guard))
862 uintptr_t pointer_chk_guard = _dl_setup_pointer_guard (_dl_random,
863 stack_chk_guard);
864 #ifdef THREAD_SET_POINTER_GUARD
865 THREAD_SET_POINTER_GUARD (pointer_chk_guard);
866 #endif
867 __pointer_chk_guard_local = pointer_chk_guard;
870 /* We do not need the _dl_random value anymore. The less
871 information we leave behind, the better, so clear the
872 variable. */
873 _dl_random = NULL;
876 #include "setup-vdso.h"
878 /* The library search path. */
879 static const char *library_path attribute_relro;
880 /* The list preloaded objects. */
881 static const char *preloadlist attribute_relro;
882 /* Nonzero if information about versions has to be printed. */
883 static int version_info attribute_relro;
885 static void
886 dl_main (const ElfW(Phdr) *phdr,
887 ElfW(Word) phnum,
888 ElfW(Addr) *user_entry,
889 ElfW(auxv_t) *auxv)
891 const ElfW(Phdr) *ph;
892 enum mode mode;
893 struct link_map *main_map;
894 size_t file_size;
895 char *file;
896 bool has_interp = false;
897 unsigned int i;
898 bool prelinked = false;
899 bool rtld_is_main = false;
900 #ifndef HP_TIMING_NONAVAIL
901 hp_timing_t start;
902 hp_timing_t stop;
903 hp_timing_t diff;
904 #endif
905 void *tcbp = NULL;
907 #ifdef _LIBC_REENTRANT
908 /* Explicit initialization since the reloc would just be more work. */
909 GL(dl_error_catch_tsd) = &_dl_initial_error_catch_tsd;
910 #endif
912 GL(dl_init_static_tls) = &_dl_nothread_init_static_tls;
914 #if defined SHARED && defined _LIBC_REENTRANT \
915 && defined __rtld_lock_default_lock_recursive
916 GL(dl_rtld_lock_recursive) = rtld_lock_default_lock_recursive;
917 GL(dl_rtld_unlock_recursive) = rtld_lock_default_unlock_recursive;
918 #endif
920 /* The explicit initialization here is cheaper than processing the reloc
921 in the _rtld_local definition's initializer. */
922 GL(dl_make_stack_executable_hook) = &_dl_make_stack_executable;
924 /* Process the environment variable which control the behaviour. */
925 process_envvars (&mode);
927 #ifndef HAVE_INLINED_SYSCALLS
928 /* Set up a flag which tells we are just starting. */
929 INTUSE(_dl_starting_up) = 1;
930 #endif
932 if (*user_entry == (ElfW(Addr)) ENTRY_POINT)
934 /* Ho ho. We are not the program interpreter! We are the program
935 itself! This means someone ran ld.so as a command. Well, that
936 might be convenient to do sometimes. We support it by
937 interpreting the args like this:
939 ld.so PROGRAM ARGS...
941 The first argument is the name of a file containing an ELF
942 executable we will load and run with the following arguments.
943 To simplify life here, PROGRAM is searched for using the
944 normal rules for shared objects, rather than $PATH or anything
945 like that. We just load it and use its entry point; we don't
946 pay attention to its PT_INTERP command (we are the interpreter
947 ourselves). This is an easy way to test a new ld.so before
948 installing it. */
949 rtld_is_main = true;
951 /* Note the place where the dynamic linker actually came from. */
952 GL(dl_rtld_map).l_name = rtld_progname;
954 while (_dl_argc > 1)
955 if (! strcmp (INTUSE(_dl_argv)[1], "--list"))
957 mode = list;
958 GLRO(dl_lazy) = -1; /* This means do no dependency analysis. */
960 ++_dl_skip_args;
961 --_dl_argc;
962 ++INTUSE(_dl_argv);
964 else if (! strcmp (INTUSE(_dl_argv)[1], "--verify"))
966 mode = verify;
968 ++_dl_skip_args;
969 --_dl_argc;
970 ++INTUSE(_dl_argv);
972 else if (! strcmp (INTUSE(_dl_argv)[1], "--inhibit-cache"))
974 GLRO(dl_inhibit_cache) = 1;
975 ++_dl_skip_args;
976 --_dl_argc;
977 ++INTUSE(_dl_argv);
979 else if (! strcmp (INTUSE(_dl_argv)[1], "--library-path")
980 && _dl_argc > 2)
982 library_path = INTUSE(_dl_argv)[2];
984 _dl_skip_args += 2;
985 _dl_argc -= 2;
986 INTUSE(_dl_argv) += 2;
988 else if (! strcmp (INTUSE(_dl_argv)[1], "--inhibit-rpath")
989 && _dl_argc > 2)
991 GLRO(dl_inhibit_rpath) = INTUSE(_dl_argv)[2];
993 _dl_skip_args += 2;
994 _dl_argc -= 2;
995 INTUSE(_dl_argv) += 2;
997 else if (! strcmp (INTUSE(_dl_argv)[1], "--audit") && _dl_argc > 2)
999 process_dl_audit (INTUSE(_dl_argv)[2]);
1001 _dl_skip_args += 2;
1002 _dl_argc -= 2;
1003 INTUSE(_dl_argv) += 2;
1005 else
1006 break;
1008 /* If we have no further argument the program was called incorrectly.
1009 Grant the user some education. */
1010 if (_dl_argc < 2)
1011 _dl_fatal_printf ("\
1012 Usage: ld.so [OPTION]... EXECUTABLE-FILE [ARGS-FOR-PROGRAM...]\n\
1013 You have invoked `ld.so', the helper program for shared library executables.\n\
1014 This program usually lives in the file `/lib/ld.so', and special directives\n\
1015 in executable files using ELF shared libraries tell the system's program\n\
1016 loader to load the helper program from this file. This helper program loads\n\
1017 the shared libraries needed by the program executable, prepares the program\n\
1018 to run, and runs it. You may invoke this helper program directly from the\n\
1019 command line to load and run an ELF executable file; this is like executing\n\
1020 that file itself, but always uses this helper program from the file you\n\
1021 specified, instead of the helper program file specified in the executable\n\
1022 file you run. This is mostly of use for maintainers to test new versions\n\
1023 of this helper program; chances are you did not intend to run this program.\n\
1025 --list list all dependencies and how they are resolved\n\
1026 --verify verify that given object really is a dynamically linked\n\
1027 object we can handle\n\
1028 --inhibit-cache Do not use " LD_SO_CACHE "\n\
1029 --library-path PATH use given PATH instead of content of the environment\n\
1030 variable LD_LIBRARY_PATH\n\
1031 --inhibit-rpath LIST ignore RUNPATH and RPATH information in object names\n\
1032 in LIST\n\
1033 --audit LIST use objects named in LIST as auditors\n");
1035 ++_dl_skip_args;
1036 --_dl_argc;
1037 ++INTUSE(_dl_argv);
1039 /* The initialization of _dl_stack_flags done below assumes the
1040 executable's PT_GNU_STACK may have been honored by the kernel, and
1041 so a PT_GNU_STACK with PF_X set means the stack started out with
1042 execute permission. However, this is not really true if the
1043 dynamic linker is the executable the kernel loaded. For this
1044 case, we must reinitialize _dl_stack_flags to match the dynamic
1045 linker itself. If the dynamic linker was built with a
1046 PT_GNU_STACK, then the kernel may have loaded us with a
1047 nonexecutable stack that we will have to make executable when we
1048 load the program below unless it has a PT_GNU_STACK indicating
1049 nonexecutable stack is ok. */
1051 for (ph = phdr; ph < &phdr[phnum]; ++ph)
1052 if (ph->p_type == PT_GNU_STACK)
1054 GL(dl_stack_flags) = ph->p_flags;
1055 break;
1058 if (__builtin_expect (mode, normal) == verify)
1060 const char *objname;
1061 const char *err_str = NULL;
1062 struct map_args args;
1063 bool malloced;
1065 args.str = rtld_progname;
1066 args.loader = NULL;
1067 args.mode = __RTLD_OPENEXEC;
1068 (void) _dl_catch_error (&objname, &err_str, &malloced, map_doit,
1069 &args);
1070 if (__glibc_unlikely (err_str != NULL))
1071 /* We don't free the returned string, the programs stops
1072 anyway. */
1073 _exit (EXIT_FAILURE);
1075 else
1077 HP_TIMING_NOW (start);
1078 _dl_map_object (NULL, rtld_progname, lt_library, 0,
1079 __RTLD_OPENEXEC, LM_ID_BASE);
1080 HP_TIMING_NOW (stop);
1082 HP_TIMING_DIFF (load_time, start, stop);
1085 /* Now the map for the main executable is available. */
1086 main_map = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
1088 if (__builtin_expect (mode, normal) == normal
1089 && GL(dl_rtld_map).l_info[DT_SONAME] != NULL
1090 && main_map->l_info[DT_SONAME] != NULL
1091 && strcmp ((const char *) D_PTR (&GL(dl_rtld_map), l_info[DT_STRTAB])
1092 + GL(dl_rtld_map).l_info[DT_SONAME]->d_un.d_val,
1093 (const char *) D_PTR (main_map, l_info[DT_STRTAB])
1094 + main_map->l_info[DT_SONAME]->d_un.d_val) == 0)
1095 _dl_fatal_printf ("loader cannot load itself\n");
1097 phdr = main_map->l_phdr;
1098 phnum = main_map->l_phnum;
1099 /* We overwrite here a pointer to a malloc()ed string. But since
1100 the malloc() implementation used at this point is the dummy
1101 implementations which has no real free() function it does not
1102 makes sense to free the old string first. */
1103 main_map->l_name = (char *) "";
1104 *user_entry = main_map->l_entry;
1106 #ifdef HAVE_AUX_VECTOR
1107 /* Adjust the on-stack auxiliary vector so that it looks like the
1108 binary was executed directly. */
1109 for (ElfW(auxv_t) *av = auxv; av->a_type != AT_NULL; av++)
1110 switch (av->a_type)
1112 case AT_PHDR:
1113 av->a_un.a_val = (uintptr_t) phdr;
1114 break;
1115 case AT_PHNUM:
1116 av->a_un.a_val = phnum;
1117 break;
1118 case AT_ENTRY:
1119 av->a_un.a_val = *user_entry;
1120 break;
1121 case AT_EXECFN:
1122 av->a_un.a_val = (uintptr_t) _dl_argv[0];
1123 break;
1125 #endif
1127 else
1129 /* Create a link_map for the executable itself.
1130 This will be what dlopen on "" returns. */
1131 main_map = _dl_new_object ((char *) "", "", lt_executable, NULL,
1132 __RTLD_OPENEXEC, LM_ID_BASE);
1133 assert (main_map != NULL);
1134 main_map->l_phdr = phdr;
1135 main_map->l_phnum = phnum;
1136 main_map->l_entry = *user_entry;
1138 /* Even though the link map is not yet fully initialized we can add
1139 it to the map list since there are no possible users running yet. */
1140 _dl_add_to_namespace_list (main_map, LM_ID_BASE);
1141 assert (main_map == GL(dl_ns)[LM_ID_BASE]._ns_loaded);
1143 /* At this point we are in a bit of trouble. We would have to
1144 fill in the values for l_dev and l_ino. But in general we
1145 do not know where the file is. We also do not handle AT_EXECFD
1146 even if it would be passed up.
1148 We leave the values here defined to 0. This is normally no
1149 problem as the program code itself is normally no shared
1150 object and therefore cannot be loaded dynamically. Nothing
1151 prevent the use of dynamic binaries and in these situations
1152 we might get problems. We might not be able to find out
1153 whether the object is already loaded. But since there is no
1154 easy way out and because the dynamic binary must also not
1155 have an SONAME we ignore this program for now. If it becomes
1156 a problem we can force people using SONAMEs. */
1158 /* We delay initializing the path structure until we got the dynamic
1159 information for the program. */
1162 main_map->l_map_end = 0;
1163 main_map->l_text_end = 0;
1164 /* Perhaps the executable has no PT_LOAD header entries at all. */
1165 main_map->l_map_start = ~0;
1166 /* And it was opened directly. */
1167 ++main_map->l_direct_opencount;
1169 /* Scan the program header table for the dynamic section. */
1170 for (ph = phdr; ph < &phdr[phnum]; ++ph)
1171 switch (ph->p_type)
1173 case PT_PHDR:
1174 /* Find out the load address. */
1175 main_map->l_addr = (ElfW(Addr)) phdr - ph->p_vaddr;
1176 break;
1177 case PT_DYNAMIC:
1178 /* This tells us where to find the dynamic section,
1179 which tells us everything we need to do. */
1180 main_map->l_ld = (void *) main_map->l_addr + ph->p_vaddr;
1181 break;
1182 case PT_INTERP:
1183 /* This "interpreter segment" was used by the program loader to
1184 find the program interpreter, which is this program itself, the
1185 dynamic linker. We note what name finds us, so that a future
1186 dlopen call or DT_NEEDED entry, for something that wants to link
1187 against the dynamic linker as a shared library, will know that
1188 the shared object is already loaded. */
1189 _dl_rtld_libname.name = ((const char *) main_map->l_addr
1190 + ph->p_vaddr);
1191 /* _dl_rtld_libname.next = NULL; Already zero. */
1192 GL(dl_rtld_map).l_libname = &_dl_rtld_libname;
1194 /* Ordinarilly, we would get additional names for the loader from
1195 our DT_SONAME. This can't happen if we were actually linked as
1196 a static executable (detect this case when we have no DYNAMIC).
1197 If so, assume the filename component of the interpreter path to
1198 be our SONAME, and add it to our name list. */
1199 if (GL(dl_rtld_map).l_ld == NULL)
1201 const char *p = NULL;
1202 const char *cp = _dl_rtld_libname.name;
1204 /* Find the filename part of the path. */
1205 while (*cp != '\0')
1206 if (*cp++ == '/')
1207 p = cp;
1209 if (p != NULL)
1211 _dl_rtld_libname2.name = p;
1212 /* _dl_rtld_libname2.next = NULL; Already zero. */
1213 _dl_rtld_libname.next = &_dl_rtld_libname2;
1217 has_interp = true;
1218 break;
1219 case PT_LOAD:
1221 ElfW(Addr) mapstart;
1222 ElfW(Addr) allocend;
1224 /* Remember where the main program starts in memory. */
1225 mapstart = (main_map->l_addr
1226 + (ph->p_vaddr & ~(GLRO(dl_pagesize) - 1)));
1227 if (main_map->l_map_start > mapstart)
1228 main_map->l_map_start = mapstart;
1230 /* Also where it ends. */
1231 allocend = main_map->l_addr + ph->p_vaddr + ph->p_memsz;
1232 if (main_map->l_map_end < allocend)
1233 main_map->l_map_end = allocend;
1234 if ((ph->p_flags & PF_X) && allocend > main_map->l_text_end)
1235 main_map->l_text_end = allocend;
1237 break;
1239 case PT_TLS:
1240 if (ph->p_memsz > 0)
1242 /* Note that in the case the dynamic linker we duplicate work
1243 here since we read the PT_TLS entry already in
1244 _dl_start_final. But the result is repeatable so do not
1245 check for this special but unimportant case. */
1246 main_map->l_tls_blocksize = ph->p_memsz;
1247 main_map->l_tls_align = ph->p_align;
1248 if (ph->p_align == 0)
1249 main_map->l_tls_firstbyte_offset = 0;
1250 else
1251 main_map->l_tls_firstbyte_offset = (ph->p_vaddr
1252 & (ph->p_align - 1));
1253 main_map->l_tls_initimage_size = ph->p_filesz;
1254 main_map->l_tls_initimage = (void *) ph->p_vaddr;
1256 /* This image gets the ID one. */
1257 GL(dl_tls_max_dtv_idx) = main_map->l_tls_modid = 1;
1259 break;
1261 case PT_GNU_STACK:
1262 GL(dl_stack_flags) = ph->p_flags;
1263 break;
1265 case PT_GNU_RELRO:
1266 main_map->l_relro_addr = ph->p_vaddr;
1267 main_map->l_relro_size = ph->p_memsz;
1268 break;
1271 /* Adjust the address of the TLS initialization image in case
1272 the executable is actually an ET_DYN object. */
1273 if (main_map->l_tls_initimage != NULL)
1274 main_map->l_tls_initimage
1275 = (char *) main_map->l_tls_initimage + main_map->l_addr;
1276 if (! main_map->l_map_end)
1277 main_map->l_map_end = ~0;
1278 if (! main_map->l_text_end)
1279 main_map->l_text_end = ~0;
1280 if (! GL(dl_rtld_map).l_libname && GL(dl_rtld_map).l_name)
1282 /* We were invoked directly, so the program might not have a
1283 PT_INTERP. */
1284 _dl_rtld_libname.name = GL(dl_rtld_map).l_name;
1285 /* _dl_rtld_libname.next = NULL; Already zero. */
1286 GL(dl_rtld_map).l_libname = &_dl_rtld_libname;
1288 else
1289 assert (GL(dl_rtld_map).l_libname); /* How else did we get here? */
1291 /* If the current libname is different from the SONAME, add the
1292 latter as well. */
1293 if (GL(dl_rtld_map).l_info[DT_SONAME] != NULL
1294 && strcmp (GL(dl_rtld_map).l_libname->name,
1295 (const char *) D_PTR (&GL(dl_rtld_map), l_info[DT_STRTAB])
1296 + GL(dl_rtld_map).l_info[DT_SONAME]->d_un.d_val) != 0)
1298 static struct libname_list newname;
1299 newname.name = ((char *) D_PTR (&GL(dl_rtld_map), l_info[DT_STRTAB])
1300 + GL(dl_rtld_map).l_info[DT_SONAME]->d_un.d_ptr);
1301 newname.next = NULL;
1302 newname.dont_free = 1;
1304 assert (GL(dl_rtld_map).l_libname->next == NULL);
1305 GL(dl_rtld_map).l_libname->next = &newname;
1307 /* The ld.so must be relocated since otherwise loading audit modules
1308 will fail since they reuse the very same ld.so. */
1309 assert (GL(dl_rtld_map).l_relocated);
1311 if (! rtld_is_main)
1313 /* Extract the contents of the dynamic section for easy access. */
1314 elf_get_dynamic_info (main_map, NULL);
1315 /* Set up our cache of pointers into the hash table. */
1316 _dl_setup_hash (main_map);
1319 if (__builtin_expect (mode, normal) == verify)
1321 /* We were called just to verify that this is a dynamic
1322 executable using us as the program interpreter. Exit with an
1323 error if we were not able to load the binary or no interpreter
1324 is specified (i.e., this is no dynamically linked binary. */
1325 if (main_map->l_ld == NULL)
1326 _exit (1);
1328 /* We allow here some platform specific code. */
1329 #ifdef DISTINGUISH_LIB_VERSIONS
1330 DISTINGUISH_LIB_VERSIONS;
1331 #endif
1332 _exit (has_interp ? 0 : 2);
1335 struct link_map **first_preload = &GL(dl_rtld_map).l_next;
1336 /* Set up the data structures for the system-supplied DSO early,
1337 so they can influence _dl_init_paths. */
1338 setup_vdso (main_map, &first_preload);
1340 #ifdef DL_SYSDEP_OSCHECK
1341 DL_SYSDEP_OSCHECK (_dl_fatal_printf);
1342 #endif
1344 /* Initialize the data structures for the search paths for shared
1345 objects. */
1346 _dl_init_paths (library_path);
1348 /* Initialize _r_debug. */
1349 struct r_debug *r = _dl_debug_initialize (GL(dl_rtld_map).l_addr,
1350 LM_ID_BASE);
1351 r->r_state = RT_CONSISTENT;
1353 /* Put the link_map for ourselves on the chain so it can be found by
1354 name. Note that at this point the global chain of link maps contains
1355 exactly one element, which is pointed to by dl_loaded. */
1356 if (! GL(dl_rtld_map).l_name)
1357 /* If not invoked directly, the dynamic linker shared object file was
1358 found by the PT_INTERP name. */
1359 GL(dl_rtld_map).l_name = (char *) GL(dl_rtld_map).l_libname->name;
1360 GL(dl_rtld_map).l_type = lt_library;
1361 main_map->l_next = &GL(dl_rtld_map);
1362 GL(dl_rtld_map).l_prev = main_map;
1363 ++GL(dl_ns)[LM_ID_BASE]._ns_nloaded;
1364 ++GL(dl_load_adds);
1366 /* If LD_USE_LOAD_BIAS env variable has not been seen, default
1367 to not using bias for non-prelinked PIEs and libraries
1368 and using it for executables or prelinked PIEs or libraries. */
1369 if (GLRO(dl_use_load_bias) == (ElfW(Addr)) -2)
1370 GLRO(dl_use_load_bias) = main_map->l_addr == 0 ? -1 : 0;
1372 /* Set up the program header information for the dynamic linker
1373 itself. It is needed in the dl_iterate_phdr() callbacks. */
1374 ElfW(Ehdr) *rtld_ehdr = (ElfW(Ehdr) *) GL(dl_rtld_map).l_map_start;
1375 ElfW(Phdr) *rtld_phdr = (ElfW(Phdr) *) (GL(dl_rtld_map).l_map_start
1376 + rtld_ehdr->e_phoff);
1377 GL(dl_rtld_map).l_phdr = rtld_phdr;
1378 GL(dl_rtld_map).l_phnum = rtld_ehdr->e_phnum;
1381 /* PT_GNU_RELRO is usually the last phdr. */
1382 size_t cnt = rtld_ehdr->e_phnum;
1383 while (cnt-- > 0)
1384 if (rtld_phdr[cnt].p_type == PT_GNU_RELRO)
1386 GL(dl_rtld_map).l_relro_addr = rtld_phdr[cnt].p_vaddr;
1387 GL(dl_rtld_map).l_relro_size = rtld_phdr[cnt].p_memsz;
1388 break;
1391 /* Add the dynamic linker to the TLS list if it also uses TLS. */
1392 if (GL(dl_rtld_map).l_tls_blocksize != 0)
1393 /* Assign a module ID. Do this before loading any audit modules. */
1394 GL(dl_rtld_map).l_tls_modid = _dl_next_tls_modid ();
1396 /* If we have auditing DSOs to load, do it now. */
1397 if (__glibc_unlikely (audit_list != NULL))
1399 /* Iterate over all entries in the list. The order is important. */
1400 struct audit_ifaces *last_audit = NULL;
1401 struct audit_list *al = audit_list->next;
1403 /* Since we start using the auditing DSOs right away we need to
1404 initialize the data structures now. */
1405 tcbp = init_tls ();
1407 /* Initialize security features. We need to do it this early
1408 since otherwise the constructors of the audit libraries will
1409 use different values (especially the pointer guard) and will
1410 fail later on. */
1411 security_init ();
1415 int tls_idx = GL(dl_tls_max_dtv_idx);
1417 /* Now it is time to determine the layout of the static TLS
1418 block and allocate it for the initial thread. Note that we
1419 always allocate the static block, we never defer it even if
1420 no DF_STATIC_TLS bit is set. The reason is that we know
1421 glibc will use the static model. */
1422 struct dlmopen_args dlmargs;
1423 dlmargs.fname = al->name;
1424 dlmargs.map = NULL;
1426 const char *objname;
1427 const char *err_str = NULL;
1428 bool malloced;
1429 (void) _dl_catch_error (&objname, &err_str, &malloced, dlmopen_doit,
1430 &dlmargs);
1431 if (__glibc_unlikely (err_str != NULL))
1433 not_loaded:
1434 _dl_error_printf ("\
1435 ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n",
1436 al->name, err_str);
1437 if (malloced)
1438 free ((char *) err_str);
1440 else
1442 struct lookup_args largs;
1443 largs.name = "la_version";
1444 largs.map = dlmargs.map;
1446 /* Check whether the interface version matches. */
1447 (void) _dl_catch_error (&objname, &err_str, &malloced,
1448 lookup_doit, &largs);
1450 unsigned int (*laversion) (unsigned int);
1451 unsigned int lav;
1452 if (err_str == NULL
1453 && (laversion = largs.result) != NULL
1454 && (lav = laversion (LAV_CURRENT)) > 0
1455 && lav <= LAV_CURRENT)
1457 /* Allocate structure for the callback function pointers.
1458 This call can never fail. */
1459 union
1461 struct audit_ifaces ifaces;
1462 #define naudit_ifaces 8
1463 void (*fptr[naudit_ifaces]) (void);
1464 } *newp = malloc (sizeof (*newp));
1466 /* Names of the auditing interfaces. All in one
1467 long string. */
1468 static const char audit_iface_names[] =
1469 "la_activity\0"
1470 "la_objsearch\0"
1471 "la_objopen\0"
1472 "la_preinit\0"
1473 #if __ELF_NATIVE_CLASS == 32
1474 "la_symbind32\0"
1475 #elif __ELF_NATIVE_CLASS == 64
1476 "la_symbind64\0"
1477 #else
1478 # error "__ELF_NATIVE_CLASS must be defined"
1479 #endif
1480 #define STRING(s) __STRING (s)
1481 "la_" STRING (ARCH_LA_PLTENTER) "\0"
1482 "la_" STRING (ARCH_LA_PLTEXIT) "\0"
1483 "la_objclose\0";
1484 unsigned int cnt = 0;
1485 const char *cp = audit_iface_names;
1488 largs.name = cp;
1489 (void) _dl_catch_error (&objname, &err_str, &malloced,
1490 lookup_doit, &largs);
1492 /* Store the pointer. */
1493 if (err_str == NULL && largs.result != NULL)
1495 newp->fptr[cnt] = largs.result;
1497 /* The dynamic linker link map is statically
1498 allocated, initialize the data now. */
1499 GL(dl_rtld_map).l_audit[cnt].cookie
1500 = (intptr_t) &GL(dl_rtld_map);
1502 else
1503 newp->fptr[cnt] = NULL;
1504 ++cnt;
1506 cp = (char *) rawmemchr (cp, '\0') + 1;
1508 while (*cp != '\0');
1509 assert (cnt == naudit_ifaces);
1511 /* Now append the new auditing interface to the list. */
1512 newp->ifaces.next = NULL;
1513 if (last_audit == NULL)
1514 last_audit = GLRO(dl_audit) = &newp->ifaces;
1515 else
1516 last_audit = last_audit->next = &newp->ifaces;
1517 ++GLRO(dl_naudit);
1519 /* Mark the DSO as being used for auditing. */
1520 dlmargs.map->l_auditing = 1;
1522 else
1524 /* We cannot use the DSO, it does not have the
1525 appropriate interfaces or it expects something
1526 more recent. */
1527 #ifndef NDEBUG
1528 Lmid_t ns = dlmargs.map->l_ns;
1529 #endif
1530 _dl_close (dlmargs.map);
1532 /* Make sure the namespace has been cleared entirely. */
1533 assert (GL(dl_ns)[ns]._ns_loaded == NULL);
1534 assert (GL(dl_ns)[ns]._ns_nloaded == 0);
1536 GL(dl_tls_max_dtv_idx) = tls_idx;
1537 goto not_loaded;
1541 al = al->next;
1543 while (al != audit_list->next);
1545 /* If we have any auditing modules, announce that we already
1546 have two objects loaded. */
1547 if (__glibc_unlikely (GLRO(dl_naudit) > 0))
1549 struct link_map *ls[2] = { main_map, &GL(dl_rtld_map) };
1551 for (unsigned int outer = 0; outer < 2; ++outer)
1553 struct audit_ifaces *afct = GLRO(dl_audit);
1554 for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
1556 if (afct->objopen != NULL)
1558 ls[outer]->l_audit[cnt].bindflags
1559 = afct->objopen (ls[outer], LM_ID_BASE,
1560 &ls[outer]->l_audit[cnt].cookie);
1562 ls[outer]->l_audit_any_plt
1563 |= ls[outer]->l_audit[cnt].bindflags != 0;
1566 afct = afct->next;
1572 /* Keep track of the currently loaded modules to count how many
1573 non-audit modules which use TLS are loaded. */
1574 size_t count_modids = _dl_count_modids ();
1576 /* Set up debugging before the debugger is notified for the first time. */
1577 #ifdef ELF_MACHINE_DEBUG_SETUP
1578 /* Some machines (e.g. MIPS) don't use DT_DEBUG in this way. */
1579 ELF_MACHINE_DEBUG_SETUP (main_map, r);
1580 ELF_MACHINE_DEBUG_SETUP (&GL(dl_rtld_map), r);
1581 #else
1582 if (main_map->l_info[DT_DEBUG] != NULL)
1583 /* There is a DT_DEBUG entry in the dynamic section. Fill it in
1584 with the run-time address of the r_debug structure */
1585 main_map->l_info[DT_DEBUG]->d_un.d_ptr = (ElfW(Addr)) r;
1587 /* Fill in the pointer in the dynamic linker's own dynamic section, in
1588 case you run gdb on the dynamic linker directly. */
1589 if (GL(dl_rtld_map).l_info[DT_DEBUG] != NULL)
1590 GL(dl_rtld_map).l_info[DT_DEBUG]->d_un.d_ptr = (ElfW(Addr)) r;
1591 #endif
1593 /* We start adding objects. */
1594 r->r_state = RT_ADD;
1595 _dl_debug_state ();
1596 LIBC_PROBE (init_start, 2, LM_ID_BASE, r);
1598 /* Auditing checkpoint: we are ready to signal that the initial map
1599 is being constructed. */
1600 if (__glibc_unlikely (GLRO(dl_naudit) > 0))
1602 struct audit_ifaces *afct = GLRO(dl_audit);
1603 for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
1605 if (afct->activity != NULL)
1606 afct->activity (&main_map->l_audit[cnt].cookie, LA_ACT_ADD);
1608 afct = afct->next;
1612 /* We have two ways to specify objects to preload: via environment
1613 variable and via the file /etc/ld.so.preload. The latter can also
1614 be used when security is enabled. */
1615 assert (*first_preload == NULL);
1616 struct link_map **preloads = NULL;
1617 unsigned int npreloads = 0;
1619 if (__glibc_unlikely (preloadlist != NULL))
1621 /* The LD_PRELOAD environment variable gives list of libraries
1622 separated by white space or colons that are loaded before the
1623 executable's dependencies and prepended to the global scope
1624 list. If the binary is running setuid all elements
1625 containing a '/' are ignored since it is insecure. */
1626 char *list = strdupa (preloadlist);
1627 char *p;
1629 HP_TIMING_NOW (start);
1631 /* Prevent optimizing strsep. Speed is not important here. */
1632 while ((p = (strsep) (&list, " :")) != NULL)
1633 if (p[0] != '\0'
1634 && (__builtin_expect (! INTUSE(__libc_enable_secure), 1)
1635 || strchr (p, '/') == NULL))
1636 npreloads += do_preload (p, main_map, "LD_PRELOAD");
1638 HP_TIMING_NOW (stop);
1639 HP_TIMING_DIFF (diff, start, stop);
1640 HP_TIMING_ACCUM_NT (load_time, diff);
1643 /* There usually is no ld.so.preload file, it should only be used
1644 for emergencies and testing. So the open call etc should usually
1645 fail. Using access() on a non-existing file is faster than using
1646 open(). So we do this first. If it succeeds we do almost twice
1647 the work but this does not matter, since it is not for production
1648 use. */
1649 static const char preload_file[] = "/etc/ld.so.preload";
1650 if (__glibc_unlikely (__access (preload_file, R_OK) == 0))
1652 /* Read the contents of the file. */
1653 file = _dl_sysdep_read_whole_file (preload_file, &file_size,
1654 PROT_READ | PROT_WRITE);
1655 if (__glibc_unlikely (file != MAP_FAILED))
1657 /* Parse the file. It contains names of libraries to be loaded,
1658 separated by white spaces or `:'. It may also contain
1659 comments introduced by `#'. */
1660 char *problem;
1661 char *runp;
1662 size_t rest;
1664 /* Eliminate comments. */
1665 runp = file;
1666 rest = file_size;
1667 while (rest > 0)
1669 char *comment = memchr (runp, '#', rest);
1670 if (comment == NULL)
1671 break;
1673 rest -= comment - runp;
1675 *comment = ' ';
1676 while (--rest > 0 && *++comment != '\n');
1679 /* We have one problematic case: if we have a name at the end of
1680 the file without a trailing terminating characters, we cannot
1681 place the \0. Handle the case separately. */
1682 if (file[file_size - 1] != ' ' && file[file_size - 1] != '\t'
1683 && file[file_size - 1] != '\n' && file[file_size - 1] != ':')
1685 problem = &file[file_size];
1686 while (problem > file && problem[-1] != ' '
1687 && problem[-1] != '\t'
1688 && problem[-1] != '\n' && problem[-1] != ':')
1689 --problem;
1691 if (problem > file)
1692 problem[-1] = '\0';
1694 else
1696 problem = NULL;
1697 file[file_size - 1] = '\0';
1700 HP_TIMING_NOW (start);
1702 if (file != problem)
1704 char *p;
1705 runp = file;
1706 while ((p = strsep (&runp, ": \t\n")) != NULL)
1707 if (p[0] != '\0')
1708 npreloads += do_preload (p, main_map, preload_file);
1711 if (problem != NULL)
1713 char *p = strndupa (problem, file_size - (problem - file));
1715 npreloads += do_preload (p, main_map, preload_file);
1718 HP_TIMING_NOW (stop);
1719 HP_TIMING_DIFF (diff, start, stop);
1720 HP_TIMING_ACCUM_NT (load_time, diff);
1722 /* We don't need the file anymore. */
1723 __munmap (file, file_size);
1727 if (__glibc_unlikely (*first_preload != NULL))
1729 /* Set up PRELOADS with a vector of the preloaded libraries. */
1730 struct link_map *l = *first_preload;
1731 preloads = __alloca (npreloads * sizeof preloads[0]);
1732 i = 0;
1735 preloads[i++] = l;
1736 l = l->l_next;
1737 } while (l);
1738 assert (i == npreloads);
1741 /* Load all the libraries specified by DT_NEEDED entries. If LD_PRELOAD
1742 specified some libraries to load, these are inserted before the actual
1743 dependencies in the executable's searchlist for symbol resolution. */
1744 HP_TIMING_NOW (start);
1745 _dl_map_object_deps (main_map, preloads, npreloads, mode == trace, 0);
1746 HP_TIMING_NOW (stop);
1747 HP_TIMING_DIFF (diff, start, stop);
1748 HP_TIMING_ACCUM_NT (load_time, diff);
1750 /* Mark all objects as being in the global scope. */
1751 for (i = main_map->l_searchlist.r_nlist; i > 0; )
1752 main_map->l_searchlist.r_list[--i]->l_global = 1;
1754 /* Remove _dl_rtld_map from the chain. */
1755 GL(dl_rtld_map).l_prev->l_next = GL(dl_rtld_map).l_next;
1756 if (GL(dl_rtld_map).l_next != NULL)
1757 GL(dl_rtld_map).l_next->l_prev = GL(dl_rtld_map).l_prev;
1759 for (i = 1; i < main_map->l_searchlist.r_nlist; ++i)
1760 if (main_map->l_searchlist.r_list[i] == &GL(dl_rtld_map))
1761 break;
1763 bool rtld_multiple_ref = false;
1764 if (__glibc_likely (i < main_map->l_searchlist.r_nlist))
1766 /* Some DT_NEEDED entry referred to the interpreter object itself, so
1767 put it back in the list of visible objects. We insert it into the
1768 chain in symbol search order because gdb uses the chain's order as
1769 its symbol search order. */
1770 rtld_multiple_ref = true;
1772 GL(dl_rtld_map).l_prev = main_map->l_searchlist.r_list[i - 1];
1773 if (__builtin_expect (mode, normal) == normal)
1775 GL(dl_rtld_map).l_next = (i + 1 < main_map->l_searchlist.r_nlist
1776 ? main_map->l_searchlist.r_list[i + 1]
1777 : NULL);
1778 #ifdef NEED_DL_SYSINFO_DSO
1779 if (GLRO(dl_sysinfo_map) != NULL
1780 && GL(dl_rtld_map).l_prev->l_next == GLRO(dl_sysinfo_map)
1781 && GL(dl_rtld_map).l_next != GLRO(dl_sysinfo_map))
1782 GL(dl_rtld_map).l_prev = GLRO(dl_sysinfo_map);
1783 #endif
1785 else
1786 /* In trace mode there might be an invisible object (which we
1787 could not find) after the previous one in the search list.
1788 In this case it doesn't matter much where we put the
1789 interpreter object, so we just initialize the list pointer so
1790 that the assertion below holds. */
1791 GL(dl_rtld_map).l_next = GL(dl_rtld_map).l_prev->l_next;
1793 assert (GL(dl_rtld_map).l_prev->l_next == GL(dl_rtld_map).l_next);
1794 GL(dl_rtld_map).l_prev->l_next = &GL(dl_rtld_map);
1795 if (GL(dl_rtld_map).l_next != NULL)
1797 assert (GL(dl_rtld_map).l_next->l_prev == GL(dl_rtld_map).l_prev);
1798 GL(dl_rtld_map).l_next->l_prev = &GL(dl_rtld_map);
1802 /* Now let us see whether all libraries are available in the
1803 versions we need. */
1805 struct version_check_args args;
1806 args.doexit = mode == normal;
1807 args.dotrace = mode == trace;
1808 _dl_receive_error (print_missing_version, version_check_doit, &args);
1811 /* We do not initialize any of the TLS functionality unless any of the
1812 initial modules uses TLS. This makes dynamic loading of modules with
1813 TLS impossible, but to support it requires either eagerly doing setup
1814 now or lazily doing it later. Doing it now makes us incompatible with
1815 an old kernel that can't perform TLS_INIT_TP, even if no TLS is ever
1816 used. Trying to do it lazily is too hairy to try when there could be
1817 multiple threads (from a non-TLS-using libpthread). */
1818 bool was_tls_init_tp_called = tls_init_tp_called;
1819 if (tcbp == NULL)
1820 tcbp = init_tls ();
1822 if (__glibc_likely (audit_list == NULL))
1823 /* Initialize security features. But only if we have not done it
1824 earlier. */
1825 security_init ();
1827 if (__builtin_expect (mode, normal) != normal)
1829 /* We were run just to list the shared libraries. It is
1830 important that we do this before real relocation, because the
1831 functions we call below for output may no longer work properly
1832 after relocation. */
1833 struct link_map *l;
1835 if (GLRO(dl_debug_mask) & DL_DEBUG_PRELINK)
1837 struct r_scope_elem *scope = &main_map->l_searchlist;
1839 for (i = 0; i < scope->r_nlist; i++)
1841 l = scope->r_list [i];
1842 if (l->l_faked)
1844 _dl_printf ("\t%s => not found\n", l->l_libname->name);
1845 continue;
1847 if (_dl_name_match_p (GLRO(dl_trace_prelink), l))
1848 GLRO(dl_trace_prelink_map) = l;
1849 _dl_printf ("\t%s => %s (0x%0*Zx, 0x%0*Zx)",
1850 DSO_FILENAME (l->l_libname->name),
1851 DSO_FILENAME (l->l_name),
1852 (int) sizeof l->l_map_start * 2,
1853 (size_t) l->l_map_start,
1854 (int) sizeof l->l_addr * 2,
1855 (size_t) l->l_addr);
1857 if (l->l_tls_modid)
1858 _dl_printf (" TLS(0x%Zx, 0x%0*Zx)\n", l->l_tls_modid,
1859 (int) sizeof l->l_tls_offset * 2,
1860 (size_t) l->l_tls_offset);
1861 else
1862 _dl_printf ("\n");
1865 else if (GLRO(dl_debug_mask) & DL_DEBUG_UNUSED)
1867 /* Look through the dependencies of the main executable
1868 and determine which of them is not actually
1869 required. */
1870 struct link_map *l = main_map;
1872 /* Relocate the main executable. */
1873 struct relocate_args args = { .l = l,
1874 .reloc_mode = ((GLRO(dl_lazy)
1875 ? RTLD_LAZY : 0)
1876 | __RTLD_NOIFUNC) };
1877 _dl_receive_error (print_unresolved, relocate_doit, &args);
1879 /* This loop depends on the dependencies of the executable to
1880 correspond in number and order to the DT_NEEDED entries. */
1881 ElfW(Dyn) *dyn = main_map->l_ld;
1882 bool first = true;
1883 while (dyn->d_tag != DT_NULL)
1885 if (dyn->d_tag == DT_NEEDED)
1887 l = l->l_next;
1888 #ifdef NEED_DL_SYSINFO_DSO
1889 /* Skip the VDSO since it's not part of the list
1890 of objects we brought in via DT_NEEDED entries. */
1891 if (l == GLRO(dl_sysinfo_map))
1892 l = l->l_next;
1893 #endif
1894 if (!l->l_used)
1896 if (first)
1898 _dl_printf ("Unused direct dependencies:\n");
1899 first = false;
1902 _dl_printf ("\t%s\n", l->l_name);
1906 ++dyn;
1909 _exit (first != true);
1911 else if (! main_map->l_info[DT_NEEDED])
1912 _dl_printf ("\tstatically linked\n");
1913 else
1915 for (l = main_map->l_next; l; l = l->l_next)
1916 if (l->l_faked)
1917 /* The library was not found. */
1918 _dl_printf ("\t%s => not found\n", l->l_libname->name);
1919 else if (strcmp (l->l_libname->name, l->l_name) == 0)
1920 _dl_printf ("\t%s (0x%0*Zx)\n", l->l_libname->name,
1921 (int) sizeof l->l_map_start * 2,
1922 (size_t) l->l_map_start);
1923 else
1924 _dl_printf ("\t%s => %s (0x%0*Zx)\n", l->l_libname->name,
1925 l->l_name, (int) sizeof l->l_map_start * 2,
1926 (size_t) l->l_map_start);
1929 if (__builtin_expect (mode, trace) != trace)
1930 for (i = 1; i < (unsigned int) _dl_argc; ++i)
1932 const ElfW(Sym) *ref = NULL;
1933 ElfW(Addr) loadbase;
1934 lookup_t result;
1936 result = _dl_lookup_symbol_x (INTUSE(_dl_argv)[i], main_map,
1937 &ref, main_map->l_scope,
1938 NULL, ELF_RTYPE_CLASS_PLT,
1939 DL_LOOKUP_ADD_DEPENDENCY, NULL);
1941 loadbase = LOOKUP_VALUE_ADDRESS (result);
1943 _dl_printf ("%s found at 0x%0*Zd in object at 0x%0*Zd\n",
1944 INTUSE(_dl_argv)[i],
1945 (int) sizeof ref->st_value * 2,
1946 (size_t) ref->st_value,
1947 (int) sizeof loadbase * 2, (size_t) loadbase);
1949 else
1951 /* If LD_WARN is set, warn about undefined symbols. */
1952 if (GLRO(dl_lazy) >= 0 && GLRO(dl_verbose))
1954 /* We have to do symbol dependency testing. */
1955 struct relocate_args args;
1956 unsigned int i;
1958 args.reloc_mode = ((GLRO(dl_lazy) ? RTLD_LAZY : 0)
1959 | __RTLD_NOIFUNC);
1961 i = main_map->l_searchlist.r_nlist;
1962 while (i-- > 0)
1964 struct link_map *l = main_map->l_initfini[i];
1965 if (l != &GL(dl_rtld_map) && ! l->l_faked)
1967 args.l = l;
1968 _dl_receive_error (print_unresolved, relocate_doit,
1969 &args);
1973 if ((GLRO(dl_debug_mask) & DL_DEBUG_PRELINK)
1974 && rtld_multiple_ref)
1976 /* Mark the link map as not yet relocated again. */
1977 GL(dl_rtld_map).l_relocated = 0;
1978 _dl_relocate_object (&GL(dl_rtld_map),
1979 main_map->l_scope, __RTLD_NOIFUNC, 0);
1982 #define VERNEEDTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERNEED))
1983 if (version_info)
1985 /* Print more information. This means here, print information
1986 about the versions needed. */
1987 int first = 1;
1988 struct link_map *map;
1990 for (map = main_map; map != NULL; map = map->l_next)
1992 const char *strtab;
1993 ElfW(Dyn) *dyn = map->l_info[VERNEEDTAG];
1994 ElfW(Verneed) *ent;
1996 if (dyn == NULL)
1997 continue;
1999 strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
2000 ent = (ElfW(Verneed) *) (map->l_addr + dyn->d_un.d_ptr);
2002 if (first)
2004 _dl_printf ("\n\tVersion information:\n");
2005 first = 0;
2008 _dl_printf ("\t%s:\n", DSO_FILENAME (map->l_name));
2010 while (1)
2012 ElfW(Vernaux) *aux;
2013 struct link_map *needed;
2015 needed = find_needed (strtab + ent->vn_file);
2016 aux = (ElfW(Vernaux) *) ((char *) ent + ent->vn_aux);
2018 while (1)
2020 const char *fname = NULL;
2022 if (needed != NULL
2023 && match_version (strtab + aux->vna_name,
2024 needed))
2025 fname = needed->l_name;
2027 _dl_printf ("\t\t%s (%s) %s=> %s\n",
2028 strtab + ent->vn_file,
2029 strtab + aux->vna_name,
2030 aux->vna_flags & VER_FLG_WEAK
2031 ? "[WEAK] " : "",
2032 fname ?: "not found");
2034 if (aux->vna_next == 0)
2035 /* No more symbols. */
2036 break;
2038 /* Next symbol. */
2039 aux = (ElfW(Vernaux) *) ((char *) aux
2040 + aux->vna_next);
2043 if (ent->vn_next == 0)
2044 /* No more dependencies. */
2045 break;
2047 /* Next dependency. */
2048 ent = (ElfW(Verneed) *) ((char *) ent + ent->vn_next);
2054 _exit (0);
2057 if (main_map->l_info[ADDRIDX (DT_GNU_LIBLIST)]
2058 && ! __builtin_expect (GLRO(dl_profile) != NULL, 0)
2059 && ! __builtin_expect (GLRO(dl_dynamic_weak), 0))
2061 ElfW(Lib) *liblist, *liblistend;
2062 struct link_map **r_list, **r_listend, *l;
2063 const char *strtab = (const void *) D_PTR (main_map, l_info[DT_STRTAB]);
2065 assert (main_map->l_info[VALIDX (DT_GNU_LIBLISTSZ)] != NULL);
2066 liblist = (ElfW(Lib) *)
2067 main_map->l_info[ADDRIDX (DT_GNU_LIBLIST)]->d_un.d_ptr;
2068 liblistend = (ElfW(Lib) *)
2069 ((char *) liblist +
2070 main_map->l_info[VALIDX (DT_GNU_LIBLISTSZ)]->d_un.d_val);
2071 r_list = main_map->l_searchlist.r_list;
2072 r_listend = r_list + main_map->l_searchlist.r_nlist;
2074 for (; r_list < r_listend && liblist < liblistend; r_list++)
2076 l = *r_list;
2078 if (l == main_map)
2079 continue;
2081 /* If the library is not mapped where it should, fail. */
2082 if (l->l_addr)
2083 break;
2085 /* Next, check if checksum matches. */
2086 if (l->l_info [VALIDX(DT_CHECKSUM)] == NULL
2087 || l->l_info [VALIDX(DT_CHECKSUM)]->d_un.d_val
2088 != liblist->l_checksum)
2089 break;
2091 if (l->l_info [VALIDX(DT_GNU_PRELINKED)] == NULL
2092 || l->l_info [VALIDX(DT_GNU_PRELINKED)]->d_un.d_val
2093 != liblist->l_time_stamp)
2094 break;
2096 if (! _dl_name_match_p (strtab + liblist->l_name, l))
2097 break;
2099 ++liblist;
2103 if (r_list == r_listend && liblist == liblistend)
2104 prelinked = true;
2106 if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_LIBS))
2107 _dl_debug_printf ("\nprelink checking: %s\n",
2108 prelinked ? "ok" : "failed");
2112 /* Now set up the variable which helps the assembler startup code. */
2113 GL(dl_ns)[LM_ID_BASE]._ns_main_searchlist = &main_map->l_searchlist;
2115 /* Save the information about the original global scope list since
2116 we need it in the memory handling later. */
2117 GLRO(dl_initial_searchlist) = *GL(dl_ns)[LM_ID_BASE]._ns_main_searchlist;
2119 /* Remember the last search directory added at startup, now that
2120 malloc will no longer be the one from dl-minimal.c. */
2121 GLRO(dl_init_all_dirs) = GL(dl_all_dirs);
2123 /* Print scope information. */
2124 if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_SCOPES))
2126 _dl_debug_printf ("\nInitial object scopes\n");
2128 for (struct link_map *l = main_map; l != NULL; l = l->l_next)
2129 _dl_show_scope (l, 0);
2132 if (prelinked)
2134 if (main_map->l_info [ADDRIDX (DT_GNU_CONFLICT)] != NULL)
2136 ElfW(Rela) *conflict, *conflictend;
2137 #ifndef HP_TIMING_NONAVAIL
2138 hp_timing_t start;
2139 hp_timing_t stop;
2140 #endif
2142 HP_TIMING_NOW (start);
2143 assert (main_map->l_info [VALIDX (DT_GNU_CONFLICTSZ)] != NULL);
2144 conflict = (ElfW(Rela) *)
2145 main_map->l_info [ADDRIDX (DT_GNU_CONFLICT)]->d_un.d_ptr;
2146 conflictend = (ElfW(Rela) *)
2147 ((char *) conflict
2148 + main_map->l_info [VALIDX (DT_GNU_CONFLICTSZ)]->d_un.d_val);
2149 _dl_resolve_conflicts (main_map, conflict, conflictend);
2150 HP_TIMING_NOW (stop);
2151 HP_TIMING_DIFF (relocate_time, start, stop);
2155 /* Mark all the objects so we know they have been already relocated. */
2156 for (struct link_map *l = main_map; l != NULL; l = l->l_next)
2158 l->l_relocated = 1;
2159 if (l->l_relro_size)
2160 _dl_protect_relro (l);
2162 /* Add object to slot information data if necessasy. */
2163 if (l->l_tls_blocksize != 0 && tls_init_tp_called)
2164 _dl_add_to_slotinfo (l);
2167 else
2169 /* Now we have all the objects loaded. Relocate them all except for
2170 the dynamic linker itself. We do this in reverse order so that copy
2171 relocs of earlier objects overwrite the data written by later
2172 objects. We do not re-relocate the dynamic linker itself in this
2173 loop because that could result in the GOT entries for functions we
2174 call being changed, and that would break us. It is safe to relocate
2175 the dynamic linker out of order because it has no copy relocs (we
2176 know that because it is self-contained). */
2178 int consider_profiling = GLRO(dl_profile) != NULL;
2179 #ifndef HP_TIMING_NONAVAIL
2180 hp_timing_t start;
2181 hp_timing_t stop;
2182 #endif
2184 /* If we are profiling we also must do lazy reloaction. */
2185 GLRO(dl_lazy) |= consider_profiling;
2187 HP_TIMING_NOW (start);
2188 unsigned i = main_map->l_searchlist.r_nlist;
2189 while (i-- > 0)
2191 struct link_map *l = main_map->l_initfini[i];
2193 /* While we are at it, help the memory handling a bit. We have to
2194 mark some data structures as allocated with the fake malloc()
2195 implementation in ld.so. */
2196 struct libname_list *lnp = l->l_libname->next;
2198 while (__builtin_expect (lnp != NULL, 0))
2200 lnp->dont_free = 1;
2201 lnp = lnp->next;
2203 /* Also allocated with the fake malloc(). */
2204 l->l_free_initfini = 0;
2206 if (l != &GL(dl_rtld_map))
2207 _dl_relocate_object (l, l->l_scope, GLRO(dl_lazy) ? RTLD_LAZY : 0,
2208 consider_profiling);
2210 /* Add object to slot information data if necessasy. */
2211 if (l->l_tls_blocksize != 0 && tls_init_tp_called)
2212 _dl_add_to_slotinfo (l);
2214 HP_TIMING_NOW (stop);
2216 HP_TIMING_DIFF (relocate_time, start, stop);
2218 /* Now enable profiling if needed. Like the previous call,
2219 this has to go here because the calls it makes should use the
2220 rtld versions of the functions (particularly calloc()), but it
2221 needs to have _dl_profile_map set up by the relocator. */
2222 if (__glibc_unlikely (GL(dl_profile_map) != NULL))
2223 /* We must prepare the profiling. */
2224 _dl_start_profile ();
2227 if ((!was_tls_init_tp_called && GL(dl_tls_max_dtv_idx) > 0)
2228 || count_modids != _dl_count_modids ())
2229 ++GL(dl_tls_generation);
2231 /* Now that we have completed relocation, the initializer data
2232 for the TLS blocks has its final values and we can copy them
2233 into the main thread's TLS area, which we allocated above. */
2234 _dl_allocate_tls_init (tcbp);
2236 /* And finally install it for the main thread. If ld.so itself uses
2237 TLS we know the thread pointer was initialized earlier. */
2238 if (! tls_init_tp_called)
2240 const char *lossage
2241 #ifdef USE___THREAD
2242 = TLS_INIT_TP (tcbp, USE___THREAD);
2243 #else
2244 = TLS_INIT_TP (tcbp, 0);
2245 #endif
2246 if (__glibc_unlikely (lossage != NULL))
2247 _dl_fatal_printf ("cannot set up thread-local storage: %s\n",
2248 lossage);
2251 /* Make sure no new search directories have been added. */
2252 assert (GLRO(dl_init_all_dirs) == GL(dl_all_dirs));
2254 if (! prelinked && rtld_multiple_ref)
2256 /* There was an explicit ref to the dynamic linker as a shared lib.
2257 Re-relocate ourselves with user-controlled symbol definitions.
2259 We must do this after TLS initialization in case after this
2260 re-relocation, we might call a user-supplied function
2261 (e.g. calloc from _dl_relocate_object) that uses TLS data. */
2263 #ifndef HP_TIMING_NONAVAIL
2264 hp_timing_t start;
2265 hp_timing_t stop;
2266 hp_timing_t add;
2267 #endif
2269 HP_TIMING_NOW (start);
2270 /* Mark the link map as not yet relocated again. */
2271 GL(dl_rtld_map).l_relocated = 0;
2272 _dl_relocate_object (&GL(dl_rtld_map), main_map->l_scope, 0, 0);
2273 HP_TIMING_NOW (stop);
2274 HP_TIMING_DIFF (add, start, stop);
2275 HP_TIMING_ACCUM_NT (relocate_time, add);
2278 /* Do any necessary cleanups for the startup OS interface code.
2279 We do these now so that no calls are made after rtld re-relocation
2280 which might be resolved to different functions than we expect.
2281 We cannot do this before relocating the other objects because
2282 _dl_relocate_object might need to call `mprotect' for DT_TEXTREL. */
2283 _dl_sysdep_start_cleanup ();
2285 #ifdef SHARED
2286 /* Auditing checkpoint: we have added all objects. */
2287 if (__glibc_unlikely (GLRO(dl_naudit) > 0))
2289 struct link_map *head = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
2290 /* Do not call the functions for any auditing object. */
2291 if (head->l_auditing == 0)
2293 struct audit_ifaces *afct = GLRO(dl_audit);
2294 for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
2296 if (afct->activity != NULL)
2297 afct->activity (&head->l_audit[cnt].cookie, LA_ACT_CONSISTENT);
2299 afct = afct->next;
2303 #endif
2305 /* Notify the debugger all new objects are now ready to go. We must re-get
2306 the address since by now the variable might be in another object. */
2307 r = _dl_debug_initialize (0, LM_ID_BASE);
2308 r->r_state = RT_CONSISTENT;
2309 _dl_debug_state ();
2310 LIBC_PROBE (init_complete, 2, LM_ID_BASE, r);
2312 #if defined USE_LDCONFIG && !defined MAP_COPY
2313 /* We must munmap() the cache file. */
2314 _dl_unload_cache ();
2315 #endif
2317 /* Once we return, _dl_sysdep_start will invoke
2318 the DT_INIT functions and then *USER_ENTRY. */
2321 /* This is a little helper function for resolving symbols while
2322 tracing the binary. */
2323 static void
2324 print_unresolved (int errcode __attribute__ ((unused)), const char *objname,
2325 const char *errstring)
2327 if (objname[0] == '\0')
2328 objname = RTLD_PROGNAME;
2329 _dl_error_printf ("%s (%s)\n", errstring, objname);
2332 /* This is a little helper function for resolving symbols while
2333 tracing the binary. */
2334 static void
2335 print_missing_version (int errcode __attribute__ ((unused)),
2336 const char *objname, const char *errstring)
2338 _dl_error_printf ("%s: %s: %s\n", RTLD_PROGNAME,
2339 objname, errstring);
2342 /* Nonzero if any of the debugging options is enabled. */
2343 static int any_debug attribute_relro;
2345 /* Process the string given as the parameter which explains which debugging
2346 options are enabled. */
2347 static void
2348 process_dl_debug (const char *dl_debug)
2350 /* When adding new entries make sure that the maximal length of a name
2351 is correctly handled in the LD_DEBUG_HELP code below. */
2352 static const struct
2354 unsigned char len;
2355 const char name[10];
2356 const char helptext[41];
2357 unsigned short int mask;
2358 } debopts[] =
2360 #define LEN_AND_STR(str) sizeof (str) - 1, str
2361 { LEN_AND_STR ("libs"), "display library search paths",
2362 DL_DEBUG_LIBS | DL_DEBUG_IMPCALLS },
2363 { LEN_AND_STR ("reloc"), "display relocation processing",
2364 DL_DEBUG_RELOC | DL_DEBUG_IMPCALLS },
2365 { LEN_AND_STR ("files"), "display progress for input file",
2366 DL_DEBUG_FILES | DL_DEBUG_IMPCALLS },
2367 { LEN_AND_STR ("symbols"), "display symbol table processing",
2368 DL_DEBUG_SYMBOLS | DL_DEBUG_IMPCALLS },
2369 { LEN_AND_STR ("bindings"), "display information about symbol binding",
2370 DL_DEBUG_BINDINGS | DL_DEBUG_IMPCALLS },
2371 { LEN_AND_STR ("versions"), "display version dependencies",
2372 DL_DEBUG_VERSIONS | DL_DEBUG_IMPCALLS },
2373 { LEN_AND_STR ("scopes"), "display scope information",
2374 DL_DEBUG_SCOPES },
2375 { LEN_AND_STR ("all"), "all previous options combined",
2376 DL_DEBUG_LIBS | DL_DEBUG_RELOC | DL_DEBUG_FILES | DL_DEBUG_SYMBOLS
2377 | DL_DEBUG_BINDINGS | DL_DEBUG_VERSIONS | DL_DEBUG_IMPCALLS
2378 | DL_DEBUG_SCOPES },
2379 { LEN_AND_STR ("statistics"), "display relocation statistics",
2380 DL_DEBUG_STATISTICS },
2381 { LEN_AND_STR ("unused"), "determined unused DSOs",
2382 DL_DEBUG_UNUSED },
2383 { LEN_AND_STR ("help"), "display this help message and exit",
2384 DL_DEBUG_HELP },
2386 #define ndebopts (sizeof (debopts) / sizeof (debopts[0]))
2388 /* Skip separating white spaces and commas. */
2389 while (*dl_debug != '\0')
2391 if (*dl_debug != ' ' && *dl_debug != ',' && *dl_debug != ':')
2393 size_t cnt;
2394 size_t len = 1;
2396 while (dl_debug[len] != '\0' && dl_debug[len] != ' '
2397 && dl_debug[len] != ',' && dl_debug[len] != ':')
2398 ++len;
2400 for (cnt = 0; cnt < ndebopts; ++cnt)
2401 if (debopts[cnt].len == len
2402 && memcmp (dl_debug, debopts[cnt].name, len) == 0)
2404 GLRO(dl_debug_mask) |= debopts[cnt].mask;
2405 any_debug = 1;
2406 break;
2409 if (cnt == ndebopts)
2411 /* Display a warning and skip everything until next
2412 separator. */
2413 char *copy = strndupa (dl_debug, len);
2414 _dl_error_printf ("\
2415 warning: debug option `%s' unknown; try LD_DEBUG=help\n", copy);
2418 dl_debug += len;
2419 continue;
2422 ++dl_debug;
2425 if (GLRO(dl_debug_mask) & DL_DEBUG_UNUSED)
2427 /* In order to get an accurate picture of whether a particular
2428 DT_NEEDED entry is actually used we have to process both
2429 the PLT and non-PLT relocation entries. */
2430 GLRO(dl_lazy) = 0;
2433 if (GLRO(dl_debug_mask) & DL_DEBUG_HELP)
2435 size_t cnt;
2437 _dl_printf ("\
2438 Valid options for the LD_DEBUG environment variable are:\n\n");
2440 for (cnt = 0; cnt < ndebopts; ++cnt)
2441 _dl_printf (" %.*s%s%s\n", debopts[cnt].len, debopts[cnt].name,
2442 " " + debopts[cnt].len - 3,
2443 debopts[cnt].helptext);
2445 _dl_printf ("\n\
2446 To direct the debugging output into a file instead of standard output\n\
2447 a filename can be specified using the LD_DEBUG_OUTPUT environment variable.\n");
2448 _exit (0);
2452 static void
2453 process_dl_audit (char *str)
2455 /* The parameter is a colon separated list of DSO names. */
2456 char *p;
2458 while ((p = (strsep) (&str, ":")) != NULL)
2459 if (p[0] != '\0'
2460 && (__builtin_expect (! INTUSE(__libc_enable_secure), 1)
2461 || strchr (p, '/') == NULL))
2463 /* This is using the local malloc, not the system malloc. The
2464 memory can never be freed. */
2465 struct audit_list *newp = malloc (sizeof (*newp));
2466 newp->name = p;
2468 if (audit_list == NULL)
2469 audit_list = newp->next = newp;
2470 else
2472 newp->next = audit_list->next;
2473 audit_list = audit_list->next = newp;
2478 /* Process all environments variables the dynamic linker must recognize.
2479 Since all of them start with `LD_' we are a bit smarter while finding
2480 all the entries. */
2481 extern char **_environ attribute_hidden;
2484 static void
2485 process_envvars (enum mode *modep)
2487 char **runp = _environ;
2488 char *envline;
2489 enum mode mode = normal;
2490 char *debug_output = NULL;
2492 /* This is the default place for profiling data file. */
2493 GLRO(dl_profile_output)
2494 = &"/var/tmp\0/var/profile"[INTUSE(__libc_enable_secure) ? 9 : 0];
2496 while ((envline = _dl_next_ld_env_entry (&runp)) != NULL)
2498 size_t len = 0;
2500 while (envline[len] != '\0' && envline[len] != '=')
2501 ++len;
2503 if (envline[len] != '=')
2504 /* This is a "LD_" variable at the end of the string without
2505 a '=' character. Ignore it since otherwise we will access
2506 invalid memory below. */
2507 continue;
2509 switch (len)
2511 case 4:
2512 /* Warning level, verbose or not. */
2513 if (memcmp (envline, "WARN", 4) == 0)
2514 GLRO(dl_verbose) = envline[5] != '\0';
2515 break;
2517 case 5:
2518 /* Debugging of the dynamic linker? */
2519 if (memcmp (envline, "DEBUG", 5) == 0)
2521 process_dl_debug (&envline[6]);
2522 break;
2524 if (memcmp (envline, "AUDIT", 5) == 0)
2525 process_dl_audit (&envline[6]);
2526 break;
2528 case 7:
2529 /* Print information about versions. */
2530 if (memcmp (envline, "VERBOSE", 7) == 0)
2532 version_info = envline[8] != '\0';
2533 break;
2536 /* List of objects to be preloaded. */
2537 if (memcmp (envline, "PRELOAD", 7) == 0)
2539 preloadlist = &envline[8];
2540 break;
2543 /* Which shared object shall be profiled. */
2544 if (memcmp (envline, "PROFILE", 7) == 0 && envline[8] != '\0')
2545 GLRO(dl_profile) = &envline[8];
2546 break;
2548 case 8:
2549 /* Do we bind early? */
2550 if (memcmp (envline, "BIND_NOW", 8) == 0)
2552 GLRO(dl_lazy) = envline[9] == '\0';
2553 break;
2555 if (memcmp (envline, "BIND_NOT", 8) == 0)
2556 GLRO(dl_bind_not) = envline[9] != '\0';
2557 break;
2559 case 9:
2560 /* Test whether we want to see the content of the auxiliary
2561 array passed up from the kernel. */
2562 if (!INTUSE(__libc_enable_secure)
2563 && memcmp (envline, "SHOW_AUXV", 9) == 0)
2564 _dl_show_auxv ();
2565 break;
2567 case 10:
2568 /* Mask for the important hardware capabilities. */
2569 if (memcmp (envline, "HWCAP_MASK", 10) == 0)
2570 GLRO(dl_hwcap_mask) = __strtoul_internal (&envline[11], NULL,
2571 0, 0);
2572 break;
2574 case 11:
2575 /* Path where the binary is found. */
2576 if (!INTUSE(__libc_enable_secure)
2577 && memcmp (envline, "ORIGIN_PATH", 11) == 0)
2578 GLRO(dl_origin_path) = &envline[12];
2579 break;
2581 case 12:
2582 /* The library search path. */
2583 if (memcmp (envline, "LIBRARY_PATH", 12) == 0)
2585 library_path = &envline[13];
2586 break;
2589 /* Where to place the profiling data file. */
2590 if (memcmp (envline, "DEBUG_OUTPUT", 12) == 0)
2592 debug_output = &envline[13];
2593 break;
2596 if (!INTUSE(__libc_enable_secure)
2597 && memcmp (envline, "DYNAMIC_WEAK", 12) == 0)
2598 GLRO(dl_dynamic_weak) = 1;
2599 break;
2601 case 13:
2602 /* We might have some extra environment variable with length 13
2603 to handle. */
2604 #ifdef EXTRA_LD_ENVVARS_13
2605 EXTRA_LD_ENVVARS_13
2606 #endif
2607 if (!INTUSE(__libc_enable_secure)
2608 && memcmp (envline, "USE_LOAD_BIAS", 13) == 0)
2610 GLRO(dl_use_load_bias) = envline[14] == '1' ? -1 : 0;
2611 break;
2614 if (memcmp (envline, "POINTER_GUARD", 13) == 0)
2615 GLRO(dl_pointer_guard) = envline[14] != '0';
2616 break;
2618 case 14:
2619 /* Where to place the profiling data file. */
2620 if (!INTUSE(__libc_enable_secure)
2621 && memcmp (envline, "PROFILE_OUTPUT", 14) == 0
2622 && envline[15] != '\0')
2623 GLRO(dl_profile_output) = &envline[15];
2624 break;
2626 case 16:
2627 /* The mode of the dynamic linker can be set. */
2628 if (memcmp (envline, "TRACE_PRELINKING", 16) == 0)
2630 mode = trace;
2631 GLRO(dl_verbose) = 1;
2632 GLRO(dl_debug_mask) |= DL_DEBUG_PRELINK;
2633 GLRO(dl_trace_prelink) = &envline[17];
2635 break;
2637 case 20:
2638 /* The mode of the dynamic linker can be set. */
2639 if (memcmp (envline, "TRACE_LOADED_OBJECTS", 20) == 0)
2640 mode = trace;
2641 break;
2643 /* We might have some extra environment variable to handle. This
2644 is tricky due to the pre-processing of the length of the name
2645 in the switch statement here. The code here assumes that added
2646 environment variables have a different length. */
2647 #ifdef EXTRA_LD_ENVVARS
2648 EXTRA_LD_ENVVARS
2649 #endif
2653 /* The caller wants this information. */
2654 *modep = mode;
2656 /* Extra security for SUID binaries. Remove all dangerous environment
2657 variables. */
2658 if (__builtin_expect (INTUSE(__libc_enable_secure), 0))
2660 static const char unsecure_envvars[] =
2661 #ifdef EXTRA_UNSECURE_ENVVARS
2662 EXTRA_UNSECURE_ENVVARS
2663 #endif
2664 UNSECURE_ENVVARS;
2665 const char *nextp;
2667 nextp = unsecure_envvars;
2670 unsetenv (nextp);
2671 /* We could use rawmemchr but this need not be fast. */
2672 nextp = (char *) (strchr) (nextp, '\0') + 1;
2674 while (*nextp != '\0');
2676 if (__access ("/etc/suid-debug", F_OK) != 0)
2678 unsetenv ("MALLOC_CHECK_");
2679 GLRO(dl_debug_mask) = 0;
2682 if (mode != normal)
2683 _exit (5);
2685 /* If we have to run the dynamic linker in debugging mode and the
2686 LD_DEBUG_OUTPUT environment variable is given, we write the debug
2687 messages to this file. */
2688 else if (any_debug && debug_output != NULL)
2690 #ifdef O_NOFOLLOW
2691 const int flags = O_WRONLY | O_APPEND | O_CREAT | O_NOFOLLOW;
2692 #else
2693 const int flags = O_WRONLY | O_APPEND | O_CREAT;
2694 #endif
2695 size_t name_len = strlen (debug_output);
2696 char buf[name_len + 12];
2697 char *startp;
2699 buf[name_len + 11] = '\0';
2700 startp = _itoa (__getpid (), &buf[name_len + 11], 10, 0);
2701 *--startp = '.';
2702 startp = memcpy (startp - name_len, debug_output, name_len);
2704 GLRO(dl_debug_fd) = __open (startp, flags, DEFFILEMODE);
2705 if (GLRO(dl_debug_fd) == -1)
2706 /* We use standard output if opening the file failed. */
2707 GLRO(dl_debug_fd) = STDOUT_FILENO;
2712 /* Print the various times we collected. */
2713 static void
2714 __attribute ((noinline))
2715 print_statistics (hp_timing_t *rtld_total_timep)
2717 #ifndef HP_TIMING_NONAVAIL
2718 char buf[200];
2719 char *cp;
2720 char *wp;
2722 /* Total time rtld used. */
2723 if (HP_TIMING_AVAIL)
2725 HP_TIMING_PRINT (buf, sizeof (buf), *rtld_total_timep);
2726 _dl_debug_printf ("\nruntime linker statistics:\n"
2727 " total startup time in dynamic loader: %s\n", buf);
2729 /* Print relocation statistics. */
2730 char pbuf[30];
2731 HP_TIMING_PRINT (buf, sizeof (buf), relocate_time);
2732 cp = _itoa ((1000ULL * relocate_time) / *rtld_total_timep,
2733 pbuf + sizeof (pbuf), 10, 0);
2734 wp = pbuf;
2735 switch (pbuf + sizeof (pbuf) - cp)
2737 case 3:
2738 *wp++ = *cp++;
2739 case 2:
2740 *wp++ = *cp++;
2741 case 1:
2742 *wp++ = '.';
2743 *wp++ = *cp++;
2745 *wp = '\0';
2746 _dl_debug_printf ("\
2747 time needed for relocation: %s (%s%%)\n", buf, pbuf);
2749 #endif
2751 unsigned long int num_relative_relocations = 0;
2752 for (Lmid_t ns = 0; ns < GL(dl_nns); ++ns)
2754 if (GL(dl_ns)[ns]._ns_loaded == NULL)
2755 continue;
2757 struct r_scope_elem *scope = &GL(dl_ns)[ns]._ns_loaded->l_searchlist;
2759 for (unsigned int i = 0; i < scope->r_nlist; i++)
2761 struct link_map *l = scope->r_list [i];
2763 if (l->l_addr != 0 && l->l_info[VERSYMIDX (DT_RELCOUNT)])
2764 num_relative_relocations
2765 += l->l_info[VERSYMIDX (DT_RELCOUNT)]->d_un.d_val;
2766 #ifndef ELF_MACHINE_REL_RELATIVE
2767 /* Relative relocations are processed on these architectures if
2768 library is loaded to different address than p_vaddr or
2769 if not prelinked. */
2770 if ((l->l_addr != 0 || !l->l_info[VALIDX(DT_GNU_PRELINKED)])
2771 && l->l_info[VERSYMIDX (DT_RELACOUNT)])
2772 #else
2773 /* On e.g. IA-64 or Alpha, relative relocations are processed
2774 only if library is loaded to different address than p_vaddr. */
2775 if (l->l_addr != 0 && l->l_info[VERSYMIDX (DT_RELACOUNT)])
2776 #endif
2777 num_relative_relocations
2778 += l->l_info[VERSYMIDX (DT_RELACOUNT)]->d_un.d_val;
2782 _dl_debug_printf (" number of relocations: %lu\n"
2783 " number of relocations from cache: %lu\n"
2784 " number of relative relocations: %lu\n",
2785 GL(dl_num_relocations),
2786 GL(dl_num_cache_relocations),
2787 num_relative_relocations);
2789 #ifndef HP_TIMING_NONAVAIL
2790 /* Time spend while loading the object and the dependencies. */
2791 if (HP_TIMING_AVAIL)
2793 char pbuf[30];
2794 HP_TIMING_PRINT (buf, sizeof (buf), load_time);
2795 cp = _itoa ((1000ULL * load_time) / *rtld_total_timep,
2796 pbuf + sizeof (pbuf), 10, 0);
2797 wp = pbuf;
2798 switch (pbuf + sizeof (pbuf) - cp)
2800 case 3:
2801 *wp++ = *cp++;
2802 case 2:
2803 *wp++ = *cp++;
2804 case 1:
2805 *wp++ = '.';
2806 *wp++ = *cp++;
2808 *wp = '\0';
2809 _dl_debug_printf ("\
2810 time needed to load objects: %s (%s%%)\n",
2811 buf, pbuf);
2813 #endif