1/* Copyright (C) 1998-2017 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Lesser General Public
6 License as published by the Free Software Foundation; either
7 version 2.1 of the License, or (at your option) any later version.
8
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Lesser General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public
15 License along with the GNU C Library; if not, see
16 <http://www.gnu.org/licenses/>. */
17
18#include <assert.h>
19#include <stdlib.h>
20#include <stdio.h>
21#include <unistd.h>
22#include <ldsodefs.h>
23#include <exit-thread.h>
24#include <libc-internal.h>
25
26#include <elf/dl-tunables.h>
27
28extern void __libc_init_first (int argc, char **argv, char **envp);
29
30extern int __libc_multiple_libcs;
31
32#include <tls.h>
33#ifndef SHARED
34# include <dl-osinfo.h>
35# ifndef THREAD_SET_STACK_GUARD
36/* Only exported for architectures that don't store the stack guard canary
37 in thread local area. */
38uintptr_t __stack_chk_guard attribute_relro;
39# endif
40# ifndef THREAD_SET_POINTER_GUARD
41/* Only exported for architectures that don't store the pointer guard
42 value in thread local area. */
43uintptr_t __pointer_chk_guard_local
44 attribute_relro attribute_hidden __attribute__ ((nocommon));
45# endif
46#endif
47
48#ifdef HAVE_PTR_NTHREADS
49/* We need atomic operations. */
50# include <atomic.h>
51#endif
52
53
54#ifndef SHARED
55# include <link.h>
56# include <dl-irel.h>
57
58# ifdef ELF_MACHINE_IRELA
59# define IREL_T ElfW(Rela)
60# define IPLT_START __rela_iplt_start
61# define IPLT_END __rela_iplt_end
62# define IREL elf_irela
63# elif defined ELF_MACHINE_IREL
64# define IREL_T ElfW(Rel)
65# define IPLT_START __rel_iplt_start
66# define IPLT_END __rel_iplt_end
67# define IREL elf_irel
68# endif
69
70static void
71apply_irel (void)
72{
73# ifdef IREL
74 /* We use weak references for these so that we'll still work with a linker
75 that doesn't define them. Such a linker doesn't support IFUNC at all
76 and so uses won't work, but a statically-linked program that doesn't
77 use any IFUNC symbols won't have a problem. */
78 extern const IREL_T IPLT_START[] __attribute__ ((weak));
79 extern const IREL_T IPLT_END[] __attribute__ ((weak));
80 for (const IREL_T *ipltent = IPLT_START; ipltent < IPLT_END; ++ipltent)
81 IREL (ipltent);
82# endif
83}
84#endif
85
86
87#ifdef LIBC_START_MAIN
88# ifdef LIBC_START_DISABLE_INLINE
89# define STATIC static
90# else
91# define STATIC static inline __attribute__ ((always_inline))
92# endif
93#else
94# define STATIC
95# define LIBC_START_MAIN __libc_start_main
96#endif
97
98#ifdef MAIN_AUXVEC_ARG
99/* main gets passed a pointer to the auxiliary. */
100# define MAIN_AUXVEC_DECL , void *
101# define MAIN_AUXVEC_PARAM , auxvec
102#else
103# define MAIN_AUXVEC_DECL
104# define MAIN_AUXVEC_PARAM
105#endif
106
107STATIC int LIBC_START_MAIN (int (*main) (int, char **, char **
108 MAIN_AUXVEC_DECL),
109 int argc,
110 char **argv,
111#ifdef LIBC_START_MAIN_AUXVEC_ARG
112 ElfW(auxv_t) *auxvec,
113#endif
114 __typeof (main) init,
115 void (*fini) (void),
116 void (*rtld_fini) (void),
117 void *stack_end)
118 __attribute__ ((noreturn));
119
120
121/* Note: the fini parameter is ignored here for shared library. It
122 is registered with __cxa_atexit. This had the disadvantage that
123 finalizers were called in more than one place. */
124STATIC int
125LIBC_START_MAIN (int (*main) (int, char **, char ** MAIN_AUXVEC_DECL),
126 int argc, char **argv,
127#ifdef LIBC_START_MAIN_AUXVEC_ARG
128 ElfW(auxv_t) *auxvec,
129#endif
130 __typeof (main) init,
131 void (*fini) (void),
132 void (*rtld_fini) (void), void *stack_end)
133{
134 /* Result of the 'main' function. */
135 int result;
136
137 __libc_multiple_libcs = &_dl_starting_up && !_dl_starting_up;
138
139#ifndef SHARED
140 char **ev = &argv[argc + 1];
141
142 __environ = ev;
143
144 /* Store the lowest stack address. This is done in ld.so if this is
145 the code for the DSO. */
146 __libc_stack_end = stack_end;
147
148# ifdef HAVE_AUX_VECTOR
149 /* First process the auxiliary vector since we need to find the
150 program header to locate an eventually present PT_TLS entry. */
151# ifndef LIBC_START_MAIN_AUXVEC_ARG
152 ElfW(auxv_t) *auxvec;
153 {
154 char **evp = ev;
155 while (*evp++ != NULL)
156 ;
157 auxvec = (ElfW(auxv_t) *) evp;
158 }
159# endif
160 _dl_aux_init (auxvec);
161 if (GL(dl_phdr) == NULL)
162# endif
163 {
164 /* Starting from binutils-2.23, the linker will define the
165 magic symbol __ehdr_start to point to our own ELF header
166 if it is visible in a segment that also includes the phdrs.
167 So we can set up _dl_phdr and _dl_phnum even without any
168 information from auxv. */
169
170 extern const ElfW(Ehdr) __ehdr_start
171 __attribute__ ((weak, visibility ("hidden")));
172 if (&__ehdr_start != NULL)
173 {
174 assert (__ehdr_start.e_phentsize == sizeof *GL(dl_phdr));
175 GL(dl_phdr) = (const void *) &__ehdr_start + __ehdr_start.e_phoff;
176 GL(dl_phnum) = __ehdr_start.e_phnum;
177 }
178 }
179
180 /* Initialize very early so that tunables can use it. */
181 __libc_init_secure ();
182
183 __tunables_init (__environ);
184
185 /* Perform IREL{,A} relocations. */
186 apply_irel ();
187
188 /* The stack guard goes into the TCB, so initialize it early. */
189 __libc_setup_tls ();
190
191 /* Set up the stack checker's canary. */
192 uintptr_t stack_chk_guard = _dl_setup_stack_chk_guard (_dl_random);
193# ifdef THREAD_SET_STACK_GUARD
194 THREAD_SET_STACK_GUARD (stack_chk_guard);
195# else
196 __stack_chk_guard = stack_chk_guard;
197# endif
198
199# ifdef DL_SYSDEP_OSCHECK
200 if (!__libc_multiple_libcs)
201 {
202 /* This needs to run to initiliaze _dl_osversion before TLS
203 setup might check it. */
204 DL_SYSDEP_OSCHECK (__libc_fatal);
205 }
206# endif
207
208 /* Initialize libpthread if linked in. */
209 if (__pthread_initialize_minimal != NULL)
210 __pthread_initialize_minimal ();
211
212 /* Set up the pointer guard value. */
213 uintptr_t pointer_chk_guard = _dl_setup_pointer_guard (_dl_random,
214 stack_chk_guard);
215# ifdef THREAD_SET_POINTER_GUARD
216 THREAD_SET_POINTER_GUARD (pointer_chk_guard);
217# else
218 __pointer_chk_guard_local = pointer_chk_guard;
219# endif
220
221#endif
222
223 /* Register the destructor of the dynamic linker if there is any. */
224 if (__glibc_likely (rtld_fini != NULL))
225 __cxa_atexit ((void (*) (void *)) rtld_fini, NULL, NULL);
226
227#ifndef SHARED
228 /* Call the initializer of the libc. This is only needed here if we
229 are compiling for the static library in which case we haven't
230 run the constructors in `_dl_start_user'. */
231 __libc_init_first (argc, argv, __environ);
232
233 /* Register the destructor of the program, if any. */
234 if (fini)
235 __cxa_atexit ((void (*) (void *)) fini, NULL, NULL);
236
237 /* Some security at this point. Prevent starting a SUID binary where
238 the standard file descriptors are not opened. We have to do this
239 only for statically linked applications since otherwise the dynamic
240 loader did the work already. */
241 if (__builtin_expect (__libc_enable_secure, 0))
242 __libc_check_standard_fds ();
243#endif
244
245 /* Call the initializer of the program, if any. */
246#ifdef SHARED
247 if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS, 0))
248 GLRO(dl_debug_printf) ("\ninitialize program: %s\n\n", argv[0]);
249#endif
250 if (init)
251 (*init) (argc, argv, __environ MAIN_AUXVEC_PARAM);
252
253#ifdef SHARED
254 /* Auditing checkpoint: we have a new object. */
255 if (__glibc_unlikely (GLRO(dl_naudit) > 0))
256 {
257 struct audit_ifaces *afct = GLRO(dl_audit);
258 struct link_map *head = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
259 for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
260 {
261 if (afct->preinit != NULL)
262 afct->preinit (&head->l_audit[cnt].cookie);
263
264 afct = afct->next;
265 }
266 }
267#endif
268
269#ifdef SHARED
270 if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS))
271 GLRO(dl_debug_printf) ("\ntransferring control: %s\n\n", argv[0]);
272#endif
273
274#ifndef SHARED
275 _dl_debug_initialize (0, LM_ID_BASE);
276#endif
277#ifdef HAVE_CLEANUP_JMP_BUF
278 /* Memory for the cancellation buffer. */
279 struct pthread_unwind_buf unwind_buf;
280
281 int not_first_call;
282 not_first_call = setjmp ((struct __jmp_buf_tag *) unwind_buf.cancel_jmp_buf);
283 if (__glibc_likely (! not_first_call))
284 {
285 struct pthread *self = THREAD_SELF;
286
287 /* Store old info. */
288 unwind_buf.priv.data.prev = THREAD_GETMEM (self, cleanup_jmp_buf);
289 unwind_buf.priv.data.cleanup = THREAD_GETMEM (self, cleanup);
290
291 /* Store the new cleanup handler info. */
292 THREAD_SETMEM (self, cleanup_jmp_buf, &unwind_buf);
293
294 /* Run the program. */
295 result = main (argc, argv, __environ MAIN_AUXVEC_PARAM);
296 }
297 else
298 {
299 /* Remove the thread-local data. */
300# ifdef SHARED
301 PTHFCT_CALL (ptr__nptl_deallocate_tsd, ());
302# else
303 extern void __nptl_deallocate_tsd (void) __attribute ((weak));
304 __nptl_deallocate_tsd ();
305# endif
306
307 /* One less thread. Decrement the counter. If it is zero we
308 terminate the entire process. */
309 result = 0;
310# ifdef SHARED
311 unsigned int *ptr = __libc_pthread_functions.ptr_nthreads;
312# ifdef PTR_DEMANGLE
313 PTR_DEMANGLE (ptr);
314# endif
315# else
316 extern unsigned int __nptl_nthreads __attribute ((weak));
317 unsigned int *const ptr = &__nptl_nthreads;
318# endif
319
320 if (! atomic_decrement_and_test (ptr))
321 /* Not much left to do but to exit the thread, not the process. */
322 __exit_thread ();
323 }
324#else
325 /* Nothing fancy, just call the function. */
326 result = main (argc, argv, __environ MAIN_AUXVEC_PARAM);
327#endif
328
329 exit (result);
330}
331