| /* Copyright (C) 1998-2006, 2007, 2009 Free Software Foundation, Inc. |
| This file is part of the GNU C Library. |
| |
| The GNU C Library is free software; you can redistribute it and/or |
| modify it under the terms of the GNU Lesser General Public |
| License as published by the Free Software Foundation; either |
| version 2.1 of the License, or (at your option) any later version. |
| |
| The GNU C Library is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| Lesser General Public License for more details. |
| |
| You should have received a copy of the GNU Lesser General Public |
| License along with the GNU C Library; if not, write to the Free |
| Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA |
| 02111-1307 USA. */ |
| |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <unistd.h> |
| #include <ldsodefs.h> |
| #include <bp-start.h> |
| #include <bp-sym.h> |
| |
| extern void __libc_init_first (int argc, char **argv, char **envp); |
| #ifndef SHARED |
| extern void __libc_csu_irel (void); |
| #endif |
| |
| extern int __libc_multiple_libcs; |
| |
| #include <tls.h> |
| #ifndef SHARED |
| # include <dl-osinfo.h> |
| extern void __pthread_initialize_minimal (void); |
| # ifndef THREAD_SET_STACK_GUARD |
| /* Only exported for architectures that don't store the stack guard canary |
| in thread local area. */ |
| uintptr_t __stack_chk_guard attribute_relro; |
| # endif |
| #endif |
| |
| #ifdef HAVE_PTR_NTHREADS |
| /* We need atomic operations. */ |
| # include <atomic.h> |
| #endif |
| |
| |
| #ifdef LIBC_START_MAIN |
| # ifdef LIBC_START_DISABLE_INLINE |
| # define STATIC static |
| # else |
| # define STATIC static inline __attribute__ ((always_inline)) |
| # endif |
| #else |
| # define STATIC |
| # define LIBC_START_MAIN BP_SYM (__libc_start_main) |
| #endif |
| |
| #ifdef MAIN_AUXVEC_ARG |
| /* main gets passed a pointer to the auxiliary. */ |
| # define MAIN_AUXVEC_DECL , void * |
| # define MAIN_AUXVEC_PARAM , auxvec |
| #else |
| # define MAIN_AUXVEC_DECL |
| # define MAIN_AUXVEC_PARAM |
| #endif |
| |
| STATIC int LIBC_START_MAIN (int (*main) (int, char **, char ** |
| MAIN_AUXVEC_DECL), |
| int argc, |
| char *__unbounded *__unbounded ubp_av, |
| #ifdef LIBC_START_MAIN_AUXVEC_ARG |
| ElfW(auxv_t) *__unbounded auxvec, |
| #endif |
| __typeof (main) init, |
| void (*fini) (void), |
| void (*rtld_fini) (void), |
| void *__unbounded stack_end) |
| __attribute__ ((noreturn)); |
| |
| |
| /* Note: the fini parameter is ignored here for shared library. It |
| is registered with __cxa_atexit. This had the disadvantage that |
| finalizers were called in more than one place. */ |
| STATIC int |
| LIBC_START_MAIN (int (*main) (int, char **, char ** MAIN_AUXVEC_DECL), |
| int argc, char *__unbounded *__unbounded ubp_av, |
| #ifdef LIBC_START_MAIN_AUXVEC_ARG |
| ElfW(auxv_t) *__unbounded auxvec, |
| #endif |
| __typeof (main) init, |
| void (*fini) (void), |
| void (*rtld_fini) (void), void *__unbounded stack_end) |
| { |
| #if __BOUNDED_POINTERS__ |
| char **argv; |
| #else |
| # define argv ubp_av |
| #endif |
| |
| /* Result of the 'main' function. */ |
| int result; |
| |
| __libc_multiple_libcs = &_dl_starting_up && !_dl_starting_up; |
| |
| #ifndef SHARED |
| char *__unbounded *__unbounded ubp_ev = &ubp_av[argc + 1]; |
| |
| INIT_ARGV_and_ENVIRON; |
| |
| /* Store the lowest stack address. This is done in ld.so if this is |
| the code for the DSO. */ |
| __libc_stack_end = stack_end; |
| |
| # ifdef HAVE_AUX_VECTOR |
| /* First process the auxiliary vector since we need to find the |
| program header to locate an eventually present PT_TLS entry. */ |
| # ifndef LIBC_START_MAIN_AUXVEC_ARG |
| ElfW(auxv_t) *__unbounded auxvec; |
| { |
| char *__unbounded *__unbounded evp = ubp_ev; |
| while (*evp++ != NULL) |
| ; |
| auxvec = (ElfW(auxv_t) *__unbounded) evp; |
| } |
| # endif |
| _dl_aux_init (auxvec); |
| # endif |
| # ifdef DL_SYSDEP_OSCHECK |
| if (!__libc_multiple_libcs) |
| { |
| /* This needs to run to initiliaze _dl_osversion before TLS |
| setup might check it. */ |
| DL_SYSDEP_OSCHECK (__libc_fatal); |
| } |
| # endif |
| |
| /* Performe IREL{,A} relocations. */ |
| __libc_csu_irel (); |
| |
| /* Initialize the thread library at least a bit since the libgcc |
| functions are using thread functions if these are available and |
| we need to setup errno. */ |
| __pthread_initialize_minimal (); |
| |
| /* Set up the stack checker's canary. */ |
| uintptr_t stack_chk_guard = _dl_setup_stack_chk_guard (_dl_random); |
| # ifdef THREAD_SET_STACK_GUARD |
| THREAD_SET_STACK_GUARD (stack_chk_guard); |
| # else |
| __stack_chk_guard = stack_chk_guard; |
| # endif |
| #endif |
| |
| /* Register the destructor of the dynamic linker if there is any. */ |
| if (__builtin_expect (rtld_fini != NULL, 1)) |
| __cxa_atexit ((void (*) (void *)) rtld_fini, NULL, NULL); |
| |
| #ifndef SHARED |
| /* Call the initializer of the libc. This is only needed here if we |
| are compiling for the static library in which case we haven't |
| run the constructors in `_dl_start_user'. */ |
| __libc_init_first (argc, argv, __environ); |
| |
| /* Register the destructor of the program, if any. */ |
| if (fini) |
| __cxa_atexit ((void (*) (void *)) fini, NULL, NULL); |
| |
| /* Some security at this point. Prevent starting a SUID binary where |
| the standard file descriptors are not opened. We have to do this |
| only for statically linked applications since otherwise the dynamic |
| loader did the work already. */ |
| if (__builtin_expect (__libc_enable_secure, 0)) |
| __libc_check_standard_fds (); |
| #endif |
| |
| /* Call the initializer of the program, if any. */ |
| #ifdef SHARED |
| if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS, 0)) |
| GLRO(dl_debug_printf) ("\ninitialize program: %s\n\n", argv[0]); |
| #endif |
| if (init) |
| (*init) (argc, argv, __environ MAIN_AUXVEC_PARAM); |
| |
| #ifdef SHARED |
| /* Auditing checkpoint: we have a new object. */ |
| if (__builtin_expect (GLRO(dl_naudit) > 0, 0)) |
| { |
| struct audit_ifaces *afct = GLRO(dl_audit); |
| struct link_map *head = GL(dl_ns)[LM_ID_BASE]._ns_loaded; |
| for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt) |
| { |
| if (afct->preinit != NULL) |
| afct->preinit (&head->l_audit[cnt].cookie); |
| |
| afct = afct->next; |
| } |
| } |
| #endif |
| |
| #ifdef SHARED |
| if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS, 0)) |
| GLRO(dl_debug_printf) ("\ntransferring control: %s\n\n", argv[0]); |
| #endif |
| |
| #ifdef HAVE_CLEANUP_JMP_BUF |
| /* Memory for the cancellation buffer. */ |
| struct pthread_unwind_buf unwind_buf; |
| |
| int not_first_call; |
| not_first_call = setjmp ((struct __jmp_buf_tag *) unwind_buf.cancel_jmp_buf); |
| if (__builtin_expect (! not_first_call, 1)) |
| { |
| struct pthread *self = THREAD_SELF; |
| |
| /* Store old info. */ |
| unwind_buf.priv.data.prev = THREAD_GETMEM (self, cleanup_jmp_buf); |
| unwind_buf.priv.data.cleanup = THREAD_GETMEM (self, cleanup); |
| |
| /* Store the new cleanup handler info. */ |
| THREAD_SETMEM (self, cleanup_jmp_buf, &unwind_buf); |
| |
| /* Run the program. */ |
| result = main (argc, argv, __environ MAIN_AUXVEC_PARAM); |
| } |
| else |
| { |
| /* Remove the thread-local data. */ |
| # ifdef SHARED |
| PTHFCT_CALL (ptr__nptl_deallocate_tsd, ()); |
| # else |
| extern void __nptl_deallocate_tsd (void) __attribute ((weak)); |
| __nptl_deallocate_tsd (); |
| # endif |
| |
| /* One less thread. Decrement the counter. If it is zero we |
| terminate the entire process. */ |
| result = 0; |
| # ifdef SHARED |
| unsigned int *ptr = __libc_pthread_functions.ptr_nthreads; |
| PTR_DEMANGLE (ptr); |
| # else |
| extern unsigned int __nptl_nthreads __attribute ((weak)); |
| unsigned int *const ptr = &__nptl_nthreads; |
| # endif |
| |
| if (! atomic_decrement_and_test (ptr)) |
| /* Not much left to do but to exit the thread, not the process. */ |
| __exit_thread (0); |
| } |
| #else |
| /* Nothing fancy, just call the function. */ |
| result = main (argc, argv, __environ MAIN_AUXVEC_PARAM); |
| #endif |
| |
| exit (result); |
| } |