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