csu/libc-start.c

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