1 /* Perform initialization and invoke main.
2 Copyright (C) 1998-2021 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 /* Note: This code is only part of the startup code proper for
20 statically linked binaries. For dynamically linked binaries, it
21 resides in libc.so. */
22
23 /* Mark symbols hidden in static PIE for early self relocation to work. */
24 #if BUILD_PIE_DEFAULT
25 # pragma GCC visibility push(hidden)
26 #endif
27
28 #include <assert.h>
29 #include <stdlib.h>
30 #include <stdio.h>
31 #include <unistd.h>
32 #include <ldsodefs.h>
33 #include <libc-diag.h>
34 #include <libc-internal.h>
35 #include <elf/libc-early-init.h>
36 #include <stdbool.h>
37 #include <elf-initfini.h>
38 #include <shlib-compat.h>
39
40 #include <elf/dl-tunables.h>
41
42 extern void __libc_init_first (int argc, char **argv, char **envp);
43
44 #include <tls.h>
45 #ifndef SHARED
46 # include <dl-osinfo.h>
47 # ifndef THREAD_SET_STACK_GUARD
48 /* Only exported for architectures that don't store the stack guard canary
49 in thread local area. */
50 uintptr_t __stack_chk_guard attribute_relro;
51 # endif
52 # ifndef THREAD_SET_POINTER_GUARD
53 /* Only exported for architectures that don't store the pointer guard
54 value in thread local area. */
55 uintptr_t __pointer_chk_guard_local attribute_relro attribute_hidden;
56 # endif
57 #endif
58
59 #ifndef SHARED
60 # include <link.h>
61 # include <dl-irel.h>
62
63 # ifdef ELF_MACHINE_IRELA
64 # define IREL_T ElfW(Rela)
65 # define IPLT_START __rela_iplt_start
66 # define IPLT_END __rela_iplt_end
67 # define IREL elf_irela
68 # elif defined ELF_MACHINE_IREL
69 # define IREL_T ElfW(Rel)
70 # define IPLT_START __rel_iplt_start
71 # define IPLT_END __rel_iplt_end
72 # define IREL elf_irel
73 # endif
74
75 static void
apply_irel(void)76 apply_irel (void)
77 {
78 # ifdef IREL
79 /* We use weak references for these so that we'll still work with a linker
80 that doesn't define them. Such a linker doesn't support IFUNC at all
81 and so uses won't work, but a statically-linked program that doesn't
82 use any IFUNC symbols won't have a problem. */
83 extern const IREL_T IPLT_START[] __attribute__ ((weak));
84 extern const IREL_T IPLT_END[] __attribute__ ((weak));
85 for (const IREL_T *ipltent = IPLT_START; ipltent < IPLT_END; ++ipltent)
86 IREL (ipltent);
87 # endif
88 }
89 #endif
90
91
92 #ifdef LIBC_START_MAIN
93 # ifdef LIBC_START_DISABLE_INLINE
94 # define STATIC static
95 # else
96 # define STATIC static inline __attribute__ ((always_inline))
97 # endif
98 # define DO_DEFINE_LIBC_START_MAIN_VERSION 0
99 #else
100 # define STATIC
101 # define LIBC_START_MAIN __libc_start_main_impl
102 # define DO_DEFINE_LIBC_START_MAIN_VERSION 1
103 #endif
104
105 #ifdef MAIN_AUXVEC_ARG
106 /* main gets passed a pointer to the auxiliary. */
107 # define MAIN_AUXVEC_DECL , void *
108 # define MAIN_AUXVEC_PARAM , auxvec
109 #else
110 # define MAIN_AUXVEC_DECL
111 # define MAIN_AUXVEC_PARAM
112 #endif
113
114 #ifndef ARCH_INIT_CPU_FEATURES
115 # define ARCH_INIT_CPU_FEATURES()
116 #endif
117
118 /* Obtain the definition of __libc_start_call_main. */
119 #include <libc_start_call_main.h>
120
121 #ifdef SHARED
122 /* Initialization for dynamic executables. Find the main executable
123 link map and run its init functions. */
124 static void
call_init(int argc,char ** argv,char ** env)125 call_init (int argc, char **argv, char **env)
126 {
127 /* Obtain the main map of the executable. */
128 struct link_map *l = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
129
130 /* DT_PREINIT_ARRAY is not processed here. It is already handled in
131 _dl_init in elf/dl-init.c. Also see the call_init function in
132 the same file. */
133
134 if (ELF_INITFINI && l->l_info[DT_INIT] != NULL)
135 DL_CALL_DT_INIT(l, l->l_addr + l->l_info[DT_INIT]->d_un.d_ptr,
136 argc, argv, env);
137
138 ElfW(Dyn) *init_array = l->l_info[DT_INIT_ARRAY];
139 if (init_array != NULL)
140 {
141 unsigned int jm
142 = l->l_info[DT_INIT_ARRAYSZ]->d_un.d_val / sizeof (ElfW(Addr));
143 ElfW(Addr) *addrs = (void *) (init_array->d_un.d_ptr + l->l_addr);
144 for (unsigned int j = 0; j < jm; ++j)
145 ((dl_init_t) addrs[j]) (argc, argv, env);
146 }
147 }
148
149 #else /* !SHARED */
150
151 /* These magic symbols are provided by the linker. */
152 extern void (*__preinit_array_start []) (int, char **, char **)
153 attribute_hidden;
154 extern void (*__preinit_array_end []) (int, char **, char **)
155 attribute_hidden;
156 extern void (*__init_array_start []) (int, char **, char **)
157 attribute_hidden;
158 extern void (*__init_array_end []) (int, char **, char **)
159 attribute_hidden;
160 extern void (*__fini_array_start []) (void) attribute_hidden;
161 extern void (*__fini_array_end []) (void) attribute_hidden;
162
163 # if ELF_INITFINI
164 /* These function symbols are provided for the .init/.fini section entry
165 points automagically by the linker. */
166 extern void _init (void);
167 extern void _fini (void);
168 # endif
169
170 /* Initialization for static executables. There is no dynamic
171 segment, so we access the symbols directly. */
172 static void
call_init(int argc,char ** argv,char ** envp)173 call_init (int argc, char **argv, char **envp)
174 {
175 /* For static executables, preinit happens right before init. */
176 {
177 const size_t size = __preinit_array_end - __preinit_array_start;
178 size_t i;
179 for (i = 0; i < size; i++)
180 (*__preinit_array_start [i]) (argc, argv, envp);
181 }
182
183 # if ELF_INITFINI
184 _init ();
185 # endif
186
187 const size_t size = __init_array_end - __init_array_start;
188 for (size_t i = 0; i < size; i++)
189 (*__init_array_start [i]) (argc, argv, envp);
190 }
191
192 /* Likewise for the destructor. */
193 static void
call_fini(void * unused)194 call_fini (void *unused)
195 {
196 size_t i = __fini_array_end - __fini_array_start;
197 while (i-- > 0)
198 (*__fini_array_start [i]) ();
199
200 # if ELF_INITFINI
201 _fini ();
202 # endif
203 }
204
205 #endif /* !SHARED */
206
207 #include <libc-start.h>
208
209 STATIC int LIBC_START_MAIN (int (*main) (int, char **, char **
210 MAIN_AUXVEC_DECL),
211 int argc,
212 char **argv,
213 #ifdef LIBC_START_MAIN_AUXVEC_ARG
214 ElfW(auxv_t) *auxvec,
215 #endif
216 __typeof (main) init,
217 void (*fini) (void),
218 void (*rtld_fini) (void),
219 void *stack_end)
220 __attribute__ ((noreturn));
221
222
223 /* Note: The init and fini parameters are no longer used. fini is
224 completely unused, init is still called if not NULL, but the
225 current startup code always passes NULL. (In the future, it would
226 be possible to use fini to pass a version code if init is NULL, to
227 indicate the link-time glibc without introducing a hard
228 incompatibility for new programs with older glibc versions.)
229
230 For dynamically linked executables, the dynamic segment is used to
231 locate constructors and destructors. For statically linked
232 executables, the relevant symbols are access directly. */
233 STATIC int
LIBC_START_MAIN(int (* main)(int,char **,char ** MAIN_AUXVEC_DECL),int argc,char ** argv,ElfW (auxv_t)* auxvec,__typeof (main)init,void (* fini)(void),void (* rtld_fini)(void),void * stack_end)234 LIBC_START_MAIN (int (*main) (int, char **, char ** MAIN_AUXVEC_DECL),
235 int argc, char **argv,
236 #ifdef LIBC_START_MAIN_AUXVEC_ARG
237 ElfW(auxv_t) *auxvec,
238 #endif
239 __typeof (main) init,
240 void (*fini) (void),
241 void (*rtld_fini) (void), void *stack_end)
242 {
243 #ifndef SHARED
244 char **ev = &argv[argc + 1];
245
246 __environ = ev;
247
248 /* Store the lowest stack address. This is done in ld.so if this is
249 the code for the DSO. */
250 __libc_stack_end = stack_end;
251
252 # ifdef HAVE_AUX_VECTOR
253 /* First process the auxiliary vector since we need to find the
254 program header to locate an eventually present PT_TLS entry. */
255 # ifndef LIBC_START_MAIN_AUXVEC_ARG
256 ElfW(auxv_t) *auxvec;
257 {
258 char **evp = ev;
259 while (*evp++ != NULL)
260 ;
261 auxvec = (ElfW(auxv_t) *) evp;
262 }
263 # endif
264 _dl_aux_init (auxvec);
265 if (GL(dl_phdr) == NULL)
266 # endif
267 {
268 /* Starting from binutils-2.23, the linker will define the
269 magic symbol __ehdr_start to point to our own ELF header
270 if it is visible in a segment that also includes the phdrs.
271 So we can set up _dl_phdr and _dl_phnum even without any
272 information from auxv. */
273
274 extern const ElfW(Ehdr) __ehdr_start
275 # if BUILD_PIE_DEFAULT
276 __attribute__ ((visibility ("hidden")));
277 # else
278 __attribute__ ((weak, visibility ("hidden")));
279 if (&__ehdr_start != NULL)
280 # endif
281 {
282 assert (__ehdr_start.e_phentsize == sizeof *GL(dl_phdr));
283 GL(dl_phdr) = (const void *) &__ehdr_start + __ehdr_start.e_phoff;
284 GL(dl_phnum) = __ehdr_start.e_phnum;
285 }
286 }
287
288 /* Initialize very early so that tunables can use it. */
289 __libc_init_secure ();
290
291 __tunables_init (__environ);
292
293 ARCH_INIT_CPU_FEATURES ();
294
295 /* Do static pie self relocation after tunables and cpu features
296 are setup for ifunc resolvers. Before this point relocations
297 must be avoided. */
298 _dl_relocate_static_pie ();
299
300 /* Perform IREL{,A} relocations. */
301 ARCH_SETUP_IREL ();
302
303 /* The stack guard goes into the TCB, so initialize it early. */
304 ARCH_SETUP_TLS ();
305
306 /* In some architectures, IREL{,A} relocations happen after TLS setup in
307 order to let IFUNC resolvers benefit from TCB information, e.g. powerpc's
308 hwcap and platform fields available in the TCB. */
309 ARCH_APPLY_IREL ();
310
311 /* Set up the stack checker's canary. */
312 uintptr_t stack_chk_guard = _dl_setup_stack_chk_guard (_dl_random);
313 # ifdef THREAD_SET_STACK_GUARD
314 THREAD_SET_STACK_GUARD (stack_chk_guard);
315 # else
316 __stack_chk_guard = stack_chk_guard;
317 # endif
318
319 # ifdef DL_SYSDEP_OSCHECK
320 {
321 /* This needs to run to initiliaze _dl_osversion before TLS
322 setup might check it. */
323 DL_SYSDEP_OSCHECK (__libc_fatal);
324 }
325 # endif
326
327 /* Initialize libpthread if linked in. */
328 if (__pthread_initialize_minimal != NULL)
329 __pthread_initialize_minimal ();
330
331 /* Set up the pointer guard value. */
332 uintptr_t pointer_chk_guard = _dl_setup_pointer_guard (_dl_random,
333 stack_chk_guard);
334 # ifdef THREAD_SET_POINTER_GUARD
335 THREAD_SET_POINTER_GUARD (pointer_chk_guard);
336 # else
337 __pointer_chk_guard_local = pointer_chk_guard;
338 # endif
339
340 #endif /* !SHARED */
341
342 /* Register the destructor of the dynamic linker if there is any. */
343 if (__glibc_likely (rtld_fini != NULL))
344 __cxa_atexit ((void (*) (void *)) rtld_fini, NULL, NULL);
345
346 #ifndef SHARED
347 /* Perform early initialization. In the shared case, this function
348 is called from the dynamic loader as early as possible. */
349 __libc_early_init (true);
350
351 /* Call the initializer of the libc. This is only needed here if we
352 are compiling for the static library in which case we haven't
353 run the constructors in `_dl_start_user'. */
354 __libc_init_first (argc, argv, __environ);
355
356 /* Register the destructor of the statically-linked program. */
357 __cxa_atexit (call_fini, NULL, NULL);
358
359 /* Some security at this point. Prevent starting a SUID binary where
360 the standard file descriptors are not opened. We have to do this
361 only for statically linked applications since otherwise the dynamic
362 loader did the work already. */
363 if (__builtin_expect (__libc_enable_secure, 0))
364 __libc_check_standard_fds ();
365 #endif /* !SHARED */
366
367 /* Call the initializer of the program, if any. */
368 #ifdef SHARED
369 if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS, 0))
370 GLRO(dl_debug_printf) ("\ninitialize program: %s\n\n", argv[0]);
371
372 if (init != NULL)
373 /* This is a legacy program which supplied its own init
374 routine. */
375 (*init) (argc, argv, __environ MAIN_AUXVEC_PARAM);
376 else
377 /* This is a current program. Use the dynamic segment to find
378 constructors. */
379 call_init (argc, argv, __environ);
380
381 /* Auditing checkpoint: we have a new object. */
382 _dl_audit_preinit (GL(dl_ns)[LM_ID_BASE]._ns_loaded);
383
384 if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS))
385 GLRO(dl_debug_printf) ("\ntransferring control: %s\n\n", argv[0]);
386 #else /* !SHARED */
387 call_init (argc, argv, __environ);
388
389 _dl_debug_initialize (0, LM_ID_BASE);
390 #endif
391
392 __libc_start_call_main (main, argc, argv MAIN_AUXVEC_PARAM);
393 }
394
395 /* Starting with glibc 2.34, the init parameter is always NULL. Older
396 libcs are not prepared to handle that. The macro
397 DEFINE_LIBC_START_MAIN_VERSION creates GLIBC_2.34 alias, so that
398 newly linked binaries reflect that dependency. The macros below
399 expect that the exported function is called
400 __libc_start_main_impl. */
401 #ifdef SHARED
402 # define DEFINE_LIBC_START_MAIN_VERSION \
403 DEFINE_LIBC_START_MAIN_VERSION_1 \
404 strong_alias (__libc_start_main_impl, __libc_start_main_alias_2) \
405 versioned_symbol (libc, __libc_start_main_alias_2, __libc_start_main, \
406 GLIBC_2_34);
407
408 # if SHLIB_COMPAT(libc, GLIBC_2_0, GLIBC_2_34)
409 # define DEFINE_LIBC_START_MAIN_VERSION_1 \
410 strong_alias (__libc_start_main_impl, __libc_start_main_alias_1) \
411 compat_symbol (libc, __libc_start_main_alias_1, __libc_start_main, GLIBC_2_0);
412 # else
413 # define DEFINE_LIBC_START_MAIN_VERSION_1
414 # endif
415 #else /* !SHARED */
416 /* Enable calling the function under its exported name. */
417 # define DEFINE_LIBC_START_MAIN_VERSION \
418 strong_alias (__libc_start_main_impl, __libc_start_main)
419 #endif
420
421 /* Only define the version information if LIBC_START_MAIN was not set.
422 If there is a wrapper file, it must expand
423 DEFINE_LIBC_START_MAIN_VERSION on its own. */
424 #if DO_DEFINE_LIBC_START_MAIN_VERSION
425 DEFINE_LIBC_START_MAIN_VERSION
426 #endif
427