1 /* Run time dynamic linker.
2 Copyright (C) 1995-2019 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 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.
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.
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <http://www.gnu.org/licenses/>. */
27 #include <sys/param.h>
32 #include <fpu_control.h>
33 #include <hp-timing.h>
34 #include <libc-lock.h>
35 #include "dynamic-link.h"
36 #include <dl-librecon.h>
37 #include <unsecvars.h>
39 #include <dl-osinfo.h>
40 #include <dl-procinfo.h>
43 #include <stap-probe.h>
44 #include <stackinfo.h>
45 #include <not-cancel.h>
49 /* Avoid PLT use for our local calls at startup. */
50 extern __typeof (__mempcpy) __mempcpy attribute_hidden;
52 /* GCC has mental blocks about _exit. */
53 extern __typeof (_exit) exit_internal asm ("_exit") attribute_hidden;
54 #define _exit exit_internal
56 /* Helper function to handle errors while resolving symbols. */
57 static void print_unresolved (int errcode, const char *objname,
58 const char *errsting);
60 /* Helper function to handle errors when a version is missing. */
61 static void print_missing_version (int errcode, const char *objname,
62 const char *errsting);
64 /* Print the various times we collected. */
65 static void print_statistics (hp_timing_t *total_timep);
67 /* Add audit objects. */
68 static void process_dl_audit (char *str);
70 /* This is a list of all the modes the dynamic loader can be in. */
71 enum mode { normal, list, verify, trace };
73 /* Process all environments variables the dynamic linker must recognize.
74 Since all of them start with `LD_' we are a bit smarter while finding
76 static void process_envvars (enum mode *modep);
78 #ifdef DL_ARGV_NOT_RELRO
79 int _dl_argc attribute_hidden;
80 char **_dl_argv = NULL;
81 /* Nonzero if we were run directly. */
82 unsigned int _dl_skip_args attribute_hidden;
84 int _dl_argc attribute_relro attribute_hidden;
85 char **_dl_argv attribute_relro = NULL;
86 unsigned int _dl_skip_args attribute_relro attribute_hidden;
88 rtld_hidden_data_def (_dl_argv)
90 #ifndef THREAD_SET_STACK_GUARD
91 /* Only exported for architectures that don't store the stack guard canary
92 in thread local area. */
93 uintptr_t __stack_chk_guard attribute_relro;
96 /* Only exported for architectures that don't store the pointer guard
97 value in thread local area. */
98 uintptr_t __pointer_chk_guard_local
99 attribute_relro attribute_hidden __attribute__ ((nocommon));
100 #ifndef THREAD_SET_POINTER_GUARD
101 strong_alias (__pointer_chk_guard_local, __pointer_chk_guard)
104 /* Length limits for names and paths, to protect the dynamic linker,
105 particularly when __libc_enable_secure is active. */
107 # define SECURE_NAME_LIMIT NAME_MAX
109 # define SECURE_NAME_LIMIT 255
112 # define SECURE_PATH_LIMIT PATH_MAX
114 # define SECURE_PATH_LIMIT 1024
117 /* Check that AT_SECURE=0, or that the passed name does not contain
118 directories and is not overly long. Reject empty names
121 dso_name_valid_for_suid (const char *p)
123 if (__glibc_unlikely (__libc_enable_secure))
125 /* Ignore pathnames with directories for AT_SECURE=1
126 programs, and also skip overlong names. */
127 size_t len = strlen (p);
128 if (len >= SECURE_NAME_LIMIT || memchr (p, '/', len) != NULL)
134 /* LD_AUDIT variable contents. Must be processed before the
136 const char *audit_list_string;
138 /* Cyclic list of auditing DSOs. audit_list->next is the first
140 static struct audit_list
143 struct audit_list *next;
146 /* Iterator for audit_list_string followed by audit_list. */
147 struct audit_list_iter
149 /* Tail of audit_list_string still needing processing, or NULL. */
150 const char *audit_list_tail;
152 /* The list element returned in the previous iteration. NULL before
153 the first element. */
154 struct audit_list *previous;
156 /* Scratch buffer for returning a name which is part of
157 audit_list_string. */
158 char fname[SECURE_NAME_LIMIT];
161 /* Initialize an audit list iterator. */
163 audit_list_iter_init (struct audit_list_iter *iter)
165 iter->audit_list_tail = audit_list_string;
166 iter->previous = NULL;
169 /* Iterate through both audit_list_string and audit_list. */
171 audit_list_iter_next (struct audit_list_iter *iter)
173 if (iter->audit_list_tail != NULL)
175 /* First iterate over audit_list_string. */
176 while (*iter->audit_list_tail != '\0')
178 /* Split audit list at colon. */
179 size_t len = strcspn (iter->audit_list_tail, ":");
180 if (len > 0 && len < sizeof (iter->fname))
182 memcpy (iter->fname, iter->audit_list_tail, len);
183 iter->fname[len] = '\0';
186 /* Do not return this name to the caller. */
187 iter->fname[0] = '\0';
189 /* Skip over the substring and the following delimiter. */
190 iter->audit_list_tail += len;
191 if (*iter->audit_list_tail == ':')
192 ++iter->audit_list_tail;
194 /* If the name is valid, return it. */
195 if (dso_name_valid_for_suid (iter->fname))
197 /* Otherwise, wrap around and try the next name. */
199 /* Fall through to the procesing of audit_list. */
202 if (iter->previous == NULL)
204 if (audit_list == NULL)
205 /* No pre-parsed audit list. */
207 /* Start of audit list. The first list element is at
208 audit_list->next (cyclic list). */
209 iter->previous = audit_list->next;
210 return iter->previous->name;
212 if (iter->previous == audit_list)
213 /* Cyclic list wrap-around. */
215 iter->previous = iter->previous->next;
216 return iter->previous->name;
219 #ifndef HAVE_INLINED_SYSCALLS
220 /* Set nonzero during loading and initialization of executable and
221 libraries, cleared before the executable's entry point runs. This
222 must not be initialized to nonzero, because the unused dynamic
223 linker loaded in for libc.so's "ld.so.1" dep will provide the
224 definition seen by libc.so's initializer; that value must be zero,
225 and will be since that dynamic linker's _dl_start and dl_main will
227 int _dl_starting_up = 0;
228 rtld_hidden_def (_dl_starting_up)
231 /* This is the structure which defines all variables global to ld.so
232 (except those which cannot be added for some reason). */
233 struct rtld_global _rtld_global =
235 /* Generally the default presumption without further information is an
236 * executable stack but this is not true for all platforms. */
237 ._dl_stack_flags = DEFAULT_STACK_PERMS,
238 #ifdef _LIBC_REENTRANT
239 ._dl_load_lock = _RTLD_LOCK_RECURSIVE_INITIALIZER,
240 ._dl_load_write_lock = _RTLD_LOCK_RECURSIVE_INITIALIZER,
245 #ifdef _LIBC_REENTRANT
246 [LM_ID_BASE] = { ._ns_unique_sym_table
247 = { .lock = _RTLD_LOCK_RECURSIVE_INITIALIZER } }
251 /* If we would use strong_alias here the compiler would see a
252 non-hidden definition. This would undo the effect of the previous
253 declaration. So spell out was strong_alias does plus add the
254 visibility attribute. */
255 extern struct rtld_global _rtld_local
256 __attribute__ ((alias ("_rtld_global"), visibility ("hidden")));
259 /* This variable is similar to _rtld_local, but all values are
260 read-only after relocation. */
261 struct rtld_global_ro _rtld_global_ro attribute_relro =
263 /* Get architecture specific initializer. */
264 #include <dl-procinfo.c>
265 #ifdef NEED_DL_SYSINFO
266 ._dl_sysinfo = DL_SYSINFO_DEFAULT,
268 ._dl_debug_fd = STDERR_FILENO,
269 ._dl_use_load_bias = -2,
270 ._dl_correct_cache_id = _DL_CACHE_DEFAULT_ID,
272 ._dl_hwcap_mask = HWCAP_IMPORTANT,
275 ._dl_fpu_control = _FPU_DEFAULT,
276 ._dl_pagesize = EXEC_PAGESIZE,
277 ._dl_inhibit_cache = 0,
279 /* Function pointers. */
280 ._dl_debug_printf = _dl_debug_printf,
281 ._dl_mcount = _dl_mcount,
282 ._dl_lookup_symbol_x = _dl_lookup_symbol_x,
283 ._dl_open = _dl_open,
284 ._dl_close = _dl_close,
285 ._dl_tls_get_addr_soft = _dl_tls_get_addr_soft,
286 #ifdef HAVE_DL_DISCOVER_OSVERSION
287 ._dl_discover_osversion = _dl_discover_osversion
290 /* If we would use strong_alias here the compiler would see a
291 non-hidden definition. This would undo the effect of the previous
292 declaration. So spell out was strong_alias does plus add the
293 visibility attribute. */
294 extern struct rtld_global_ro _rtld_local_ro
295 __attribute__ ((alias ("_rtld_global_ro"), visibility ("hidden")));
298 static void dl_main (const ElfW(Phdr) *phdr, ElfW(Word) phnum,
299 ElfW(Addr) *user_entry, ElfW(auxv_t) *auxv);
301 /* These two variables cannot be moved into .data.rel.ro. */
302 static struct libname_list _dl_rtld_libname;
303 static struct libname_list _dl_rtld_libname2;
305 /* Variable for statistics. */
306 #ifndef HP_TIMING_NONAVAIL
307 static hp_timing_t relocate_time;
308 static hp_timing_t load_time attribute_relro;
309 static hp_timing_t start_time attribute_relro;
312 /* Additional definitions needed by TLS initialization. */
313 #ifdef TLS_INIT_HELPER
317 /* Helper function for syscall implementation. */
318 #ifdef DL_SYSINFO_IMPLEMENTATION
319 DL_SYSINFO_IMPLEMENTATION
322 /* Before ld.so is relocated we must not access variables which need
323 relocations. This means variables which are exported. Variables
324 declared as static are fine. If we can mark a variable hidden this
325 is fine, too. The latter is important here. We can avoid setting
326 up a temporary link map for ld.so if we can mark _rtld_global as
328 #ifdef PI_STATIC_AND_HIDDEN
329 # define DONT_USE_BOOTSTRAP_MAP 1
332 #ifdef DONT_USE_BOOTSTRAP_MAP
333 static ElfW(Addr) _dl_start_final (void *arg);
335 struct dl_start_final_info
338 #if !defined HP_TIMING_NONAVAIL && HP_TIMING_INLINE
339 hp_timing_t start_time;
342 static ElfW(Addr) _dl_start_final (void *arg,
343 struct dl_start_final_info *info);
346 /* These defined magically in the linker script. */
347 extern char _begin[] attribute_hidden;
348 extern char _etext[] attribute_hidden;
349 extern char _end[] attribute_hidden;
355 # error "sysdeps/MACHINE/dl-machine.h fails to define RTLD_START"
358 /* This is the second half of _dl_start (below). It can be inlined safely
359 under DONT_USE_BOOTSTRAP_MAP, where it is careful not to make any GOT
360 references. When the tools don't permit us to avoid using a GOT entry
361 for _dl_rtld_global (no attribute_hidden support), we must make sure
362 this function is not inlined (see below). */
364 #ifdef DONT_USE_BOOTSTRAP_MAP
365 static inline ElfW(Addr) __attribute__ ((always_inline))
366 _dl_start_final (void *arg)
368 static ElfW(Addr) __attribute__ ((noinline))
369 _dl_start_final (void *arg, struct dl_start_final_info *info)
372 ElfW(Addr) start_addr;
374 if (HP_SMALL_TIMING_AVAIL)
376 /* If it hasn't happen yet record the startup time. */
377 if (! HP_TIMING_INLINE)
378 HP_TIMING_NOW (start_time);
379 #if !defined DONT_USE_BOOTSTRAP_MAP && !defined HP_TIMING_NONAVAIL
381 start_time = info->start_time;
385 /* Transfer data about ourselves to the permanent link_map structure. */
386 #ifndef DONT_USE_BOOTSTRAP_MAP
387 GL(dl_rtld_map).l_addr = info->l.l_addr;
388 GL(dl_rtld_map).l_ld = info->l.l_ld;
389 memcpy (GL(dl_rtld_map).l_info, info->l.l_info,
390 sizeof GL(dl_rtld_map).l_info);
391 GL(dl_rtld_map).l_mach = info->l.l_mach;
392 GL(dl_rtld_map).l_relocated = 1;
394 _dl_setup_hash (&GL(dl_rtld_map));
395 GL(dl_rtld_map).l_real = &GL(dl_rtld_map);
396 GL(dl_rtld_map).l_map_start = (ElfW(Addr)) _begin;
397 GL(dl_rtld_map).l_map_end = (ElfW(Addr)) _end;
398 GL(dl_rtld_map).l_text_end = (ElfW(Addr)) _etext;
399 /* Copy the TLS related data if necessary. */
400 #ifndef DONT_USE_BOOTSTRAP_MAP
401 # if NO_TLS_OFFSET != 0
402 GL(dl_rtld_map).l_tls_offset = NO_TLS_OFFSET;
406 HP_TIMING_NOW (GL(dl_cpuclock_offset));
408 /* Initialize the stack end variable. */
409 __libc_stack_end = __builtin_frame_address (0);
411 /* Call the OS-dependent function to set up life so we can do things like
412 file access. It will call `dl_main' (below) to do all the real work
413 of the dynamic linker, and then unwind our frame and run the user
414 entry point on the same stack we entered on. */
415 start_addr = _dl_sysdep_start (arg, &dl_main);
417 #ifndef HP_TIMING_NONAVAIL
418 hp_timing_t rtld_total_time;
419 if (HP_SMALL_TIMING_AVAIL)
421 hp_timing_t end_time;
423 /* Get the current time. */
424 HP_TIMING_NOW (end_time);
426 /* Compute the difference. */
427 HP_TIMING_DIFF (rtld_total_time, start_time, end_time);
431 if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_STATISTICS))
433 #ifndef HP_TIMING_NONAVAIL
434 print_statistics (&rtld_total_time);
436 print_statistics (NULL);
443 static ElfW(Addr) __attribute_used__
444 _dl_start (void *arg)
446 #ifdef DONT_USE_BOOTSTRAP_MAP
447 # define bootstrap_map GL(dl_rtld_map)
449 struct dl_start_final_info info;
450 # define bootstrap_map info.l
453 /* This #define produces dynamic linking inline functions for
454 bootstrap relocation instead of general-purpose relocation.
455 Since ld.so must not have any undefined symbols the result
456 is trivial: always the map of ld.so itself. */
457 #define RTLD_BOOTSTRAP
458 #define BOOTSTRAP_MAP (&bootstrap_map)
459 #define RESOLVE_MAP(sym, version, flags) BOOTSTRAP_MAP
460 #include "dynamic-link.h"
462 if (HP_TIMING_INLINE && HP_SMALL_TIMING_AVAIL)
463 #ifdef DONT_USE_BOOTSTRAP_MAP
464 HP_TIMING_NOW (start_time);
466 HP_TIMING_NOW (info.start_time);
469 /* Partly clean the `bootstrap_map' structure up. Don't use
470 `memset' since it might not be built in or inlined and we cannot
471 make function calls at this point. Use '__builtin_memset' if we
472 know it is available. We do not have to clear the memory if we
473 do not have to use the temporary bootstrap_map. Global variables
474 are initialized to zero by default. */
475 #ifndef DONT_USE_BOOTSTRAP_MAP
476 # ifdef HAVE_BUILTIN_MEMSET
477 __builtin_memset (bootstrap_map.l_info, '\0', sizeof (bootstrap_map.l_info));
480 cnt < sizeof (bootstrap_map.l_info) / sizeof (bootstrap_map.l_info[0]);
482 bootstrap_map.l_info[cnt] = 0;
486 /* Figure out the run-time load address of the dynamic linker itself. */
487 bootstrap_map.l_addr = elf_machine_load_address ();
489 /* Read our own dynamic section and fill in the info array. */
490 bootstrap_map.l_ld = (void *) bootstrap_map.l_addr + elf_machine_dynamic ();
491 elf_get_dynamic_info (&bootstrap_map, NULL);
493 #if NO_TLS_OFFSET != 0
494 bootstrap_map.l_tls_offset = NO_TLS_OFFSET;
497 #ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
498 ELF_MACHINE_BEFORE_RTLD_RELOC (bootstrap_map.l_info);
501 if (bootstrap_map.l_addr || ! bootstrap_map.l_info[VALIDX(DT_GNU_PRELINKED)])
503 /* Relocate ourselves so we can do normal function calls and
504 data access using the global offset table. */
506 ELF_DYNAMIC_RELOCATE (&bootstrap_map, 0, 0, 0);
508 bootstrap_map.l_relocated = 1;
510 /* Please note that we don't allow profiling of this object and
511 therefore need not test whether we have to allocate the array
512 for the relocation results (as done in dl-reloc.c). */
514 /* Now life is sane; we can call functions and access global data.
515 Set up to use the operating system facilities, and find out from
516 the operating system's program loader where to find the program
517 header table in core. Put the rest of _dl_start into a separate
518 function, that way the compiler cannot put accesses to the GOT
519 before ELF_DYNAMIC_RELOCATE. */
521 #ifdef DONT_USE_BOOTSTRAP_MAP
522 ElfW(Addr) entry = _dl_start_final (arg);
524 ElfW(Addr) entry = _dl_start_final (arg, &info);
527 #ifndef ELF_MACHINE_START_ADDRESS
528 # define ELF_MACHINE_START_ADDRESS(map, start) (start)
531 return ELF_MACHINE_START_ADDRESS (GL(dl_ns)[LM_ID_BASE]._ns_loaded, entry);
537 /* Now life is peachy; we can do all normal operations.
538 On to the real work. */
540 /* Some helper functions. */
542 /* Arguments to relocate_doit. */
551 /* Argument to map_doit. */
553 struct link_map *loader;
555 /* Return value of map_doit. */
556 struct link_map *map;
562 struct link_map *map;
568 struct link_map *map;
572 /* Arguments to version_check_doit. */
573 struct version_check_args
580 relocate_doit (void *a)
582 struct relocate_args *args = (struct relocate_args *) a;
584 _dl_relocate_object (args->l, args->l->l_scope, args->reloc_mode, 0);
590 struct map_args *args = (struct map_args *) a;
591 int type = (args->mode == __RTLD_OPENEXEC) ? lt_executable : lt_library;
592 args->map = _dl_map_object (args->loader, args->str, type, 0,
593 args->mode, LM_ID_BASE);
597 dlmopen_doit (void *a)
599 struct dlmopen_args *args = (struct dlmopen_args *) a;
600 args->map = _dl_open (args->fname,
601 (RTLD_LAZY | __RTLD_DLOPEN | __RTLD_AUDIT
603 dl_main, LM_ID_NEWLM, _dl_argc, _dl_argv,
608 lookup_doit (void *a)
610 struct lookup_args *args = (struct lookup_args *) a;
611 const ElfW(Sym) *ref = NULL;
613 lookup_t l = _dl_lookup_symbol_x (args->name, args->map, &ref,
614 args->map->l_local_scope, NULL, 0,
615 DL_LOOKUP_RETURN_NEWEST, NULL);
617 args->result = DL_SYMBOL_ADDRESS (l, ref);
621 version_check_doit (void *a)
623 struct version_check_args *args = (struct version_check_args *) a;
624 if (_dl_check_all_versions (GL(dl_ns)[LM_ID_BASE]._ns_loaded, 1,
625 args->dotrace) && args->doexit)
626 /* We cannot start the application. Abort now. */
631 static inline struct link_map *
632 find_needed (const char *name)
634 struct r_scope_elem *scope = &GL(dl_ns)[LM_ID_BASE]._ns_loaded->l_searchlist;
635 unsigned int n = scope->r_nlist;
638 if (_dl_name_match_p (name, scope->r_list[n]))
639 return scope->r_list[n];
641 /* Should never happen. */
646 match_version (const char *string, struct link_map *map)
648 const char *strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
651 #define VERDEFTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERDEF))
652 if (map->l_info[VERDEFTAG] == NULL)
653 /* The file has no symbol versioning. */
656 def = (ElfW(Verdef) *) ((char *) map->l_addr
657 + map->l_info[VERDEFTAG]->d_un.d_ptr);
660 ElfW(Verdaux) *aux = (ElfW(Verdaux) *) ((char *) def + def->vd_aux);
662 /* Compare the version strings. */
663 if (strcmp (string, strtab + aux->vda_name) == 0)
667 /* If no more definitions we failed to find what we want. */
668 if (def->vd_next == 0)
671 /* Next definition. */
672 def = (ElfW(Verdef) *) ((char *) def + def->vd_next);
678 static bool tls_init_tp_called;
683 /* Number of elements in the static TLS block. */
684 GL(dl_tls_static_nelem) = GL(dl_tls_max_dtv_idx);
686 /* Do not do this twice. The audit interface might have required
687 the DTV interfaces to be set up early. */
688 if (GL(dl_initial_dtv) != NULL)
691 /* Allocate the array which contains the information about the
692 dtv slots. We allocate a few entries more than needed to
693 avoid the need for reallocation. */
694 size_t nelem = GL(dl_tls_max_dtv_idx) + 1 + TLS_SLOTINFO_SURPLUS;
697 GL(dl_tls_dtv_slotinfo_list) = (struct dtv_slotinfo_list *)
698 calloc (sizeof (struct dtv_slotinfo_list)
699 + nelem * sizeof (struct dtv_slotinfo), 1);
700 /* No need to check the return value. If memory allocation failed
701 the program would have been terminated. */
703 struct dtv_slotinfo *slotinfo = GL(dl_tls_dtv_slotinfo_list)->slotinfo;
704 GL(dl_tls_dtv_slotinfo_list)->len = nelem;
705 GL(dl_tls_dtv_slotinfo_list)->next = NULL;
707 /* Fill in the information from the loaded modules. No namespace
708 but the base one can be filled at this time. */
709 assert (GL(dl_ns)[LM_ID_BASE + 1]._ns_loaded == NULL);
711 for (struct link_map *l = GL(dl_ns)[LM_ID_BASE]._ns_loaded; l != NULL;
713 if (l->l_tls_blocksize != 0)
715 /* This is a module with TLS data. Store the map reference.
716 The generation counter is zero. */
718 /* slotinfo[i].gen = 0; */
721 assert (i == GL(dl_tls_max_dtv_idx));
723 /* Compute the TLS offsets for the various blocks. */
724 _dl_determine_tlsoffset ();
726 /* Construct the static TLS block and the dtv for the initial
727 thread. For some platforms this will include allocating memory
728 for the thread descriptor. The memory for the TLS block will
729 never be freed. It should be allocated accordingly. The dtv
730 array can be changed if dynamic loading requires it. */
731 void *tcbp = _dl_allocate_tls_storage ();
734 cannot allocate TLS data structures for initial thread\n");
736 /* Store for detection of the special case by __tls_get_addr
737 so it knows not to pass this dtv to the normal realloc. */
738 GL(dl_initial_dtv) = GET_DTV (tcbp);
740 /* And finally install it for the main thread. */
741 const char *lossage = TLS_INIT_TP (tcbp);
742 if (__glibc_unlikely (lossage != NULL))
743 _dl_fatal_printf ("cannot set up thread-local storage: %s\n", lossage);
744 tls_init_tp_called = true;
750 do_preload (const char *fname, struct link_map *main_map, const char *where)
753 const char *err_str = NULL;
754 struct map_args args;
758 args.loader = main_map;
759 args.mode = __RTLD_SECURE;
761 unsigned int old_nloaded = GL(dl_ns)[LM_ID_BASE]._ns_nloaded;
763 (void) _dl_catch_error (&objname, &err_str, &malloced, map_doit, &args);
764 if (__glibc_unlikely (err_str != NULL))
767 ERROR: ld.so: object '%s' from %s cannot be preloaded (%s): ignored.\n",
768 fname, where, err_str);
769 /* No need to call free, this is still before
770 the libc's malloc is used. */
772 else if (GL(dl_ns)[LM_ID_BASE]._ns_nloaded != old_nloaded)
773 /* It is no duplicate. */
776 /* Nothing loaded. */
780 #if defined SHARED && defined _LIBC_REENTRANT \
781 && defined __rtld_lock_default_lock_recursive
783 rtld_lock_default_lock_recursive (void *lock)
785 __rtld_lock_default_lock_recursive (lock);
789 rtld_lock_default_unlock_recursive (void *lock)
791 __rtld_lock_default_unlock_recursive (lock);
799 /* Set up the stack checker's canary. */
800 uintptr_t stack_chk_guard = _dl_setup_stack_chk_guard (_dl_random);
801 #ifdef THREAD_SET_STACK_GUARD
802 THREAD_SET_STACK_GUARD (stack_chk_guard);
804 __stack_chk_guard = stack_chk_guard;
807 /* Set up the pointer guard as well, if necessary. */
808 uintptr_t pointer_chk_guard
809 = _dl_setup_pointer_guard (_dl_random, stack_chk_guard);
810 #ifdef THREAD_SET_POINTER_GUARD
811 THREAD_SET_POINTER_GUARD (pointer_chk_guard);
813 __pointer_chk_guard_local = pointer_chk_guard;
815 /* We do not need the _dl_random value anymore. The less
816 information we leave behind, the better, so clear the
821 #include "setup-vdso.h"
823 /* The library search path. */
824 static const char *library_path attribute_relro;
825 /* The list preloaded objects. */
826 static const char *preloadlist attribute_relro;
827 /* Nonzero if information about versions has to be printed. */
828 static int version_info attribute_relro;
829 /* The preload list passed as a command argument. */
830 static const char *preloadarg attribute_relro;
832 /* The LD_PRELOAD environment variable gives list of libraries
833 separated by white space or colons that are loaded before the
834 executable's dependencies and prepended to the global scope list.
835 (If the binary is running setuid all elements containing a '/' are
836 ignored since it is insecure.) Return the number of preloads
837 performed. Ditto for --preload command argument. */
839 handle_preload_list (const char *preloadlist, struct link_map *main_map,
842 unsigned int npreloads = 0;
843 const char *p = preloadlist;
844 char fname[SECURE_PATH_LIMIT];
848 /* Split preload list at space/colon. */
849 size_t len = strcspn (p, " :");
850 if (len > 0 && len < sizeof (fname))
852 memcpy (fname, p, len);
858 /* Skip over the substring and the following delimiter. */
863 if (dso_name_valid_for_suid (fname))
864 npreloads += do_preload (fname, main_map, where);
870 dl_main (const ElfW(Phdr) *phdr,
872 ElfW(Addr) *user_entry,
875 const ElfW(Phdr) *ph;
877 struct link_map *main_map;
880 bool has_interp = false;
882 bool prelinked = false;
883 bool rtld_is_main = false;
884 #ifndef HP_TIMING_NONAVAIL
891 GL(dl_init_static_tls) = &_dl_nothread_init_static_tls;
893 #if defined SHARED && defined _LIBC_REENTRANT \
894 && defined __rtld_lock_default_lock_recursive
895 GL(dl_rtld_lock_recursive) = rtld_lock_default_lock_recursive;
896 GL(dl_rtld_unlock_recursive) = rtld_lock_default_unlock_recursive;
899 /* The explicit initialization here is cheaper than processing the reloc
900 in the _rtld_local definition's initializer. */
901 GL(dl_make_stack_executable_hook) = &_dl_make_stack_executable;
903 /* Process the environment variable which control the behaviour. */
904 process_envvars (&mode);
906 #ifndef HAVE_INLINED_SYSCALLS
907 /* Set up a flag which tells we are just starting. */
911 if (*user_entry == (ElfW(Addr)) ENTRY_POINT)
913 /* Ho ho. We are not the program interpreter! We are the program
914 itself! This means someone ran ld.so as a command. Well, that
915 might be convenient to do sometimes. We support it by
916 interpreting the args like this:
918 ld.so PROGRAM ARGS...
920 The first argument is the name of a file containing an ELF
921 executable we will load and run with the following arguments.
922 To simplify life here, PROGRAM is searched for using the
923 normal rules for shared objects, rather than $PATH or anything
924 like that. We just load it and use its entry point; we don't
925 pay attention to its PT_INTERP command (we are the interpreter
926 ourselves). This is an easy way to test a new ld.so before
930 /* Note the place where the dynamic linker actually came from. */
931 GL(dl_rtld_map).l_name = rtld_progname;
934 if (! strcmp (_dl_argv[1], "--list"))
937 GLRO(dl_lazy) = -1; /* This means do no dependency analysis. */
943 else if (! strcmp (_dl_argv[1], "--verify"))
951 else if (! strcmp (_dl_argv[1], "--inhibit-cache"))
953 GLRO(dl_inhibit_cache) = 1;
958 else if (! strcmp (_dl_argv[1], "--library-path")
961 library_path = _dl_argv[2];
967 else if (! strcmp (_dl_argv[1], "--inhibit-rpath")
970 GLRO(dl_inhibit_rpath) = _dl_argv[2];
976 else if (! strcmp (_dl_argv[1], "--audit") && _dl_argc > 2)
978 process_dl_audit (_dl_argv[2]);
984 else if (! strcmp (_dl_argv[1], "--preload") && _dl_argc > 2)
986 preloadarg = _dl_argv[2];
994 /* If we have no further argument the program was called incorrectly.
995 Grant the user some education. */
998 Usage: ld.so [OPTION]... EXECUTABLE-FILE [ARGS-FOR-PROGRAM...]\n\
999 You have invoked `ld.so', the helper program for shared library executables.\n\
1000 This program usually lives in the file `/lib/ld.so', and special directives\n\
1001 in executable files using ELF shared libraries tell the system's program\n\
1002 loader to load the helper program from this file. This helper program loads\n\
1003 the shared libraries needed by the program executable, prepares the program\n\
1004 to run, and runs it. You may invoke this helper program directly from the\n\
1005 command line to load and run an ELF executable file; this is like executing\n\
1006 that file itself, but always uses this helper program from the file you\n\
1007 specified, instead of the helper program file specified in the executable\n\
1008 file you run. This is mostly of use for maintainers to test new versions\n\
1009 of this helper program; chances are you did not intend to run this program.\n\
1011 --list list all dependencies and how they are resolved\n\
1012 --verify verify that given object really is a dynamically linked\n\
1013 object we can handle\n\
1014 --inhibit-cache Do not use " LD_SO_CACHE "\n\
1015 --library-path PATH use given PATH instead of content of the environment\n\
1016 variable LD_LIBRARY_PATH\n\
1017 --inhibit-rpath LIST ignore RUNPATH and RPATH information in object names\n\
1019 --audit LIST use objects named in LIST as auditors\n\
1020 --preload LIST preload objects named in LIST\n");
1026 /* The initialization of _dl_stack_flags done below assumes the
1027 executable's PT_GNU_STACK may have been honored by the kernel, and
1028 so a PT_GNU_STACK with PF_X set means the stack started out with
1029 execute permission. However, this is not really true if the
1030 dynamic linker is the executable the kernel loaded. For this
1031 case, we must reinitialize _dl_stack_flags to match the dynamic
1032 linker itself. If the dynamic linker was built with a
1033 PT_GNU_STACK, then the kernel may have loaded us with a
1034 nonexecutable stack that we will have to make executable when we
1035 load the program below unless it has a PT_GNU_STACK indicating
1036 nonexecutable stack is ok. */
1038 for (ph = phdr; ph < &phdr[phnum]; ++ph)
1039 if (ph->p_type == PT_GNU_STACK)
1041 GL(dl_stack_flags) = ph->p_flags;
1045 if (__builtin_expect (mode, normal) == verify)
1047 const char *objname;
1048 const char *err_str = NULL;
1049 struct map_args args;
1052 args.str = rtld_progname;
1054 args.mode = __RTLD_OPENEXEC;
1055 (void) _dl_catch_error (&objname, &err_str, &malloced, map_doit,
1057 if (__glibc_unlikely (err_str != NULL))
1058 /* We don't free the returned string, the programs stops
1060 _exit (EXIT_FAILURE);
1064 HP_TIMING_NOW (start);
1065 _dl_map_object (NULL, rtld_progname, lt_executable, 0,
1066 __RTLD_OPENEXEC, LM_ID_BASE);
1067 HP_TIMING_NOW (stop);
1069 HP_TIMING_DIFF (load_time, start, stop);
1072 /* Now the map for the main executable is available. */
1073 main_map = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
1075 if (__builtin_expect (mode, normal) == normal
1076 && GL(dl_rtld_map).l_info[DT_SONAME] != NULL
1077 && main_map->l_info[DT_SONAME] != NULL
1078 && strcmp ((const char *) D_PTR (&GL(dl_rtld_map), l_info[DT_STRTAB])
1079 + GL(dl_rtld_map).l_info[DT_SONAME]->d_un.d_val,
1080 (const char *) D_PTR (main_map, l_info[DT_STRTAB])
1081 + main_map->l_info[DT_SONAME]->d_un.d_val) == 0)
1082 _dl_fatal_printf ("loader cannot load itself\n");
1084 phdr = main_map->l_phdr;
1085 phnum = main_map->l_phnum;
1086 /* We overwrite here a pointer to a malloc()ed string. But since
1087 the malloc() implementation used at this point is the dummy
1088 implementations which has no real free() function it does not
1089 makes sense to free the old string first. */
1090 main_map->l_name = (char *) "";
1091 *user_entry = main_map->l_entry;
1093 #ifdef HAVE_AUX_VECTOR
1094 /* Adjust the on-stack auxiliary vector so that it looks like the
1095 binary was executed directly. */
1096 for (ElfW(auxv_t) *av = auxv; av->a_type != AT_NULL; av++)
1100 av->a_un.a_val = (uintptr_t) phdr;
1103 av->a_un.a_val = phnum;
1106 av->a_un.a_val = *user_entry;
1109 av->a_un.a_val = (uintptr_t) _dl_argv[0];
1116 /* Create a link_map for the executable itself.
1117 This will be what dlopen on "" returns. */
1118 main_map = _dl_new_object ((char *) "", "", lt_executable, NULL,
1119 __RTLD_OPENEXEC, LM_ID_BASE);
1120 assert (main_map != NULL);
1121 main_map->l_phdr = phdr;
1122 main_map->l_phnum = phnum;
1123 main_map->l_entry = *user_entry;
1125 /* Even though the link map is not yet fully initialized we can add
1126 it to the map list since there are no possible users running yet. */
1127 _dl_add_to_namespace_list (main_map, LM_ID_BASE);
1128 assert (main_map == GL(dl_ns)[LM_ID_BASE]._ns_loaded);
1130 /* At this point we are in a bit of trouble. We would have to
1131 fill in the values for l_dev and l_ino. But in general we
1132 do not know where the file is. We also do not handle AT_EXECFD
1133 even if it would be passed up.
1135 We leave the values here defined to 0. This is normally no
1136 problem as the program code itself is normally no shared
1137 object and therefore cannot be loaded dynamically. Nothing
1138 prevent the use of dynamic binaries and in these situations
1139 we might get problems. We might not be able to find out
1140 whether the object is already loaded. But since there is no
1141 easy way out and because the dynamic binary must also not
1142 have an SONAME we ignore this program for now. If it becomes
1143 a problem we can force people using SONAMEs. */
1145 /* We delay initializing the path structure until we got the dynamic
1146 information for the program. */
1149 main_map->l_map_end = 0;
1150 main_map->l_text_end = 0;
1151 /* Perhaps the executable has no PT_LOAD header entries at all. */
1152 main_map->l_map_start = ~0;
1153 /* And it was opened directly. */
1154 ++main_map->l_direct_opencount;
1156 /* Scan the program header table for the dynamic section. */
1157 for (ph = phdr; ph < &phdr[phnum]; ++ph)
1161 /* Find out the load address. */
1162 main_map->l_addr = (ElfW(Addr)) phdr - ph->p_vaddr;
1165 /* This tells us where to find the dynamic section,
1166 which tells us everything we need to do. */
1167 main_map->l_ld = (void *) main_map->l_addr + ph->p_vaddr;
1170 /* This "interpreter segment" was used by the program loader to
1171 find the program interpreter, which is this program itself, the
1172 dynamic linker. We note what name finds us, so that a future
1173 dlopen call or DT_NEEDED entry, for something that wants to link
1174 against the dynamic linker as a shared library, will know that
1175 the shared object is already loaded. */
1176 _dl_rtld_libname.name = ((const char *) main_map->l_addr
1178 /* _dl_rtld_libname.next = NULL; Already zero. */
1179 GL(dl_rtld_map).l_libname = &_dl_rtld_libname;
1181 /* Ordinarilly, we would get additional names for the loader from
1182 our DT_SONAME. This can't happen if we were actually linked as
1183 a static executable (detect this case when we have no DYNAMIC).
1184 If so, assume the filename component of the interpreter path to
1185 be our SONAME, and add it to our name list. */
1186 if (GL(dl_rtld_map).l_ld == NULL)
1188 const char *p = NULL;
1189 const char *cp = _dl_rtld_libname.name;
1191 /* Find the filename part of the path. */
1198 _dl_rtld_libname2.name = p;
1199 /* _dl_rtld_libname2.next = NULL; Already zero. */
1200 _dl_rtld_libname.next = &_dl_rtld_libname2;
1208 ElfW(Addr) mapstart;
1209 ElfW(Addr) allocend;
1211 /* Remember where the main program starts in memory. */
1212 mapstart = (main_map->l_addr
1213 + (ph->p_vaddr & ~(GLRO(dl_pagesize) - 1)));
1214 if (main_map->l_map_start > mapstart)
1215 main_map->l_map_start = mapstart;
1217 /* Also where it ends. */
1218 allocend = main_map->l_addr + ph->p_vaddr + ph->p_memsz;
1219 if (main_map->l_map_end < allocend)
1220 main_map->l_map_end = allocend;
1221 if ((ph->p_flags & PF_X) && allocend > main_map->l_text_end)
1222 main_map->l_text_end = allocend;
1227 if (ph->p_memsz > 0)
1229 /* Note that in the case the dynamic linker we duplicate work
1230 here since we read the PT_TLS entry already in
1231 _dl_start_final. But the result is repeatable so do not
1232 check for this special but unimportant case. */
1233 main_map->l_tls_blocksize = ph->p_memsz;
1234 main_map->l_tls_align = ph->p_align;
1235 if (ph->p_align == 0)
1236 main_map->l_tls_firstbyte_offset = 0;
1238 main_map->l_tls_firstbyte_offset = (ph->p_vaddr
1239 & (ph->p_align - 1));
1240 main_map->l_tls_initimage_size = ph->p_filesz;
1241 main_map->l_tls_initimage = (void *) ph->p_vaddr;
1243 /* This image gets the ID one. */
1244 GL(dl_tls_max_dtv_idx) = main_map->l_tls_modid = 1;
1249 GL(dl_stack_flags) = ph->p_flags;
1253 main_map->l_relro_addr = ph->p_vaddr;
1254 main_map->l_relro_size = ph->p_memsz;
1258 if (_rtld_process_pt_note (main_map, ph))
1259 _dl_error_printf ("\
1260 ERROR: '%s': cannot process note segment.\n", _dl_argv[0]);
1264 /* Adjust the address of the TLS initialization image in case
1265 the executable is actually an ET_DYN object. */
1266 if (main_map->l_tls_initimage != NULL)
1267 main_map->l_tls_initimage
1268 = (char *) main_map->l_tls_initimage + main_map->l_addr;
1269 if (! main_map->l_map_end)
1270 main_map->l_map_end = ~0;
1271 if (! main_map->l_text_end)
1272 main_map->l_text_end = ~0;
1273 if (! GL(dl_rtld_map).l_libname && GL(dl_rtld_map).l_name)
1275 /* We were invoked directly, so the program might not have a
1277 _dl_rtld_libname.name = GL(dl_rtld_map).l_name;
1278 /* _dl_rtld_libname.next = NULL; Already zero. */
1279 GL(dl_rtld_map).l_libname = &_dl_rtld_libname;
1282 assert (GL(dl_rtld_map).l_libname); /* How else did we get here? */
1284 /* If the current libname is different from the SONAME, add the
1286 if (GL(dl_rtld_map).l_info[DT_SONAME] != NULL
1287 && strcmp (GL(dl_rtld_map).l_libname->name,
1288 (const char *) D_PTR (&GL(dl_rtld_map), l_info[DT_STRTAB])
1289 + GL(dl_rtld_map).l_info[DT_SONAME]->d_un.d_val) != 0)
1291 static struct libname_list newname;
1292 newname.name = ((char *) D_PTR (&GL(dl_rtld_map), l_info[DT_STRTAB])
1293 + GL(dl_rtld_map).l_info[DT_SONAME]->d_un.d_ptr);
1294 newname.next = NULL;
1295 newname.dont_free = 1;
1297 assert (GL(dl_rtld_map).l_libname->next == NULL);
1298 GL(dl_rtld_map).l_libname->next = &newname;
1300 /* The ld.so must be relocated since otherwise loading audit modules
1301 will fail since they reuse the very same ld.so. */
1302 assert (GL(dl_rtld_map).l_relocated);
1306 /* Extract the contents of the dynamic section for easy access. */
1307 elf_get_dynamic_info (main_map, NULL);
1308 /* Set up our cache of pointers into the hash table. */
1309 _dl_setup_hash (main_map);
1312 if (__builtin_expect (mode, normal) == verify)
1314 /* We were called just to verify that this is a dynamic
1315 executable using us as the program interpreter. Exit with an
1316 error if we were not able to load the binary or no interpreter
1317 is specified (i.e., this is no dynamically linked binary. */
1318 if (main_map->l_ld == NULL)
1321 /* We allow here some platform specific code. */
1322 #ifdef DISTINGUISH_LIB_VERSIONS
1323 DISTINGUISH_LIB_VERSIONS;
1325 _exit (has_interp ? 0 : 2);
1328 struct link_map **first_preload = &GL(dl_rtld_map).l_next;
1329 /* Set up the data structures for the system-supplied DSO early,
1330 so they can influence _dl_init_paths. */
1331 setup_vdso (main_map, &first_preload);
1333 #ifdef DL_SYSDEP_OSCHECK
1334 DL_SYSDEP_OSCHECK (_dl_fatal_printf);
1337 /* Initialize the data structures for the search paths for shared
1339 _dl_init_paths (library_path);
1341 /* Initialize _r_debug. */
1342 struct r_debug *r = _dl_debug_initialize (GL(dl_rtld_map).l_addr,
1344 r->r_state = RT_CONSISTENT;
1346 /* Put the link_map for ourselves on the chain so it can be found by
1347 name. Note that at this point the global chain of link maps contains
1348 exactly one element, which is pointed to by dl_loaded. */
1349 if (! GL(dl_rtld_map).l_name)
1350 /* If not invoked directly, the dynamic linker shared object file was
1351 found by the PT_INTERP name. */
1352 GL(dl_rtld_map).l_name = (char *) GL(dl_rtld_map).l_libname->name;
1353 GL(dl_rtld_map).l_type = lt_library;
1354 main_map->l_next = &GL(dl_rtld_map);
1355 GL(dl_rtld_map).l_prev = main_map;
1356 ++GL(dl_ns)[LM_ID_BASE]._ns_nloaded;
1359 /* If LD_USE_LOAD_BIAS env variable has not been seen, default
1360 to not using bias for non-prelinked PIEs and libraries
1361 and using it for executables or prelinked PIEs or libraries. */
1362 if (GLRO(dl_use_load_bias) == (ElfW(Addr)) -2)
1363 GLRO(dl_use_load_bias) = main_map->l_addr == 0 ? -1 : 0;
1365 /* Set up the program header information for the dynamic linker
1366 itself. It is needed in the dl_iterate_phdr callbacks. */
1367 const ElfW(Ehdr) *rtld_ehdr;
1369 /* Starting from binutils-2.23, the linker will define the magic symbol
1370 __ehdr_start to point to our own ELF header if it is visible in a
1371 segment that also includes the phdrs. If that's not available, we use
1372 the old method that assumes the beginning of the file is part of the
1373 lowest-addressed PT_LOAD segment. */
1374 #ifdef HAVE_EHDR_START
1375 extern const ElfW(Ehdr) __ehdr_start __attribute__ ((visibility ("hidden")));
1376 rtld_ehdr = &__ehdr_start;
1378 rtld_ehdr = (void *) GL(dl_rtld_map).l_map_start;
1380 assert (rtld_ehdr->e_ehsize == sizeof *rtld_ehdr);
1381 assert (rtld_ehdr->e_phentsize == sizeof (ElfW(Phdr)));
1383 const ElfW(Phdr) *rtld_phdr = (const void *) rtld_ehdr + rtld_ehdr->e_phoff;
1385 GL(dl_rtld_map).l_phdr = rtld_phdr;
1386 GL(dl_rtld_map).l_phnum = rtld_ehdr->e_phnum;
1389 /* PT_GNU_RELRO is usually the last phdr. */
1390 size_t cnt = rtld_ehdr->e_phnum;
1392 if (rtld_phdr[cnt].p_type == PT_GNU_RELRO)
1394 GL(dl_rtld_map).l_relro_addr = rtld_phdr[cnt].p_vaddr;
1395 GL(dl_rtld_map).l_relro_size = rtld_phdr[cnt].p_memsz;
1399 /* Add the dynamic linker to the TLS list if it also uses TLS. */
1400 if (GL(dl_rtld_map).l_tls_blocksize != 0)
1401 /* Assign a module ID. Do this before loading any audit modules. */
1402 GL(dl_rtld_map).l_tls_modid = _dl_next_tls_modid ();
1404 /* If we have auditing DSOs to load, do it now. */
1405 bool need_security_init = true;
1406 if (__glibc_unlikely (audit_list != NULL)
1407 || __glibc_unlikely (audit_list_string != NULL))
1409 struct audit_ifaces *last_audit = NULL;
1410 struct audit_list_iter al_iter;
1411 audit_list_iter_init (&al_iter);
1413 /* Since we start using the auditing DSOs right away we need to
1414 initialize the data structures now. */
1417 /* Initialize security features. We need to do it this early
1418 since otherwise the constructors of the audit libraries will
1419 use different values (especially the pointer guard) and will
1422 need_security_init = false;
1426 const char *name = audit_list_iter_next (&al_iter);
1430 int tls_idx = GL(dl_tls_max_dtv_idx);
1432 /* Now it is time to determine the layout of the static TLS
1433 block and allocate it for the initial thread. Note that we
1434 always allocate the static block, we never defer it even if
1435 no DF_STATIC_TLS bit is set. The reason is that we know
1436 glibc will use the static model. */
1437 struct dlmopen_args dlmargs;
1438 dlmargs.fname = name;
1441 const char *objname;
1442 const char *err_str = NULL;
1444 (void) _dl_catch_error (&objname, &err_str, &malloced, dlmopen_doit,
1446 if (__glibc_unlikely (err_str != NULL))
1449 _dl_error_printf ("\
1450 ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n",
1453 free ((char *) err_str);
1457 struct lookup_args largs;
1458 largs.name = "la_version";
1459 largs.map = dlmargs.map;
1461 /* Check whether the interface version matches. */
1462 (void) _dl_catch_error (&objname, &err_str, &malloced,
1463 lookup_doit, &largs);
1465 unsigned int (*laversion) (unsigned int);
1468 && (laversion = largs.result) != NULL
1469 && (lav = laversion (LAV_CURRENT)) > 0
1470 && lav <= LAV_CURRENT)
1472 /* Allocate structure for the callback function pointers.
1473 This call can never fail. */
1476 struct audit_ifaces ifaces;
1477 #define naudit_ifaces 8
1478 void (*fptr[naudit_ifaces]) (void);
1479 } *newp = malloc (sizeof (*newp));
1481 /* Names of the auditing interfaces. All in one
1483 static const char audit_iface_names[] =
1488 #if __ELF_NATIVE_CLASS == 32
1490 #elif __ELF_NATIVE_CLASS == 64
1493 # error "__ELF_NATIVE_CLASS must be defined"
1495 #define STRING(s) __STRING (s)
1496 "la_" STRING (ARCH_LA_PLTENTER) "\0"
1497 "la_" STRING (ARCH_LA_PLTEXIT) "\0"
1499 unsigned int cnt = 0;
1500 const char *cp = audit_iface_names;
1504 (void) _dl_catch_error (&objname, &err_str, &malloced,
1505 lookup_doit, &largs);
1507 /* Store the pointer. */
1508 if (err_str == NULL && largs.result != NULL)
1510 newp->fptr[cnt] = largs.result;
1512 /* The dynamic linker link map is statically
1513 allocated, initialize the data now. */
1514 GL(dl_rtld_map).l_audit[cnt].cookie
1515 = (intptr_t) &GL(dl_rtld_map);
1518 newp->fptr[cnt] = NULL;
1521 cp = (char *) rawmemchr (cp, '\0') + 1;
1523 while (*cp != '\0');
1524 assert (cnt == naudit_ifaces);
1526 /* Now append the new auditing interface to the list. */
1527 newp->ifaces.next = NULL;
1528 if (last_audit == NULL)
1529 last_audit = GLRO(dl_audit) = &newp->ifaces;
1531 last_audit = last_audit->next = &newp->ifaces;
1534 /* Mark the DSO as being used for auditing. */
1535 dlmargs.map->l_auditing = 1;
1539 /* We cannot use the DSO, it does not have the
1540 appropriate interfaces or it expects something
1543 Lmid_t ns = dlmargs.map->l_ns;
1545 _dl_close (dlmargs.map);
1547 /* Make sure the namespace has been cleared entirely. */
1548 assert (GL(dl_ns)[ns]._ns_loaded == NULL);
1549 assert (GL(dl_ns)[ns]._ns_nloaded == 0);
1551 GL(dl_tls_max_dtv_idx) = tls_idx;
1557 /* If we have any auditing modules, announce that we already
1558 have two objects loaded. */
1559 if (__glibc_unlikely (GLRO(dl_naudit) > 0))
1561 struct link_map *ls[2] = { main_map, &GL(dl_rtld_map) };
1563 for (unsigned int outer = 0; outer < 2; ++outer)
1565 struct audit_ifaces *afct = GLRO(dl_audit);
1566 for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
1568 if (afct->objopen != NULL)
1570 ls[outer]->l_audit[cnt].bindflags
1571 = afct->objopen (ls[outer], LM_ID_BASE,
1572 &ls[outer]->l_audit[cnt].cookie);
1574 ls[outer]->l_audit_any_plt
1575 |= ls[outer]->l_audit[cnt].bindflags != 0;
1584 /* Keep track of the currently loaded modules to count how many
1585 non-audit modules which use TLS are loaded. */
1586 size_t count_modids = _dl_count_modids ();
1588 /* Set up debugging before the debugger is notified for the first time. */
1589 #ifdef ELF_MACHINE_DEBUG_SETUP
1590 /* Some machines (e.g. MIPS) don't use DT_DEBUG in this way. */
1591 ELF_MACHINE_DEBUG_SETUP (main_map, r);
1592 ELF_MACHINE_DEBUG_SETUP (&GL(dl_rtld_map), r);
1594 if (main_map->l_info[DT_DEBUG] != NULL)
1595 /* There is a DT_DEBUG entry in the dynamic section. Fill it in
1596 with the run-time address of the r_debug structure */
1597 main_map->l_info[DT_DEBUG]->d_un.d_ptr = (ElfW(Addr)) r;
1599 /* Fill in the pointer in the dynamic linker's own dynamic section, in
1600 case you run gdb on the dynamic linker directly. */
1601 if (GL(dl_rtld_map).l_info[DT_DEBUG] != NULL)
1602 GL(dl_rtld_map).l_info[DT_DEBUG]->d_un.d_ptr = (ElfW(Addr)) r;
1605 /* We start adding objects. */
1606 r->r_state = RT_ADD;
1608 LIBC_PROBE (init_start, 2, LM_ID_BASE, r);
1610 /* Auditing checkpoint: we are ready to signal that the initial map
1611 is being constructed. */
1612 if (__glibc_unlikely (GLRO(dl_naudit) > 0))
1614 struct audit_ifaces *afct = GLRO(dl_audit);
1615 for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
1617 if (afct->activity != NULL)
1618 afct->activity (&main_map->l_audit[cnt].cookie, LA_ACT_ADD);
1624 /* We have two ways to specify objects to preload: via environment
1625 variable and via the file /etc/ld.so.preload. The latter can also
1626 be used when security is enabled. */
1627 assert (*first_preload == NULL);
1628 struct link_map **preloads = NULL;
1629 unsigned int npreloads = 0;
1631 if (__glibc_unlikely (preloadlist != NULL))
1633 HP_TIMING_NOW (start);
1634 npreloads += handle_preload_list (preloadlist, main_map, "LD_PRELOAD");
1635 HP_TIMING_NOW (stop);
1636 HP_TIMING_DIFF (diff, start, stop);
1637 HP_TIMING_ACCUM_NT (load_time, diff);
1640 if (__glibc_unlikely (preloadarg != NULL))
1642 HP_TIMING_NOW (start);
1643 npreloads += handle_preload_list (preloadarg, main_map, "--preload");
1644 HP_TIMING_NOW (stop);
1645 HP_TIMING_DIFF (diff, start, stop);
1646 HP_TIMING_ACCUM_NT (load_time, diff);
1649 /* There usually is no ld.so.preload file, it should only be used
1650 for emergencies and testing. So the open call etc should usually
1651 fail. Using access() on a non-existing file is faster than using
1652 open(). So we do this first. If it succeeds we do almost twice
1653 the work but this does not matter, since it is not for production
1655 static const char preload_file[] = "/etc/ld.so.preload";
1656 if (__glibc_unlikely (__access (preload_file, R_OK) == 0))
1658 /* Read the contents of the file. */
1659 file = _dl_sysdep_read_whole_file (preload_file, &file_size,
1660 PROT_READ | PROT_WRITE);
1661 if (__glibc_unlikely (file != MAP_FAILED))
1663 /* Parse the file. It contains names of libraries to be loaded,
1664 separated by white spaces or `:'. It may also contain
1665 comments introduced by `#'. */
1670 /* Eliminate comments. */
1675 char *comment = memchr (runp, '#', rest);
1676 if (comment == NULL)
1679 rest -= comment - runp;
1682 while (--rest > 0 && *++comment != '\n');
1685 /* We have one problematic case: if we have a name at the end of
1686 the file without a trailing terminating characters, we cannot
1687 place the \0. Handle the case separately. */
1688 if (file[file_size - 1] != ' ' && file[file_size - 1] != '\t'
1689 && file[file_size - 1] != '\n' && file[file_size - 1] != ':')
1691 problem = &file[file_size];
1692 while (problem > file && problem[-1] != ' '
1693 && problem[-1] != '\t'
1694 && problem[-1] != '\n' && problem[-1] != ':')
1703 file[file_size - 1] = '\0';
1706 HP_TIMING_NOW (start);
1708 if (file != problem)
1712 while ((p = strsep (&runp, ": \t\n")) != NULL)
1714 npreloads += do_preload (p, main_map, preload_file);
1717 if (problem != NULL)
1719 char *p = strndupa (problem, file_size - (problem - file));
1721 npreloads += do_preload (p, main_map, preload_file);
1724 HP_TIMING_NOW (stop);
1725 HP_TIMING_DIFF (diff, start, stop);
1726 HP_TIMING_ACCUM_NT (load_time, diff);
1728 /* We don't need the file anymore. */
1729 __munmap (file, file_size);
1733 if (__glibc_unlikely (*first_preload != NULL))
1735 /* Set up PRELOADS with a vector of the preloaded libraries. */
1736 struct link_map *l = *first_preload;
1737 preloads = __alloca (npreloads * sizeof preloads[0]);
1744 assert (i == npreloads);
1747 /* Load all the libraries specified by DT_NEEDED entries. If LD_PRELOAD
1748 specified some libraries to load, these are inserted before the actual
1749 dependencies in the executable's searchlist for symbol resolution. */
1750 HP_TIMING_NOW (start);
1751 _dl_map_object_deps (main_map, preloads, npreloads, mode == trace, 0);
1752 HP_TIMING_NOW (stop);
1753 HP_TIMING_DIFF (diff, start, stop);
1754 HP_TIMING_ACCUM_NT (load_time, diff);
1756 /* Mark all objects as being in the global scope. */
1757 for (i = main_map->l_searchlist.r_nlist; i > 0; )
1758 main_map->l_searchlist.r_list[--i]->l_global = 1;
1760 /* Remove _dl_rtld_map from the chain. */
1761 GL(dl_rtld_map).l_prev->l_next = GL(dl_rtld_map).l_next;
1762 if (GL(dl_rtld_map).l_next != NULL)
1763 GL(dl_rtld_map).l_next->l_prev = GL(dl_rtld_map).l_prev;
1765 for (i = 1; i < main_map->l_searchlist.r_nlist; ++i)
1766 if (main_map->l_searchlist.r_list[i] == &GL(dl_rtld_map))
1769 bool rtld_multiple_ref = false;
1770 if (__glibc_likely (i < main_map->l_searchlist.r_nlist))
1772 /* Some DT_NEEDED entry referred to the interpreter object itself, so
1773 put it back in the list of visible objects. We insert it into the
1774 chain in symbol search order because gdb uses the chain's order as
1775 its symbol search order. */
1776 rtld_multiple_ref = true;
1778 GL(dl_rtld_map).l_prev = main_map->l_searchlist.r_list[i - 1];
1779 if (__builtin_expect (mode, normal) == normal)
1781 GL(dl_rtld_map).l_next = (i + 1 < main_map->l_searchlist.r_nlist
1782 ? main_map->l_searchlist.r_list[i + 1]
1784 #ifdef NEED_DL_SYSINFO_DSO
1785 if (GLRO(dl_sysinfo_map) != NULL
1786 && GL(dl_rtld_map).l_prev->l_next == GLRO(dl_sysinfo_map)
1787 && GL(dl_rtld_map).l_next != GLRO(dl_sysinfo_map))
1788 GL(dl_rtld_map).l_prev = GLRO(dl_sysinfo_map);
1792 /* In trace mode there might be an invisible object (which we
1793 could not find) after the previous one in the search list.
1794 In this case it doesn't matter much where we put the
1795 interpreter object, so we just initialize the list pointer so
1796 that the assertion below holds. */
1797 GL(dl_rtld_map).l_next = GL(dl_rtld_map).l_prev->l_next;
1799 assert (GL(dl_rtld_map).l_prev->l_next == GL(dl_rtld_map).l_next);
1800 GL(dl_rtld_map).l_prev->l_next = &GL(dl_rtld_map);
1801 if (GL(dl_rtld_map).l_next != NULL)
1803 assert (GL(dl_rtld_map).l_next->l_prev == GL(dl_rtld_map).l_prev);
1804 GL(dl_rtld_map).l_next->l_prev = &GL(dl_rtld_map);
1808 /* Now let us see whether all libraries are available in the
1809 versions we need. */
1811 struct version_check_args args;
1812 args.doexit = mode == normal;
1813 args.dotrace = mode == trace;
1814 _dl_receive_error (print_missing_version, version_check_doit, &args);
1817 /* We do not initialize any of the TLS functionality unless any of the
1818 initial modules uses TLS. This makes dynamic loading of modules with
1819 TLS impossible, but to support it requires either eagerly doing setup
1820 now or lazily doing it later. Doing it now makes us incompatible with
1821 an old kernel that can't perform TLS_INIT_TP, even if no TLS is ever
1822 used. Trying to do it lazily is too hairy to try when there could be
1823 multiple threads (from a non-TLS-using libpthread). */
1824 bool was_tls_init_tp_called = tls_init_tp_called;
1828 if (__glibc_likely (need_security_init))
1829 /* Initialize security features. But only if we have not done it
1833 if (__builtin_expect (mode, normal) != normal)
1835 /* We were run just to list the shared libraries. It is
1836 important that we do this before real relocation, because the
1837 functions we call below for output may no longer work properly
1838 after relocation. */
1841 if (GLRO(dl_debug_mask) & DL_DEBUG_PRELINK)
1843 struct r_scope_elem *scope = &main_map->l_searchlist;
1845 for (i = 0; i < scope->r_nlist; i++)
1847 l = scope->r_list [i];
1850 _dl_printf ("\t%s => not found\n", l->l_libname->name);
1853 if (_dl_name_match_p (GLRO(dl_trace_prelink), l))
1854 GLRO(dl_trace_prelink_map) = l;
1855 _dl_printf ("\t%s => %s (0x%0*Zx, 0x%0*Zx)",
1856 DSO_FILENAME (l->l_libname->name),
1857 DSO_FILENAME (l->l_name),
1858 (int) sizeof l->l_map_start * 2,
1859 (size_t) l->l_map_start,
1860 (int) sizeof l->l_addr * 2,
1861 (size_t) l->l_addr);
1864 _dl_printf (" TLS(0x%Zx, 0x%0*Zx)\n", l->l_tls_modid,
1865 (int) sizeof l->l_tls_offset * 2,
1866 (size_t) l->l_tls_offset);
1871 else if (GLRO(dl_debug_mask) & DL_DEBUG_UNUSED)
1873 /* Look through the dependencies of the main executable
1874 and determine which of them is not actually
1876 struct link_map *l = main_map;
1878 /* Relocate the main executable. */
1879 struct relocate_args args = { .l = l,
1880 .reloc_mode = ((GLRO(dl_lazy)
1882 | __RTLD_NOIFUNC) };
1883 _dl_receive_error (print_unresolved, relocate_doit, &args);
1885 /* This loop depends on the dependencies of the executable to
1886 correspond in number and order to the DT_NEEDED entries. */
1887 ElfW(Dyn) *dyn = main_map->l_ld;
1889 while (dyn->d_tag != DT_NULL)
1891 if (dyn->d_tag == DT_NEEDED)
1894 #ifdef NEED_DL_SYSINFO_DSO
1895 /* Skip the VDSO since it's not part of the list
1896 of objects we brought in via DT_NEEDED entries. */
1897 if (l == GLRO(dl_sysinfo_map))
1904 _dl_printf ("Unused direct dependencies:\n");
1908 _dl_printf ("\t%s\n", l->l_name);
1915 _exit (first != true);
1917 else if (! main_map->l_info[DT_NEEDED])
1918 _dl_printf ("\tstatically linked\n");
1921 for (l = main_map->l_next; l; l = l->l_next)
1923 /* The library was not found. */
1924 _dl_printf ("\t%s => not found\n", l->l_libname->name);
1925 else if (strcmp (l->l_libname->name, l->l_name) == 0)
1926 _dl_printf ("\t%s (0x%0*Zx)\n", l->l_libname->name,
1927 (int) sizeof l->l_map_start * 2,
1928 (size_t) l->l_map_start);
1930 _dl_printf ("\t%s => %s (0x%0*Zx)\n", l->l_libname->name,
1931 l->l_name, (int) sizeof l->l_map_start * 2,
1932 (size_t) l->l_map_start);
1935 if (__builtin_expect (mode, trace) != trace)
1936 for (i = 1; i < (unsigned int) _dl_argc; ++i)
1938 const ElfW(Sym) *ref = NULL;
1939 ElfW(Addr) loadbase;
1942 result = _dl_lookup_symbol_x (_dl_argv[i], main_map,
1943 &ref, main_map->l_scope,
1944 NULL, ELF_RTYPE_CLASS_PLT,
1945 DL_LOOKUP_ADD_DEPENDENCY, NULL);
1947 loadbase = LOOKUP_VALUE_ADDRESS (result, false);
1949 _dl_printf ("%s found at 0x%0*Zd in object at 0x%0*Zd\n",
1951 (int) sizeof ref->st_value * 2,
1952 (size_t) ref->st_value,
1953 (int) sizeof loadbase * 2, (size_t) loadbase);
1957 /* If LD_WARN is set, warn about undefined symbols. */
1958 if (GLRO(dl_lazy) >= 0 && GLRO(dl_verbose))
1960 /* We have to do symbol dependency testing. */
1961 struct relocate_args args;
1964 args.reloc_mode = ((GLRO(dl_lazy) ? RTLD_LAZY : 0)
1967 i = main_map->l_searchlist.r_nlist;
1970 struct link_map *l = main_map->l_initfini[i];
1971 if (l != &GL(dl_rtld_map) && ! l->l_faked)
1974 _dl_receive_error (print_unresolved, relocate_doit,
1979 if ((GLRO(dl_debug_mask) & DL_DEBUG_PRELINK)
1980 && rtld_multiple_ref)
1982 /* Mark the link map as not yet relocated again. */
1983 GL(dl_rtld_map).l_relocated = 0;
1984 _dl_relocate_object (&GL(dl_rtld_map),
1985 main_map->l_scope, __RTLD_NOIFUNC, 0);
1988 #define VERNEEDTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERNEED))
1991 /* Print more information. This means here, print information
1992 about the versions needed. */
1994 struct link_map *map;
1996 for (map = main_map; map != NULL; map = map->l_next)
1999 ElfW(Dyn) *dyn = map->l_info[VERNEEDTAG];
2005 strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
2006 ent = (ElfW(Verneed) *) (map->l_addr + dyn->d_un.d_ptr);
2010 _dl_printf ("\n\tVersion information:\n");
2014 _dl_printf ("\t%s:\n", DSO_FILENAME (map->l_name));
2019 struct link_map *needed;
2021 needed = find_needed (strtab + ent->vn_file);
2022 aux = (ElfW(Vernaux) *) ((char *) ent + ent->vn_aux);
2026 const char *fname = NULL;
2029 && match_version (strtab + aux->vna_name,
2031 fname = needed->l_name;
2033 _dl_printf ("\t\t%s (%s) %s=> %s\n",
2034 strtab + ent->vn_file,
2035 strtab + aux->vna_name,
2036 aux->vna_flags & VER_FLG_WEAK
2038 fname ?: "not found");
2040 if (aux->vna_next == 0)
2041 /* No more symbols. */
2045 aux = (ElfW(Vernaux) *) ((char *) aux
2049 if (ent->vn_next == 0)
2050 /* No more dependencies. */
2053 /* Next dependency. */
2054 ent = (ElfW(Verneed) *) ((char *) ent + ent->vn_next);
2063 if (main_map->l_info[ADDRIDX (DT_GNU_LIBLIST)]
2064 && ! __builtin_expect (GLRO(dl_profile) != NULL, 0)
2065 && ! __builtin_expect (GLRO(dl_dynamic_weak), 0))
2067 ElfW(Lib) *liblist, *liblistend;
2068 struct link_map **r_list, **r_listend, *l;
2069 const char *strtab = (const void *) D_PTR (main_map, l_info[DT_STRTAB]);
2071 assert (main_map->l_info[VALIDX (DT_GNU_LIBLISTSZ)] != NULL);
2072 liblist = (ElfW(Lib) *)
2073 main_map->l_info[ADDRIDX (DT_GNU_LIBLIST)]->d_un.d_ptr;
2074 liblistend = (ElfW(Lib) *)
2076 main_map->l_info[VALIDX (DT_GNU_LIBLISTSZ)]->d_un.d_val);
2077 r_list = main_map->l_searchlist.r_list;
2078 r_listend = r_list + main_map->l_searchlist.r_nlist;
2080 for (; r_list < r_listend && liblist < liblistend; r_list++)
2087 /* If the library is not mapped where it should, fail. */
2091 /* Next, check if checksum matches. */
2092 if (l->l_info [VALIDX(DT_CHECKSUM)] == NULL
2093 || l->l_info [VALIDX(DT_CHECKSUM)]->d_un.d_val
2094 != liblist->l_checksum)
2097 if (l->l_info [VALIDX(DT_GNU_PRELINKED)] == NULL
2098 || l->l_info [VALIDX(DT_GNU_PRELINKED)]->d_un.d_val
2099 != liblist->l_time_stamp)
2102 if (! _dl_name_match_p (strtab + liblist->l_name, l))
2109 if (r_list == r_listend && liblist == liblistend)
2112 if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_LIBS))
2113 _dl_debug_printf ("\nprelink checking: %s\n",
2114 prelinked ? "ok" : "failed");
2118 /* Now set up the variable which helps the assembler startup code. */
2119 GL(dl_ns)[LM_ID_BASE]._ns_main_searchlist = &main_map->l_searchlist;
2121 /* Save the information about the original global scope list since
2122 we need it in the memory handling later. */
2123 GLRO(dl_initial_searchlist) = *GL(dl_ns)[LM_ID_BASE]._ns_main_searchlist;
2125 /* Remember the last search directory added at startup, now that
2126 malloc will no longer be the one from dl-minimal.c. As a side
2127 effect, this marks ld.so as initialized, so that the rtld_active
2128 function returns true from now on. */
2129 GLRO(dl_init_all_dirs) = GL(dl_all_dirs);
2131 /* Print scope information. */
2132 if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_SCOPES))
2134 _dl_debug_printf ("\nInitial object scopes\n");
2136 for (struct link_map *l = main_map; l != NULL; l = l->l_next)
2137 _dl_show_scope (l, 0);
2140 _rtld_main_check (main_map, _dl_argv[0]);
2144 if (main_map->l_info [ADDRIDX (DT_GNU_CONFLICT)] != NULL)
2146 ElfW(Rela) *conflict, *conflictend;
2147 #ifndef HP_TIMING_NONAVAIL
2152 HP_TIMING_NOW (start);
2153 assert (main_map->l_info [VALIDX (DT_GNU_CONFLICTSZ)] != NULL);
2154 conflict = (ElfW(Rela) *)
2155 main_map->l_info [ADDRIDX (DT_GNU_CONFLICT)]->d_un.d_ptr;
2156 conflictend = (ElfW(Rela) *)
2158 + main_map->l_info [VALIDX (DT_GNU_CONFLICTSZ)]->d_un.d_val);
2159 _dl_resolve_conflicts (main_map, conflict, conflictend);
2160 HP_TIMING_NOW (stop);
2161 HP_TIMING_DIFF (relocate_time, start, stop);
2165 /* Mark all the objects so we know they have been already relocated. */
2166 for (struct link_map *l = main_map; l != NULL; l = l->l_next)
2169 if (l->l_relro_size)
2170 _dl_protect_relro (l);
2172 /* Add object to slot information data if necessasy. */
2173 if (l->l_tls_blocksize != 0 && tls_init_tp_called)
2174 _dl_add_to_slotinfo (l);
2179 /* Now we have all the objects loaded. Relocate them all except for
2180 the dynamic linker itself. We do this in reverse order so that copy
2181 relocs of earlier objects overwrite the data written by later
2182 objects. We do not re-relocate the dynamic linker itself in this
2183 loop because that could result in the GOT entries for functions we
2184 call being changed, and that would break us. It is safe to relocate
2185 the dynamic linker out of order because it has no copy relocs (we
2186 know that because it is self-contained). */
2188 int consider_profiling = GLRO(dl_profile) != NULL;
2189 #ifndef HP_TIMING_NONAVAIL
2194 /* If we are profiling we also must do lazy reloaction. */
2195 GLRO(dl_lazy) |= consider_profiling;
2197 HP_TIMING_NOW (start);
2198 unsigned i = main_map->l_searchlist.r_nlist;
2201 struct link_map *l = main_map->l_initfini[i];
2203 /* While we are at it, help the memory handling a bit. We have to
2204 mark some data structures as allocated with the fake malloc()
2205 implementation in ld.so. */
2206 struct libname_list *lnp = l->l_libname->next;
2208 while (__builtin_expect (lnp != NULL, 0))
2213 /* Also allocated with the fake malloc(). */
2214 l->l_free_initfini = 0;
2216 if (l != &GL(dl_rtld_map))
2217 _dl_relocate_object (l, l->l_scope, GLRO(dl_lazy) ? RTLD_LAZY : 0,
2218 consider_profiling);
2220 /* Add object to slot information data if necessasy. */
2221 if (l->l_tls_blocksize != 0 && tls_init_tp_called)
2222 _dl_add_to_slotinfo (l);
2224 HP_TIMING_NOW (stop);
2226 HP_TIMING_DIFF (relocate_time, start, stop);
2228 /* Now enable profiling if needed. Like the previous call,
2229 this has to go here because the calls it makes should use the
2230 rtld versions of the functions (particularly calloc()), but it
2231 needs to have _dl_profile_map set up by the relocator. */
2232 if (__glibc_unlikely (GL(dl_profile_map) != NULL))
2233 /* We must prepare the profiling. */
2234 _dl_start_profile ();
2237 if ((!was_tls_init_tp_called && GL(dl_tls_max_dtv_idx) > 0)
2238 || count_modids != _dl_count_modids ())
2239 ++GL(dl_tls_generation);
2241 /* Now that we have completed relocation, the initializer data
2242 for the TLS blocks has its final values and we can copy them
2243 into the main thread's TLS area, which we allocated above.
2244 Note: thread-local variables must only be accessed after completing
2246 _dl_allocate_tls_init (tcbp);
2248 /* And finally install it for the main thread. */
2249 if (! tls_init_tp_called)
2251 const char *lossage = TLS_INIT_TP (tcbp);
2252 if (__glibc_unlikely (lossage != NULL))
2253 _dl_fatal_printf ("cannot set up thread-local storage: %s\n",
2257 /* Make sure no new search directories have been added. */
2258 assert (GLRO(dl_init_all_dirs) == GL(dl_all_dirs));
2260 if (! prelinked && rtld_multiple_ref)
2262 /* There was an explicit ref to the dynamic linker as a shared lib.
2263 Re-relocate ourselves with user-controlled symbol definitions.
2265 We must do this after TLS initialization in case after this
2266 re-relocation, we might call a user-supplied function
2267 (e.g. calloc from _dl_relocate_object) that uses TLS data. */
2269 #ifndef HP_TIMING_NONAVAIL
2275 HP_TIMING_NOW (start);
2276 /* Mark the link map as not yet relocated again. */
2277 GL(dl_rtld_map).l_relocated = 0;
2278 _dl_relocate_object (&GL(dl_rtld_map), main_map->l_scope, 0, 0);
2279 HP_TIMING_NOW (stop);
2280 HP_TIMING_DIFF (add, start, stop);
2281 HP_TIMING_ACCUM_NT (relocate_time, add);
2284 /* Do any necessary cleanups for the startup OS interface code.
2285 We do these now so that no calls are made after rtld re-relocation
2286 which might be resolved to different functions than we expect.
2287 We cannot do this before relocating the other objects because
2288 _dl_relocate_object might need to call `mprotect' for DT_TEXTREL. */
2289 _dl_sysdep_start_cleanup ();
2292 /* Auditing checkpoint: we have added all objects. */
2293 if (__glibc_unlikely (GLRO(dl_naudit) > 0))
2295 struct link_map *head = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
2296 /* Do not call the functions for any auditing object. */
2297 if (head->l_auditing == 0)
2299 struct audit_ifaces *afct = GLRO(dl_audit);
2300 for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
2302 if (afct->activity != NULL)
2303 afct->activity (&head->l_audit[cnt].cookie, LA_ACT_CONSISTENT);
2311 /* Notify the debugger all new objects are now ready to go. We must re-get
2312 the address since by now the variable might be in another object. */
2313 r = _dl_debug_initialize (0, LM_ID_BASE);
2314 r->r_state = RT_CONSISTENT;
2316 LIBC_PROBE (init_complete, 2, LM_ID_BASE, r);
2318 #if defined USE_LDCONFIG && !defined MAP_COPY
2319 /* We must munmap() the cache file. */
2320 _dl_unload_cache ();
2323 /* Once we return, _dl_sysdep_start will invoke
2324 the DT_INIT functions and then *USER_ENTRY. */
2327 /* This is a little helper function for resolving symbols while
2328 tracing the binary. */
2330 print_unresolved (int errcode __attribute__ ((unused)), const char *objname,
2331 const char *errstring)
2333 if (objname[0] == '\0')
2334 objname = RTLD_PROGNAME;
2335 _dl_error_printf ("%s (%s)\n", errstring, objname);
2338 /* This is a little helper function for resolving symbols while
2339 tracing the binary. */
2341 print_missing_version (int errcode __attribute__ ((unused)),
2342 const char *objname, const char *errstring)
2344 _dl_error_printf ("%s: %s: %s\n", RTLD_PROGNAME,
2345 objname, errstring);
2348 /* Nonzero if any of the debugging options is enabled. */
2349 static int any_debug attribute_relro;
2351 /* Process the string given as the parameter which explains which debugging
2352 options are enabled. */
2354 process_dl_debug (const char *dl_debug)
2356 /* When adding new entries make sure that the maximal length of a name
2357 is correctly handled in the LD_DEBUG_HELP code below. */
2361 const char name[10];
2362 const char helptext[41];
2363 unsigned short int mask;
2366 #define LEN_AND_STR(str) sizeof (str) - 1, str
2367 { LEN_AND_STR ("libs"), "display library search paths",
2368 DL_DEBUG_LIBS | DL_DEBUG_IMPCALLS },
2369 { LEN_AND_STR ("reloc"), "display relocation processing",
2370 DL_DEBUG_RELOC | DL_DEBUG_IMPCALLS },
2371 { LEN_AND_STR ("files"), "display progress for input file",
2372 DL_DEBUG_FILES | DL_DEBUG_IMPCALLS },
2373 { LEN_AND_STR ("symbols"), "display symbol table processing",
2374 DL_DEBUG_SYMBOLS | DL_DEBUG_IMPCALLS },
2375 { LEN_AND_STR ("bindings"), "display information about symbol binding",
2376 DL_DEBUG_BINDINGS | DL_DEBUG_IMPCALLS },
2377 { LEN_AND_STR ("versions"), "display version dependencies",
2378 DL_DEBUG_VERSIONS | DL_DEBUG_IMPCALLS },
2379 { LEN_AND_STR ("scopes"), "display scope information",
2381 { LEN_AND_STR ("all"), "all previous options combined",
2382 DL_DEBUG_LIBS | DL_DEBUG_RELOC | DL_DEBUG_FILES | DL_DEBUG_SYMBOLS
2383 | DL_DEBUG_BINDINGS | DL_DEBUG_VERSIONS | DL_DEBUG_IMPCALLS
2384 | DL_DEBUG_SCOPES },
2385 { LEN_AND_STR ("statistics"), "display relocation statistics",
2386 DL_DEBUG_STATISTICS },
2387 { LEN_AND_STR ("unused"), "determined unused DSOs",
2389 { LEN_AND_STR ("help"), "display this help message and exit",
2392 #define ndebopts (sizeof (debopts) / sizeof (debopts[0]))
2394 /* Skip separating white spaces and commas. */
2395 while (*dl_debug != '\0')
2397 if (*dl_debug != ' ' && *dl_debug != ',' && *dl_debug != ':')
2402 while (dl_debug[len] != '\0' && dl_debug[len] != ' '
2403 && dl_debug[len] != ',' && dl_debug[len] != ':')
2406 for (cnt = 0; cnt < ndebopts; ++cnt)
2407 if (debopts[cnt].len == len
2408 && memcmp (dl_debug, debopts[cnt].name, len) == 0)
2410 GLRO(dl_debug_mask) |= debopts[cnt].mask;
2415 if (cnt == ndebopts)
2417 /* Display a warning and skip everything until next
2419 char *copy = strndupa (dl_debug, len);
2420 _dl_error_printf ("\
2421 warning: debug option `%s' unknown; try LD_DEBUG=help\n", copy);
2431 if (GLRO(dl_debug_mask) & DL_DEBUG_UNUSED)
2433 /* In order to get an accurate picture of whether a particular
2434 DT_NEEDED entry is actually used we have to process both
2435 the PLT and non-PLT relocation entries. */
2439 if (GLRO(dl_debug_mask) & DL_DEBUG_HELP)
2444 Valid options for the LD_DEBUG environment variable are:\n\n");
2446 for (cnt = 0; cnt < ndebopts; ++cnt)
2447 _dl_printf (" %.*s%s%s\n", debopts[cnt].len, debopts[cnt].name,
2448 " " + debopts[cnt].len - 3,
2449 debopts[cnt].helptext);
2452 To direct the debugging output into a file instead of standard output\n\
2453 a filename can be specified using the LD_DEBUG_OUTPUT environment variable.\n");
2459 process_dl_audit (char *str)
2461 /* The parameter is a colon separated list of DSO names. */
2464 while ((p = (strsep) (&str, ":")) != NULL)
2465 if (dso_name_valid_for_suid (p))
2467 /* This is using the local malloc, not the system malloc. The
2468 memory can never be freed. */
2469 struct audit_list *newp = malloc (sizeof (*newp));
2472 if (audit_list == NULL)
2473 audit_list = newp->next = newp;
2476 newp->next = audit_list->next;
2477 audit_list = audit_list->next = newp;
2482 /* Process all environments variables the dynamic linker must recognize.
2483 Since all of them start with `LD_' we are a bit smarter while finding
2485 extern char **_environ attribute_hidden;
2489 process_envvars (enum mode *modep)
2491 char **runp = _environ;
2493 enum mode mode = normal;
2494 char *debug_output = NULL;
2496 /* This is the default place for profiling data file. */
2497 GLRO(dl_profile_output)
2498 = &"/var/tmp\0/var/profile"[__libc_enable_secure ? 9 : 0];
2500 while ((envline = _dl_next_ld_env_entry (&runp)) != NULL)
2504 while (envline[len] != '\0' && envline[len] != '=')
2507 if (envline[len] != '=')
2508 /* This is a "LD_" variable at the end of the string without
2509 a '=' character. Ignore it since otherwise we will access
2510 invalid memory below. */
2516 /* Warning level, verbose or not. */
2517 if (memcmp (envline, "WARN", 4) == 0)
2518 GLRO(dl_verbose) = envline[5] != '\0';
2522 /* Debugging of the dynamic linker? */
2523 if (memcmp (envline, "DEBUG", 5) == 0)
2525 process_dl_debug (&envline[6]);
2528 if (memcmp (envline, "AUDIT", 5) == 0)
2529 audit_list_string = &envline[6];
2533 /* Print information about versions. */
2534 if (memcmp (envline, "VERBOSE", 7) == 0)
2536 version_info = envline[8] != '\0';
2540 /* List of objects to be preloaded. */
2541 if (memcmp (envline, "PRELOAD", 7) == 0)
2543 preloadlist = &envline[8];
2547 /* Which shared object shall be profiled. */
2548 if (memcmp (envline, "PROFILE", 7) == 0 && envline[8] != '\0')
2549 GLRO(dl_profile) = &envline[8];
2553 /* Do we bind early? */
2554 if (memcmp (envline, "BIND_NOW", 8) == 0)
2556 GLRO(dl_lazy) = envline[9] == '\0';
2559 if (memcmp (envline, "BIND_NOT", 8) == 0)
2560 GLRO(dl_bind_not) = envline[9] != '\0';
2564 /* Test whether we want to see the content of the auxiliary
2565 array passed up from the kernel. */
2566 if (!__libc_enable_secure
2567 && memcmp (envline, "SHOW_AUXV", 9) == 0)
2573 /* Mask for the important hardware capabilities. */
2574 if (!__libc_enable_secure
2575 && memcmp (envline, "HWCAP_MASK", 10) == 0)
2576 GLRO(dl_hwcap_mask) = _dl_strtoul (&envline[11], NULL);
2581 /* Path where the binary is found. */
2582 if (!__libc_enable_secure
2583 && memcmp (envline, "ORIGIN_PATH", 11) == 0)
2584 GLRO(dl_origin_path) = &envline[12];
2588 /* The library search path. */
2589 if (!__libc_enable_secure
2590 && memcmp (envline, "LIBRARY_PATH", 12) == 0)
2592 library_path = &envline[13];
2596 /* Where to place the profiling data file. */
2597 if (memcmp (envline, "DEBUG_OUTPUT", 12) == 0)
2599 debug_output = &envline[13];
2603 if (!__libc_enable_secure
2604 && memcmp (envline, "DYNAMIC_WEAK", 12) == 0)
2605 GLRO(dl_dynamic_weak) = 1;
2609 /* We might have some extra environment variable with length 13
2611 #ifdef EXTRA_LD_ENVVARS_13
2614 if (!__libc_enable_secure
2615 && memcmp (envline, "USE_LOAD_BIAS", 13) == 0)
2617 GLRO(dl_use_load_bias) = envline[14] == '1' ? -1 : 0;
2623 /* Where to place the profiling data file. */
2624 if (!__libc_enable_secure
2625 && memcmp (envline, "PROFILE_OUTPUT", 14) == 0
2626 && envline[15] != '\0')
2627 GLRO(dl_profile_output) = &envline[15];
2631 /* The mode of the dynamic linker can be set. */
2632 if (memcmp (envline, "TRACE_PRELINKING", 16) == 0)
2635 GLRO(dl_verbose) = 1;
2636 GLRO(dl_debug_mask) |= DL_DEBUG_PRELINK;
2637 GLRO(dl_trace_prelink) = &envline[17];
2642 /* The mode of the dynamic linker can be set. */
2643 if (memcmp (envline, "TRACE_LOADED_OBJECTS", 20) == 0)
2647 /* We might have some extra environment variable to handle. This
2648 is tricky due to the pre-processing of the length of the name
2649 in the switch statement here. The code here assumes that added
2650 environment variables have a different length. */
2651 #ifdef EXTRA_LD_ENVVARS
2657 /* The caller wants this information. */
2660 /* Extra security for SUID binaries. Remove all dangerous environment
2662 if (__builtin_expect (__libc_enable_secure, 0))
2664 static const char unsecure_envvars[] =
2665 #ifdef EXTRA_UNSECURE_ENVVARS
2666 EXTRA_UNSECURE_ENVVARS
2671 nextp = unsecure_envvars;
2675 /* We could use rawmemchr but this need not be fast. */
2676 nextp = (char *) (strchr) (nextp, '\0') + 1;
2678 while (*nextp != '\0');
2680 if (__access ("/etc/suid-debug", F_OK) != 0)
2683 unsetenv ("MALLOC_CHECK_");
2685 GLRO(dl_debug_mask) = 0;
2691 /* If we have to run the dynamic linker in debugging mode and the
2692 LD_DEBUG_OUTPUT environment variable is given, we write the debug
2693 messages to this file. */
2694 else if (any_debug && debug_output != NULL)
2696 const int flags = O_WRONLY | O_APPEND | O_CREAT | O_NOFOLLOW;
2697 size_t name_len = strlen (debug_output);
2698 char buf[name_len + 12];
2701 buf[name_len + 11] = '\0';
2702 startp = _itoa (__getpid (), &buf[name_len + 11], 10, 0);
2704 startp = memcpy (startp - name_len, debug_output, name_len);
2706 GLRO(dl_debug_fd) = __open64_nocancel (startp, flags, DEFFILEMODE);
2707 if (GLRO(dl_debug_fd) == -1)
2708 /* We use standard output if opening the file failed. */
2709 GLRO(dl_debug_fd) = STDOUT_FILENO;
2714 /* Print the various times we collected. */
2716 __attribute ((noinline))
2717 print_statistics (hp_timing_t *rtld_total_timep)
2719 #ifndef HP_TIMING_NONAVAIL
2724 /* Total time rtld used. */
2725 if (HP_SMALL_TIMING_AVAIL)
2727 HP_TIMING_PRINT (buf, sizeof (buf), *rtld_total_timep);
2728 _dl_debug_printf ("\nruntime linker statistics:\n"
2729 " total startup time in dynamic loader: %s\n", buf);
2731 /* Print relocation statistics. */
2733 HP_TIMING_PRINT (buf, sizeof (buf), relocate_time);
2734 cp = _itoa ((1000ULL * relocate_time) / *rtld_total_timep,
2735 pbuf + sizeof (pbuf), 10, 0);
2737 switch (pbuf + sizeof (pbuf) - cp)
2750 _dl_debug_printf ("\
2751 time needed for relocation: %s (%s%%)\n", buf, pbuf);
2755 unsigned long int num_relative_relocations = 0;
2756 for (Lmid_t ns = 0; ns < GL(dl_nns); ++ns)
2758 if (GL(dl_ns)[ns]._ns_loaded == NULL)
2761 struct r_scope_elem *scope = &GL(dl_ns)[ns]._ns_loaded->l_searchlist;
2763 for (unsigned int i = 0; i < scope->r_nlist; i++)
2765 struct link_map *l = scope->r_list [i];
2767 if (l->l_addr != 0 && l->l_info[VERSYMIDX (DT_RELCOUNT)])
2768 num_relative_relocations
2769 += l->l_info[VERSYMIDX (DT_RELCOUNT)]->d_un.d_val;
2770 #ifndef ELF_MACHINE_REL_RELATIVE
2771 /* Relative relocations are processed on these architectures if
2772 library is loaded to different address than p_vaddr or
2773 if not prelinked. */
2774 if ((l->l_addr != 0 || !l->l_info[VALIDX(DT_GNU_PRELINKED)])
2775 && l->l_info[VERSYMIDX (DT_RELACOUNT)])
2777 /* On e.g. IA-64 or Alpha, relative relocations are processed
2778 only if library is loaded to different address than p_vaddr. */
2779 if (l->l_addr != 0 && l->l_info[VERSYMIDX (DT_RELACOUNT)])
2781 num_relative_relocations
2782 += l->l_info[VERSYMIDX (DT_RELACOUNT)]->d_un.d_val;
2786 _dl_debug_printf (" number of relocations: %lu\n"
2787 " number of relocations from cache: %lu\n"
2788 " number of relative relocations: %lu\n",
2789 GL(dl_num_relocations),
2790 GL(dl_num_cache_relocations),
2791 num_relative_relocations);
2793 #ifndef HP_TIMING_NONAVAIL
2794 /* Time spend while loading the object and the dependencies. */
2795 if (HP_SMALL_TIMING_AVAIL)
2798 HP_TIMING_PRINT (buf, sizeof (buf), load_time);
2799 cp = _itoa ((1000ULL * load_time) / *rtld_total_timep,
2800 pbuf + sizeof (pbuf), 10, 0);
2802 switch (pbuf + sizeof (pbuf) - cp)
2815 _dl_debug_printf ("\
2816 time needed to load objects: %s (%s%%)\n",