1 /* Run time dynamic linker.
2 Copyright (C) 1995-2020 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 <https://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 <dl-vdso-setup.h>
45 #include <stap-probe.h>
46 #include <stackinfo.h>
47 #include <not-cancel.h>
48 #include <array_length.h>
49 #include <libc-early-init.h>
53 /* Only enables rtld profiling for architectures which provides non generic
54 hp-timing support. The generic support requires either syscall
55 (clock_gettime), which will incur in extra overhead on loading time.
56 Using vDSO is also an option, but it will require extra support on loader
57 to setup the vDSO pointer before its usage. */
59 # define RLTD_TIMING_DECLARE(var, classifier,...) \
60 classifier hp_timing_t var __VA_ARGS__
61 # define RTLD_TIMING_VAR(var) RLTD_TIMING_DECLARE (var, )
62 # define RTLD_TIMING_SET(var, value) (var) = (value)
63 # define RTLD_TIMING_REF(var) &(var)
66 rtld_timer_start (hp_timing_t
*var
)
72 rtld_timer_stop (hp_timing_t
*var
, hp_timing_t start
)
76 HP_TIMING_DIFF (*var
, start
, stop
);
80 rtld_timer_accum (hp_timing_t
*sum
, hp_timing_t start
)
83 rtld_timer_stop (&stop
, start
);
84 HP_TIMING_ACCUM_NT(*sum
, stop
);
87 # define RLTD_TIMING_DECLARE(var, classifier...)
88 # define RTLD_TIMING_SET(var, value)
89 # define RTLD_TIMING_VAR(var)
90 # define RTLD_TIMING_REF(var) 0
91 # define rtld_timer_start(var)
92 # define rtld_timer_stop(var, start)
93 # define rtld_timer_accum(sum, start)
96 /* Avoid PLT use for our local calls at startup. */
97 extern __typeof (__mempcpy
) __mempcpy attribute_hidden
;
99 /* GCC has mental blocks about _exit. */
100 extern __typeof (_exit
) exit_internal
asm ("_exit") attribute_hidden
;
101 #define _exit exit_internal
103 /* Helper function to handle errors while resolving symbols. */
104 static void print_unresolved (int errcode
, const char *objname
,
105 const char *errsting
);
107 /* Helper function to handle errors when a version is missing. */
108 static void print_missing_version (int errcode
, const char *objname
,
109 const char *errsting
);
111 /* Print the various times we collected. */
112 static void print_statistics (const hp_timing_t
*total_timep
);
114 /* Length limits for names and paths, to protect the dynamic linker,
115 particularly when __libc_enable_secure is active. */
117 # define SECURE_NAME_LIMIT NAME_MAX
119 # define SECURE_NAME_LIMIT 255
122 # define SECURE_PATH_LIMIT PATH_MAX
124 # define SECURE_PATH_LIMIT 1024
127 /* Strings containing colon-separated lists of audit modules. */
130 /* Array of strings containing colon-separated path lists. Each
131 audit module needs its own namespace, so pre-allocate the largest
133 const char *audit_strings
[DL_NNS
];
135 /* Number of entries added to audit_strings. */
138 /* Index into the audit_strings array (for the iteration phase). */
139 size_t current_index
;
141 /* Tail of audit_strings[current_index] which still needs
143 const char *current_tail
;
145 /* Scratch buffer for returning a name which is part of the strings
147 char fname
[SECURE_NAME_LIMIT
];
150 /* Creates an empty audit list. */
151 static void audit_list_init (struct audit_list
*);
153 /* Add a string to the end of the audit list, for later parsing. Must
154 not be called after audit_list_next. */
155 static void audit_list_add_string (struct audit_list
*, const char *);
157 /* Add the audit strings from the link map, found in the dynamic
158 segment at TG (either DT_AUDIT and DT_DEPAUDIT). Must be called
159 before audit_list_next. */
160 static void audit_list_add_dynamic_tag (struct audit_list
*,
164 /* Extract the next audit module from the audit list. Only modules
165 for which dso_name_valid_for_suid is true are returned. Must be
166 called after all the audit_list_add_string,
167 audit_list_add_dynamic_tags calls. */
168 static const char *audit_list_next (struct audit_list
*);
170 /* This is a list of all the modes the dynamic loader can be in. */
171 enum mode
{ normal
, list
, verify
, trace
};
173 /* Process all environments variables the dynamic linker must recognize.
174 Since all of them start with `LD_' we are a bit smarter while finding
176 static void process_envvars (enum mode
*modep
, struct audit_list
*);
178 #ifdef DL_ARGV_NOT_RELRO
179 int _dl_argc attribute_hidden
;
180 char **_dl_argv
= NULL
;
181 /* Nonzero if we were run directly. */
182 unsigned int _dl_skip_args attribute_hidden
;
184 int _dl_argc attribute_relro attribute_hidden
;
185 char **_dl_argv attribute_relro
= NULL
;
186 unsigned int _dl_skip_args attribute_relro attribute_hidden
;
188 rtld_hidden_data_def (_dl_argv
)
190 #ifndef THREAD_SET_STACK_GUARD
191 /* Only exported for architectures that don't store the stack guard canary
192 in thread local area. */
193 uintptr_t __stack_chk_guard attribute_relro
;
196 /* Only exported for architectures that don't store the pointer guard
197 value in thread local area. */
198 uintptr_t __pointer_chk_guard_local
199 attribute_relro attribute_hidden
__attribute__ ((nocommon
));
200 #ifndef THREAD_SET_POINTER_GUARD
201 strong_alias (__pointer_chk_guard_local
, __pointer_chk_guard
)
204 /* Check that AT_SECURE=0, or that the passed name does not contain
205 directories and is not overly long. Reject empty names
208 dso_name_valid_for_suid (const char *p
)
210 if (__glibc_unlikely (__libc_enable_secure
))
212 /* Ignore pathnames with directories for AT_SECURE=1
213 programs, and also skip overlong names. */
214 size_t len
= strlen (p
);
215 if (len
>= SECURE_NAME_LIMIT
|| memchr (p
, '/', len
) != NULL
)
222 audit_list_init (struct audit_list
*list
)
225 list
->current_index
= 0;
226 list
->current_tail
= NULL
;
230 audit_list_add_string (struct audit_list
*list
, const char *string
)
232 /* Empty strings do not load anything. */
236 if (list
->length
== array_length (list
->audit_strings
))
237 _dl_fatal_printf ("Fatal glibc error: Too many audit modules requested\n");
239 list
->audit_strings
[list
->length
++] = string
;
241 /* Initialize processing of the first string for
243 if (list
->length
== 1)
244 list
->current_tail
= string
;
248 audit_list_add_dynamic_tag (struct audit_list
*list
, struct link_map
*main_map
,
251 ElfW(Dyn
) *info
= main_map
->l_info
[ADDRIDX (tag
)];
252 const char *strtab
= (const char *) D_PTR (main_map
, l_info
[DT_STRTAB
]);
254 audit_list_add_string (list
, strtab
+ info
->d_un
.d_val
);
258 audit_list_next (struct audit_list
*list
)
260 if (list
->current_tail
== NULL
)
265 /* Advance to the next string in audit_strings if the current
266 string has been exhausted. */
267 while (*list
->current_tail
== '\0')
269 ++list
->current_index
;
270 if (list
->current_index
== list
->length
)
272 list
->current_tail
= NULL
;
275 list
->current_tail
= list
->audit_strings
[list
->current_index
];
278 /* Split the in-string audit list at the next colon colon. */
279 size_t len
= strcspn (list
->current_tail
, ":");
280 if (len
> 0 && len
< sizeof (list
->fname
))
282 memcpy (list
->fname
, list
->current_tail
, len
);
283 list
->fname
[len
] = '\0';
286 /* Mark the name as unusable for dso_name_valid_for_suid. */
287 list
->fname
[0] = '\0';
289 /* Skip over the substring and the following delimiter. */
290 list
->current_tail
+= len
;
291 if (*list
->current_tail
== ':')
292 ++list
->current_tail
;
294 /* If the name is valid, return it. */
295 if (dso_name_valid_for_suid (list
->fname
))
298 /* Otherwise wrap around to find the next list element. . */
302 #ifndef HAVE_INLINED_SYSCALLS
303 /* Set nonzero during loading and initialization of executable and
304 libraries, cleared before the executable's entry point runs. This
305 must not be initialized to nonzero, because the unused dynamic
306 linker loaded in for libc.so's "ld.so.1" dep will provide the
307 definition seen by libc.so's initializer; that value must be zero,
308 and will be since that dynamic linker's _dl_start and dl_main will
310 int _dl_starting_up
= 0;
311 rtld_hidden_def (_dl_starting_up
)
314 /* This is the structure which defines all variables global to ld.so
315 (except those which cannot be added for some reason). */
316 struct rtld_global _rtld_global
=
318 /* Generally the default presumption without further information is an
319 * executable stack but this is not true for all platforms. */
320 ._dl_stack_flags
= DEFAULT_STACK_PERMS
,
321 #ifdef _LIBC_REENTRANT
322 ._dl_load_lock
= _RTLD_LOCK_RECURSIVE_INITIALIZER
,
323 ._dl_load_write_lock
= _RTLD_LOCK_RECURSIVE_INITIALIZER
,
328 #ifdef _LIBC_REENTRANT
329 [LM_ID_BASE
] = { ._ns_unique_sym_table
330 = { .lock
= _RTLD_LOCK_RECURSIVE_INITIALIZER
} }
334 /* If we would use strong_alias here the compiler would see a
335 non-hidden definition. This would undo the effect of the previous
336 declaration. So spell out was strong_alias does plus add the
337 visibility attribute. */
338 extern struct rtld_global _rtld_local
339 __attribute__ ((alias ("_rtld_global"), visibility ("hidden")));
342 /* This variable is similar to _rtld_local, but all values are
343 read-only after relocation. */
344 struct rtld_global_ro _rtld_global_ro attribute_relro
=
346 /* Get architecture specific initializer. */
347 #include <dl-procinfo.c>
348 #ifdef NEED_DL_SYSINFO
349 ._dl_sysinfo
= DL_SYSINFO_DEFAULT
,
351 ._dl_debug_fd
= STDERR_FILENO
,
352 ._dl_use_load_bias
= -2,
353 ._dl_correct_cache_id
= _DL_CACHE_DEFAULT_ID
,
355 ._dl_hwcap_mask
= HWCAP_IMPORTANT
,
358 ._dl_fpu_control
= _FPU_DEFAULT
,
359 ._dl_pagesize
= EXEC_PAGESIZE
,
360 ._dl_inhibit_cache
= 0,
362 /* Function pointers. */
363 ._dl_debug_printf
= _dl_debug_printf
,
364 ._dl_mcount
= _dl_mcount
,
365 ._dl_lookup_symbol_x
= _dl_lookup_symbol_x
,
366 ._dl_open
= _dl_open
,
367 ._dl_close
= _dl_close
,
368 ._dl_tls_get_addr_soft
= _dl_tls_get_addr_soft
,
369 #ifdef HAVE_DL_DISCOVER_OSVERSION
370 ._dl_discover_osversion
= _dl_discover_osversion
373 /* If we would use strong_alias here the compiler would see a
374 non-hidden definition. This would undo the effect of the previous
375 declaration. So spell out was strong_alias does plus add the
376 visibility attribute. */
377 extern struct rtld_global_ro _rtld_local_ro
378 __attribute__ ((alias ("_rtld_global_ro"), visibility ("hidden")));
381 static void dl_main (const ElfW(Phdr
) *phdr
, ElfW(Word
) phnum
,
382 ElfW(Addr
) *user_entry
, ElfW(auxv_t
) *auxv
);
384 /* These two variables cannot be moved into .data.rel.ro. */
385 static struct libname_list _dl_rtld_libname
;
386 static struct libname_list _dl_rtld_libname2
;
388 /* Variable for statistics. */
389 RLTD_TIMING_DECLARE (relocate_time
, static);
390 RLTD_TIMING_DECLARE (load_time
, static, attribute_relro
);
391 RLTD_TIMING_DECLARE (start_time
, static, attribute_relro
);
393 /* Additional definitions needed by TLS initialization. */
394 #ifdef TLS_INIT_HELPER
398 /* Helper function for syscall implementation. */
399 #ifdef DL_SYSINFO_IMPLEMENTATION
400 DL_SYSINFO_IMPLEMENTATION
403 /* Before ld.so is relocated we must not access variables which need
404 relocations. This means variables which are exported. Variables
405 declared as static are fine. If we can mark a variable hidden this
406 is fine, too. The latter is important here. We can avoid setting
407 up a temporary link map for ld.so if we can mark _rtld_global as
409 #ifdef PI_STATIC_AND_HIDDEN
410 # define DONT_USE_BOOTSTRAP_MAP 1
413 #ifdef DONT_USE_BOOTSTRAP_MAP
414 static ElfW(Addr
) _dl_start_final (void *arg
);
416 struct dl_start_final_info
419 RTLD_TIMING_VAR (start_time
);
421 static ElfW(Addr
) _dl_start_final (void *arg
,
422 struct dl_start_final_info
*info
);
425 /* These defined magically in the linker script. */
426 extern char _begin
[] attribute_hidden
;
427 extern char _etext
[] attribute_hidden
;
428 extern char _end
[] attribute_hidden
;
434 # error "sysdeps/MACHINE/dl-machine.h fails to define RTLD_START"
437 /* This is the second half of _dl_start (below). It can be inlined safely
438 under DONT_USE_BOOTSTRAP_MAP, where it is careful not to make any GOT
439 references. When the tools don't permit us to avoid using a GOT entry
440 for _dl_rtld_global (no attribute_hidden support), we must make sure
441 this function is not inlined (see below). */
443 #ifdef DONT_USE_BOOTSTRAP_MAP
444 static inline ElfW(Addr
) __attribute__ ((always_inline
))
445 _dl_start_final (void *arg
)
447 static ElfW(Addr
) __attribute__ ((noinline
))
448 _dl_start_final (void *arg
, struct dl_start_final_info
*info
)
451 ElfW(Addr
) start_addr
;
453 /* If it hasn't happen yet record the startup time. */
454 rtld_timer_start (&start_time
);
455 #if !defined DONT_USE_BOOTSTRAP_MAP
456 RTLD_TIMING_SET (start_time
, info
->start_time
);
459 /* Transfer data about ourselves to the permanent link_map structure. */
460 #ifndef DONT_USE_BOOTSTRAP_MAP
461 GL(dl_rtld_map
).l_addr
= info
->l
.l_addr
;
462 GL(dl_rtld_map
).l_ld
= info
->l
.l_ld
;
463 memcpy (GL(dl_rtld_map
).l_info
, info
->l
.l_info
,
464 sizeof GL(dl_rtld_map
).l_info
);
465 GL(dl_rtld_map
).l_mach
= info
->l
.l_mach
;
466 GL(dl_rtld_map
).l_relocated
= 1;
468 _dl_setup_hash (&GL(dl_rtld_map
));
469 GL(dl_rtld_map
).l_real
= &GL(dl_rtld_map
);
470 GL(dl_rtld_map
).l_map_start
= (ElfW(Addr
)) _begin
;
471 GL(dl_rtld_map
).l_map_end
= (ElfW(Addr
)) _end
;
472 GL(dl_rtld_map
).l_text_end
= (ElfW(Addr
)) _etext
;
473 /* Copy the TLS related data if necessary. */
474 #ifndef DONT_USE_BOOTSTRAP_MAP
475 # if NO_TLS_OFFSET != 0
476 GL(dl_rtld_map
).l_tls_offset
= NO_TLS_OFFSET
;
480 /* Initialize the stack end variable. */
481 __libc_stack_end
= __builtin_frame_address (0);
483 /* Call the OS-dependent function to set up life so we can do things like
484 file access. It will call `dl_main' (below) to do all the real work
485 of the dynamic linker, and then unwind our frame and run the user
486 entry point on the same stack we entered on. */
487 start_addr
= _dl_sysdep_start (arg
, &dl_main
);
489 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_STATISTICS
))
491 RTLD_TIMING_VAR (rtld_total_time
);
492 rtld_timer_stop (&rtld_total_time
, start_time
);
493 print_statistics (RTLD_TIMING_REF(rtld_total_time
));
499 static ElfW(Addr
) __attribute_used__
500 _dl_start (void *arg
)
502 #ifdef DONT_USE_BOOTSTRAP_MAP
503 # define bootstrap_map GL(dl_rtld_map)
505 struct dl_start_final_info info
;
506 # define bootstrap_map info.l
509 /* This #define produces dynamic linking inline functions for
510 bootstrap relocation instead of general-purpose relocation.
511 Since ld.so must not have any undefined symbols the result
512 is trivial: always the map of ld.so itself. */
513 #define RTLD_BOOTSTRAP
514 #define BOOTSTRAP_MAP (&bootstrap_map)
515 #define RESOLVE_MAP(sym, version, flags) BOOTSTRAP_MAP
516 #include "dynamic-link.h"
518 #ifdef DONT_USE_BOOTSTRAP_MAP
519 rtld_timer_start (&start_time
);
521 rtld_timer_start (&info
.start_time
);
524 /* Partly clean the `bootstrap_map' structure up. Don't use
525 `memset' since it might not be built in or inlined and we cannot
526 make function calls at this point. Use '__builtin_memset' if we
527 know it is available. We do not have to clear the memory if we
528 do not have to use the temporary bootstrap_map. Global variables
529 are initialized to zero by default. */
530 #ifndef DONT_USE_BOOTSTRAP_MAP
531 # ifdef HAVE_BUILTIN_MEMSET
532 __builtin_memset (bootstrap_map
.l_info
, '\0', sizeof (bootstrap_map
.l_info
));
535 cnt
< sizeof (bootstrap_map
.l_info
) / sizeof (bootstrap_map
.l_info
[0]);
537 bootstrap_map
.l_info
[cnt
] = 0;
541 /* Figure out the run-time load address of the dynamic linker itself. */
542 bootstrap_map
.l_addr
= elf_machine_load_address ();
544 /* Read our own dynamic section and fill in the info array. */
545 bootstrap_map
.l_ld
= (void *) bootstrap_map
.l_addr
+ elf_machine_dynamic ();
546 elf_get_dynamic_info (&bootstrap_map
, NULL
);
548 #if NO_TLS_OFFSET != 0
549 bootstrap_map
.l_tls_offset
= NO_TLS_OFFSET
;
552 #ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
553 ELF_MACHINE_BEFORE_RTLD_RELOC (bootstrap_map
.l_info
);
556 if (bootstrap_map
.l_addr
|| ! bootstrap_map
.l_info
[VALIDX(DT_GNU_PRELINKED
)])
558 /* Relocate ourselves so we can do normal function calls and
559 data access using the global offset table. */
561 ELF_DYNAMIC_RELOCATE (&bootstrap_map
, 0, 0, 0);
563 bootstrap_map
.l_relocated
= 1;
565 /* Please note that we don't allow profiling of this object and
566 therefore need not test whether we have to allocate the array
567 for the relocation results (as done in dl-reloc.c). */
569 /* Now life is sane; we can call functions and access global data.
570 Set up to use the operating system facilities, and find out from
571 the operating system's program loader where to find the program
572 header table in core. Put the rest of _dl_start into a separate
573 function, that way the compiler cannot put accesses to the GOT
574 before ELF_DYNAMIC_RELOCATE. */
576 __rtld_malloc_init_stubs ();
579 #ifdef DONT_USE_BOOTSTRAP_MAP
580 ElfW(Addr
) entry
= _dl_start_final (arg
);
582 ElfW(Addr
) entry
= _dl_start_final (arg
, &info
);
585 #ifndef ELF_MACHINE_START_ADDRESS
586 # define ELF_MACHINE_START_ADDRESS(map, start) (start)
589 return ELF_MACHINE_START_ADDRESS (GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
, entry
);
595 /* Now life is peachy; we can do all normal operations.
596 On to the real work. */
598 /* Some helper functions. */
600 /* Arguments to relocate_doit. */
609 /* Argument to map_doit. */
611 struct link_map
*loader
;
613 /* Return value of map_doit. */
614 struct link_map
*map
;
620 struct link_map
*map
;
626 struct link_map
*map
;
630 /* Arguments to version_check_doit. */
631 struct version_check_args
638 relocate_doit (void *a
)
640 struct relocate_args
*args
= (struct relocate_args
*) a
;
642 _dl_relocate_object (args
->l
, args
->l
->l_scope
, args
->reloc_mode
, 0);
648 struct map_args
*args
= (struct map_args
*) a
;
649 int type
= (args
->mode
== __RTLD_OPENEXEC
) ? lt_executable
: lt_library
;
650 args
->map
= _dl_map_object (args
->loader
, args
->str
, type
, 0,
651 args
->mode
, LM_ID_BASE
);
655 dlmopen_doit (void *a
)
657 struct dlmopen_args
*args
= (struct dlmopen_args
*) a
;
658 args
->map
= _dl_open (args
->fname
,
659 (RTLD_LAZY
| __RTLD_DLOPEN
| __RTLD_AUDIT
661 dl_main
, LM_ID_NEWLM
, _dl_argc
, _dl_argv
,
666 lookup_doit (void *a
)
668 struct lookup_args
*args
= (struct lookup_args
*) a
;
669 const ElfW(Sym
) *ref
= NULL
;
671 lookup_t l
= _dl_lookup_symbol_x (args
->name
, args
->map
, &ref
,
672 args
->map
->l_local_scope
, NULL
, 0,
673 DL_LOOKUP_RETURN_NEWEST
, NULL
);
675 args
->result
= DL_SYMBOL_ADDRESS (l
, ref
);
679 version_check_doit (void *a
)
681 struct version_check_args
*args
= (struct version_check_args
*) a
;
682 if (_dl_check_all_versions (GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
, 1,
683 args
->dotrace
) && args
->doexit
)
684 /* We cannot start the application. Abort now. */
689 static inline struct link_map
*
690 find_needed (const char *name
)
692 struct r_scope_elem
*scope
= &GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
->l_searchlist
;
693 unsigned int n
= scope
->r_nlist
;
696 if (_dl_name_match_p (name
, scope
->r_list
[n
]))
697 return scope
->r_list
[n
];
699 /* Should never happen. */
704 match_version (const char *string
, struct link_map
*map
)
706 const char *strtab
= (const void *) D_PTR (map
, l_info
[DT_STRTAB
]);
709 #define VERDEFTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERDEF))
710 if (map
->l_info
[VERDEFTAG
] == NULL
)
711 /* The file has no symbol versioning. */
714 def
= (ElfW(Verdef
) *) ((char *) map
->l_addr
715 + map
->l_info
[VERDEFTAG
]->d_un
.d_ptr
);
718 ElfW(Verdaux
) *aux
= (ElfW(Verdaux
) *) ((char *) def
+ def
->vd_aux
);
720 /* Compare the version strings. */
721 if (strcmp (string
, strtab
+ aux
->vda_name
) == 0)
725 /* If no more definitions we failed to find what we want. */
726 if (def
->vd_next
== 0)
729 /* Next definition. */
730 def
= (ElfW(Verdef
) *) ((char *) def
+ def
->vd_next
);
736 static bool tls_init_tp_called
;
741 /* Number of elements in the static TLS block. */
742 GL(dl_tls_static_nelem
) = GL(dl_tls_max_dtv_idx
);
744 /* Do not do this twice. The audit interface might have required
745 the DTV interfaces to be set up early. */
746 if (GL(dl_initial_dtv
) != NULL
)
749 /* Allocate the array which contains the information about the
750 dtv slots. We allocate a few entries more than needed to
751 avoid the need for reallocation. */
752 size_t nelem
= GL(dl_tls_max_dtv_idx
) + 1 + TLS_SLOTINFO_SURPLUS
;
755 GL(dl_tls_dtv_slotinfo_list
) = (struct dtv_slotinfo_list
*)
756 calloc (sizeof (struct dtv_slotinfo_list
)
757 + nelem
* sizeof (struct dtv_slotinfo
), 1);
758 /* No need to check the return value. If memory allocation failed
759 the program would have been terminated. */
761 struct dtv_slotinfo
*slotinfo
= GL(dl_tls_dtv_slotinfo_list
)->slotinfo
;
762 GL(dl_tls_dtv_slotinfo_list
)->len
= nelem
;
763 GL(dl_tls_dtv_slotinfo_list
)->next
= NULL
;
765 /* Fill in the information from the loaded modules. No namespace
766 but the base one can be filled at this time. */
767 assert (GL(dl_ns
)[LM_ID_BASE
+ 1]._ns_loaded
== NULL
);
769 for (struct link_map
*l
= GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
; l
!= NULL
;
771 if (l
->l_tls_blocksize
!= 0)
773 /* This is a module with TLS data. Store the map reference.
774 The generation counter is zero. */
776 /* slotinfo[i].gen = 0; */
779 assert (i
== GL(dl_tls_max_dtv_idx
));
781 /* Compute the TLS offsets for the various blocks. */
782 _dl_determine_tlsoffset ();
784 /* Construct the static TLS block and the dtv for the initial
785 thread. For some platforms this will include allocating memory
786 for the thread descriptor. The memory for the TLS block will
787 never be freed. It should be allocated accordingly. The dtv
788 array can be changed if dynamic loading requires it. */
789 void *tcbp
= _dl_allocate_tls_storage ();
792 cannot allocate TLS data structures for initial thread\n");
794 /* Store for detection of the special case by __tls_get_addr
795 so it knows not to pass this dtv to the normal realloc. */
796 GL(dl_initial_dtv
) = GET_DTV (tcbp
);
798 /* And finally install it for the main thread. */
799 const char *lossage
= TLS_INIT_TP (tcbp
);
800 if (__glibc_unlikely (lossage
!= NULL
))
801 _dl_fatal_printf ("cannot set up thread-local storage: %s\n", lossage
);
802 tls_init_tp_called
= true;
808 do_preload (const char *fname
, struct link_map
*main_map
, const char *where
)
811 const char *err_str
= NULL
;
812 struct map_args args
;
816 args
.loader
= main_map
;
817 args
.mode
= __RTLD_SECURE
;
819 unsigned int old_nloaded
= GL(dl_ns
)[LM_ID_BASE
]._ns_nloaded
;
821 (void) _dl_catch_error (&objname
, &err_str
, &malloced
, map_doit
, &args
);
822 if (__glibc_unlikely (err_str
!= NULL
))
825 ERROR: ld.so: object '%s' from %s cannot be preloaded (%s): ignored.\n",
826 fname
, where
, err_str
);
827 /* No need to call free, this is still before
828 the libc's malloc is used. */
830 else if (GL(dl_ns
)[LM_ID_BASE
]._ns_nloaded
!= old_nloaded
)
831 /* It is no duplicate. */
834 /* Nothing loaded. */
838 #if defined SHARED && defined _LIBC_REENTRANT \
839 && defined __rtld_lock_default_lock_recursive
841 rtld_lock_default_lock_recursive (void *lock
)
843 __rtld_lock_default_lock_recursive (lock
);
847 rtld_lock_default_unlock_recursive (void *lock
)
849 __rtld_lock_default_unlock_recursive (lock
);
857 /* Set up the stack checker's canary. */
858 uintptr_t stack_chk_guard
= _dl_setup_stack_chk_guard (_dl_random
);
859 #ifdef THREAD_SET_STACK_GUARD
860 THREAD_SET_STACK_GUARD (stack_chk_guard
);
862 __stack_chk_guard
= stack_chk_guard
;
865 /* Set up the pointer guard as well, if necessary. */
866 uintptr_t pointer_chk_guard
867 = _dl_setup_pointer_guard (_dl_random
, stack_chk_guard
);
868 #ifdef THREAD_SET_POINTER_GUARD
869 THREAD_SET_POINTER_GUARD (pointer_chk_guard
);
871 __pointer_chk_guard_local
= pointer_chk_guard
;
873 /* We do not need the _dl_random value anymore. The less
874 information we leave behind, the better, so clear the
879 #include <setup-vdso.h>
881 /* The library search path. */
882 static const char *library_path attribute_relro
;
883 /* The list preloaded objects. */
884 static const char *preloadlist attribute_relro
;
885 /* Nonzero if information about versions has to be printed. */
886 static int version_info attribute_relro
;
887 /* The preload list passed as a command argument. */
888 static const char *preloadarg attribute_relro
;
890 /* The LD_PRELOAD environment variable gives list of libraries
891 separated by white space or colons that are loaded before the
892 executable's dependencies and prepended to the global scope list.
893 (If the binary is running setuid all elements containing a '/' are
894 ignored since it is insecure.) Return the number of preloads
895 performed. Ditto for --preload command argument. */
897 handle_preload_list (const char *preloadlist
, struct link_map
*main_map
,
900 unsigned int npreloads
= 0;
901 const char *p
= preloadlist
;
902 char fname
[SECURE_PATH_LIMIT
];
906 /* Split preload list at space/colon. */
907 size_t len
= strcspn (p
, " :");
908 if (len
> 0 && len
< sizeof (fname
))
910 memcpy (fname
, p
, len
);
916 /* Skip over the substring and the following delimiter. */
921 if (dso_name_valid_for_suid (fname
))
922 npreloads
+= do_preload (fname
, main_map
, where
);
927 /* Called if the audit DSO cannot be used: if it does not have the
928 appropriate interfaces, or it expects a more recent version library
929 version than what the dynamic linker provides. */
931 unload_audit_module (struct link_map
*map
, int original_tls_idx
)
934 Lmid_t ns
= map
->l_ns
;
938 /* Make sure the namespace has been cleared entirely. */
939 assert (GL(dl_ns
)[ns
]._ns_loaded
== NULL
);
940 assert (GL(dl_ns
)[ns
]._ns_nloaded
== 0);
942 GL(dl_tls_max_dtv_idx
) = original_tls_idx
;
945 /* Called to print an error message if loading of an audit module
948 report_audit_module_load_error (const char *name
, const char *err_str
,
952 ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n",
955 free ((char *) err_str
);
958 /* Load one audit module. */
960 load_audit_module (const char *name
, struct audit_ifaces
**last_audit
)
962 int original_tls_idx
= GL(dl_tls_max_dtv_idx
);
964 struct dlmopen_args dlmargs
;
965 dlmargs
.fname
= name
;
969 const char *err_str
= NULL
;
971 _dl_catch_error (&objname
, &err_str
, &malloced
, dlmopen_doit
, &dlmargs
);
972 if (__glibc_unlikely (err_str
!= NULL
))
974 report_audit_module_load_error (name
, err_str
, malloced
);
978 struct lookup_args largs
;
979 largs
.name
= "la_version";
980 largs
.map
= dlmargs
.map
;
981 _dl_catch_error (&objname
, &err_str
, &malloced
, lookup_doit
, &largs
);
982 if (__glibc_likely (err_str
!= NULL
))
984 unload_audit_module (dlmargs
.map
, original_tls_idx
);
985 report_audit_module_load_error (name
, err_str
, malloced
);
989 unsigned int (*laversion
) (unsigned int) = largs
.result
;
991 /* A null symbol indicates that something is very wrong with the
992 loaded object because defined symbols are supposed to have a
993 valid, non-null address. */
994 assert (laversion
!= NULL
);
996 unsigned int lav
= laversion (LAV_CURRENT
);
999 /* Only print an error message if debugging because this can
1000 happen deliberately. */
1001 if (GLRO(dl_debug_mask
) & DL_DEBUG_FILES
)
1002 _dl_debug_printf ("\
1003 file=%s [%lu]; audit interface function la_version returned zero; ignored.\n",
1004 dlmargs
.map
->l_name
, dlmargs
.map
->l_ns
);
1005 unload_audit_module (dlmargs
.map
, original_tls_idx
);
1009 if (lav
> LAV_CURRENT
)
1011 _dl_debug_printf ("\
1012 ERROR: audit interface '%s' requires version %d (maximum supported version %d); ignored.\n",
1013 name
, lav
, LAV_CURRENT
);
1014 unload_audit_module (dlmargs
.map
, original_tls_idx
);
1018 enum { naudit_ifaces
= 8 };
1021 struct audit_ifaces ifaces
;
1022 void (*fptr
[naudit_ifaces
]) (void);
1023 } *newp
= malloc (sizeof (*newp
));
1025 _dl_fatal_printf ("Out of memory while loading audit modules\n");
1027 /* Names of the auditing interfaces. All in one
1029 static const char audit_iface_names
[] =
1034 #if __ELF_NATIVE_CLASS == 32
1036 #elif __ELF_NATIVE_CLASS == 64
1039 # error "__ELF_NATIVE_CLASS must be defined"
1041 #define STRING(s) __STRING (s)
1042 "la_" STRING (ARCH_LA_PLTENTER
) "\0"
1043 "la_" STRING (ARCH_LA_PLTEXIT
) "\0"
1045 unsigned int cnt
= 0;
1046 const char *cp
= audit_iface_names
;
1050 _dl_catch_error (&objname
, &err_str
, &malloced
, lookup_doit
, &largs
);
1052 /* Store the pointer. */
1053 if (err_str
== NULL
&& largs
.result
!= NULL
)
1054 newp
->fptr
[cnt
] = largs
.result
;
1056 newp
->fptr
[cnt
] = NULL
;
1059 cp
= rawmemchr (cp
, '\0') + 1;
1061 while (*cp
!= '\0');
1062 assert (cnt
== naudit_ifaces
);
1064 /* Now append the new auditing interface to the list. */
1065 newp
->ifaces
.next
= NULL
;
1066 if (*last_audit
== NULL
)
1067 *last_audit
= GLRO(dl_audit
) = &newp
->ifaces
;
1069 *last_audit
= (*last_audit
)->next
= &newp
->ifaces
;
1071 /* The dynamic linker link map is statically allocated, so the
1072 cookie in _dl_new_object has not happened. */
1073 link_map_audit_state (&GL (dl_rtld_map
), GLRO (dl_naudit
))->cookie
1074 = (intptr_t) &GL (dl_rtld_map
);
1078 /* Mark the DSO as being used for auditing. */
1079 dlmargs
.map
->l_auditing
= 1;
1082 /* Notify the the audit modules that the object MAP has already been
1085 notify_audit_modules_of_loaded_object (struct link_map
*map
)
1087 struct audit_ifaces
*afct
= GLRO(dl_audit
);
1088 for (unsigned int cnt
= 0; cnt
< GLRO(dl_naudit
); ++cnt
)
1090 if (afct
->objopen
!= NULL
)
1092 struct auditstate
*state
= link_map_audit_state (map
, cnt
);
1093 state
->bindflags
= afct
->objopen (map
, LM_ID_BASE
, &state
->cookie
);
1094 map
->l_audit_any_plt
|= state
->bindflags
!= 0;
1101 /* Load all audit modules. */
1103 load_audit_modules (struct link_map
*main_map
, struct audit_list
*audit_list
)
1105 struct audit_ifaces
*last_audit
= NULL
;
1109 const char *name
= audit_list_next (audit_list
);
1112 load_audit_module (name
, &last_audit
);
1115 /* Notify audit modules of the initially loaded modules (the main
1116 program and the dynamic linker itself). */
1117 if (GLRO(dl_naudit
) > 0)
1119 notify_audit_modules_of_loaded_object (main_map
);
1120 notify_audit_modules_of_loaded_object (&GL(dl_rtld_map
));
1125 dl_main (const ElfW(Phdr
) *phdr
,
1127 ElfW(Addr
) *user_entry
,
1130 const ElfW(Phdr
) *ph
;
1132 struct link_map
*main_map
;
1135 bool has_interp
= false;
1137 bool prelinked
= false;
1138 bool rtld_is_main
= false;
1141 struct audit_list audit_list
;
1142 audit_list_init (&audit_list
);
1144 GL(dl_init_static_tls
) = &_dl_nothread_init_static_tls
;
1146 #if defined SHARED && defined _LIBC_REENTRANT \
1147 && defined __rtld_lock_default_lock_recursive
1148 GL(dl_rtld_lock_recursive
) = rtld_lock_default_lock_recursive
;
1149 GL(dl_rtld_unlock_recursive
) = rtld_lock_default_unlock_recursive
;
1152 /* The explicit initialization here is cheaper than processing the reloc
1153 in the _rtld_local definition's initializer. */
1154 GL(dl_make_stack_executable_hook
) = &_dl_make_stack_executable
;
1156 /* Process the environment variable which control the behaviour. */
1157 process_envvars (&mode
, &audit_list
);
1159 #ifndef HAVE_INLINED_SYSCALLS
1160 /* Set up a flag which tells we are just starting. */
1161 _dl_starting_up
= 1;
1164 if (*user_entry
== (ElfW(Addr
)) ENTRY_POINT
)
1166 /* Ho ho. We are not the program interpreter! We are the program
1167 itself! This means someone ran ld.so as a command. Well, that
1168 might be convenient to do sometimes. We support it by
1169 interpreting the args like this:
1171 ld.so PROGRAM ARGS...
1173 The first argument is the name of a file containing an ELF
1174 executable we will load and run with the following arguments.
1175 To simplify life here, PROGRAM is searched for using the
1176 normal rules for shared objects, rather than $PATH or anything
1177 like that. We just load it and use its entry point; we don't
1178 pay attention to its PT_INTERP command (we are the interpreter
1179 ourselves). This is an easy way to test a new ld.so before
1181 rtld_is_main
= true;
1183 /* Note the place where the dynamic linker actually came from. */
1184 GL(dl_rtld_map
).l_name
= rtld_progname
;
1186 while (_dl_argc
> 1)
1187 if (! strcmp (_dl_argv
[1], "--list"))
1190 GLRO(dl_lazy
) = -1; /* This means do no dependency analysis. */
1196 else if (! strcmp (_dl_argv
[1], "--verify"))
1204 else if (! strcmp (_dl_argv
[1], "--inhibit-cache"))
1206 GLRO(dl_inhibit_cache
) = 1;
1211 else if (! strcmp (_dl_argv
[1], "--library-path")
1214 library_path
= _dl_argv
[2];
1220 else if (! strcmp (_dl_argv
[1], "--inhibit-rpath")
1223 GLRO(dl_inhibit_rpath
) = _dl_argv
[2];
1229 else if (! strcmp (_dl_argv
[1], "--audit") && _dl_argc
> 2)
1231 audit_list_add_string (&audit_list
, _dl_argv
[2]);
1237 else if (! strcmp (_dl_argv
[1], "--preload") && _dl_argc
> 2)
1239 preloadarg
= _dl_argv
[2];
1247 /* If we have no further argument the program was called incorrectly.
1248 Grant the user some education. */
1250 _dl_fatal_printf ("\
1251 Usage: ld.so [OPTION]... EXECUTABLE-FILE [ARGS-FOR-PROGRAM...]\n\
1252 You have invoked `ld.so', the helper program for shared library executables.\n\
1253 This program usually lives in the file `/lib/ld.so', and special directives\n\
1254 in executable files using ELF shared libraries tell the system's program\n\
1255 loader to load the helper program from this file. This helper program loads\n\
1256 the shared libraries needed by the program executable, prepares the program\n\
1257 to run, and runs it. You may invoke this helper program directly from the\n\
1258 command line to load and run an ELF executable file; this is like executing\n\
1259 that file itself, but always uses this helper program from the file you\n\
1260 specified, instead of the helper program file specified in the executable\n\
1261 file you run. This is mostly of use for maintainers to test new versions\n\
1262 of this helper program; chances are you did not intend to run this program.\n\
1264 --list list all dependencies and how they are resolved\n\
1265 --verify verify that given object really is a dynamically linked\n\
1266 object we can handle\n\
1267 --inhibit-cache Do not use " LD_SO_CACHE
"\n\
1268 --library-path PATH use given PATH instead of content of the environment\n\
1269 variable LD_LIBRARY_PATH\n\
1270 --inhibit-rpath LIST ignore RUNPATH and RPATH information in object names\n\
1272 --audit LIST use objects named in LIST as auditors\n\
1273 --preload LIST preload objects named in LIST\n");
1279 /* The initialization of _dl_stack_flags done below assumes the
1280 executable's PT_GNU_STACK may have been honored by the kernel, and
1281 so a PT_GNU_STACK with PF_X set means the stack started out with
1282 execute permission. However, this is not really true if the
1283 dynamic linker is the executable the kernel loaded. For this
1284 case, we must reinitialize _dl_stack_flags to match the dynamic
1285 linker itself. If the dynamic linker was built with a
1286 PT_GNU_STACK, then the kernel may have loaded us with a
1287 nonexecutable stack that we will have to make executable when we
1288 load the program below unless it has a PT_GNU_STACK indicating
1289 nonexecutable stack is ok. */
1291 for (ph
= phdr
; ph
< &phdr
[phnum
]; ++ph
)
1292 if (ph
->p_type
== PT_GNU_STACK
)
1294 GL(dl_stack_flags
) = ph
->p_flags
;
1298 if (__builtin_expect (mode
, normal
) == verify
)
1300 const char *objname
;
1301 const char *err_str
= NULL
;
1302 struct map_args args
;
1305 args
.str
= rtld_progname
;
1307 args
.mode
= __RTLD_OPENEXEC
;
1308 (void) _dl_catch_error (&objname
, &err_str
, &malloced
, map_doit
,
1310 if (__glibc_unlikely (err_str
!= NULL
))
1311 /* We don't free the returned string, the programs stops
1313 _exit (EXIT_FAILURE
);
1317 RTLD_TIMING_VAR (start
);
1318 rtld_timer_start (&start
);
1319 _dl_map_object (NULL
, rtld_progname
, lt_executable
, 0,
1320 __RTLD_OPENEXEC
, LM_ID_BASE
);
1321 rtld_timer_stop (&load_time
, start
);
1324 /* Now the map for the main executable is available. */
1325 main_map
= GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
;
1327 if (__builtin_expect (mode
, normal
) == normal
1328 && GL(dl_rtld_map
).l_info
[DT_SONAME
] != NULL
1329 && main_map
->l_info
[DT_SONAME
] != NULL
1330 && strcmp ((const char *) D_PTR (&GL(dl_rtld_map
), l_info
[DT_STRTAB
])
1331 + GL(dl_rtld_map
).l_info
[DT_SONAME
]->d_un
.d_val
,
1332 (const char *) D_PTR (main_map
, l_info
[DT_STRTAB
])
1333 + main_map
->l_info
[DT_SONAME
]->d_un
.d_val
) == 0)
1334 _dl_fatal_printf ("loader cannot load itself\n");
1336 phdr
= main_map
->l_phdr
;
1337 phnum
= main_map
->l_phnum
;
1338 /* We overwrite here a pointer to a malloc()ed string. But since
1339 the malloc() implementation used at this point is the dummy
1340 implementations which has no real free() function it does not
1341 makes sense to free the old string first. */
1342 main_map
->l_name
= (char *) "";
1343 *user_entry
= main_map
->l_entry
;
1345 #ifdef HAVE_AUX_VECTOR
1346 /* Adjust the on-stack auxiliary vector so that it looks like the
1347 binary was executed directly. */
1348 for (ElfW(auxv_t
) *av
= auxv
; av
->a_type
!= AT_NULL
; av
++)
1352 av
->a_un
.a_val
= (uintptr_t) phdr
;
1355 av
->a_un
.a_val
= phnum
;
1358 av
->a_un
.a_val
= *user_entry
;
1361 av
->a_un
.a_val
= (uintptr_t) _dl_argv
[0];
1368 /* Create a link_map for the executable itself.
1369 This will be what dlopen on "" returns. */
1370 main_map
= _dl_new_object ((char *) "", "", lt_executable
, NULL
,
1371 __RTLD_OPENEXEC
, LM_ID_BASE
);
1372 assert (main_map
!= NULL
);
1373 main_map
->l_phdr
= phdr
;
1374 main_map
->l_phnum
= phnum
;
1375 main_map
->l_entry
= *user_entry
;
1377 /* Even though the link map is not yet fully initialized we can add
1378 it to the map list since there are no possible users running yet. */
1379 _dl_add_to_namespace_list (main_map
, LM_ID_BASE
);
1380 assert (main_map
== GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
);
1382 /* At this point we are in a bit of trouble. We would have to
1383 fill in the values for l_dev and l_ino. But in general we
1384 do not know where the file is. We also do not handle AT_EXECFD
1385 even if it would be passed up.
1387 We leave the values here defined to 0. This is normally no
1388 problem as the program code itself is normally no shared
1389 object and therefore cannot be loaded dynamically. Nothing
1390 prevent the use of dynamic binaries and in these situations
1391 we might get problems. We might not be able to find out
1392 whether the object is already loaded. But since there is no
1393 easy way out and because the dynamic binary must also not
1394 have an SONAME we ignore this program for now. If it becomes
1395 a problem we can force people using SONAMEs. */
1397 /* We delay initializing the path structure until we got the dynamic
1398 information for the program. */
1401 main_map
->l_map_end
= 0;
1402 main_map
->l_text_end
= 0;
1403 /* Perhaps the executable has no PT_LOAD header entries at all. */
1404 main_map
->l_map_start
= ~0;
1405 /* And it was opened directly. */
1406 ++main_map
->l_direct_opencount
;
1408 /* Scan the program header table for the dynamic section. */
1409 for (ph
= phdr
; ph
< &phdr
[phnum
]; ++ph
)
1413 /* Find out the load address. */
1414 main_map
->l_addr
= (ElfW(Addr
)) phdr
- ph
->p_vaddr
;
1417 /* This tells us where to find the dynamic section,
1418 which tells us everything we need to do. */
1419 main_map
->l_ld
= (void *) main_map
->l_addr
+ ph
->p_vaddr
;
1422 /* This "interpreter segment" was used by the program loader to
1423 find the program interpreter, which is this program itself, the
1424 dynamic linker. We note what name finds us, so that a future
1425 dlopen call or DT_NEEDED entry, for something that wants to link
1426 against the dynamic linker as a shared library, will know that
1427 the shared object is already loaded. */
1428 _dl_rtld_libname
.name
= ((const char *) main_map
->l_addr
1430 /* _dl_rtld_libname.next = NULL; Already zero. */
1431 GL(dl_rtld_map
).l_libname
= &_dl_rtld_libname
;
1433 /* Ordinarilly, we would get additional names for the loader from
1434 our DT_SONAME. This can't happen if we were actually linked as
1435 a static executable (detect this case when we have no DYNAMIC).
1436 If so, assume the filename component of the interpreter path to
1437 be our SONAME, and add it to our name list. */
1438 if (GL(dl_rtld_map
).l_ld
== NULL
)
1440 const char *p
= NULL
;
1441 const char *cp
= _dl_rtld_libname
.name
;
1443 /* Find the filename part of the path. */
1450 _dl_rtld_libname2
.name
= p
;
1451 /* _dl_rtld_libname2.next = NULL; Already zero. */
1452 _dl_rtld_libname
.next
= &_dl_rtld_libname2
;
1460 ElfW(Addr
) mapstart
;
1461 ElfW(Addr
) allocend
;
1463 /* Remember where the main program starts in memory. */
1464 mapstart
= (main_map
->l_addr
1465 + (ph
->p_vaddr
& ~(GLRO(dl_pagesize
) - 1)));
1466 if (main_map
->l_map_start
> mapstart
)
1467 main_map
->l_map_start
= mapstart
;
1469 /* Also where it ends. */
1470 allocend
= main_map
->l_addr
+ ph
->p_vaddr
+ ph
->p_memsz
;
1471 if (main_map
->l_map_end
< allocend
)
1472 main_map
->l_map_end
= allocend
;
1473 if ((ph
->p_flags
& PF_X
) && allocend
> main_map
->l_text_end
)
1474 main_map
->l_text_end
= allocend
;
1479 if (ph
->p_memsz
> 0)
1481 /* Note that in the case the dynamic linker we duplicate work
1482 here since we read the PT_TLS entry already in
1483 _dl_start_final. But the result is repeatable so do not
1484 check for this special but unimportant case. */
1485 main_map
->l_tls_blocksize
= ph
->p_memsz
;
1486 main_map
->l_tls_align
= ph
->p_align
;
1487 if (ph
->p_align
== 0)
1488 main_map
->l_tls_firstbyte_offset
= 0;
1490 main_map
->l_tls_firstbyte_offset
= (ph
->p_vaddr
1491 & (ph
->p_align
- 1));
1492 main_map
->l_tls_initimage_size
= ph
->p_filesz
;
1493 main_map
->l_tls_initimage
= (void *) ph
->p_vaddr
;
1495 /* This image gets the ID one. */
1496 GL(dl_tls_max_dtv_idx
) = main_map
->l_tls_modid
= 1;
1501 GL(dl_stack_flags
) = ph
->p_flags
;
1505 main_map
->l_relro_addr
= ph
->p_vaddr
;
1506 main_map
->l_relro_size
= ph
->p_memsz
;
1510 if (_rtld_process_pt_note (main_map
, ph
))
1511 _dl_error_printf ("\
1512 ERROR: '%s': cannot process note segment.\n", _dl_argv
[0]);
1516 /* Adjust the address of the TLS initialization image in case
1517 the executable is actually an ET_DYN object. */
1518 if (main_map
->l_tls_initimage
!= NULL
)
1519 main_map
->l_tls_initimage
1520 = (char *) main_map
->l_tls_initimage
+ main_map
->l_addr
;
1521 if (! main_map
->l_map_end
)
1522 main_map
->l_map_end
= ~0;
1523 if (! main_map
->l_text_end
)
1524 main_map
->l_text_end
= ~0;
1525 if (! GL(dl_rtld_map
).l_libname
&& GL(dl_rtld_map
).l_name
)
1527 /* We were invoked directly, so the program might not have a
1529 _dl_rtld_libname
.name
= GL(dl_rtld_map
).l_name
;
1530 /* _dl_rtld_libname.next = NULL; Already zero. */
1531 GL(dl_rtld_map
).l_libname
= &_dl_rtld_libname
;
1534 assert (GL(dl_rtld_map
).l_libname
); /* How else did we get here? */
1536 /* If the current libname is different from the SONAME, add the
1538 if (GL(dl_rtld_map
).l_info
[DT_SONAME
] != NULL
1539 && strcmp (GL(dl_rtld_map
).l_libname
->name
,
1540 (const char *) D_PTR (&GL(dl_rtld_map
), l_info
[DT_STRTAB
])
1541 + GL(dl_rtld_map
).l_info
[DT_SONAME
]->d_un
.d_val
) != 0)
1543 static struct libname_list newname
;
1544 newname
.name
= ((char *) D_PTR (&GL(dl_rtld_map
), l_info
[DT_STRTAB
])
1545 + GL(dl_rtld_map
).l_info
[DT_SONAME
]->d_un
.d_ptr
);
1546 newname
.next
= NULL
;
1547 newname
.dont_free
= 1;
1549 assert (GL(dl_rtld_map
).l_libname
->next
== NULL
);
1550 GL(dl_rtld_map
).l_libname
->next
= &newname
;
1552 /* The ld.so must be relocated since otherwise loading audit modules
1553 will fail since they reuse the very same ld.so. */
1554 assert (GL(dl_rtld_map
).l_relocated
);
1558 /* Extract the contents of the dynamic section for easy access. */
1559 elf_get_dynamic_info (main_map
, NULL
);
1560 /* Set up our cache of pointers into the hash table. */
1561 _dl_setup_hash (main_map
);
1564 if (__builtin_expect (mode
, normal
) == verify
)
1566 /* We were called just to verify that this is a dynamic
1567 executable using us as the program interpreter. Exit with an
1568 error if we were not able to load the binary or no interpreter
1569 is specified (i.e., this is no dynamically linked binary. */
1570 if (main_map
->l_ld
== NULL
)
1573 /* We allow here some platform specific code. */
1574 #ifdef DISTINGUISH_LIB_VERSIONS
1575 DISTINGUISH_LIB_VERSIONS
;
1577 _exit (has_interp
? 0 : 2);
1580 struct link_map
**first_preload
= &GL(dl_rtld_map
).l_next
;
1581 /* Set up the data structures for the system-supplied DSO early,
1582 so they can influence _dl_init_paths. */
1583 setup_vdso (main_map
, &first_preload
);
1585 /* With vDSO setup we can initialize the function pointers. */
1586 setup_vdso_pointers ();
1588 #ifdef DL_SYSDEP_OSCHECK
1589 DL_SYSDEP_OSCHECK (_dl_fatal_printf
);
1592 /* Initialize the data structures for the search paths for shared
1594 _dl_init_paths (library_path
);
1596 /* Initialize _r_debug. */
1597 struct r_debug
*r
= _dl_debug_initialize (GL(dl_rtld_map
).l_addr
,
1599 r
->r_state
= RT_CONSISTENT
;
1601 /* Put the link_map for ourselves on the chain so it can be found by
1602 name. Note that at this point the global chain of link maps contains
1603 exactly one element, which is pointed to by dl_loaded. */
1604 if (! GL(dl_rtld_map
).l_name
)
1605 /* If not invoked directly, the dynamic linker shared object file was
1606 found by the PT_INTERP name. */
1607 GL(dl_rtld_map
).l_name
= (char *) GL(dl_rtld_map
).l_libname
->name
;
1608 GL(dl_rtld_map
).l_type
= lt_library
;
1609 main_map
->l_next
= &GL(dl_rtld_map
);
1610 GL(dl_rtld_map
).l_prev
= main_map
;
1611 ++GL(dl_ns
)[LM_ID_BASE
]._ns_nloaded
;
1614 /* If LD_USE_LOAD_BIAS env variable has not been seen, default
1615 to not using bias for non-prelinked PIEs and libraries
1616 and using it for executables or prelinked PIEs or libraries. */
1617 if (GLRO(dl_use_load_bias
) == (ElfW(Addr
)) -2)
1618 GLRO(dl_use_load_bias
) = main_map
->l_addr
== 0 ? -1 : 0;
1620 /* Set up the program header information for the dynamic linker
1621 itself. It is needed in the dl_iterate_phdr callbacks. */
1622 const ElfW(Ehdr
) *rtld_ehdr
;
1624 /* Starting from binutils-2.23, the linker will define the magic symbol
1625 __ehdr_start to point to our own ELF header if it is visible in a
1626 segment that also includes the phdrs. If that's not available, we use
1627 the old method that assumes the beginning of the file is part of the
1628 lowest-addressed PT_LOAD segment. */
1629 #ifdef HAVE_EHDR_START
1630 extern const ElfW(Ehdr
) __ehdr_start
__attribute__ ((visibility ("hidden")));
1631 rtld_ehdr
= &__ehdr_start
;
1633 rtld_ehdr
= (void *) GL(dl_rtld_map
).l_map_start
;
1635 assert (rtld_ehdr
->e_ehsize
== sizeof *rtld_ehdr
);
1636 assert (rtld_ehdr
->e_phentsize
== sizeof (ElfW(Phdr
)));
1638 const ElfW(Phdr
) *rtld_phdr
= (const void *) rtld_ehdr
+ rtld_ehdr
->e_phoff
;
1640 GL(dl_rtld_map
).l_phdr
= rtld_phdr
;
1641 GL(dl_rtld_map
).l_phnum
= rtld_ehdr
->e_phnum
;
1644 /* PT_GNU_RELRO is usually the last phdr. */
1645 size_t cnt
= rtld_ehdr
->e_phnum
;
1647 if (rtld_phdr
[cnt
].p_type
== PT_GNU_RELRO
)
1649 GL(dl_rtld_map
).l_relro_addr
= rtld_phdr
[cnt
].p_vaddr
;
1650 GL(dl_rtld_map
).l_relro_size
= rtld_phdr
[cnt
].p_memsz
;
1654 /* Add the dynamic linker to the TLS list if it also uses TLS. */
1655 if (GL(dl_rtld_map
).l_tls_blocksize
!= 0)
1656 /* Assign a module ID. Do this before loading any audit modules. */
1657 GL(dl_rtld_map
).l_tls_modid
= _dl_next_tls_modid ();
1659 audit_list_add_dynamic_tag (&audit_list
, main_map
, DT_AUDIT
);
1660 audit_list_add_dynamic_tag (&audit_list
, main_map
, DT_DEPAUDIT
);
1662 /* If we have auditing DSOs to load, do it now. */
1663 bool need_security_init
= true;
1664 if (audit_list
.length
> 0)
1666 /* Since we start using the auditing DSOs right away we need to
1667 initialize the data structures now. */
1670 /* Initialize security features. We need to do it this early
1671 since otherwise the constructors of the audit libraries will
1672 use different values (especially the pointer guard) and will
1675 need_security_init
= false;
1677 load_audit_modules (main_map
, &audit_list
);
1680 /* Keep track of the currently loaded modules to count how many
1681 non-audit modules which use TLS are loaded. */
1682 size_t count_modids
= _dl_count_modids ();
1684 /* Set up debugging before the debugger is notified for the first time. */
1685 #ifdef ELF_MACHINE_DEBUG_SETUP
1686 /* Some machines (e.g. MIPS) don't use DT_DEBUG in this way. */
1687 ELF_MACHINE_DEBUG_SETUP (main_map
, r
);
1688 ELF_MACHINE_DEBUG_SETUP (&GL(dl_rtld_map
), r
);
1690 if (main_map
->l_info
[DT_DEBUG
] != NULL
)
1691 /* There is a DT_DEBUG entry in the dynamic section. Fill it in
1692 with the run-time address of the r_debug structure */
1693 main_map
->l_info
[DT_DEBUG
]->d_un
.d_ptr
= (ElfW(Addr
)) r
;
1695 /* Fill in the pointer in the dynamic linker's own dynamic section, in
1696 case you run gdb on the dynamic linker directly. */
1697 if (GL(dl_rtld_map
).l_info
[DT_DEBUG
] != NULL
)
1698 GL(dl_rtld_map
).l_info
[DT_DEBUG
]->d_un
.d_ptr
= (ElfW(Addr
)) r
;
1701 /* We start adding objects. */
1702 r
->r_state
= RT_ADD
;
1704 LIBC_PROBE (init_start
, 2, LM_ID_BASE
, r
);
1706 /* Auditing checkpoint: we are ready to signal that the initial map
1707 is being constructed. */
1708 if (__glibc_unlikely (GLRO(dl_naudit
) > 0))
1710 struct audit_ifaces
*afct
= GLRO(dl_audit
);
1711 for (unsigned int cnt
= 0; cnt
< GLRO(dl_naudit
); ++cnt
)
1713 if (afct
->activity
!= NULL
)
1714 afct
->activity (&link_map_audit_state (main_map
, cnt
)->cookie
,
1721 /* We have two ways to specify objects to preload: via environment
1722 variable and via the file /etc/ld.so.preload. The latter can also
1723 be used when security is enabled. */
1724 assert (*first_preload
== NULL
);
1725 struct link_map
**preloads
= NULL
;
1726 unsigned int npreloads
= 0;
1728 if (__glibc_unlikely (preloadlist
!= NULL
))
1730 RTLD_TIMING_VAR (start
);
1731 rtld_timer_start (&start
);
1732 npreloads
+= handle_preload_list (preloadlist
, main_map
, "LD_PRELOAD");
1733 rtld_timer_accum (&load_time
, start
);
1736 if (__glibc_unlikely (preloadarg
!= NULL
))
1738 RTLD_TIMING_VAR (start
);
1739 rtld_timer_start (&start
);
1740 npreloads
+= handle_preload_list (preloadarg
, main_map
, "--preload");
1741 rtld_timer_accum (&load_time
, start
);
1744 /* There usually is no ld.so.preload file, it should only be used
1745 for emergencies and testing. So the open call etc should usually
1746 fail. Using access() on a non-existing file is faster than using
1747 open(). So we do this first. If it succeeds we do almost twice
1748 the work but this does not matter, since it is not for production
1750 static const char preload_file
[] = "/etc/ld.so.preload";
1751 if (__glibc_unlikely (__access (preload_file
, R_OK
) == 0))
1753 /* Read the contents of the file. */
1754 file
= _dl_sysdep_read_whole_file (preload_file
, &file_size
,
1755 PROT_READ
| PROT_WRITE
);
1756 if (__glibc_unlikely (file
!= MAP_FAILED
))
1758 /* Parse the file. It contains names of libraries to be loaded,
1759 separated by white spaces or `:'. It may also contain
1760 comments introduced by `#'. */
1765 /* Eliminate comments. */
1770 char *comment
= memchr (runp
, '#', rest
);
1771 if (comment
== NULL
)
1774 rest
-= comment
- runp
;
1777 while (--rest
> 0 && *++comment
!= '\n');
1780 /* We have one problematic case: if we have a name at the end of
1781 the file without a trailing terminating characters, we cannot
1782 place the \0. Handle the case separately. */
1783 if (file
[file_size
- 1] != ' ' && file
[file_size
- 1] != '\t'
1784 && file
[file_size
- 1] != '\n' && file
[file_size
- 1] != ':')
1786 problem
= &file
[file_size
];
1787 while (problem
> file
&& problem
[-1] != ' '
1788 && problem
[-1] != '\t'
1789 && problem
[-1] != '\n' && problem
[-1] != ':')
1798 file
[file_size
- 1] = '\0';
1801 RTLD_TIMING_VAR (start
);
1802 rtld_timer_start (&start
);
1804 if (file
!= problem
)
1808 while ((p
= strsep (&runp
, ": \t\n")) != NULL
)
1810 npreloads
+= do_preload (p
, main_map
, preload_file
);
1813 if (problem
!= NULL
)
1815 char *p
= strndupa (problem
, file_size
- (problem
- file
));
1817 npreloads
+= do_preload (p
, main_map
, preload_file
);
1820 rtld_timer_accum (&load_time
, start
);
1822 /* We don't need the file anymore. */
1823 __munmap (file
, file_size
);
1827 if (__glibc_unlikely (*first_preload
!= NULL
))
1829 /* Set up PRELOADS with a vector of the preloaded libraries. */
1830 struct link_map
*l
= *first_preload
;
1831 preloads
= __alloca (npreloads
* sizeof preloads
[0]);
1838 assert (i
== npreloads
);
1841 /* Load all the libraries specified by DT_NEEDED entries. If LD_PRELOAD
1842 specified some libraries to load, these are inserted before the actual
1843 dependencies in the executable's searchlist for symbol resolution. */
1845 RTLD_TIMING_VAR (start
);
1846 rtld_timer_start (&start
);
1847 _dl_map_object_deps (main_map
, preloads
, npreloads
, mode
== trace
, 0);
1848 rtld_timer_accum (&load_time
, start
);
1851 /* Mark all objects as being in the global scope. */
1852 for (i
= main_map
->l_searchlist
.r_nlist
; i
> 0; )
1853 main_map
->l_searchlist
.r_list
[--i
]->l_global
= 1;
1855 /* Remove _dl_rtld_map from the chain. */
1856 GL(dl_rtld_map
).l_prev
->l_next
= GL(dl_rtld_map
).l_next
;
1857 if (GL(dl_rtld_map
).l_next
!= NULL
)
1858 GL(dl_rtld_map
).l_next
->l_prev
= GL(dl_rtld_map
).l_prev
;
1860 for (i
= 1; i
< main_map
->l_searchlist
.r_nlist
; ++i
)
1861 if (main_map
->l_searchlist
.r_list
[i
] == &GL(dl_rtld_map
))
1864 bool rtld_multiple_ref
= false;
1865 if (__glibc_likely (i
< main_map
->l_searchlist
.r_nlist
))
1867 /* Some DT_NEEDED entry referred to the interpreter object itself, so
1868 put it back in the list of visible objects. We insert it into the
1869 chain in symbol search order because gdb uses the chain's order as
1870 its symbol search order. */
1871 rtld_multiple_ref
= true;
1873 GL(dl_rtld_map
).l_prev
= main_map
->l_searchlist
.r_list
[i
- 1];
1874 if (__builtin_expect (mode
, normal
) == normal
)
1876 GL(dl_rtld_map
).l_next
= (i
+ 1 < main_map
->l_searchlist
.r_nlist
1877 ? main_map
->l_searchlist
.r_list
[i
+ 1]
1879 #ifdef NEED_DL_SYSINFO_DSO
1880 if (GLRO(dl_sysinfo_map
) != NULL
1881 && GL(dl_rtld_map
).l_prev
->l_next
== GLRO(dl_sysinfo_map
)
1882 && GL(dl_rtld_map
).l_next
!= GLRO(dl_sysinfo_map
))
1883 GL(dl_rtld_map
).l_prev
= GLRO(dl_sysinfo_map
);
1887 /* In trace mode there might be an invisible object (which we
1888 could not find) after the previous one in the search list.
1889 In this case it doesn't matter much where we put the
1890 interpreter object, so we just initialize the list pointer so
1891 that the assertion below holds. */
1892 GL(dl_rtld_map
).l_next
= GL(dl_rtld_map
).l_prev
->l_next
;
1894 assert (GL(dl_rtld_map
).l_prev
->l_next
== GL(dl_rtld_map
).l_next
);
1895 GL(dl_rtld_map
).l_prev
->l_next
= &GL(dl_rtld_map
);
1896 if (GL(dl_rtld_map
).l_next
!= NULL
)
1898 assert (GL(dl_rtld_map
).l_next
->l_prev
== GL(dl_rtld_map
).l_prev
);
1899 GL(dl_rtld_map
).l_next
->l_prev
= &GL(dl_rtld_map
);
1903 /* Now let us see whether all libraries are available in the
1904 versions we need. */
1906 struct version_check_args args
;
1907 args
.doexit
= mode
== normal
;
1908 args
.dotrace
= mode
== trace
;
1909 _dl_receive_error (print_missing_version
, version_check_doit
, &args
);
1912 /* We do not initialize any of the TLS functionality unless any of the
1913 initial modules uses TLS. This makes dynamic loading of modules with
1914 TLS impossible, but to support it requires either eagerly doing setup
1915 now or lazily doing it later. Doing it now makes us incompatible with
1916 an old kernel that can't perform TLS_INIT_TP, even if no TLS is ever
1917 used. Trying to do it lazily is too hairy to try when there could be
1918 multiple threads (from a non-TLS-using libpthread). */
1919 bool was_tls_init_tp_called
= tls_init_tp_called
;
1923 if (__glibc_likely (need_security_init
))
1924 /* Initialize security features. But only if we have not done it
1928 if (__builtin_expect (mode
, normal
) != normal
)
1930 /* We were run just to list the shared libraries. It is
1931 important that we do this before real relocation, because the
1932 functions we call below for output may no longer work properly
1933 after relocation. */
1936 if (GLRO(dl_debug_mask
) & DL_DEBUG_PRELINK
)
1938 struct r_scope_elem
*scope
= &main_map
->l_searchlist
;
1940 for (i
= 0; i
< scope
->r_nlist
; i
++)
1942 l
= scope
->r_list
[i
];
1945 _dl_printf ("\t%s => not found\n", l
->l_libname
->name
);
1948 if (_dl_name_match_p (GLRO(dl_trace_prelink
), l
))
1949 GLRO(dl_trace_prelink_map
) = l
;
1950 _dl_printf ("\t%s => %s (0x%0*Zx, 0x%0*Zx)",
1951 DSO_FILENAME (l
->l_libname
->name
),
1952 DSO_FILENAME (l
->l_name
),
1953 (int) sizeof l
->l_map_start
* 2,
1954 (size_t) l
->l_map_start
,
1955 (int) sizeof l
->l_addr
* 2,
1956 (size_t) l
->l_addr
);
1959 _dl_printf (" TLS(0x%Zx, 0x%0*Zx)\n", l
->l_tls_modid
,
1960 (int) sizeof l
->l_tls_offset
* 2,
1961 (size_t) l
->l_tls_offset
);
1966 else if (GLRO(dl_debug_mask
) & DL_DEBUG_UNUSED
)
1968 /* Look through the dependencies of the main executable
1969 and determine which of them is not actually
1971 struct link_map
*l
= main_map
;
1973 /* Relocate the main executable. */
1974 struct relocate_args args
= { .l
= l
,
1975 .reloc_mode
= ((GLRO(dl_lazy
)
1977 | __RTLD_NOIFUNC
) };
1978 _dl_receive_error (print_unresolved
, relocate_doit
, &args
);
1980 /* This loop depends on the dependencies of the executable to
1981 correspond in number and order to the DT_NEEDED entries. */
1982 ElfW(Dyn
) *dyn
= main_map
->l_ld
;
1984 while (dyn
->d_tag
!= DT_NULL
)
1986 if (dyn
->d_tag
== DT_NEEDED
)
1989 #ifdef NEED_DL_SYSINFO_DSO
1990 /* Skip the VDSO since it's not part of the list
1991 of objects we brought in via DT_NEEDED entries. */
1992 if (l
== GLRO(dl_sysinfo_map
))
1999 _dl_printf ("Unused direct dependencies:\n");
2003 _dl_printf ("\t%s\n", l
->l_name
);
2010 _exit (first
!= true);
2012 else if (! main_map
->l_info
[DT_NEEDED
])
2013 _dl_printf ("\tstatically linked\n");
2016 for (l
= main_map
->l_next
; l
; l
= l
->l_next
)
2018 /* The library was not found. */
2019 _dl_printf ("\t%s => not found\n", l
->l_libname
->name
);
2020 else if (strcmp (l
->l_libname
->name
, l
->l_name
) == 0)
2021 _dl_printf ("\t%s (0x%0*Zx)\n", l
->l_libname
->name
,
2022 (int) sizeof l
->l_map_start
* 2,
2023 (size_t) l
->l_map_start
);
2025 _dl_printf ("\t%s => %s (0x%0*Zx)\n", l
->l_libname
->name
,
2026 l
->l_name
, (int) sizeof l
->l_map_start
* 2,
2027 (size_t) l
->l_map_start
);
2030 if (__builtin_expect (mode
, trace
) != trace
)
2031 for (i
= 1; i
< (unsigned int) _dl_argc
; ++i
)
2033 const ElfW(Sym
) *ref
= NULL
;
2034 ElfW(Addr
) loadbase
;
2037 result
= _dl_lookup_symbol_x (_dl_argv
[i
], main_map
,
2038 &ref
, main_map
->l_scope
,
2039 NULL
, ELF_RTYPE_CLASS_PLT
,
2040 DL_LOOKUP_ADD_DEPENDENCY
, NULL
);
2042 loadbase
= LOOKUP_VALUE_ADDRESS (result
, false);
2044 _dl_printf ("%s found at 0x%0*Zd in object at 0x%0*Zd\n",
2046 (int) sizeof ref
->st_value
* 2,
2047 (size_t) ref
->st_value
,
2048 (int) sizeof loadbase
* 2, (size_t) loadbase
);
2052 /* If LD_WARN is set, warn about undefined symbols. */
2053 if (GLRO(dl_lazy
) >= 0 && GLRO(dl_verbose
))
2055 /* We have to do symbol dependency testing. */
2056 struct relocate_args args
;
2059 args
.reloc_mode
= ((GLRO(dl_lazy
) ? RTLD_LAZY
: 0)
2062 i
= main_map
->l_searchlist
.r_nlist
;
2065 struct link_map
*l
= main_map
->l_initfini
[i
];
2066 if (l
!= &GL(dl_rtld_map
) && ! l
->l_faked
)
2069 _dl_receive_error (print_unresolved
, relocate_doit
,
2074 if ((GLRO(dl_debug_mask
) & DL_DEBUG_PRELINK
)
2075 && rtld_multiple_ref
)
2077 /* Mark the link map as not yet relocated again. */
2078 GL(dl_rtld_map
).l_relocated
= 0;
2079 _dl_relocate_object (&GL(dl_rtld_map
),
2080 main_map
->l_scope
, __RTLD_NOIFUNC
, 0);
2083 #define VERNEEDTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERNEED))
2086 /* Print more information. This means here, print information
2087 about the versions needed. */
2089 struct link_map
*map
;
2091 for (map
= main_map
; map
!= NULL
; map
= map
->l_next
)
2094 ElfW(Dyn
) *dyn
= map
->l_info
[VERNEEDTAG
];
2100 strtab
= (const void *) D_PTR (map
, l_info
[DT_STRTAB
]);
2101 ent
= (ElfW(Verneed
) *) (map
->l_addr
+ dyn
->d_un
.d_ptr
);
2105 _dl_printf ("\n\tVersion information:\n");
2109 _dl_printf ("\t%s:\n", DSO_FILENAME (map
->l_name
));
2114 struct link_map
*needed
;
2116 needed
= find_needed (strtab
+ ent
->vn_file
);
2117 aux
= (ElfW(Vernaux
) *) ((char *) ent
+ ent
->vn_aux
);
2121 const char *fname
= NULL
;
2124 && match_version (strtab
+ aux
->vna_name
,
2126 fname
= needed
->l_name
;
2128 _dl_printf ("\t\t%s (%s) %s=> %s\n",
2129 strtab
+ ent
->vn_file
,
2130 strtab
+ aux
->vna_name
,
2131 aux
->vna_flags
& VER_FLG_WEAK
2133 fname
?: "not found");
2135 if (aux
->vna_next
== 0)
2136 /* No more symbols. */
2140 aux
= (ElfW(Vernaux
) *) ((char *) aux
2144 if (ent
->vn_next
== 0)
2145 /* No more dependencies. */
2148 /* Next dependency. */
2149 ent
= (ElfW(Verneed
) *) ((char *) ent
+ ent
->vn_next
);
2158 if (main_map
->l_info
[ADDRIDX (DT_GNU_LIBLIST
)]
2159 && ! __builtin_expect (GLRO(dl_profile
) != NULL
, 0)
2160 && ! __builtin_expect (GLRO(dl_dynamic_weak
), 0))
2162 ElfW(Lib
) *liblist
, *liblistend
;
2163 struct link_map
**r_list
, **r_listend
, *l
;
2164 const char *strtab
= (const void *) D_PTR (main_map
, l_info
[DT_STRTAB
]);
2166 assert (main_map
->l_info
[VALIDX (DT_GNU_LIBLISTSZ
)] != NULL
);
2167 liblist
= (ElfW(Lib
) *)
2168 main_map
->l_info
[ADDRIDX (DT_GNU_LIBLIST
)]->d_un
.d_ptr
;
2169 liblistend
= (ElfW(Lib
) *)
2171 + main_map
->l_info
[VALIDX (DT_GNU_LIBLISTSZ
)]->d_un
.d_val
);
2172 r_list
= main_map
->l_searchlist
.r_list
;
2173 r_listend
= r_list
+ main_map
->l_searchlist
.r_nlist
;
2175 for (; r_list
< r_listend
&& liblist
< liblistend
; r_list
++)
2182 /* If the library is not mapped where it should, fail. */
2186 /* Next, check if checksum matches. */
2187 if (l
->l_info
[VALIDX(DT_CHECKSUM
)] == NULL
2188 || l
->l_info
[VALIDX(DT_CHECKSUM
)]->d_un
.d_val
2189 != liblist
->l_checksum
)
2192 if (l
->l_info
[VALIDX(DT_GNU_PRELINKED
)] == NULL
2193 || l
->l_info
[VALIDX(DT_GNU_PRELINKED
)]->d_un
.d_val
2194 != liblist
->l_time_stamp
)
2197 if (! _dl_name_match_p (strtab
+ liblist
->l_name
, l
))
2204 if (r_list
== r_listend
&& liblist
== liblistend
)
2207 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_LIBS
))
2208 _dl_debug_printf ("\nprelink checking: %s\n",
2209 prelinked
? "ok" : "failed");
2213 /* Now set up the variable which helps the assembler startup code. */
2214 GL(dl_ns
)[LM_ID_BASE
]._ns_main_searchlist
= &main_map
->l_searchlist
;
2216 /* Save the information about the original global scope list since
2217 we need it in the memory handling later. */
2218 GLRO(dl_initial_searchlist
) = *GL(dl_ns
)[LM_ID_BASE
]._ns_main_searchlist
;
2220 /* Remember the last search directory added at startup, now that
2221 malloc will no longer be the one from dl-minimal.c. As a side
2222 effect, this marks ld.so as initialized, so that the rtld_active
2223 function returns true from now on. */
2224 GLRO(dl_init_all_dirs
) = GL(dl_all_dirs
);
2226 /* Print scope information. */
2227 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_SCOPES
))
2229 _dl_debug_printf ("\nInitial object scopes\n");
2231 for (struct link_map
*l
= main_map
; l
!= NULL
; l
= l
->l_next
)
2232 _dl_show_scope (l
, 0);
2235 _rtld_main_check (main_map
, _dl_argv
[0]);
2239 if (main_map
->l_info
[ADDRIDX (DT_GNU_CONFLICT
)] != NULL
)
2241 ElfW(Rela
) *conflict
, *conflictend
;
2243 RTLD_TIMING_VAR (start
);
2244 rtld_timer_start (&start
);
2246 assert (main_map
->l_info
[VALIDX (DT_GNU_CONFLICTSZ
)] != NULL
);
2247 conflict
= (ElfW(Rela
) *)
2248 main_map
->l_info
[ADDRIDX (DT_GNU_CONFLICT
)]->d_un
.d_ptr
;
2249 conflictend
= (ElfW(Rela
) *)
2251 + main_map
->l_info
[VALIDX (DT_GNU_CONFLICTSZ
)]->d_un
.d_val
);
2252 _dl_resolve_conflicts (main_map
, conflict
, conflictend
);
2254 rtld_timer_stop (&relocate_time
, start
);
2257 /* The library defining malloc has already been relocated due to
2258 prelinking. Resolve the malloc symbols for the dynamic
2260 __rtld_malloc_init_real (main_map
);
2262 /* Mark all the objects so we know they have been already relocated. */
2263 for (struct link_map
*l
= main_map
; l
!= NULL
; l
= l
->l_next
)
2266 if (l
->l_relro_size
)
2267 _dl_protect_relro (l
);
2269 /* Add object to slot information data if necessasy. */
2270 if (l
->l_tls_blocksize
!= 0 && tls_init_tp_called
)
2271 _dl_add_to_slotinfo (l
, true);
2276 /* Now we have all the objects loaded. Relocate them all except for
2277 the dynamic linker itself. We do this in reverse order so that copy
2278 relocs of earlier objects overwrite the data written by later
2279 objects. We do not re-relocate the dynamic linker itself in this
2280 loop because that could result in the GOT entries for functions we
2281 call being changed, and that would break us. It is safe to relocate
2282 the dynamic linker out of order because it has no copy relocs (we
2283 know that because it is self-contained). */
2285 int consider_profiling
= GLRO(dl_profile
) != NULL
;
2287 /* If we are profiling we also must do lazy reloaction. */
2288 GLRO(dl_lazy
) |= consider_profiling
;
2290 RTLD_TIMING_VAR (start
);
2291 rtld_timer_start (&start
);
2292 unsigned i
= main_map
->l_searchlist
.r_nlist
;
2295 struct link_map
*l
= main_map
->l_initfini
[i
];
2297 /* While we are at it, help the memory handling a bit. We have to
2298 mark some data structures as allocated with the fake malloc()
2299 implementation in ld.so. */
2300 struct libname_list
*lnp
= l
->l_libname
->next
;
2302 while (__builtin_expect (lnp
!= NULL
, 0))
2307 /* Also allocated with the fake malloc(). */
2308 l
->l_free_initfini
= 0;
2310 if (l
!= &GL(dl_rtld_map
))
2311 _dl_relocate_object (l
, l
->l_scope
, GLRO(dl_lazy
) ? RTLD_LAZY
: 0,
2312 consider_profiling
);
2314 /* Add object to slot information data if necessasy. */
2315 if (l
->l_tls_blocksize
!= 0 && tls_init_tp_called
)
2316 _dl_add_to_slotinfo (l
, true);
2318 rtld_timer_stop (&relocate_time
, start
);
2320 /* Now enable profiling if needed. Like the previous call,
2321 this has to go here because the calls it makes should use the
2322 rtld versions of the functions (particularly calloc()), but it
2323 needs to have _dl_profile_map set up by the relocator. */
2324 if (__glibc_unlikely (GL(dl_profile_map
) != NULL
))
2325 /* We must prepare the profiling. */
2326 _dl_start_profile ();
2329 if ((!was_tls_init_tp_called
&& GL(dl_tls_max_dtv_idx
) > 0)
2330 || count_modids
!= _dl_count_modids ())
2331 ++GL(dl_tls_generation
);
2333 /* Now that we have completed relocation, the initializer data
2334 for the TLS blocks has its final values and we can copy them
2335 into the main thread's TLS area, which we allocated above.
2336 Note: thread-local variables must only be accessed after completing
2338 _dl_allocate_tls_init (tcbp
);
2340 /* And finally install it for the main thread. */
2341 if (! tls_init_tp_called
)
2343 const char *lossage
= TLS_INIT_TP (tcbp
);
2344 if (__glibc_unlikely (lossage
!= NULL
))
2345 _dl_fatal_printf ("cannot set up thread-local storage: %s\n",
2349 /* Make sure no new search directories have been added. */
2350 assert (GLRO(dl_init_all_dirs
) == GL(dl_all_dirs
));
2352 if (! prelinked
&& rtld_multiple_ref
)
2354 /* There was an explicit ref to the dynamic linker as a shared lib.
2355 Re-relocate ourselves with user-controlled symbol definitions.
2357 We must do this after TLS initialization in case after this
2358 re-relocation, we might call a user-supplied function
2359 (e.g. calloc from _dl_relocate_object) that uses TLS data. */
2361 /* The malloc implementation has been relocated, so resolving
2362 its symbols (and potentially calling IFUNC resolvers) is safe
2364 __rtld_malloc_init_real (main_map
);
2366 RTLD_TIMING_VAR (start
);
2367 rtld_timer_start (&start
);
2369 /* Mark the link map as not yet relocated again. */
2370 GL(dl_rtld_map
).l_relocated
= 0;
2371 _dl_relocate_object (&GL(dl_rtld_map
), main_map
->l_scope
, 0, 0);
2373 rtld_timer_accum (&relocate_time
, start
);
2376 /* Relocation is complete. Perform early libc initialization. */
2377 _dl_call_libc_early_init (GL(dl_ns
)[LM_ID_BASE
].libc_map
);
2379 /* Do any necessary cleanups for the startup OS interface code.
2380 We do these now so that no calls are made after rtld re-relocation
2381 which might be resolved to different functions than we expect.
2382 We cannot do this before relocating the other objects because
2383 _dl_relocate_object might need to call `mprotect' for DT_TEXTREL. */
2384 _dl_sysdep_start_cleanup ();
2387 /* Auditing checkpoint: we have added all objects. */
2388 if (__glibc_unlikely (GLRO(dl_naudit
) > 0))
2390 struct link_map
*head
= GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
;
2391 /* Do not call the functions for any auditing object. */
2392 if (head
->l_auditing
== 0)
2394 struct audit_ifaces
*afct
= GLRO(dl_audit
);
2395 for (unsigned int cnt
= 0; cnt
< GLRO(dl_naudit
); ++cnt
)
2397 if (afct
->activity
!= NULL
)
2398 afct
->activity (&link_map_audit_state (head
, cnt
)->cookie
,
2407 /* Notify the debugger all new objects are now ready to go. We must re-get
2408 the address since by now the variable might be in another object. */
2409 r
= _dl_debug_initialize (0, LM_ID_BASE
);
2410 r
->r_state
= RT_CONSISTENT
;
2412 LIBC_PROBE (init_complete
, 2, LM_ID_BASE
, r
);
2414 #if defined USE_LDCONFIG && !defined MAP_COPY
2415 /* We must munmap() the cache file. */
2416 _dl_unload_cache ();
2419 /* Once we return, _dl_sysdep_start will invoke
2420 the DT_INIT functions and then *USER_ENTRY. */
2423 /* This is a little helper function for resolving symbols while
2424 tracing the binary. */
2426 print_unresolved (int errcode
__attribute__ ((unused
)), const char *objname
,
2427 const char *errstring
)
2429 if (objname
[0] == '\0')
2430 objname
= RTLD_PROGNAME
;
2431 _dl_error_printf ("%s (%s)\n", errstring
, objname
);
2434 /* This is a little helper function for resolving symbols while
2435 tracing the binary. */
2437 print_missing_version (int errcode
__attribute__ ((unused
)),
2438 const char *objname
, const char *errstring
)
2440 _dl_error_printf ("%s: %s: %s\n", RTLD_PROGNAME
,
2441 objname
, errstring
);
2444 /* Nonzero if any of the debugging options is enabled. */
2445 static int any_debug attribute_relro
;
2447 /* Process the string given as the parameter which explains which debugging
2448 options are enabled. */
2450 process_dl_debug (const char *dl_debug
)
2452 /* When adding new entries make sure that the maximal length of a name
2453 is correctly handled in the LD_DEBUG_HELP code below. */
2457 const char name
[10];
2458 const char helptext
[41];
2459 unsigned short int mask
;
2462 #define LEN_AND_STR(str) sizeof (str) - 1, str
2463 { LEN_AND_STR ("libs"), "display library search paths",
2464 DL_DEBUG_LIBS
| DL_DEBUG_IMPCALLS
},
2465 { LEN_AND_STR ("reloc"), "display relocation processing",
2466 DL_DEBUG_RELOC
| DL_DEBUG_IMPCALLS
},
2467 { LEN_AND_STR ("files"), "display progress for input file",
2468 DL_DEBUG_FILES
| DL_DEBUG_IMPCALLS
},
2469 { LEN_AND_STR ("symbols"), "display symbol table processing",
2470 DL_DEBUG_SYMBOLS
| DL_DEBUG_IMPCALLS
},
2471 { LEN_AND_STR ("bindings"), "display information about symbol binding",
2472 DL_DEBUG_BINDINGS
| DL_DEBUG_IMPCALLS
},
2473 { LEN_AND_STR ("versions"), "display version dependencies",
2474 DL_DEBUG_VERSIONS
| DL_DEBUG_IMPCALLS
},
2475 { LEN_AND_STR ("scopes"), "display scope information",
2477 { LEN_AND_STR ("all"), "all previous options combined",
2478 DL_DEBUG_LIBS
| DL_DEBUG_RELOC
| DL_DEBUG_FILES
| DL_DEBUG_SYMBOLS
2479 | DL_DEBUG_BINDINGS
| DL_DEBUG_VERSIONS
| DL_DEBUG_IMPCALLS
2480 | DL_DEBUG_SCOPES
},
2481 { LEN_AND_STR ("statistics"), "display relocation statistics",
2482 DL_DEBUG_STATISTICS
},
2483 { LEN_AND_STR ("unused"), "determined unused DSOs",
2485 { LEN_AND_STR ("help"), "display this help message and exit",
2488 #define ndebopts (sizeof (debopts) / sizeof (debopts[0]))
2490 /* Skip separating white spaces and commas. */
2491 while (*dl_debug
!= '\0')
2493 if (*dl_debug
!= ' ' && *dl_debug
!= ',' && *dl_debug
!= ':')
2498 while (dl_debug
[len
] != '\0' && dl_debug
[len
] != ' '
2499 && dl_debug
[len
] != ',' && dl_debug
[len
] != ':')
2502 for (cnt
= 0; cnt
< ndebopts
; ++cnt
)
2503 if (debopts
[cnt
].len
== len
2504 && memcmp (dl_debug
, debopts
[cnt
].name
, len
) == 0)
2506 GLRO(dl_debug_mask
) |= debopts
[cnt
].mask
;
2511 if (cnt
== ndebopts
)
2513 /* Display a warning and skip everything until next
2515 char *copy
= strndupa (dl_debug
, len
);
2516 _dl_error_printf ("\
2517 warning: debug option `%s' unknown; try LD_DEBUG=help\n", copy
);
2527 if (GLRO(dl_debug_mask
) & DL_DEBUG_UNUSED
)
2529 /* In order to get an accurate picture of whether a particular
2530 DT_NEEDED entry is actually used we have to process both
2531 the PLT and non-PLT relocation entries. */
2535 if (GLRO(dl_debug_mask
) & DL_DEBUG_HELP
)
2540 Valid options for the LD_DEBUG environment variable are:\n\n");
2542 for (cnt
= 0; cnt
< ndebopts
; ++cnt
)
2543 _dl_printf (" %.*s%s%s\n", debopts
[cnt
].len
, debopts
[cnt
].name
,
2544 " " + debopts
[cnt
].len
- 3,
2545 debopts
[cnt
].helptext
);
2548 To direct the debugging output into a file instead of standard output\n\
2549 a filename can be specified using the LD_DEBUG_OUTPUT environment variable.\n");
2554 /* Process all environments variables the dynamic linker must recognize.
2555 Since all of them start with `LD_' we are a bit smarter while finding
2557 extern char **_environ attribute_hidden
;
2561 process_envvars (enum mode
*modep
, struct audit_list
*audit_list
)
2563 char **runp
= _environ
;
2565 enum mode mode
= normal
;
2566 char *debug_output
= NULL
;
2568 /* This is the default place for profiling data file. */
2569 GLRO(dl_profile_output
)
2570 = &"/var/tmp\0/var/profile"[__libc_enable_secure
? 9 : 0];
2572 while ((envline
= _dl_next_ld_env_entry (&runp
)) != NULL
)
2576 while (envline
[len
] != '\0' && envline
[len
] != '=')
2579 if (envline
[len
] != '=')
2580 /* This is a "LD_" variable at the end of the string without
2581 a '=' character. Ignore it since otherwise we will access
2582 invalid memory below. */
2588 /* Warning level, verbose or not. */
2589 if (memcmp (envline
, "WARN", 4) == 0)
2590 GLRO(dl_verbose
) = envline
[5] != '\0';
2594 /* Debugging of the dynamic linker? */
2595 if (memcmp (envline
, "DEBUG", 5) == 0)
2597 process_dl_debug (&envline
[6]);
2600 if (memcmp (envline
, "AUDIT", 5) == 0)
2601 audit_list_add_string (audit_list
, &envline
[6]);
2605 /* Print information about versions. */
2606 if (memcmp (envline
, "VERBOSE", 7) == 0)
2608 version_info
= envline
[8] != '\0';
2612 /* List of objects to be preloaded. */
2613 if (memcmp (envline
, "PRELOAD", 7) == 0)
2615 preloadlist
= &envline
[8];
2619 /* Which shared object shall be profiled. */
2620 if (memcmp (envline
, "PROFILE", 7) == 0 && envline
[8] != '\0')
2621 GLRO(dl_profile
) = &envline
[8];
2625 /* Do we bind early? */
2626 if (memcmp (envline
, "BIND_NOW", 8) == 0)
2628 GLRO(dl_lazy
) = envline
[9] == '\0';
2631 if (memcmp (envline
, "BIND_NOT", 8) == 0)
2632 GLRO(dl_bind_not
) = envline
[9] != '\0';
2636 /* Test whether we want to see the content of the auxiliary
2637 array passed up from the kernel. */
2638 if (!__libc_enable_secure
2639 && memcmp (envline
, "SHOW_AUXV", 9) == 0)
2645 /* Mask for the important hardware capabilities. */
2646 if (!__libc_enable_secure
2647 && memcmp (envline
, "HWCAP_MASK", 10) == 0)
2648 GLRO(dl_hwcap_mask
) = _dl_strtoul (&envline
[11], NULL
);
2653 /* Path where the binary is found. */
2654 if (!__libc_enable_secure
2655 && memcmp (envline
, "ORIGIN_PATH", 11) == 0)
2656 GLRO(dl_origin_path
) = &envline
[12];
2660 /* The library search path. */
2661 if (!__libc_enable_secure
2662 && memcmp (envline
, "LIBRARY_PATH", 12) == 0)
2664 library_path
= &envline
[13];
2668 /* Where to place the profiling data file. */
2669 if (memcmp (envline
, "DEBUG_OUTPUT", 12) == 0)
2671 debug_output
= &envline
[13];
2675 if (!__libc_enable_secure
2676 && memcmp (envline
, "DYNAMIC_WEAK", 12) == 0)
2677 GLRO(dl_dynamic_weak
) = 1;
2681 /* We might have some extra environment variable with length 13
2683 #ifdef EXTRA_LD_ENVVARS_13
2686 if (!__libc_enable_secure
2687 && memcmp (envline
, "USE_LOAD_BIAS", 13) == 0)
2689 GLRO(dl_use_load_bias
) = envline
[14] == '1' ? -1 : 0;
2695 /* Where to place the profiling data file. */
2696 if (!__libc_enable_secure
2697 && memcmp (envline
, "PROFILE_OUTPUT", 14) == 0
2698 && envline
[15] != '\0')
2699 GLRO(dl_profile_output
) = &envline
[15];
2703 /* The mode of the dynamic linker can be set. */
2704 if (memcmp (envline
, "TRACE_PRELINKING", 16) == 0)
2707 GLRO(dl_verbose
) = 1;
2708 GLRO(dl_debug_mask
) |= DL_DEBUG_PRELINK
;
2709 GLRO(dl_trace_prelink
) = &envline
[17];
2714 /* The mode of the dynamic linker can be set. */
2715 if (memcmp (envline
, "TRACE_LOADED_OBJECTS", 20) == 0)
2719 /* We might have some extra environment variable to handle. This
2720 is tricky due to the pre-processing of the length of the name
2721 in the switch statement here. The code here assumes that added
2722 environment variables have a different length. */
2723 #ifdef EXTRA_LD_ENVVARS
2729 /* The caller wants this information. */
2732 /* Extra security for SUID binaries. Remove all dangerous environment
2734 if (__builtin_expect (__libc_enable_secure
, 0))
2736 static const char unsecure_envvars
[] =
2737 #ifdef EXTRA_UNSECURE_ENVVARS
2738 EXTRA_UNSECURE_ENVVARS
2743 nextp
= unsecure_envvars
;
2747 /* We could use rawmemchr but this need not be fast. */
2748 nextp
= (char *) (strchr
) (nextp
, '\0') + 1;
2750 while (*nextp
!= '\0');
2752 if (__access ("/etc/suid-debug", F_OK
) != 0)
2755 unsetenv ("MALLOC_CHECK_");
2757 GLRO(dl_debug_mask
) = 0;
2763 /* If we have to run the dynamic linker in debugging mode and the
2764 LD_DEBUG_OUTPUT environment variable is given, we write the debug
2765 messages to this file. */
2766 else if (any_debug
&& debug_output
!= NULL
)
2768 const int flags
= O_WRONLY
| O_APPEND
| O_CREAT
| O_NOFOLLOW
;
2769 size_t name_len
= strlen (debug_output
);
2770 char buf
[name_len
+ 12];
2773 buf
[name_len
+ 11] = '\0';
2774 startp
= _itoa (__getpid (), &buf
[name_len
+ 11], 10, 0);
2776 startp
= memcpy (startp
- name_len
, debug_output
, name_len
);
2778 GLRO(dl_debug_fd
) = __open64_nocancel (startp
, flags
, DEFFILEMODE
);
2779 if (GLRO(dl_debug_fd
) == -1)
2780 /* We use standard output if opening the file failed. */
2781 GLRO(dl_debug_fd
) = STDOUT_FILENO
;
2785 #if HP_TIMING_INLINE
2787 print_statistics_item (const char *title
, hp_timing_t time
,
2790 char cycles
[HP_TIMING_PRINT_SIZE
];
2791 HP_TIMING_PRINT (cycles
, sizeof (cycles
), time
);
2793 char relative
[3 * sizeof (hp_timing_t
) + 2];
2794 char *cp
= _itoa ((1000ULL * time
) / total
, relative
+ sizeof (relative
),
2796 /* Sets the decimal point. */
2797 char *wp
= relative
;
2798 switch (relative
+ sizeof (relative
) - cp
)
2811 _dl_debug_printf ("%s: %s cycles (%s%%)\n", title
, cycles
, relative
);
2815 /* Print the various times we collected. */
2817 __attribute ((noinline
))
2818 print_statistics (const hp_timing_t
*rtld_total_timep
)
2820 #if HP_TIMING_INLINE
2822 char cycles
[HP_TIMING_PRINT_SIZE
];
2823 HP_TIMING_PRINT (cycles
, sizeof (cycles
), *rtld_total_timep
);
2824 _dl_debug_printf ("\nruntime linker statistics:\n"
2825 " total startup time in dynamic loader: %s cycles\n",
2827 print_statistics_item (" time needed for relocation",
2828 relocate_time
, *rtld_total_timep
);
2832 unsigned long int num_relative_relocations
= 0;
2833 for (Lmid_t ns
= 0; ns
< GL(dl_nns
); ++ns
)
2835 if (GL(dl_ns
)[ns
]._ns_loaded
== NULL
)
2838 struct r_scope_elem
*scope
= &GL(dl_ns
)[ns
]._ns_loaded
->l_searchlist
;
2840 for (unsigned int i
= 0; i
< scope
->r_nlist
; i
++)
2842 struct link_map
*l
= scope
->r_list
[i
];
2844 if (l
->l_addr
!= 0 && l
->l_info
[VERSYMIDX (DT_RELCOUNT
)])
2845 num_relative_relocations
2846 += l
->l_info
[VERSYMIDX (DT_RELCOUNT
)]->d_un
.d_val
;
2847 #ifndef ELF_MACHINE_REL_RELATIVE
2848 /* Relative relocations are processed on these architectures if
2849 library is loaded to different address than p_vaddr or
2850 if not prelinked. */
2851 if ((l
->l_addr
!= 0 || !l
->l_info
[VALIDX(DT_GNU_PRELINKED
)])
2852 && l
->l_info
[VERSYMIDX (DT_RELACOUNT
)])
2854 /* On e.g. IA-64 or Alpha, relative relocations are processed
2855 only if library is loaded to different address than p_vaddr. */
2856 if (l
->l_addr
!= 0 && l
->l_info
[VERSYMIDX (DT_RELACOUNT
)])
2858 num_relative_relocations
2859 += l
->l_info
[VERSYMIDX (DT_RELACOUNT
)]->d_un
.d_val
;
2863 _dl_debug_printf (" number of relocations: %lu\n"
2864 " number of relocations from cache: %lu\n"
2865 " number of relative relocations: %lu\n",
2866 GL(dl_num_relocations
),
2867 GL(dl_num_cache_relocations
),
2868 num_relative_relocations
);
2870 #if HP_TIMING_INLINE
2871 print_statistics_item (" time needed to load objects",
2872 load_time
, *rtld_total_timep
);