1: /* Copyright (C) 1998-2006, 2007 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, write to the Free
   16:    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   17:    02111-1307 USA.  */
   18: 
   19: #include <stdlib.h>
   20: #include <stdio.h>
   21: #include <unistd.h>
   22: #include <ldsodefs.h>
   23: #include <bp-start.h>
   24: #include <bp-sym.h>
   25: 
   26: extern void __libc_init_first (int argc, char **argv, char **envp);
   27: 
   28: extern int __libc_multiple_libcs;
   29: 
   30: #include <tls.h>
   31: #ifndef SHARED
   32: # include <dl-osinfo.h>
   33: extern void __pthread_initialize_minimal (void);
   34: # ifndef THREAD_SET_STACK_GUARD
   35: /* Only exported for architectures that don't store the stack guard canary
   36:    in thread local area.  */
   37: uintptr_t __stack_chk_guard attribute_relro;
   38: # endif
   39: #endif
   40: 
   41: #ifdef HAVE_PTR_NTHREADS
   42: /* We need atomic operations.  */
   43: # include <atomic.h>
   44: #endif
   45: 
   46: 
   47: #ifdef LIBC_START_MAIN
   48: # ifdef LIBC_START_DISABLE_INLINE
   49: #  define STATIC static
   50: # else
   51: #  define STATIC static inline __attribute__ ((always_inline))
   52: # endif
   53: #else
   54: # define STATIC
   55: # define LIBC_START_MAIN BP_SYM (__libc_start_main)
   56: #endif
   57: 
   58: #ifdef MAIN_AUXVEC_ARG
   59: /* main gets passed a pointer to the auxiliary.  */
   60: # define MAIN_AUXVEC_DECL       , void *
   61: # define MAIN_AUXVEC_PARAM      , auxvec
   62: #else
   63: # define MAIN_AUXVEC_DECL
   64: # define MAIN_AUXVEC_PARAM
   65: #endif
   66: 
   67: STATIC int LIBC_START_MAIN (int (*main) (int, char **, char **
   68:                                          MAIN_AUXVEC_DECL),
   69:                             int argc,
   70:                             char *__unbounded *__unbounded ubp_av,
   71: #ifdef LIBC_START_MAIN_AUXVEC_ARG
   72:                             ElfW(auxv_t) *__unbounded auxvec,
   73: #endif
   74:                             __typeof (main) init,
   75:                             void (*fini) (void),
   76:                             void (*rtld_fini) (void),
   77:                             void *__unbounded stack_end)
   78:      __attribute__ ((noreturn));
   79: 
   80: 
   81: /* Note: the fini parameter is ignored here for shared library.  It
   82:    is registered with __cxa_atexit.  This had the disadvantage that
   83:    finalizers were called in more than one place.  */
   84: STATIC int
   85: LIBC_START_MAIN (int (*main) (int, char **, char ** MAIN_AUXVEC_DECL),
   86:                  int argc, char *__unbounded *__unbounded ubp_av,
   87: #ifdef LIBC_START_MAIN_AUXVEC_ARG
   88:                  ElfW(auxv_t) *__unbounded auxvec,
   89: #endif
   90:                  __typeof (main) init,
   91:                  void (*fini) (void),
   92:                  void (*rtld_fini) (void), void *__unbounded stack_end)
   93: {
   94: #if __BOUNDED_POINTERS__
   95:   char **argv;
   96: #else
   97: # define argv ubp_av
   98: #endif
   99: 
  100:   /* Result of the 'main' function.  */
  101:   int result;
  102: 
  103:   __libc_multiple_libcs = &_dl_starting_up && !_dl_starting_up;
  104: 
  105: #ifndef SHARED
  106:   char *__unbounded *__unbounded ubp_ev = &ubp_av[argc + 1];
  107: 
  108:   INIT_ARGV_and_ENVIRON;
  109: 
  110:   /* Store the lowest stack address.  This is done in ld.so if this is
  111:      the code for the DSO.  */
  112:   __libc_stack_end = stack_end;
  113: 
  114: # ifdef HAVE_AUX_VECTOR
  115:   /* First process the auxiliary vector since we need to find the
  116:      program header to locate an eventually present PT_TLS entry.  */
  117: #  ifndef LIBC_START_MAIN_AUXVEC_ARG
  118:   ElfW(auxv_t) *__unbounded auxvec;
  119:   {
  120:     char *__unbounded *__unbounded evp = ubp_ev;
  121:     while (*evp++ != NULL)
  122:       ;
  123:     auxvec = (ElfW(auxv_t) *__unbounded) evp;
  124:   }
  125: #  endif
  126:   _dl_aux_init (auxvec);
  127: # endif
  128: # ifdef DL_SYSDEP_OSCHECK
  129:   if (!__libc_multiple_libcs)
  130:     {
  131:       /* This needs to run to initiliaze _dl_osversion before TLS
  132:          setup might check it.  */
  133:       DL_SYSDEP_OSCHECK (__libc_fatal);
  134:     }
  135: # endif
  136: 
  137:   /* Initialize the thread library at least a bit since the libgcc
  138:      functions are using thread functions if these are available and
  139:      we need to setup errno.  */
  140:   __pthread_initialize_minimal ();
  141: 
  142:   /* Set up the stack checker's canary.  */
  143:   uintptr_t stack_chk_guard = _dl_setup_stack_chk_guard ();
  144: # ifdef THREAD_SET_STACK_GUARD
  145:   THREAD_SET_STACK_GUARD (stack_chk_guard);
  146: # else
  147:   __stack_chk_guard = stack_chk_guard;
  148: # endif
  149: #endif
  150: 
  151:   /* Register the destructor of the dynamic linker if there is any.  */
  152:   if (__builtin_expect (rtld_fini != NULL, 1))
  153:     __cxa_atexit ((void (*) (void *)) rtld_fini, NULL, NULL);
  154: 
  155: #ifndef SHARED
  156:   /* Call the initializer of the libc.  This is only needed here if we
  157:      are compiling for the static library in which case we haven't
  158:      run the constructors in `_dl_start_user'.  */
  159:   __libc_init_first (argc, argv, __environ);
  160: 
  161:   /* Register the destructor of the program, if any.  */
  162:   if (fini)
  163:     __cxa_atexit ((void (*) (void *)) fini, NULL, NULL);
  164: 
  165:   /* Some security at this point.  Prevent starting a SUID binary where
  166:      the standard file descriptors are not opened.  We have to do this
  167:      only for statically linked applications since otherwise the dynamic
  168:      loader did the work already.  */
  169:   if (__builtin_expect (__libc_enable_secure, 0))
  170:     __libc_check_standard_fds ();
  171: #endif
  172: 
  173:   /* Call the initializer of the program, if any.  */
  174: #ifdef SHARED
  175:   if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS, 0))
  176:     GLRO(dl_debug_printf) ("\ninitialize program: %s\n\n", argv[0]);
  177: #endif
  178:   if (init)
  179:     (*init) (argc, argv, __environ MAIN_AUXVEC_PARAM);
  180: 
  181: #ifdef SHARED
  182:   /* Auditing checkpoint: we have a new object.  */
  183:   if (__builtin_expect (GLRO(dl_naudit) > 0, 0))
  184:     {
  185:       struct audit_ifaces *afct = GLRO(dl_audit);
  186:       struct link_map *head = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
  187:       for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
  188:         {
  189:           if (afct->preinit != NULL)
  190:             afct->preinit (&head->l_audit[cnt].cookie);
  191: 
  192:           afct = afct->next;
  193:         }
  194:     }
  195: #endif
  196: 
  197: #ifdef SHARED
  198:   if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS, 0))
  199:     GLRO(dl_debug_printf) ("\ntransferring control: %s\n\n", argv[0]);
  200: #endif
  201: 
  202: #ifdef HAVE_CLEANUP_JMP_BUF
  203:   /* Memory for the cancellation buffer.  */
  204:   struct pthread_unwind_buf unwind_buf;
  205: 
  206:   int not_first_call;
  207:   not_first_call = setjmp ((struct __jmp_buf_tag *) unwind_buf.cancel_jmp_buf);
  208:   if (__builtin_expect (! not_first_call, 1))
  209:     {
  210:       struct pthread *self = THREAD_SELF;
  211: 
  212:       /* Store old info.  */
  213:       unwind_buf.priv.data.prev = THREAD_GETMEM (self, cleanup_jmp_buf);
  214:       unwind_buf.priv.data.cleanup = THREAD_GETMEM (self, cleanup);
  215: 
  216:       /* Store the new cleanup handler info.  */
  217:       THREAD_SETMEM (self, cleanup_jmp_buf, &unwind_buf);
  218: 
  219:       /* Run the program.  */
  220:       result = main (argc, argv, __environ MAIN_AUXVEC_PARAM);
  221:     }
  222:   else
  223:     {
  224:       /* Remove the thread-local data.  */
  225: # ifdef SHARED
  226:       PTHFCT_CALL (ptr__nptl_deallocate_tsd, ());
  227: # else
  228:       extern void __nptl_deallocate_tsd (void) __attribute ((weak));
  229:       __nptl_deallocate_tsd ();
  230: # endif
  231: 
  232:       /* One less thread.  Decrement the counter.  If it is zero we
  233:          terminate the entire process.  */
  234:       result = 0;
  235: # ifdef SHARED
  236:       unsigned int *ptr = __libc_pthread_functions.ptr_nthreads;
  237:       PTR_DEMANGLE (ptr);
  238: # else
  239:       extern unsigned int __nptl_nthreads __attribute ((weak));
  240:       unsigned int *const ptr = &__nptl_nthreads;
  241: # endif
  242: 
  243:       if (! atomic_decrement_and_test (ptr))
  244:         /* Not much left to do but to exit the thread, not the process.  */
  245:         __exit_thread (0);
  246:     }
  247: #else
  248:   /* Nothing fancy, just call the function.  */
  249:   result = main (argc, argv, __environ MAIN_AUXVEC_PARAM);
  250: #endif
  251: 
  252:   exit (result);
  253: }