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