1 /* Run time dynamic linker.
2 Copyright (C) 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Library General Public License as
7 published by the Free Software Foundation; either version 2 of the
8 License, or (at your option) any later version.
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Library General Public License for more details.
15 You should have received a copy of the GNU Library General Public
16 License along with the GNU C Library; see the file COPYING.LIB. If not,
17 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA. */
24 #include <sys/mman.h> /* Check if MAP_ANON is defined. */
25 #include <elf/ldsodefs.h>
26 #include <stdio-common/_itoa.h>
28 #include "dynamic-link.h"
29 #include "dl-librecon.h"
33 /* System-specific function to do initial startup for the dynamic linker.
34 After this, file access calls and getenv must work. This is responsible
35 for setting __libc_enable_secure if we need to be secure (e.g. setuid),
36 and for setting _dl_argc and _dl_argv, and then calling _dl_main. */
37 extern ElfW(Addr
) _dl_sysdep_start (void **start_argptr
,
38 void (*dl_main
) (const ElfW(Phdr
) *phdr
,
40 ElfW(Addr
) *user_entry
));
41 extern void _dl_sysdep_start_cleanup (void);
43 /* System-dependent function to read a file's whole contents
44 in the most convenient manner available. */
45 extern void *_dl_sysdep_read_whole_file (const char *filename
,
49 /* Helper function to handle errors while resolving symbols. */
50 static void print_unresolved (int errcode
, const char *objname
,
51 const char *errsting
);
53 /* Helper function to handle errors when a version is missing. */
54 static void print_missing_version (int errcode
, const char *objname
,
55 const char *errsting
);
58 /* This is a list of all the modes the dynamic loader can be in. */
59 enum mode
{ normal
, list
, verify
, trace
};
61 /* Process all environments variables the dynamic linker must recognize.
62 Since all of them start with `LD_' we are a bit smarter while finding
64 static void process_envvars (enum mode
*modep
, int *lazyp
);
68 const char *_dl_rpath
;
70 const char *_dl_platform
;
71 size_t _dl_platformlen
;
72 unsigned long _dl_hwcap
;
73 struct r_search_path
*_dl_search_paths
;
74 const char *_dl_profile
;
75 const char *_dl_profile_output
;
76 struct link_map
*_dl_profile_map
;
78 int _dl_debug_impcalls
;
79 int _dl_debug_bindings
;
80 int _dl_debug_symbols
;
81 int _dl_debug_versions
;
84 const char *_dl_inhibit_rpath
; /* RPATH values which should be
87 /* Set nonzero during loading and initialization of executable and
88 libraries, cleared before the executable's entry point runs. This
89 must not be initialized to nonzero, because the unused dynamic
90 linker loaded in for libc.so's "ld.so.1" dep will provide the
91 definition seen by libc.so's initializer; that value must be zero,
92 and will be since that dynamic linker's _dl_start and dl_main will
97 static void dl_main (const ElfW(Phdr
) *phdr
,
99 ElfW(Addr
) *user_entry
);
101 struct link_map _dl_rtld_map
;
102 struct libname_list _dl_rtld_libname
;
103 struct libname_list _dl_rtld_libname2
;
108 #error "sysdeps/MACHINE/dl-machine.h fails to define RTLD_START"
112 _dl_start (void *arg
)
114 struct link_map bootstrap_map
;
116 /* This #define produces dynamic linking inline functions for
117 bootstrap relocation instead of general-purpose relocation. */
118 #define RTLD_BOOTSTRAP
119 #define RESOLVE(sym, version, flags) bootstrap_map.l_addr
120 #include "dynamic-link.h"
122 /* Figure out the run-time load address of the dynamic linker itself. */
123 bootstrap_map
.l_addr
= elf_machine_load_address ();
125 /* Read our own dynamic section and fill in the info array. */
126 bootstrap_map
.l_ld
= (void *) bootstrap_map
.l_addr
+ elf_machine_dynamic ();
127 elf_get_dynamic_info (bootstrap_map
.l_ld
, bootstrap_map
.l_info
);
129 #ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
130 ELF_MACHINE_BEFORE_RTLD_RELOC (bootstrap_map
.l_info
);
133 /* Relocate ourselves so we can do normal function calls and
134 data access using the global offset table. */
136 ELF_DYNAMIC_RELOCATE (&bootstrap_map
, 0, 0);
137 /* Please note that we don't allow profiling of this object and
138 therefore need not test whether we have to allocate the array
139 for the relocation results (as done in dl-reloc.c). */
141 /* Now life is sane; we can call functions and access global data.
142 Set up to use the operating system facilities, and find out from
143 the operating system's program loader where to find the program
144 header table in core. */
146 /* Transfer data about ourselves to the permanent link_map structure. */
147 _dl_rtld_map
.l_addr
= bootstrap_map
.l_addr
;
148 _dl_rtld_map
.l_ld
= bootstrap_map
.l_ld
;
149 _dl_rtld_map
.l_opencount
= 1;
150 memcpy (_dl_rtld_map
.l_info
, bootstrap_map
.l_info
,
151 sizeof _dl_rtld_map
.l_info
);
152 _dl_setup_hash (&_dl_rtld_map
);
154 /* Cache the DT_RPATH stored in ld.so itself; this will be
155 the default search path. */
156 if (_dl_rtld_map
.l_info
[DT_STRTAB
] && _dl_rtld_map
.l_info
[DT_RPATH
])
158 _dl_rpath
= (void *) (_dl_rtld_map
.l_addr
+
159 _dl_rtld_map
.l_info
[DT_STRTAB
]->d_un
.d_ptr
+
160 _dl_rtld_map
.l_info
[DT_RPATH
]->d_un
.d_val
);
163 /* Call the OS-dependent function to set up life so we can do things like
164 file access. It will call `dl_main' (below) to do all the real work
165 of the dynamic linker, and then unwind our frame and run the user
166 entry point on the same stack we entered on. */
167 return _dl_sysdep_start (arg
, &dl_main
);
170 /* Now life is peachy; we can do all normal operations.
171 On to the real work. */
173 void ENTRY_POINT (void);
175 /* Some helper functions. */
177 /* Arguments to relocate_doit. */
186 /* Argument to map_doit. */
188 /* Return value of map_doit. */
189 struct link_map
*main_map
;
192 /* Arguments to version_check_doit. */
193 struct version_check_args
195 struct link_map
*main_map
;
200 relocate_doit (void *a
)
202 struct relocate_args
*args
= (struct relocate_args
*) a
;
204 _dl_relocate_object (args
->l
, _dl_object_relocation_scope (args
->l
),
211 struct map_args
*args
= (struct map_args
*)a
;
212 args
->main_map
= _dl_map_object (NULL
, args
->str
, 0, lt_library
, 0);
216 version_check_doit (void *a
)
218 struct version_check_args
*args
= (struct version_check_args
*)a
;
219 if (_dl_check_all_versions (args
->main_map
, 1) && args
->doexit
)
220 /* We cannot start the application. Abort now. */
225 static inline struct link_map
*
226 find_needed (const char *name
)
230 for (n
= 0; n
< _dl_loaded
->l_nsearchlist
; ++n
)
231 if (_dl_name_match_p (name
, _dl_loaded
->l_searchlist
[n
]))
232 return _dl_loaded
->l_searchlist
[n
];
234 /* Should never happen. */
239 match_version (const char *string
, struct link_map
*map
)
241 const char *strtab
= (const char *) (map
->l_addr
242 + map
->l_info
[DT_STRTAB
]->d_un
.d_ptr
);
245 #define VERDEFTAG (DT_NUM + DT_PROCNUM + DT_VERSIONTAGIDX (DT_VERDEF))
246 if (map
->l_info
[VERDEFTAG
] == NULL
)
247 /* The file has no symbol versioning. */
250 def
= (ElfW(Verdef
) *) ((char *) map
->l_addr
251 + map
->l_info
[VERDEFTAG
]->d_un
.d_ptr
);
254 ElfW(Verdaux
) *aux
= (ElfW(Verdaux
) *) ((char *) def
+ def
->vd_aux
);
256 /* Compare the version strings. */
257 if (strcmp (string
, strtab
+ aux
->vda_name
) == 0)
261 /* If no more definitions we failed to find what we want. */
262 if (def
->vd_next
== 0)
265 /* Next definition. */
266 def
= (ElfW(Verdef
) *) ((char *) def
+ def
->vd_next
);
272 static unsigned int _dl_skip_args
; /* Nonzero if we were run directly. */
273 static const char *library_path
; /* The library search path. */
274 static const char *preloadlist
; /* The list preloaded objects. */
275 static int version_info
; /* Nonzero if information about
276 versions has to be printed. */
279 dl_main (const ElfW(Phdr
) *phdr
,
281 ElfW(Addr
) *user_entry
)
283 const ElfW(Phdr
) *ph
;
284 struct link_map
*main_map
;
287 struct link_map
**preloads
;
288 unsigned int npreloads
;
293 int paths_initialized
= 0;
295 /* Process the environment variable which control the behaviour. */
296 process_envvars (&mode
, &lazy
);
298 /* Set up a flag which tells we are just starting. */
301 if (*user_entry
== (ElfW(Addr
)) &ENTRY_POINT
)
303 /* Ho ho. We are not the program interpreter! We are the program
304 itself! This means someone ran ld.so as a command. Well, that
305 might be convenient to do sometimes. We support it by
306 interpreting the args like this:
308 ld.so PROGRAM ARGS...
310 The first argument is the name of a file containing an ELF
311 executable we will load and run with the following arguments.
312 To simplify life here, PROGRAM is searched for using the
313 normal rules for shared objects, rather than $PATH or anything
314 like that. We just load it and use its entry point; we don't
315 pay attention to its PT_INTERP command (we are the interpreter
316 ourselves). This is an easy way to test a new ld.so before
319 /* Note the place where the dynamic linker actually came from. */
320 _dl_rtld_map
.l_name
= _dl_argv
[0];
323 if (! strcmp (_dl_argv
[1], "--list"))
326 lazy
= -1; /* This means do no dependency analysis. */
332 else if (! strcmp (_dl_argv
[1], "--verify"))
340 else if (! strcmp (_dl_argv
[1], "--library-path") && _dl_argc
> 2)
342 library_path
= _dl_argv
[2];
348 else if (! strcmp (_dl_argv
[1], "--inhibit-rpath") && _dl_argc
> 2)
350 _dl_inhibit_rpath
= _dl_argv
[2];
359 /* If we have no further argument the program was called incorrectly.
360 Grant the user some education. */
363 Usage: ld.so [OPTION]... EXECUTABLE-FILE [ARGS-FOR-PROGRAM...]\n\
364 You have invoked `ld.so', the helper program for shared library executables.\n\
365 This program usually lives in the file `/lib/ld.so', and special directives\n\
366 in executable files using ELF shared libraries tell the system's program\n\
367 loader to load the helper program from this file. This helper program loads\n\
368 the shared libraries needed by the program executable, prepares the program\n\
369 to run, and runs it. You may invoke this helper program directly from the\n\
370 command line to load and run an ELF executable file; this is like executing\n\
371 that file itself, but always uses this helper program from the file you\n\
372 specified, instead of the helper program file specified in the executable\n\
373 file you run. This is mostly of use for maintainers to test new versions\n\
374 of this helper program; chances are you did not intend to run this program.\n\
376 --list list all dependencies and how they are resolved\n\
377 --verify verify that given object really is a dynamically linked\n\
378 object we get handle\n\
379 --library-path PATH use given PATH instead of content of the environment\n\
380 variable LD_LIBRARY_PATH\n\
381 --inhibit-rpath LIST ignore RPATH information in object names in LIST\n",
388 /* Initialize the data structures for the search paths for shared
390 _dl_init_paths (library_path
);
391 paths_initialized
= 1;
395 char *err_str
= NULL
;
396 struct map_args args
;
398 args
.str
= _dl_argv
[0];
399 (void) _dl_catch_error (&err_str
, map_doit
, &args
);
400 main_map
= args
.main_map
;
404 _exit (EXIT_FAILURE
);
408 main_map
= _dl_map_object (NULL
, _dl_argv
[0], 0, lt_library
, 0);
410 phdr
= main_map
->l_phdr
;
411 phent
= main_map
->l_phnum
;
412 main_map
->l_name
= (char *) "";
413 *user_entry
= main_map
->l_entry
;
417 /* Create a link_map for the executable itself.
418 This will be what dlopen on "" returns. */
419 main_map
= _dl_new_object ((char *) "", "", lt_executable
);
420 if (main_map
== NULL
)
421 _dl_sysdep_fatal ("cannot allocate memory for link map\n", NULL
);
422 main_map
->l_phdr
= phdr
;
423 main_map
->l_phnum
= phent
;
424 main_map
->l_entry
= *user_entry
;
425 main_map
->l_opencount
= 1;
427 /* We delay initializing the path structure until we got the dynamic
428 information for the program. */
431 /* Scan the program header table for the dynamic section. */
432 for (ph
= phdr
; ph
< &phdr
[phent
]; ++ph
)
436 /* Find out the load address. */
437 main_map
->l_addr
= (ElfW(Addr
)) phdr
- ph
->p_vaddr
;
440 /* This tells us where to find the dynamic section,
441 which tells us everything we need to do. */
442 main_map
->l_ld
= (void *) main_map
->l_addr
+ ph
->p_vaddr
;
445 /* This "interpreter segment" was used by the program loader to
446 find the program interpreter, which is this program itself, the
447 dynamic linker. We note what name finds us, so that a future
448 dlopen call or DT_NEEDED entry, for something that wants to link
449 against the dynamic linker as a shared library, will know that
450 the shared object is already loaded. */
451 _dl_rtld_libname
.name
= (const char *) main_map
->l_addr
+ ph
->p_vaddr
;
452 _dl_rtld_libname
.next
= NULL
;
453 _dl_rtld_map
.l_libname
= &_dl_rtld_libname
;
455 /* Ordinarilly, we would get additional names for the loader from
456 our DT_SONAME. This can't happen if we were actually linked as
457 a static executable (detect this case when we have no DYNAMIC).
458 If so, assume the filename component of the interpreter path to
459 be our SONAME, and add it to our name list. */
460 if (_dl_rtld_map
.l_ld
== NULL
)
462 char *p
= strrchr (_dl_rtld_libname
.name
, '/');
465 _dl_rtld_libname2
.name
= p
+1;
466 _dl_rtld_libname2
.next
= NULL
;
467 _dl_rtld_libname
.next
= &_dl_rtld_libname2
;
474 if (! _dl_rtld_map
.l_libname
&& _dl_rtld_map
.l_name
)
476 /* We were invoked directly, so the program might not have a
478 _dl_rtld_libname
.name
= _dl_rtld_map
.l_name
;
479 _dl_rtld_libname
.next
= NULL
;
480 _dl_rtld_map
.l_libname
= &_dl_rtld_libname
;
483 assert (_dl_rtld_map
.l_libname
); /* How else did we get here? */
485 /* Extract the contents of the dynamic section for easy access. */
486 elf_get_dynamic_info (main_map
->l_ld
, main_map
->l_info
);
487 if (main_map
->l_info
[DT_HASH
])
488 /* Set up our cache of pointers into the hash table. */
489 _dl_setup_hash (main_map
);
493 /* We were called just to verify that this is a dynamic
494 executable using us as the program interpreter. Exit with an
495 error if we were not able to load the binary or no interpreter
496 is specified (i.e., this is no dynamically linked binary. */
497 if (main_map
->l_ld
== NULL
)
500 /* We allow here some platform specific code. */
501 #ifdef DISTINGUISH_LIB_VERSIONS
502 DISTINGUISH_LIB_VERSIONS
;
504 _exit (has_interp
? 0 : 2);
507 if (! paths_initialized
)
508 /* Initialize the data structures for the search paths for shared
510 _dl_init_paths (library_path
);
512 /* Put the link_map for ourselves on the chain so it can be found by
513 name. Note that at this point the global chain of link maps contains
514 exactly one element, which is pointed to by main_map. */
515 if (! _dl_rtld_map
.l_name
)
516 /* If not invoked directly, the dynamic linker shared object file was
517 found by the PT_INTERP name. */
518 _dl_rtld_map
.l_name
= (char *) _dl_rtld_map
.l_libname
->name
;
519 _dl_rtld_map
.l_type
= lt_library
;
520 main_map
->l_next
= &_dl_rtld_map
;
521 _dl_rtld_map
.l_prev
= main_map
;
523 /* We have two ways to specify objects to preload: via environment
524 variable and via the file /etc/ld.so.preload. The later can also
525 be used when security is enabled. */
531 /* The LD_PRELOAD environment variable gives list of libraries
532 separated by white space or colons that are loaded before the
533 executable's dependencies and prepended to the global scope
534 list. If the binary is running setuid all elements
535 containing a '/' are ignored since it is insecure. */
536 char *list
= strdupa (preloadlist
);
538 while ((p
= strsep (&list
, " :")) != NULL
)
540 && (! __libc_enable_secure
|| strchr (p
, '/') == NULL
))
542 struct link_map
*new_map
= _dl_map_object (main_map
, p
, 1,
544 if (new_map
->l_opencount
== 1)
545 /* It is no duplicate. */
550 /* Read the contents of the file. */
551 file
= _dl_sysdep_read_whole_file ("/etc/ld.so.preload", &file_size
,
552 PROT_READ
| PROT_WRITE
);
555 /* Parse the file. It contains names of libraries to be loaded,
556 separated by white spaces or `:'. It may also contain
557 comments introduced by `#'. */
562 /* Eliminate comments. */
567 char *comment
= memchr (runp
, '#', rest
);
571 rest
-= comment
- runp
;
574 while (--rest
> 0 && *++comment
!= '\n');
577 /* We have one problematic case: if we have a name at the end of
578 the file without a trailing terminating characters, we cannot
579 place the \0. Handle the case separately. */
580 if (file
[file_size
- 1] != ' ' && file
[file_size
- 1] != '\t'
581 && file
[file_size
- 1] != '\n' && file
[file_size
- 1] != ':')
583 problem
= &file
[file_size
];
584 while (problem
> file
&& problem
[-1] != ' ' && problem
[-1] != '\t'
585 && problem
[-1] != '\n' && problem
[-1] != ':')
594 file
[file_size
- 1] = '\0';
601 while ((p
= strsep (&runp
, ": \t\n")) != NULL
)
604 struct link_map
*new_map
= _dl_map_object (main_map
, p
, 1,
606 if (new_map
->l_opencount
== 1)
607 /* It is no duplicate. */
614 char *p
= strndupa (problem
, file_size
- (problem
- file
));
615 struct link_map
*new_map
= _dl_map_object (main_map
, p
, 1,
617 if (new_map
->l_opencount
== 1)
618 /* It is no duplicate. */
622 /* We don't need the file anymore. */
623 __munmap (file
, file_size
);
628 /* Set up PRELOADS with a vector of the preloaded libraries. */
630 preloads
= __alloca (npreloads
* sizeof preloads
[0]);
631 l
= _dl_rtld_map
.l_next
; /* End of the chain before preloads. */
638 assert (i
== npreloads
);
641 /* Load all the libraries specified by DT_NEEDED entries. If LD_PRELOAD
642 specified some libraries to load, these are inserted before the actual
643 dependencies in the executable's searchlist for symbol resolution. */
644 _dl_map_object_deps (main_map
, preloads
, npreloads
, mode
== trace
);
647 /* We are done mapping things, so close the zero-fill descriptor. */
648 __close (_dl_zerofd
);
652 /* Remove _dl_rtld_map from the chain. */
653 _dl_rtld_map
.l_prev
->l_next
= _dl_rtld_map
.l_next
;
654 if (_dl_rtld_map
.l_next
)
655 _dl_rtld_map
.l_next
->l_prev
= _dl_rtld_map
.l_prev
;
657 if (_dl_rtld_map
.l_opencount
> 1)
659 /* Some DT_NEEDED entry referred to the interpreter object itself, so
660 put it back in the list of visible objects. We insert it into the
661 chain in symbol search order because gdb uses the chain's order as
662 its symbol search order. */
664 while (main_map
->l_searchlist
[i
] != &_dl_rtld_map
)
666 _dl_rtld_map
.l_prev
= main_map
->l_searchlist
[i
- 1];
667 _dl_rtld_map
.l_next
= (i
+ 1 < main_map
->l_nsearchlist
?
668 main_map
->l_searchlist
[i
+ 1] : NULL
);
669 assert (_dl_rtld_map
.l_prev
->l_next
== _dl_rtld_map
.l_next
);
670 _dl_rtld_map
.l_prev
->l_next
= &_dl_rtld_map
;
671 if (_dl_rtld_map
.l_next
)
673 assert (_dl_rtld_map
.l_next
->l_prev
== _dl_rtld_map
.l_prev
);
674 _dl_rtld_map
.l_next
->l_prev
= &_dl_rtld_map
;
678 /* Now let us see whether all libraries are available in the
681 struct version_check_args args
;
682 args
.doexit
= mode
== normal
;
683 args
.main_map
= main_map
;
684 _dl_receive_error (print_missing_version
, version_check_doit
, &args
);
689 /* We were run just to list the shared libraries. It is
690 important that we do this before real relocation, because the
691 functions we call below for output may no longer work properly
693 if (! _dl_loaded
->l_info
[DT_NEEDED
])
694 _dl_sysdep_message ("\t", "statically linked\n", NULL
);
699 for (l
= _dl_loaded
->l_next
; l
; l
= l
->l_next
)
700 if (l
->l_opencount
== 0)
701 /* The library was not found. */
702 _dl_sysdep_message ("\t", l
->l_libname
->name
, " => not found\n",
707 buf
[sizeof buf
- 1] = '\0';
708 bp
= _itoa_word (l
->l_addr
, &buf
[sizeof buf
- 1], 16, 0);
709 while ((size_t) (&buf
[sizeof buf
- 1] - bp
)
710 < sizeof l
->l_addr
* 2)
712 _dl_sysdep_message ("\t", l
->l_libname
->name
, " => ",
713 l
->l_name
, " (0x", bp
, ")\n", NULL
);
718 for (i
= 1; i
< _dl_argc
; ++i
)
720 const ElfW(Sym
) *ref
= NULL
;
721 ElfW(Addr
) loadbase
= _dl_lookup_symbol (_dl_argv
[i
], &ref
,
722 &_dl_default_scope
[2],
724 ELF_MACHINE_JMP_SLOT
);
726 buf
[sizeof buf
- 1] = '\0';
727 bp
= _itoa_word (ref
->st_value
, &buf
[sizeof buf
- 1], 16, 0);
728 while ((size_t) (&buf
[sizeof buf
- 1] - bp
) < sizeof loadbase
* 2)
730 _dl_sysdep_message (_dl_argv
[i
], " found at 0x", bp
, NULL
);
731 buf
[sizeof buf
- 1] = '\0';
732 bp
= _itoa_word (loadbase
, &buf
[sizeof buf
- 1], 16, 0);
733 while ((size_t) (&buf
[sizeof buf
- 1] - bp
) < sizeof loadbase
* 2)
735 _dl_sysdep_message (" in object at 0x", bp
, "\n", NULL
);
741 /* We have to do symbol dependency testing. */
742 struct relocate_args args
;
752 if (l
!= &_dl_rtld_map
&& l
->l_opencount
> 0)
755 _dl_receive_error (print_unresolved
, relocate_doit
,
757 *_dl_global_scope_end
= NULL
;
763 #define VERNEEDTAG (DT_NUM + DT_PROCNUM + DT_VERSIONTAGIDX (DT_VERNEED))
766 /* Print more information. This means here, print information
767 about the versions needed. */
769 struct link_map
*map
= _dl_loaded
;
771 for (map
= _dl_loaded
; map
!= NULL
; map
= map
->l_next
)
774 ElfW(Dyn
) *dyn
= map
->l_info
[VERNEEDTAG
];
780 strtab
= (const char *)
781 (map
->l_addr
+ map
->l_info
[DT_STRTAB
]->d_un
.d_ptr
);
782 ent
= (ElfW(Verneed
) *) (map
->l_addr
+ dyn
->d_un
.d_ptr
);
786 _dl_sysdep_message ("\n\tVersion information:\n", NULL
);
790 _dl_sysdep_message ("\t", (map
->l_name
[0]
791 ? map
->l_name
: _dl_argv
[0]),
797 struct link_map
*needed
;
799 needed
= find_needed (strtab
+ ent
->vn_file
);
800 aux
= (ElfW(Vernaux
) *) ((char *) ent
+ ent
->vn_aux
);
804 const char *fname
= NULL
;
806 _dl_sysdep_message ("\t\t",
807 strtab
+ ent
->vn_file
,
808 " (", strtab
+ aux
->vna_name
,
816 && match_version (strtab
+aux
->vna_name
, needed
))
817 fname
= needed
->l_name
;
819 _dl_sysdep_message (fname
?: "not found", "\n",
822 if (aux
->vna_next
== 0)
823 /* No more symbols. */
827 aux
= (ElfW(Vernaux
) *) ((char *) aux
831 if (ent
->vn_next
== 0)
832 /* No more dependencies. */
835 /* Next dependency. */
836 ent
= (ElfW(Verneed
) *) ((char *) ent
+ ent
->vn_next
);
846 /* Now we have all the objects loaded. Relocate them all except for
847 the dynamic linker itself. We do this in reverse order so that copy
848 relocs of earlier objects overwrite the data written by later
849 objects. We do not re-relocate the dynamic linker itself in this
850 loop because that could result in the GOT entries for functions we
851 call being changed, and that would break us. It is safe to relocate
852 the dynamic linker out of order because it has no copy relocs (we
853 know that because it is self-contained). */
856 int consider_profiling
= _dl_profile
!= NULL
;
858 /* If we are profiling we also must do lazy reloaction. */
859 lazy
|= consider_profiling
;
866 if (l
!= &_dl_rtld_map
)
868 _dl_relocate_object (l
, _dl_object_relocation_scope (l
), lazy
,
870 *_dl_global_scope_end
= NULL
;
875 /* Do any necessary cleanups for the startup OS interface code.
876 We do these now so that no calls are made after rtld re-relocation
877 which might be resolved to different functions than we expect.
878 We cannot do this before relocating the other objects because
879 _dl_relocate_object might need to call `mprotect' for DT_TEXTREL. */
880 _dl_sysdep_start_cleanup ();
882 if (_dl_rtld_map
.l_opencount
> 0)
883 /* There was an explicit ref to the dynamic linker as a shared lib.
884 Re-relocate ourselves with user-controlled symbol definitions. */
885 _dl_relocate_object (&_dl_rtld_map
, &_dl_default_scope
[2], 0, 0);
889 /* Initialize _r_debug. */
890 struct r_debug
*r
= _dl_debug_initialize (_dl_rtld_map
.l_addr
);
895 #ifdef ELF_MACHINE_DEBUG_SETUP
897 /* Some machines (e.g. MIPS) don't use DT_DEBUG in this way. */
899 ELF_MACHINE_DEBUG_SETUP (l
, r
);
900 ELF_MACHINE_DEBUG_SETUP (&_dl_rtld_map
, r
);
904 if (l
->l_info
[DT_DEBUG
])
905 /* There is a DT_DEBUG entry in the dynamic section. Fill it in
906 with the run-time address of the r_debug structure */
907 l
->l_info
[DT_DEBUG
]->d_un
.d_ptr
= (ElfW(Addr
)) r
;
909 /* Fill in the pointer in the dynamic linker's own dynamic section, in
910 case you run gdb on the dynamic linker directly. */
911 if (_dl_rtld_map
.l_info
[DT_DEBUG
])
912 _dl_rtld_map
.l_info
[DT_DEBUG
]->d_un
.d_ptr
= (ElfW(Addr
)) r
;
916 /* Notify the debugger that all objects are now mapped in. */
921 /* Now enable profiling if needed. */
922 if (_dl_profile_map
!= NULL
)
923 /* We must prepare the profiling. */
924 _dl_start_profile (_dl_profile_map
, _dl_profile_output
);
926 /* Once we return, _dl_sysdep_start will invoke
927 the DT_INIT functions and then *USER_ENTRY. */
930 /* This is a little helper function for resolving symbols while
931 tracing the binary. */
933 print_unresolved (int errcode
__attribute__ ((unused
)), const char *objname
,
934 const char *errstring
)
936 if (objname
[0] == '\0')
937 objname
= _dl_argv
[0] ?: "<main program>";
938 _dl_sysdep_error (errstring
, " (", objname
, ")\n", NULL
);
941 /* This is a little helper function for resolving symbols while
942 tracing the binary. */
944 print_missing_version (int errcode
__attribute__ ((unused
)),
945 const char *objname
, const char *errstring
)
947 _dl_sysdep_error (_dl_argv
[0] ?: "<program name unknown>", ": ",
948 objname
, ": ", errstring
, "\n", NULL
);
951 /* Nonzero if any of the debugging options is enabled. */
952 static int any_debug
;
954 /* Process the string given as the parameter which explains which debugging
955 options are enabled. */
957 process_dl_debug (const char *dl_debug
)
960 #define separators " ,:"
964 /* Skip separating white spaces and commas. */
965 dl_debug
+= strspn (dl_debug
, separators
);
966 if (*dl_debug
!= '\0')
968 len
= strcspn (dl_debug
, separators
);
973 /* This option is not documented since it is not generally
975 if (memcmp (dl_debug
, "all", 3) == 0)
978 _dl_debug_impcalls
= 1;
981 _dl_debug_symbols
= 1;
982 _dl_debug_bindings
= 1;
983 _dl_debug_versions
= 1;
989 if (memcmp (dl_debug
, "help", 4) == 0)
991 _dl_sysdep_message ("\
992 Valid options for the LD_DEBUG environment variable are:\n\
994 bindings display information about symbol binding\n\
995 files display processing of files and libraries\n\
996 help display this help message and exit\n\
997 libs display library search paths\n\
998 reloc display relocation processing\n\
999 symbols display symbol table processing\n\
1000 versions display version dependencies\n\
1002 To direct the debugging output into a file instead of standard output\n\
1003 a filename can be specified using the LD_DEBUG_OUTPUT environment variable.\n",
1008 if (memcmp (dl_debug
, "libs", 4) == 0)
1011 _dl_debug_impcalls
= 1;
1018 if (memcmp (dl_debug
, "reloc", 5) == 0)
1020 _dl_debug_reloc
= 1;
1021 _dl_debug_impcalls
= 1;
1026 if (memcmp (dl_debug
, "files", 5) == 0)
1028 _dl_debug_files
= 1;
1029 _dl_debug_impcalls
= 1;
1036 if (memcmp (dl_debug
, "symbols", 7) == 0)
1038 _dl_debug_symbols
= 1;
1039 _dl_debug_impcalls
= 1;
1046 if (memcmp (dl_debug
, "bindings", 8) == 0)
1048 _dl_debug_bindings
= 1;
1049 _dl_debug_impcalls
= 1;
1054 if (memcmp (dl_debug
, "versions", 8) == 0)
1056 _dl_debug_versions
= 1;
1057 _dl_debug_impcalls
= 1;
1068 /* Display a warning and skip everything until next separator. */
1069 char *startp
= strndupa (dl_debug
, len
);
1070 _dl_sysdep_error ("warning: debug option `", startp
,
1071 "' unknown; try LD_DEBUG=help\n", NULL
);
1075 while (*(dl_debug
+= len
) != '\0');
1078 /* Process all environments variables the dynamic linker must recognize.
1079 Since all of them start with `LD_' we are a bit smarter while finding
1082 process_envvars (enum mode
*modep
, int *lazyp
)
1086 enum mode mode
= normal
;
1088 char *debug_output
= NULL
;
1090 /* This is the default place for profiling data file. */
1091 _dl_profile_output
= "/var/tmp";
1093 while ((envline
= _dl_next_ld_env_entry (&runp
)) != NULL
)
1095 size_t len
= strcspn (envline
, "=") - 3;
1100 /* Warning level, verbose or not. */
1101 if (memcmp (&envline
[3], "WARN", 4) == 0)
1102 _dl_verbose
= envline
[8] != '\0';
1106 /* Debugging of the dynamic linker? */
1107 if (memcmp (&envline
[3], "DEBUG", 5) == 0)
1108 process_dl_debug (&envline
[9]);
1112 /* Print information about versions. */
1113 if (memcmp (&envline
[3], "VERBOSE", 7) == 0)
1115 version_info
= envline
[11] != '\0';
1119 /* List of objects to be preloaded. */
1120 if (memcmp (&envline
[3], "PRELOAD", 7) == 0)
1122 preloadlist
= &envline
[11];
1126 /* Which shared object shall be profiled. */
1127 if (memcmp (&envline
[3], "PROFILE", 7) == 0)
1129 _dl_profile
= &envline
[11];
1130 if (*_dl_profile
== '\0')
1136 /* Do we bind early? */
1137 if (memcmp (&envline
[3], "BIND_NOW", 8) == 0
1138 && (envline
[12] == '1' || envline
[12] == 'y'
1139 || envline
[12] == 'Y'))
1144 /* Test whether we want to see the content of the auxiliary
1145 array passed up from the kernel. */
1146 if (memcmp (&envline
[3], "SHOW_AUXV", 9) == 0)
1151 /* Mask for the important hardware capabilities. */
1152 if (memcmp (&envline
[3], "HWCAP_MASK", 10) == 0)
1153 _dl_hwcap_mask
= strtoul (&envline
[14], NULL
, 0);
1157 /* Where to place the profiling data file. */
1158 if (memcmp (&envline
[3], "DEBUG_OUTPUT", 12) == 0)
1160 debug_output
= &envline
[16];
1164 /* The library search path. */
1165 if (memcmp (&envline
[3], "LIBRARY_PATH", 12) == 0)
1166 library_path
= &envline
[16];
1170 /* Where to place the profiling data file. */
1171 if (!__libc_enable_secure
1172 && memcmp (&envline
[3], "PROFILE_OUTPUT", 14) == 0)
1174 _dl_profile_output
= &envline
[18];
1175 if (*_dl_profile_output
== '\0')
1176 _dl_profile_output
= "/var/tmp";
1181 /* The mode of the dynamic linker can be set. */
1182 if (memcmp (&envline
[3], "TRACE_LOADED_OBJECTS", 20) == 0)
1186 /* We might have some extra environment variable to handle. This
1187 is tricky due to the pre-processing of the length of the name
1188 in the switch statement here. The code here assumes that added
1189 environment variables have a different length. */
1190 #ifdef EXTRA_LD_ENVVARS
1196 /* Extra security for SUID binaries. Remove all dangerous environment
1198 if (__libc_enable_secure
)
1200 static const char *unsecure_envvars
[] =
1202 #ifdef EXTRA_UNSECURE_ENVVARS
1203 EXTRA_UNSECURE_ENVVARS
1208 if (preloadlist
!= NULL
)
1209 unsetenv ("LD_PRELOAD");
1210 if (library_path
!= NULL
)
1211 unsetenv ("LD_LIBRARY_PATH");
1214 cnt
< sizeof (unsecure_envvars
) / sizeof (unsecure_envvars
[0]);
1216 unsetenv (unsecure_envvars
[cnt
]);
1219 /* If we have to run the dynamic linker in debugging mode and the
1220 LD_DEBUG_OUTPUT environment variable is given, we write the debug
1221 messages to this file. */
1222 if (any_debug
&& debug_output
!= NULL
&& !__libc_enable_secure
)
1224 _dl_debug_fd
= __open (debug_output
, O_WRONLY
| O_APPEND
| O_CREAT
,
1226 if (_dl_debug_fd
== -1)
1227 /* We use standard output if opening the file failed. */
1228 _dl_debug_fd
= STDOUT_FILENO
;
1231 /* LAZY is determined by the environment variable LD_WARN and
1232 LD_BIND_NOW if we trace the binary. */
1234 *lazyp
= _dl_verbose
? !bind_now
: -1;
1236 *lazyp
= !__libc_enable_secure
&& !bind_now
;