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