csu/libc-start.c

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