af7b27fe24a58e027a66851459d9a916dde85b8e
[kopensolaris-gnu/glibc.git] / elf / rtld.c
1 /* Run time dynamic linker.
2    Copyright (C) 1995-1999, 2000, 2001, 2002 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 <fcntl.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <unistd.h>
24 #include <sys/mman.h>           /* Check if MAP_ANON is defined.  */
25 #include <sys/param.h>
26 #include <sys/stat.h>
27 #include <ldsodefs.h>
28 #include <stdio-common/_itoa.h>
29 #include <entry.h>
30 #include <fpu_control.h>
31 #include <hp-timing.h>
32 #include <bits/libc-lock.h>
33 #include "dynamic-link.h"
34 #include "dl-librecon.h"
35 #include <unsecvars.h>
36 #include <dl-cache.h>
37 #include <dl-procinfo.h>
38
39 #include <assert.h>
40
41 /* Helper function to handle errors while resolving symbols.  */
42 static void print_unresolved (int errcode, const char *objname,
43                               const char *errsting);
44
45 /* Helper function to handle errors when a version is missing.  */
46 static void print_missing_version (int errcode, const char *objname,
47                                    const char *errsting);
48
49 /* Print the various times we collected.  */
50 static void print_statistics (void);
51
52 /* This is a list of all the modes the dynamic loader can be in.  */
53 enum mode { normal, list, verify, trace };
54
55 /* Process all environments variables the dynamic linker must recognize.
56    Since all of them start with `LD_' we are a bit smarter while finding
57    all the entries.  */
58 static void process_envvars (enum mode *modep);
59
60 int _dl_argc;
61 char **_dl_argv;
62 unsigned int _dl_skip_args;     /* Nonzero if we were run directly.  */
63
64 /* Set nonzero during loading and initialization of executable and
65    libraries, cleared before the executable's entry point runs.  This
66    must not be initialized to nonzero, because the unused dynamic
67    linker loaded in for libc.so's "ld.so.1" dep will provide the
68    definition seen by libc.so's initializer; that value must be zero,
69    and will be since that dynamic linker's _dl_start and dl_main will
70    never be called.  */
71 int _dl_starting_up;
72
73 /* This is the structure which defines all variables global to ld.so
74    (except those which cannot be added for some reason).  */
75 struct rtld_global _rtld_global =
76   {
77     /* Get architecture specific initializer.  */
78 #include <dl-procinfo.c>
79     ._dl_debug_fd = STDERR_FILENO,
80 #if 1
81     /* XXX I know about at least one case where we depend on the old
82        weak behavior (it has to do with librt).  Until we get DSO
83        groups implemented we have to make this the default.
84        Bummer. --drepper  */
85     ._dl_dynamic_weak = 1,
86 #endif
87     ._dl_lazy = 1,
88     ._dl_fpu_control = _FPU_DEFAULT,
89     ._dl_correct_cache_id = _DL_CACHE_DEFAULT_ID,
90     ._dl_hwcap_mask = HWCAP_IMPORTANT,
91     ._dl_load_lock = _LIBC_LOCK_RECURSIVE_INITIALIZER
92   };
93 /* There must only be the definition in ld.so itself.  */
94 #ifdef HAVE_PROTECTED
95 asm (".protected _rtld_global");
96 #endif
97
98
99 static void dl_main (const ElfW(Phdr) *phdr,
100                      ElfW(Word) phnum,
101                      ElfW(Addr) *user_entry);
102
103 static struct libname_list _dl_rtld_libname;
104 static struct libname_list _dl_rtld_libname2;
105
106 /* We expect less than a second for relocation.  */
107 #ifdef HP_SMALL_TIMING_AVAIL
108 # undef HP_TIMING_AVAIL
109 # define HP_TIMING_AVAIL HP_SMALL_TIMING_AVAIL
110 #endif
111
112 /* Variable for statistics.  */
113 #ifndef HP_TIMING_NONAVAIL
114 static hp_timing_t rtld_total_time;
115 static hp_timing_t relocate_time;
116 static hp_timing_t load_time;
117 #endif
118
119 static ElfW(Addr) _dl_start_final (void *arg, struct link_map *bootstrap_map_p,
120                                    hp_timing_t start_time);
121
122 #ifdef RTLD_START
123 RTLD_START
124 #else
125 # error "sysdeps/MACHINE/dl-machine.h fails to define RTLD_START"
126 #endif
127
128 static ElfW(Addr) __attribute_used__
129 _dl_start (void *arg)
130 {
131   struct link_map bootstrap_map;
132   hp_timing_t start_time;
133 #if !__GNUC_PREREQ (2, 96)
134   size_t cnt;
135 #endif
136
137   /* This #define produces dynamic linking inline functions for
138      bootstrap relocation instead of general-purpose relocation.  */
139 #define RTLD_BOOTSTRAP
140 #define RESOLVE_MAP(sym, version, flags) \
141   ((*(sym))->st_shndx == SHN_UNDEF ? 0 : &bootstrap_map)
142 #define RESOLVE(sym, version, flags) \
143   ((*(sym))->st_shndx == SHN_UNDEF ? 0 : bootstrap_map.l_addr)
144 #include "dynamic-link.h"
145
146   if (HP_TIMING_INLINE && HP_TIMING_AVAIL)
147     HP_TIMING_NOW (start_time);
148
149   /* Partly clean the `bootstrap_map' structure up.  Don't use
150      `memset' since it might not be built in or inlined and we cannot
151      make function calls at this point.  Use '__builtin_memset' if we
152      know it is available.  */
153 #if __GNUC_PREREQ (2, 96)
154   __builtin_memset (bootstrap_map.l_info, '\0', sizeof (bootstrap_map.l_info));
155 #else
156   for (cnt = 0;
157        cnt < sizeof (bootstrap_map.l_info) / sizeof (bootstrap_map.l_info[0]);
158        ++cnt)
159     bootstrap_map.l_info[cnt] = 0;
160 #endif
161
162   /* Figure out the run-time load address of the dynamic linker itself.  */
163   bootstrap_map.l_addr = elf_machine_load_address ();
164
165   /* Read our own dynamic section and fill in the info array.  */
166   bootstrap_map.l_ld = (void *) bootstrap_map.l_addr + elf_machine_dynamic ();
167   elf_get_dynamic_info (&bootstrap_map);
168
169 #ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
170   ELF_MACHINE_BEFORE_RTLD_RELOC (bootstrap_map.l_info);
171 #endif
172
173   if (bootstrap_map.l_addr || ! bootstrap_map.l_info[VALIDX(DT_GNU_PRELINKED)])
174     {
175       /* Relocate ourselves so we can do normal function calls and
176          data access using the global offset table.  */
177
178       ELF_DYNAMIC_RELOCATE (&bootstrap_map, 0, 0);
179     }
180
181   /* Please note that we don't allow profiling of this object and
182      therefore need not test whether we have to allocate the array
183      for the relocation results (as done in dl-reloc.c).  */
184
185   /* Now life is sane; we can call functions and access global data.
186      Set up to use the operating system facilities, and find out from
187      the operating system's program loader where to find the program
188      header table in core.  Put the rest of _dl_start into a separate
189      function, that way the compiler cannot put accesses to the GOT
190      before ELF_DYNAMIC_RELOCATE.  */
191   {
192     ElfW(Addr) entry = _dl_start_final (arg, &bootstrap_map, start_time);
193
194 #ifndef ELF_MACHINE_START_ADDRESS
195 # define ELF_MACHINE_START_ADDRESS(map, start) (start)
196 #endif
197
198     return ELF_MACHINE_START_ADDRESS (GL(dl_loaded), entry);
199   }
200 }
201
202
203 #ifndef VALIDX
204 # define VALIDX(tag) (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM \
205                       + DT_EXTRANUM + DT_VALTAGIDX (tag))
206 #endif
207 #ifndef ADDRIDX
208 # define ADDRIDX(tag) (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM \
209                        + DT_EXTRANUM + DT_VALNUM + DT_ADDRTAGIDX (tag))
210 #endif
211
212 static ElfW(Addr)
213 _dl_start_final (void *arg, struct link_map *bootstrap_map_p,
214                  hp_timing_t start_time)
215 {
216   /* The use of `alloca' here looks ridiculous but it helps.  The goal
217      is to avoid the function from being inlined.  There is no official
218      way to do this so we use this trick.  gcc never inlines functions
219      which use `alloca'.  */
220   ElfW(Addr) *start_addr = alloca (sizeof (ElfW(Addr)));
221   extern char _begin[], _end[];
222
223   if (HP_TIMING_AVAIL)
224     {
225       /* If it hasn't happen yet record the startup time.  */
226       if (! HP_TIMING_INLINE)
227         HP_TIMING_NOW (start_time);
228
229       /* Initialize the timing functions.  */
230       HP_TIMING_DIFF_INIT ();
231     }
232
233   /* Transfer data about ourselves to the permanent link_map structure.  */
234   GL(dl_rtld_map).l_addr = bootstrap_map_p->l_addr;
235   GL(dl_rtld_map).l_ld = bootstrap_map_p->l_ld;
236   GL(dl_rtld_map).l_opencount = 1;
237   memcpy (GL(dl_rtld_map).l_info, bootstrap_map_p->l_info,
238           sizeof GL(dl_rtld_map).l_info);
239   _dl_setup_hash (&GL(dl_rtld_map));
240   GL(dl_rtld_map).l_mach = bootstrap_map_p->l_mach;
241   GL(dl_rtld_map).l_map_start = (ElfW(Addr)) _begin;
242   GL(dl_rtld_map).l_map_end = (ElfW(Addr)) _end;
243
244   /* Call the OS-dependent function to set up life so we can do things like
245      file access.  It will call `dl_main' (below) to do all the real work
246      of the dynamic linker, and then unwind our frame and run the user
247      entry point on the same stack we entered on.  */
248   *start_addr =  _dl_sysdep_start (arg, &dl_main);
249 #ifndef HP_TIMING_NONAVAIL
250   if (HP_TIMING_AVAIL)
251     {
252       hp_timing_t end_time;
253
254       /* Get the current time.  */
255       HP_TIMING_NOW (end_time);
256
257       /* Compute the difference.  */
258       HP_TIMING_DIFF (rtld_total_time, start_time, end_time);
259     }
260 #endif
261
262   if (__builtin_expect (GL(dl_debug_mask) & DL_DEBUG_STATISTICS, 0))
263     print_statistics ();
264
265   return *start_addr;
266 }
267
268 /* Now life is peachy; we can do all normal operations.
269    On to the real work.  */
270
271 /* Some helper functions.  */
272
273 /* Arguments to relocate_doit.  */
274 struct relocate_args
275 {
276   struct link_map *l;
277   int lazy;
278 };
279
280 struct map_args
281 {
282   /* Argument to map_doit.  */
283   char *str;
284   /* Return value of map_doit.  */
285   struct link_map *main_map;
286 };
287
288 /* Arguments to version_check_doit.  */
289 struct version_check_args
290 {
291   int doexit;
292   int dotrace;
293 };
294
295 static void
296 relocate_doit (void *a)
297 {
298   struct relocate_args *args = (struct relocate_args *) a;
299
300   _dl_relocate_object (args->l, args->l->l_scope,
301                        args->lazy, 0);
302 }
303
304 static void
305 map_doit (void *a)
306 {
307   struct map_args *args = (struct map_args *) a;
308   args->main_map = _dl_map_object (NULL, args->str, 0, lt_library, 0, 0);
309 }
310
311 static void
312 version_check_doit (void *a)
313 {
314   struct version_check_args *args = (struct version_check_args *) a;
315   if (_dl_check_all_versions (GL(dl_loaded), 1, args->dotrace) && args->doexit)
316     /* We cannot start the application.  Abort now.  */
317     _exit (1);
318 }
319
320
321 static inline struct link_map *
322 find_needed (const char *name)
323 {
324   unsigned int n = GL(dl_loaded)->l_searchlist.r_nlist;
325
326   while (n-- > 0)
327     if (_dl_name_match_p (name, GL(dl_loaded)->l_searchlist.r_list[n]))
328       return GL(dl_loaded)->l_searchlist.r_list[n];
329
330   /* Should never happen.  */
331   return NULL;
332 }
333
334 static int
335 match_version (const char *string, struct link_map *map)
336 {
337   const char *strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
338   ElfW(Verdef) *def;
339
340 #define VERDEFTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERDEF))
341   if (map->l_info[VERDEFTAG] == NULL)
342     /* The file has no symbol versioning.  */
343     return 0;
344
345   def = (ElfW(Verdef) *) ((char *) map->l_addr
346                           + map->l_info[VERDEFTAG]->d_un.d_ptr);
347   while (1)
348     {
349       ElfW(Verdaux) *aux = (ElfW(Verdaux) *) ((char *) def + def->vd_aux);
350
351       /* Compare the version strings.  */
352       if (strcmp (string, strtab + aux->vda_name) == 0)
353         /* Bingo!  */
354         return 1;
355
356       /* If no more definitions we failed to find what we want.  */
357       if (def->vd_next == 0)
358         break;
359
360       /* Next definition.  */
361       def = (ElfW(Verdef) *) ((char *) def + def->vd_next);
362     }
363
364   return 0;
365 }
366
367 static const char *library_path;        /* The library search path.  */
368 static const char *preloadlist;         /* The list preloaded objects.  */
369 static int version_info;                /* Nonzero if information about
370                                            versions has to be printed.  */
371
372 static void
373 dl_main (const ElfW(Phdr) *phdr,
374          ElfW(Word) phnum,
375          ElfW(Addr) *user_entry)
376 {
377   const ElfW(Phdr) *ph;
378   enum mode mode;
379   struct link_map **preloads;
380   unsigned int npreloads;
381   size_t file_size;
382   char *file;
383   int has_interp = 0;
384   unsigned int i;
385   int prelinked = 0;
386   int rtld_is_main = 0;
387 #ifndef HP_TIMING_NONAVAIL
388   hp_timing_t start;
389   hp_timing_t stop;
390   hp_timing_t diff;
391 #endif
392
393   /* Process the environment variable which control the behaviour.  */
394   process_envvars (&mode);
395
396   /* Set up a flag which tells we are just starting.  */
397   _dl_starting_up = 1;
398
399   if (*user_entry == (ElfW(Addr)) ENTRY_POINT)
400     {
401       /* Ho ho.  We are not the program interpreter!  We are the program
402          itself!  This means someone ran ld.so as a command.  Well, that
403          might be convenient to do sometimes.  We support it by
404          interpreting the args like this:
405
406          ld.so PROGRAM ARGS...
407
408          The first argument is the name of a file containing an ELF
409          executable we will load and run with the following arguments.
410          To simplify life here, PROGRAM is searched for using the
411          normal rules for shared objects, rather than $PATH or anything
412          like that.  We just load it and use its entry point; we don't
413          pay attention to its PT_INTERP command (we are the interpreter
414          ourselves).  This is an easy way to test a new ld.so before
415          installing it.  */
416       rtld_is_main = 1;
417
418       /* Note the place where the dynamic linker actually came from.  */
419       GL(dl_rtld_map).l_name = _dl_argv[0];
420
421       while (_dl_argc > 1)
422         if (! strcmp (_dl_argv[1], "--list"))
423           {
424             mode = list;
425             GL(dl_lazy) = -1;   /* This means do no dependency analysis.  */
426
427             ++_dl_skip_args;
428             --_dl_argc;
429             ++_dl_argv;
430           }
431         else if (! strcmp (_dl_argv[1], "--verify"))
432           {
433             mode = verify;
434
435             ++_dl_skip_args;
436             --_dl_argc;
437             ++_dl_argv;
438           }
439         else if (! strcmp (_dl_argv[1], "--library-path") && _dl_argc > 2)
440           {
441             library_path = _dl_argv[2];
442
443             _dl_skip_args += 2;
444             _dl_argc -= 2;
445             _dl_argv += 2;
446           }
447         else if (! strcmp (_dl_argv[1], "--inhibit-rpath") && _dl_argc > 2)
448           {
449             GL(dl_inhibit_rpath) = _dl_argv[2];
450
451             _dl_skip_args += 2;
452             _dl_argc -= 2;
453             _dl_argv += 2;
454           }
455         else
456           break;
457
458       /* If we have no further argument the program was called incorrectly.
459          Grant the user some education.  */
460       if (_dl_argc < 2)
461         _dl_fatal_printf ("\
462 Usage: ld.so [OPTION]... EXECUTABLE-FILE [ARGS-FOR-PROGRAM...]\n\
463 You have invoked `ld.so', the helper program for shared library executables.\n\
464 This program usually lives in the file `/lib/ld.so', and special directives\n\
465 in executable files using ELF shared libraries tell the system's program\n\
466 loader to load the helper program from this file.  This helper program loads\n\
467 the shared libraries needed by the program executable, prepares the program\n\
468 to run, and runs it.  You may invoke this helper program directly from the\n\
469 command line to load and run an ELF executable file; this is like executing\n\
470 that file itself, but always uses this helper program from the file you\n\
471 specified, instead of the helper program file specified in the executable\n\
472 file you run.  This is mostly of use for maintainers to test new versions\n\
473 of this helper program; chances are you did not intend to run this program.\n\
474 \n\
475   --list                list all dependencies and how they are resolved\n\
476   --verify              verify that given object really is a dynamically linked\n\
477                         object we can handle\n\
478   --library-path PATH   use given PATH instead of content of the environment\n\
479                         variable LD_LIBRARY_PATH\n\
480   --inhibit-rpath LIST  ignore RUNPATH and RPATH information in object names\n\
481                         in LIST\n");
482
483       ++_dl_skip_args;
484       --_dl_argc;
485       ++_dl_argv;
486
487       /* Initialize the data structures for the search paths for shared
488          objects.  */
489       _dl_init_paths (library_path);
490
491       if (__builtin_expect (mode, normal) == verify)
492         {
493           const char *objname;
494           const char *err_str = NULL;
495           struct map_args args;
496
497           args.str = _dl_argv[0];
498           (void) _dl_catch_error (&objname, &err_str, map_doit, &args);
499           if (__builtin_expect (err_str != NULL, 0))
500             {
501               if (err_str != _dl_out_of_memory)
502                 free ((char *) err_str);
503               _exit (EXIT_FAILURE);
504             }
505         }
506       else
507         {
508           HP_TIMING_NOW (start);
509           _dl_map_object (NULL, _dl_argv[0], 0, lt_library, 0, 0);
510           HP_TIMING_NOW (stop);
511
512           HP_TIMING_DIFF (load_time, start, stop);
513         }
514
515       phdr = GL(dl_loaded)->l_phdr;
516       phnum = GL(dl_loaded)->l_phnum;
517       /* We overwrite here a pointer to a malloc()ed string.  But since
518          the malloc() implementation used at this point is the dummy
519          implementations which has no real free() function it does not
520          makes sense to free the old string first.  */
521       GL(dl_loaded)->l_name = (char *) "";
522       *user_entry = GL(dl_loaded)->l_entry;
523     }
524   else
525     {
526       /* Create a link_map for the executable itself.
527          This will be what dlopen on "" returns.  */
528       _dl_new_object ((char *) "", "", lt_executable, NULL);
529       if (GL(dl_loaded) == NULL)
530         _dl_fatal_printf ("cannot allocate memory for link map\n");
531       GL(dl_loaded)->l_phdr = phdr;
532       GL(dl_loaded)->l_phnum = phnum;
533       GL(dl_loaded)->l_entry = *user_entry;
534
535       /* At this point we are in a bit of trouble.  We would have to
536          fill in the values for l_dev and l_ino.  But in general we
537          do not know where the file is.  We also do not handle AT_EXECFD
538          even if it would be passed up.
539
540          We leave the values here defined to 0.  This is normally no
541          problem as the program code itself is normally no shared
542          object and therefore cannot be loaded dynamically.  Nothing
543          prevent the use of dynamic binaries and in these situations
544          we might get problems.  We might not be able to find out
545          whether the object is already loaded.  But since there is no
546          easy way out and because the dynamic binary must also not
547          have an SONAME we ignore this program for now.  If it becomes
548          a problem we can force people using SONAMEs.  */
549
550       /* We delay initializing the path structure until we got the dynamic
551          information for the program.  */
552     }
553
554   GL(dl_loaded)->l_map_end = 0;
555   /* Perhaps the executable has no PT_LOAD header entries at all.  */
556   GL(dl_loaded)->l_map_start = ~0;
557   /* We opened the file, account for it.  */
558   ++GL(dl_loaded)->l_opencount;
559
560   /* Scan the program header table for the dynamic section.  */
561   for (ph = phdr; ph < &phdr[phnum]; ++ph)
562     switch (ph->p_type)
563       {
564       case PT_PHDR:
565         /* Find out the load address.  */
566         GL(dl_loaded)->l_addr = (ElfW(Addr)) phdr - ph->p_vaddr;
567         break;
568       case PT_DYNAMIC:
569         /* This tells us where to find the dynamic section,
570            which tells us everything we need to do.  */
571         GL(dl_loaded)->l_ld = (void *) GL(dl_loaded)->l_addr + ph->p_vaddr;
572         break;
573       case PT_INTERP:
574         /* This "interpreter segment" was used by the program loader to
575            find the program interpreter, which is this program itself, the
576            dynamic linker.  We note what name finds us, so that a future
577            dlopen call or DT_NEEDED entry, for something that wants to link
578            against the dynamic linker as a shared library, will know that
579            the shared object is already loaded.  */
580         _dl_rtld_libname.name = ((const char *) GL(dl_loaded)->l_addr
581                                  + ph->p_vaddr);
582         /* _dl_rtld_libname.next = NULL;        Already zero.  */
583         GL(dl_rtld_map).l_libname = &_dl_rtld_libname;
584
585         /* Ordinarilly, we would get additional names for the loader from
586            our DT_SONAME.  This can't happen if we were actually linked as
587            a static executable (detect this case when we have no DYNAMIC).
588            If so, assume the filename component of the interpreter path to
589            be our SONAME, and add it to our name list.  */
590         if (GL(dl_rtld_map).l_ld == NULL)
591           {
592             char *p = strrchr (_dl_rtld_libname.name, '/');
593             if (p)
594               {
595                 _dl_rtld_libname2.name = p+1;
596                 /* _dl_rtld_libname2.next = NULL;  Already zero.  */
597                 _dl_rtld_libname.next = &_dl_rtld_libname2;
598               }
599           }
600
601         has_interp = 1;
602         break;
603       case PT_LOAD:
604         {
605           ElfW(Addr) mapstart;
606           ElfW(Addr) allocend;
607
608           /* Remember where the main program starts in memory.  */
609           mapstart = (GL(dl_loaded)->l_addr
610                       + (ph->p_vaddr & ~(ph->p_align - 1)));
611           if (GL(dl_loaded)->l_map_start > mapstart)
612             GL(dl_loaded)->l_map_start = mapstart;
613
614           /* Also where it ends.  */
615           allocend = GL(dl_loaded)->l_addr + ph->p_vaddr + ph->p_memsz;
616           if (GL(dl_loaded)->l_map_end < allocend)
617             GL(dl_loaded)->l_map_end = allocend;
618         }
619         break;
620       }
621   if (! GL(dl_loaded)->l_map_end)
622     GL(dl_loaded)->l_map_end = ~0;
623   if (! GL(dl_rtld_map).l_libname && GL(dl_rtld_map).l_name)
624     {
625       /* We were invoked directly, so the program might not have a
626          PT_INTERP.  */
627       _dl_rtld_libname.name = GL(dl_rtld_map).l_name;
628       /* _dl_rtld_libname.next = NULL;  Alread zero.  */
629       GL(dl_rtld_map).l_libname =  &_dl_rtld_libname;
630     }
631   else
632     assert (GL(dl_rtld_map).l_libname); /* How else did we get here?  */
633
634   if (! rtld_is_main)
635     {
636       /* Extract the contents of the dynamic section for easy access.  */
637       elf_get_dynamic_info (GL(dl_loaded));
638       if (GL(dl_loaded)->l_info[DT_HASH])
639         /* Set up our cache of pointers into the hash table.  */
640         _dl_setup_hash (GL(dl_loaded));
641     }
642
643   if (__builtin_expect (mode, normal) == verify)
644     {
645       /* We were called just to verify that this is a dynamic
646          executable using us as the program interpreter.  Exit with an
647          error if we were not able to load the binary or no interpreter
648          is specified (i.e., this is no dynamically linked binary.  */
649       if (GL(dl_loaded)->l_ld == NULL)
650         _exit (1);
651
652       /* We allow here some platform specific code.  */
653 #ifdef DISTINGUISH_LIB_VERSIONS
654       DISTINGUISH_LIB_VERSIONS;
655 #endif
656       _exit (has_interp ? 0 : 2);
657     }
658
659   if (! rtld_is_main)
660     /* Initialize the data structures for the search paths for shared
661        objects.  */
662     _dl_init_paths (library_path);
663
664   /* Put the link_map for ourselves on the chain so it can be found by
665      name.  Note that at this point the global chain of link maps contains
666      exactly one element, which is pointed to by dl_loaded.  */
667   if (! GL(dl_rtld_map).l_name)
668     /* If not invoked directly, the dynamic linker shared object file was
669        found by the PT_INTERP name.  */
670     GL(dl_rtld_map).l_name = (char *) GL(dl_rtld_map).l_libname->name;
671   GL(dl_rtld_map).l_type = lt_library;
672   GL(dl_loaded)->l_next = &GL(dl_rtld_map);
673   GL(dl_rtld_map).l_prev = GL(dl_loaded);
674   ++GL(dl_nloaded);
675
676   /* We have two ways to specify objects to preload: via environment
677      variable and via the file /etc/ld.so.preload.  The latter can also
678      be used when security is enabled.  */
679   preloads = NULL;
680   npreloads = 0;
681
682   if (__builtin_expect (preloadlist != NULL, 0))
683     {
684       /* The LD_PRELOAD environment variable gives list of libraries
685          separated by white space or colons that are loaded before the
686          executable's dependencies and prepended to the global scope
687          list.  If the binary is running setuid all elements
688          containing a '/' are ignored since it is insecure.  */
689       char *list = strdupa (preloadlist);
690       char *p;
691
692       HP_TIMING_NOW (start);
693
694       while ((p = strsep (&list, " :")) != NULL)
695         if (p[0] != '\0'
696             && (__builtin_expect (! __libc_enable_secure, 1)
697                 || strchr (p, '/') == NULL))
698           {
699             struct link_map *new_map = _dl_map_object (GL(dl_loaded), p, 1,
700                                                        lt_library, 0, 0);
701             if (++new_map->l_opencount == 1)
702               /* It is no duplicate.  */
703               ++npreloads;
704           }
705
706       HP_TIMING_NOW (stop);
707       HP_TIMING_DIFF (diff, start, stop);
708       HP_TIMING_ACCUM_NT (load_time, diff);
709     }
710
711   /* Read the contents of the file.  */
712   file = _dl_sysdep_read_whole_file ("/etc/ld.so.preload", &file_size,
713                                      PROT_READ | PROT_WRITE);
714   if (__builtin_expect (file != MAP_FAILED, 0))
715     {
716       /* Parse the file.  It contains names of libraries to be loaded,
717          separated by white spaces or `:'.  It may also contain
718          comments introduced by `#'.  */
719       char *problem;
720       char *runp;
721       size_t rest;
722
723       /* Eliminate comments.  */
724       runp = file;
725       rest = file_size;
726       while (rest > 0)
727         {
728           char *comment = memchr (runp, '#', rest);
729           if (comment == NULL)
730             break;
731
732           rest -= comment - runp;
733           do
734             *comment = ' ';
735           while (--rest > 0 && *++comment != '\n');
736         }
737
738       /* We have one problematic case: if we have a name at the end of
739          the file without a trailing terminating characters, we cannot
740          place the \0.  Handle the case separately.  */
741       if (file[file_size - 1] != ' ' && file[file_size - 1] != '\t'
742           && file[file_size - 1] != '\n' && file[file_size - 1] != ':')
743         {
744           problem = &file[file_size];
745           while (problem > file && problem[-1] != ' ' && problem[-1] != '\t'
746                  && problem[-1] != '\n' && problem[-1] != ':')
747             --problem;
748
749           if (problem > file)
750             problem[-1] = '\0';
751         }
752       else
753         {
754           problem = NULL;
755           file[file_size - 1] = '\0';
756         }
757
758       HP_TIMING_NOW (start);
759
760       if (file != problem)
761         {
762           char *p;
763           runp = file;
764           while ((p = strsep (&runp, ": \t\n")) != NULL)
765             if (p[0] != '\0')
766               {
767                 struct link_map *new_map = _dl_map_object (GL(dl_loaded), p, 1,
768                                                            lt_library, 0, 0);
769                 if (++new_map->l_opencount == 1)
770                   /* It is no duplicate.  */
771                   ++npreloads;
772               }
773         }
774
775       if (problem != NULL)
776         {
777           char *p = strndupa (problem, file_size - (problem - file));
778           struct link_map *new_map = _dl_map_object (GL(dl_loaded), p, 1,
779                                                      lt_library, 0, 0);
780           if (++new_map->l_opencount == 1)
781             /* It is no duplicate.  */
782             ++npreloads;
783         }
784
785       HP_TIMING_NOW (stop);
786       HP_TIMING_DIFF (diff, start, stop);
787       HP_TIMING_ACCUM_NT (load_time, diff);
788
789       /* We don't need the file anymore.  */
790       __munmap (file, file_size);
791     }
792
793   if (__builtin_expect (npreloads, 0) != 0)
794     {
795       /* Set up PRELOADS with a vector of the preloaded libraries.  */
796       struct link_map *l;
797       preloads = __alloca (npreloads * sizeof preloads[0]);
798       l = GL(dl_rtld_map).l_next; /* End of the chain before preloads.  */
799       i = 0;
800       do
801         {
802           preloads[i++] = l;
803           l = l->l_next;
804         } while (l);
805       assert (i == npreloads);
806     }
807
808   /* Load all the libraries specified by DT_NEEDED entries.  If LD_PRELOAD
809      specified some libraries to load, these are inserted before the actual
810      dependencies in the executable's searchlist for symbol resolution.  */
811   HP_TIMING_NOW (start);
812   _dl_map_object_deps (GL(dl_loaded), preloads, npreloads, mode == trace);
813   HP_TIMING_NOW (stop);
814   HP_TIMING_DIFF (diff, start, stop);
815   HP_TIMING_ACCUM_NT (load_time, diff);
816
817   /* Mark all objects as being in the global scope and set the open
818      counter.  */
819   for (i = GL(dl_loaded)->l_searchlist.r_nlist; i > 0; )
820     {
821       --i;
822       GL(dl_loaded)->l_searchlist.r_list[i]->l_global = 1;
823       ++GL(dl_loaded)->l_searchlist.r_list[i]->l_opencount;
824     }
825
826 #ifndef MAP_ANON
827   /* We are done mapping things, so close the zero-fill descriptor.  */
828   __close (_dl_zerofd);
829   _dl_zerofd = -1;
830 #endif
831
832   /* Remove _dl_rtld_map from the chain.  */
833   GL(dl_rtld_map).l_prev->l_next = GL(dl_rtld_map).l_next;
834   if (GL(dl_rtld_map).l_next)
835     GL(dl_rtld_map).l_next->l_prev = GL(dl_rtld_map).l_prev;
836
837   if (__builtin_expect (GL(dl_rtld_map).l_opencount > 1, 1))
838     {
839       /* Some DT_NEEDED entry referred to the interpreter object itself, so
840          put it back in the list of visible objects.  We insert it into the
841          chain in symbol search order because gdb uses the chain's order as
842          its symbol search order.  */
843       i = 1;
844       while (GL(dl_loaded)->l_searchlist.r_list[i] != &GL(dl_rtld_map))
845         ++i;
846       GL(dl_rtld_map).l_prev = GL(dl_loaded)->l_searchlist.r_list[i - 1];
847       if (__builtin_expect (mode, normal) == normal)
848         GL(dl_rtld_map).l_next = (i + 1 < GL(dl_loaded)->l_searchlist.r_nlist
849                                   ? GL(dl_loaded)->l_searchlist.r_list[i + 1]
850                                   : NULL);
851       else
852         /* In trace mode there might be an invisible object (which we
853            could not find) after the previous one in the search list.
854            In this case it doesn't matter much where we put the
855            interpreter object, so we just initialize the list pointer so
856            that the assertion below holds.  */
857         GL(dl_rtld_map).l_next = GL(dl_rtld_map).l_prev->l_next;
858
859       assert (GL(dl_rtld_map).l_prev->l_next == GL(dl_rtld_map).l_next);
860       GL(dl_rtld_map).l_prev->l_next = &GL(dl_rtld_map);
861       if (GL(dl_rtld_map).l_next)
862         {
863           assert (GL(dl_rtld_map).l_next->l_prev == GL(dl_rtld_map).l_prev);
864           GL(dl_rtld_map).l_next->l_prev = &GL(dl_rtld_map);
865         }
866     }
867
868   /* Now let us see whether all libraries are available in the
869      versions we need.  */
870   {
871     struct version_check_args args;
872     args.doexit = mode == normal;
873     args.dotrace = mode == trace;
874     _dl_receive_error (print_missing_version, version_check_doit, &args);
875   }
876
877   if (__builtin_expect (mode, normal) != normal)
878     {
879       /* We were run just to list the shared libraries.  It is
880          important that we do this before real relocation, because the
881          functions we call below for output may no longer work properly
882          after relocation.  */
883       if (! GL(dl_loaded)->l_info[DT_NEEDED])
884         _dl_printf ("\tstatically linked\n");
885       else
886         {
887           struct link_map *l;
888
889           if (GL(dl_debug_mask) & DL_DEBUG_PRELINK)
890             {
891               struct r_scope_elem *scope = &GL(dl_loaded)->l_searchlist;
892
893               for (i = 0; i < scope->r_nlist; i++)
894                 {
895                   l = scope->r_list [i];
896                   if (l->l_faked)
897                     {
898                       _dl_printf ("\t%s => not found\n", l->l_libname->name);
899                       continue;
900                     }
901                   if (_dl_name_match_p (GL(dl_trace_prelink), l))
902                     GL(dl_trace_prelink_map) = l;
903                   _dl_printf ("\t%s => %s (0x%0*Zx, 0x%0*Zx)\n",
904                               l->l_libname->name[0] ? l->l_libname->name
905                               : _dl_argv[0] ?: "<main program>",
906                               l->l_name[0] ? l->l_name
907                               : _dl_argv[0] ?: "<main program>",
908                               (int) sizeof l->l_map_start * 2,
909                               l->l_map_start,
910                               (int) sizeof l->l_addr * 2,
911                               l->l_addr);
912                 }
913             }
914           else
915             {
916               for (l = GL(dl_loaded)->l_next; l; l = l->l_next)
917                 if (l->l_faked)
918                   /* The library was not found.  */
919                   _dl_printf ("\t%s => not found\n", l->l_libname->name);
920                 else
921                   _dl_printf ("\t%s => %s (0x%0*Zx)\n", l->l_libname->name,
922                               l->l_name, (int) sizeof l->l_map_start * 2,
923                               l->l_map_start);
924             }
925         }
926
927       if (__builtin_expect (mode, trace) != trace)
928         for (i = 1; i < _dl_argc; ++i)
929           {
930             const ElfW(Sym) *ref = NULL;
931             ElfW(Addr) loadbase;
932             lookup_t result;
933
934             result = _dl_lookup_symbol (_dl_argv[i], GL(dl_loaded),
935                                         &ref, GL(dl_loaded)->l_scope,
936                                         ELF_RTYPE_CLASS_PLT, 1);
937
938             loadbase = LOOKUP_VALUE_ADDRESS (result);
939
940             _dl_printf ("%s found at 0x%0*Zd in object at 0x%0*Zd\n",
941                         _dl_argv[i],
942                         (int) sizeof ref->st_value * 2, ref->st_value,
943                         (int) sizeof loadbase * 2, loadbase);
944           }
945       else
946         {
947           /* If LD_WARN is set warn about undefined symbols.  */
948           if (GL(dl_lazy) >= 0 && GL(dl_verbose))
949             {
950               /* We have to do symbol dependency testing.  */
951               struct relocate_args args;
952               struct link_map *l;
953
954               args.lazy = GL(dl_lazy);
955
956               l = GL(dl_loaded);
957               while (l->l_next)
958                 l = l->l_next;
959               do
960                 {
961                   if (l != &GL(dl_rtld_map) && ! l->l_faked)
962                     {
963                       args.l = l;
964                       _dl_receive_error (print_unresolved, relocate_doit,
965                                          &args);
966                     }
967                   l = l->l_prev;
968                 } while (l);
969
970               if ((GL(dl_debug_mask) & DL_DEBUG_PRELINK)
971                   && GL(dl_rtld_map).l_opencount > 1)
972                 _dl_relocate_object (&GL(dl_rtld_map), GL(dl_loaded)->l_scope,
973                                      0, 0);
974             }
975
976 #define VERNEEDTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERNEED))
977           if (version_info)
978             {
979               /* Print more information.  This means here, print information
980                  about the versions needed.  */
981               int first = 1;
982               struct link_map *map = GL(dl_loaded);
983
984               for (map = GL(dl_loaded); map != NULL; map = map->l_next)
985                 {
986                   const char *strtab;
987                   ElfW(Dyn) *dyn = map->l_info[VERNEEDTAG];
988                   ElfW(Verneed) *ent;
989
990                   if (dyn == NULL)
991                     continue;
992
993                   strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
994                   ent = (ElfW(Verneed) *) (map->l_addr + dyn->d_un.d_ptr);
995
996                   if (first)
997                     {
998                       _dl_printf ("\n\tVersion information:\n");
999                       first = 0;
1000                     }
1001
1002                   _dl_printf ("\t%s:\n",
1003                               map->l_name[0] ? map->l_name : _dl_argv[0]);
1004
1005                   while (1)
1006                     {
1007                       ElfW(Vernaux) *aux;
1008                       struct link_map *needed;
1009
1010                       needed = find_needed (strtab + ent->vn_file);
1011                       aux = (ElfW(Vernaux) *) ((char *) ent + ent->vn_aux);
1012
1013                       while (1)
1014                         {
1015                           const char *fname = NULL;
1016
1017                           if (needed != NULL
1018                               && match_version (strtab + aux->vna_name,
1019                                                 needed))
1020                             fname = needed->l_name;
1021
1022                           _dl_printf ("\t\t%s (%s) %s=> %s\n",
1023                                       strtab + ent->vn_file,
1024                                       strtab + aux->vna_name,
1025                                       aux->vna_flags & VER_FLG_WEAK
1026                                       ? "[WEAK] " : "",
1027                                       fname ?: "not found");
1028
1029                           if (aux->vna_next == 0)
1030                             /* No more symbols.  */
1031                             break;
1032
1033                           /* Next symbol.  */
1034                           aux = (ElfW(Vernaux) *) ((char *) aux
1035                                                    + aux->vna_next);
1036                         }
1037
1038                       if (ent->vn_next == 0)
1039                         /* No more dependencies.  */
1040                         break;
1041
1042                       /* Next dependency.  */
1043                       ent = (ElfW(Verneed) *) ((char *) ent + ent->vn_next);
1044                     }
1045                 }
1046             }
1047         }
1048
1049       _exit (0);
1050     }
1051
1052   if (GL(dl_loaded)->l_info [ADDRIDX (DT_GNU_LIBLIST)]
1053       && ! __builtin_expect (GL(dl_profile) != NULL, 0))
1054     {
1055       ElfW(Lib) *liblist, *liblistend;
1056       struct link_map **r_list, **r_listend, *l;
1057       const char *strtab = (const void *)
1058                            D_PTR (GL(dl_loaded), l_info[DT_STRTAB]);
1059
1060       assert (GL(dl_loaded)->l_info [VALIDX (DT_GNU_LIBLISTSZ)] != NULL);
1061       liblist = (ElfW(Lib) *)
1062                 GL(dl_loaded)->l_info [ADDRIDX (DT_GNU_LIBLIST)]->d_un.d_ptr;
1063       liblistend = (ElfW(Lib) *)
1064                    ((char *) liblist
1065                     + GL(dl_loaded)->l_info [VALIDX (DT_GNU_LIBLISTSZ)]->d_un.d_val);
1066       r_list = GL(dl_loaded)->l_searchlist.r_list;
1067       r_listend = r_list + GL(dl_loaded)->l_searchlist.r_nlist;
1068
1069       for (; r_list < r_listend && liblist < liblistend; r_list++)
1070         {
1071           l = *r_list;
1072
1073           if (l == GL(dl_loaded))
1074             continue;
1075
1076           /* If the library is not mapped where it should, fail.  */
1077           if (l->l_addr)
1078             break;
1079
1080           /* Next, check if checksum matches.  */
1081           if (l->l_info [VALIDX(DT_CHECKSUM)] == NULL
1082               || l->l_info [VALIDX(DT_CHECKSUM)]->d_un.d_val
1083                  != liblist->l_checksum)
1084             break;
1085
1086           if (l->l_info [VALIDX(DT_GNU_PRELINKED)] == NULL
1087               || l->l_info [VALIDX(DT_GNU_PRELINKED)]->d_un.d_val
1088                  != liblist->l_time_stamp)
1089             break;
1090
1091           if (! _dl_name_match_p (strtab + liblist->l_name, l))
1092             break;
1093
1094           ++liblist;
1095         }
1096
1097
1098       if (r_list == r_listend && liblist == liblistend)
1099         prelinked = 1;
1100
1101       if (__builtin_expect (GL(dl_debug_mask) & DL_DEBUG_LIBS, 0))
1102         _dl_printf ("\nprelink checking: %s\n", prelinked ? "ok" : "failed");
1103     }
1104
1105   if (prelinked)
1106     {
1107       if (GL(dl_loaded)->l_info [ADDRIDX (DT_GNU_CONFLICT)] != NULL)
1108         {
1109           ElfW(Rela) *conflict, *conflictend;
1110 #ifndef HP_TIMING_NONAVAIL
1111           hp_timing_t start;
1112           hp_timing_t stop;
1113 #endif
1114
1115           HP_TIMING_NOW (start);
1116           assert (GL(dl_loaded)->l_info [VALIDX (DT_GNU_CONFLICTSZ)] != NULL);
1117           conflict = (ElfW(Rela) *)
1118                      GL(dl_loaded)->l_info [ADDRIDX (DT_GNU_CONFLICT)]->d_un.d_ptr;
1119           conflictend = (ElfW(Rela) *)
1120                         ((char *) conflict
1121                          + GL(dl_loaded)->l_info [VALIDX (DT_GNU_CONFLICTSZ)]->d_un.d_val);
1122           _dl_resolve_conflicts (GL(dl_loaded), conflict, conflictend);
1123           HP_TIMING_NOW (stop);
1124           HP_TIMING_DIFF (relocate_time, start, stop);
1125         }
1126
1127       _dl_sysdep_start_cleanup ();
1128     }
1129   else
1130   {
1131     /* Now we have all the objects loaded.  Relocate them all except for
1132        the dynamic linker itself.  We do this in reverse order so that copy
1133        relocs of earlier objects overwrite the data written by later
1134        objects.  We do not re-relocate the dynamic linker itself in this
1135        loop because that could result in the GOT entries for functions we
1136        call being changed, and that would break us.  It is safe to relocate
1137        the dynamic linker out of order because it has no copy relocs (we
1138        know that because it is self-contained).  */
1139
1140     struct link_map *l;
1141     int consider_profiling = GL(dl_profile) != NULL;
1142 #ifndef HP_TIMING_NONAVAIL
1143     hp_timing_t start;
1144     hp_timing_t stop;
1145     hp_timing_t add;
1146 #endif
1147
1148     /* If we are profiling we also must do lazy reloaction.  */
1149     GL(dl_lazy) |= consider_profiling;
1150
1151     l = GL(dl_loaded);
1152     while (l->l_next)
1153       l = l->l_next;
1154
1155     HP_TIMING_NOW (start);
1156     do
1157       {
1158         /* While we are at it, help the memory handling a bit.  We have to
1159            mark some data structures as allocated with the fake malloc()
1160            implementation in ld.so.  */
1161         struct libname_list *lnp = l->l_libname->next;
1162
1163         while (__builtin_expect (lnp != NULL, 0))
1164           {
1165             lnp->dont_free = 1;
1166             lnp = lnp->next;
1167           }
1168
1169         if (l != &GL(dl_rtld_map))
1170           _dl_relocate_object (l, l->l_scope, GL(dl_lazy), consider_profiling);
1171
1172         l = l->l_prev;
1173       }
1174     while (l);
1175     HP_TIMING_NOW (stop);
1176
1177     HP_TIMING_DIFF (relocate_time, start, stop);
1178
1179     /* Do any necessary cleanups for the startup OS interface code.
1180        We do these now so that no calls are made after rtld re-relocation
1181        which might be resolved to different functions than we expect.
1182        We cannot do this before relocating the other objects because
1183        _dl_relocate_object might need to call `mprotect' for DT_TEXTREL.  */
1184     _dl_sysdep_start_cleanup ();
1185
1186     /* Now enable profiling if needed.  Like the previous call,
1187        this has to go here because the calls it makes should use the
1188        rtld versions of the functions (particularly calloc()), but it
1189        needs to have _dl_profile_map set up by the relocator.  */
1190     if (__builtin_expect (GL(dl_profile_map) != NULL, 0))
1191       /* We must prepare the profiling.  */
1192       _dl_start_profile (GL(dl_profile_map), GL(dl_profile_output));
1193
1194     if (GL(dl_rtld_map).l_opencount > 1)
1195       {
1196         /* There was an explicit ref to the dynamic linker as a shared lib.
1197            Re-relocate ourselves with user-controlled symbol definitions.  */
1198         HP_TIMING_NOW (start);
1199         _dl_relocate_object (&GL(dl_rtld_map), GL(dl_loaded)->l_scope, 0, 0);
1200         HP_TIMING_NOW (stop);
1201         HP_TIMING_DIFF (add, start, stop);
1202         HP_TIMING_ACCUM_NT (relocate_time, add);
1203       }
1204   }
1205
1206   /* Now set up the variable which helps the assembler startup code.  */
1207   GL(dl_main_searchlist) = &GL(dl_loaded)->l_searchlist;
1208   GL(dl_global_scope)[0] = &GL(dl_loaded)->l_searchlist;
1209
1210   /* Save the information about the original global scope list since
1211      we need it in the memory handling later.  */
1212   GL(dl_initial_searchlist) = *GL(dl_main_searchlist);
1213
1214   {
1215     /* Initialize _r_debug.  */
1216     struct r_debug *r = _dl_debug_initialize (GL(dl_rtld_map).l_addr);
1217     struct link_map *l;
1218
1219     l = GL(dl_loaded);
1220
1221 #ifdef ELF_MACHINE_DEBUG_SETUP
1222
1223     /* Some machines (e.g. MIPS) don't use DT_DEBUG in this way.  */
1224
1225     ELF_MACHINE_DEBUG_SETUP (l, r);
1226     ELF_MACHINE_DEBUG_SETUP (&GL(dl_rtld_map), r);
1227
1228 #else
1229
1230     if (l->l_info[DT_DEBUG])
1231       /* There is a DT_DEBUG entry in the dynamic section.  Fill it in
1232          with the run-time address of the r_debug structure  */
1233       l->l_info[DT_DEBUG]->d_un.d_ptr = (ElfW(Addr)) r;
1234
1235     /* Fill in the pointer in the dynamic linker's own dynamic section, in
1236        case you run gdb on the dynamic linker directly.  */
1237     if (GL(dl_rtld_map).l_info[DT_DEBUG])
1238       GL(dl_rtld_map).l_info[DT_DEBUG]->d_un.d_ptr = (ElfW(Addr)) r;
1239
1240 #endif
1241
1242     /* Notify the debugger that all objects are now mapped in.  */
1243     r->r_state = RT_ADD;
1244     _dl_debug_state ();
1245   }
1246
1247 #ifndef MAP_COPY
1248   /* We must munmap() the cache file.  */
1249   _dl_unload_cache ();
1250 #endif
1251
1252   /* Once we return, _dl_sysdep_start will invoke
1253      the DT_INIT functions and then *USER_ENTRY.  */
1254 }
1255 \f
1256 /* This is a little helper function for resolving symbols while
1257    tracing the binary.  */
1258 static void
1259 print_unresolved (int errcode __attribute__ ((unused)), const char *objname,
1260                   const char *errstring)
1261 {
1262   if (objname[0] == '\0')
1263     objname = _dl_argv[0] ?: "<main program>";
1264   _dl_error_printf ("%s (%s)\n", errstring, objname);
1265 }
1266 \f
1267 /* This is a little helper function for resolving symbols while
1268    tracing the binary.  */
1269 static void
1270 print_missing_version (int errcode __attribute__ ((unused)),
1271                        const char *objname, const char *errstring)
1272 {
1273   _dl_error_printf ("%s: %s: %s\n", _dl_argv[0] ?: "<program name unknown>",
1274                     objname, errstring);
1275 }
1276 \f
1277 /* Nonzero if any of the debugging options is enabled.  */
1278 static int any_debug;
1279
1280 /* Process the string given as the parameter which explains which debugging
1281    options are enabled.  */
1282 static void
1283 process_dl_debug (const char *dl_debug)
1284 {
1285   /* When adding new entries make sure that the maximal length of a name
1286      is correctly handled in the LD_DEBUG_HELP code below.  */
1287   static const struct
1288   {
1289     const char name[11];
1290     const char helptext[41];
1291     unsigned short int mask;
1292   } debopts[] =
1293     {
1294       { "libs", "display library search paths",
1295         DL_DEBUG_LIBS | DL_DEBUG_IMPCALLS },
1296       { "reloc", "display relocation processing",
1297         DL_DEBUG_RELOC | DL_DEBUG_IMPCALLS },
1298       { "files", "display progress for input file",
1299         DL_DEBUG_FILES | DL_DEBUG_IMPCALLS },
1300       { "symbols", "display symbol table processing",
1301         DL_DEBUG_SYMBOLS | DL_DEBUG_IMPCALLS },
1302       { "bindings", "display information about symbol binding",
1303         DL_DEBUG_BINDINGS | DL_DEBUG_IMPCALLS },
1304       { "versions", "display version dependencies",
1305         DL_DEBUG_VERSIONS | DL_DEBUG_IMPCALLS },
1306       { "all", "all previous options combined",
1307         DL_DEBUG_LIBS | DL_DEBUG_RELOC | DL_DEBUG_FILES | DL_DEBUG_SYMBOLS
1308         | DL_DEBUG_BINDINGS | DL_DEBUG_VERSIONS | DL_DEBUG_IMPCALLS },
1309       { "statistics", "display relocation statistics",
1310         DL_DEBUG_STATISTICS },
1311       { "help", "display this help message and exit",
1312         DL_DEBUG_HELP },
1313     };
1314 #define ndebopts (sizeof (debopts) / sizeof (debopts[0]))
1315   size_t len;
1316
1317 #define separators " ,:"
1318   do
1319     {
1320       len = 0;
1321       /* Skip separating white spaces and commas.  */
1322       dl_debug += strspn (dl_debug, separators);
1323       if (*dl_debug != '\0')
1324         {
1325           size_t cnt;
1326
1327           len = strcspn (dl_debug, separators);
1328
1329           for (cnt = 0; cnt < ndebopts; ++cnt)
1330             if (strncmp (dl_debug, debopts[cnt].name, len) == 0
1331                 && debopts[cnt].name[len] == '\0')
1332               {
1333                 GL(dl_debug_mask) |= debopts[cnt].mask;
1334                 any_debug = 1;
1335                 break;
1336               }
1337
1338           if (cnt == ndebopts)
1339             {
1340               /* Display a warning and skip everything until next
1341                  separator.  */
1342               char *copy = strndupa (dl_debug, len);
1343               _dl_error_printf ("\
1344 warning: debug option `%s' unknown; try LD_DEBUG=help\n", copy);
1345               break;
1346           }
1347         }
1348     }
1349   while (*(dl_debug += len) != '\0');
1350
1351   if (GL(dl_debug_mask) & DL_DEBUG_HELP)
1352     {
1353       size_t cnt;
1354
1355       _dl_printf ("\
1356 Valid options for the LD_DEBUG environment variable are:\n\n");
1357
1358       for (cnt = 0; cnt < ndebopts; ++cnt)
1359         _dl_printf ("  %s%s %s\n", debopts[cnt].name,
1360                     "       " + strlen (debopts[cnt].name) - 3,
1361                     debopts[cnt].helptext);
1362
1363       _dl_printf ("\n\
1364 To direct the debugging output into a file instead of standard output\n\
1365 a filename can be specified using the LD_DEBUG_OUTPUT environment variable.\n");
1366       _exit (0);
1367     }
1368 }
1369 \f
1370 /* Process all environments variables the dynamic linker must recognize.
1371    Since all of them start with `LD_' we are a bit smarter while finding
1372    all the entries.  */
1373 extern char **_environ;
1374
1375
1376 static void
1377 process_envvars (enum mode *modep)
1378 {
1379   char **runp = _environ;
1380   char *envline;
1381   enum mode mode = normal;
1382   char *debug_output = NULL;
1383
1384   /* This is the default place for profiling data file.  */
1385   GL(dl_profile_output) = &"/var/tmp\0/var/profile"[__libc_enable_secure
1386                                                     ? 9 : 0];
1387
1388   while ((envline = _dl_next_ld_env_entry (&runp)) != NULL)
1389     {
1390       size_t len = strcspn (envline, "=");
1391
1392       if (envline[len] != '=')
1393         /* This is a "LD_" variable at the end of the string without
1394            a '=' character.  Ignore it since otherwise we will access
1395            invalid memory below.  */
1396         continue;
1397
1398       switch (len)
1399         {
1400         case 4:
1401           /* Warning level, verbose or not.  */
1402           if (memcmp (envline, "WARN", 4) == 0)
1403             GL(dl_verbose) = envline[5] != '\0';
1404           break;
1405
1406         case 5:
1407           /* Debugging of the dynamic linker?  */
1408           if (memcmp (envline, "DEBUG", 5) == 0)
1409             process_dl_debug (&envline[6]);
1410           break;
1411
1412         case 7:
1413           /* Print information about versions.  */
1414           if (memcmp (envline, "VERBOSE", 7) == 0)
1415             {
1416               version_info = envline[8] != '\0';
1417               break;
1418             }
1419
1420           /* List of objects to be preloaded.  */
1421           if (memcmp (envline, "PRELOAD", 7) == 0)
1422             {
1423               preloadlist = &envline[8];
1424               break;
1425             }
1426
1427           /* Which shared object shall be profiled.  */
1428           if (memcmp (envline, "PROFILE", 7) == 0 && envline[8] != '\0')
1429             GL(dl_profile) = &envline[8];
1430           break;
1431
1432         case 8:
1433           /* Do we bind early?  */
1434           if (memcmp (envline, "BIND_NOW", 8) == 0)
1435             {
1436               GL(dl_lazy) = envline[9] == '\0';
1437               break;
1438             }
1439           if (memcmp (envline, "BIND_NOT", 8) == 0)
1440             GL(dl_bind_not) = envline[9] != '\0';
1441           break;
1442
1443         case 9:
1444           /* Test whether we want to see the content of the auxiliary
1445              array passed up from the kernel.  */
1446           if (memcmp (envline, "SHOW_AUXV", 9) == 0)
1447             _dl_show_auxv ();
1448           break;
1449
1450         case 10:
1451           /* Mask for the important hardware capabilities.  */
1452           if (memcmp (envline, "HWCAP_MASK", 10) == 0)
1453             GL(dl_hwcap_mask) = __strtoul_internal (&envline[11], NULL, 0, 0);
1454           break;
1455
1456         case 11:
1457           /* Path where the binary is found.  */
1458           if (!__libc_enable_secure
1459               && memcmp (envline, "ORIGIN_PATH", 11) == 0)
1460             GL(dl_origin_path) = &envline[12];
1461           break;
1462
1463         case 12:
1464           /* The library search path.  */
1465           if (memcmp (envline, "LIBRARY_PATH", 12) == 0)
1466             {
1467               library_path = &envline[13];
1468               break;
1469             }
1470
1471           /* Where to place the profiling data file.  */
1472           if (memcmp (envline, "DEBUG_OUTPUT", 12) == 0)
1473             {
1474               debug_output = &envline[13];
1475               break;
1476             }
1477
1478           if (memcmp (envline, "DYNAMIC_WEAK", 12) == 0)
1479             GL(dl_dynamic_weak) = 1;
1480           break;
1481
1482         case 14:
1483           /* Where to place the profiling data file.  */
1484           if (!__libc_enable_secure
1485               && memcmp (envline, "PROFILE_OUTPUT", 14) == 0
1486               && envline[15] != '\0')
1487             GL(dl_profile_output) = &envline[15];
1488           break;
1489
1490         case 16:
1491           /* The mode of the dynamic linker can be set.  */
1492           if (memcmp (envline, "TRACE_PRELINKING", 16) == 0)
1493             {
1494               mode = trace;
1495               GL(dl_verbose) = 1;
1496               GL(dl_debug_mask) |= DL_DEBUG_PRELINK;
1497               GL(dl_trace_prelink) = &envline[17];
1498             }
1499           break;
1500
1501         case 20:
1502           /* The mode of the dynamic linker can be set.  */
1503           if (memcmp (envline, "TRACE_LOADED_OBJECTS", 20) == 0)
1504             mode = trace;
1505           break;
1506
1507           /* We might have some extra environment variable to handle.  This
1508              is tricky due to the pre-processing of the length of the name
1509              in the switch statement here.  The code here assumes that added
1510              environment variables have a different length.  */
1511 #ifdef EXTRA_LD_ENVVARS
1512           EXTRA_LD_ENVVARS
1513 #endif
1514         }
1515     }
1516
1517   /* The caller wants this information.  */
1518   *modep = mode;
1519
1520   /* Extra security for SUID binaries.  Remove all dangerous environment
1521      variables.  */
1522   if (__builtin_expect (__libc_enable_secure, 0))
1523     {
1524       static const char unsecure_envvars[] =
1525 #ifdef EXTRA_UNSECURE_ENVVARS
1526         EXTRA_UNSECURE_ENVVARS
1527 #endif
1528         UNSECURE_ENVVARS;
1529       const char *nextp;
1530
1531       nextp = unsecure_envvars;
1532       do
1533         {
1534           unsetenv (nextp);
1535           nextp = (char *) rawmemchr (nextp, '\0') + 1;
1536         }
1537       while (*nextp != '\0');
1538
1539       if (__access ("/etc/suid-debug", F_OK) != 0)
1540         unsetenv ("MALLOC_CHECK_");
1541     }
1542   /* If we have to run the dynamic linker in debugging mode and the
1543      LD_DEBUG_OUTPUT environment variable is given, we write the debug
1544      messages to this file.  */
1545   else if (any_debug && debug_output != NULL)
1546     {
1547 #ifdef O_NOFOLLOW
1548       const int flags = O_WRONLY | O_APPEND | O_CREAT | O_NOFOLLOW;
1549 #else
1550       const int flags = O_WRONLY | O_APPEND | O_CREAT;
1551 #endif
1552       size_t name_len = strlen (debug_output);
1553       char buf[name_len + 12];
1554       char *startp;
1555
1556       buf[name_len + 11] = '\0';
1557       startp = _itoa_word (__getpid (), &buf[name_len + 11], 10, 0);
1558       *--startp = '.';
1559       startp = memcpy (startp - name_len, debug_output, name_len);
1560
1561       GL(dl_debug_fd) = __open (startp, flags, DEFFILEMODE);
1562       if (GL(dl_debug_fd) == -1)
1563         /* We use standard output if opening the file failed.  */
1564         GL(dl_debug_fd) = STDOUT_FILENO;
1565     }
1566 }
1567
1568
1569 /* Print the various times we collected.  */
1570 static void
1571 print_statistics (void)
1572 {
1573 #ifndef HP_TIMING_NONAVAIL
1574   char buf[200];
1575   char *cp;
1576   char *wp;
1577
1578   /* Total time rtld used.  */
1579   if (HP_TIMING_AVAIL)
1580     {
1581       HP_TIMING_PRINT (buf, sizeof (buf), rtld_total_time);
1582       _dl_debug_printf ("\nruntime linker statistics:\n"
1583                         "  total startup time in dynamic loader: %s\n", buf);
1584     }
1585
1586   /* Print relocation statistics.  */
1587   if (HP_TIMING_AVAIL)
1588     {
1589       char pbuf[30];
1590       HP_TIMING_PRINT (buf, sizeof (buf), relocate_time);
1591       cp = _itoa_word ((1000ULL * relocate_time) / rtld_total_time,
1592                        pbuf + sizeof (pbuf), 10, 0);
1593       wp = pbuf;
1594       switch (pbuf + sizeof (pbuf) - cp)
1595         {
1596         case 3:
1597           *wp++ = *cp++;
1598         case 2:
1599           *wp++ = *cp++;
1600         case 1:
1601           *wp++ = '.';
1602           *wp++ = *cp++;
1603         }
1604       *wp = '\0';
1605       _dl_debug_printf ("            time needed for relocation: %s (%s%%)\n",
1606                         buf, pbuf);
1607     }
1608 #endif
1609   _dl_debug_printf ("                 number of relocations: %lu\n",
1610                     GL(dl_num_relocations));
1611   _dl_debug_printf ("      number of relocations from cache: %lu\n",
1612                     GL(dl_num_cache_relocations));
1613
1614 #ifndef HP_TIMING_NONAVAIL
1615   /* Time spend while loading the object and the dependencies.  */
1616   if (HP_TIMING_AVAIL)
1617     {
1618       char pbuf[30];
1619       HP_TIMING_PRINT (buf, sizeof (buf), load_time);
1620       cp = _itoa_word ((1000ULL * load_time) / rtld_total_time,
1621                        pbuf + sizeof (pbuf), 10, 0);
1622       wp = pbuf;
1623       switch (pbuf + sizeof (pbuf) - cp)
1624         {
1625         case 3:
1626           *wp++ = *cp++;
1627         case 2:
1628           *wp++ = *cp++;
1629         case 1:
1630           *wp++ = '.';
1631           *wp++ = *cp++;
1632         }
1633       *wp = '\0';
1634       _dl_debug_printf ("           time needed to load objects: %s (%s%%)\n",
1635                         buf, pbuf);
1636     }
1637 #endif
1638 }