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