csu/libc-start.c

   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 }