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 | |
28 | extern void __libc_init_first (int argc, char **argv, char **envp); |
29 | |
30 | extern 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. */ |
38 | uintptr_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. */ |
43 | uintptr_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 | |
70 | static void |
71 | apply_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 | |
107 | STATIC 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. */ |
124 | STATIC int |
125 | LIBC_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 | |