csu/libc-start.c

   1 /* Copyright (C) 1998-2019 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 #include <tls.h>
  31 #ifndef SHARED
  32 # include <dl-osinfo.h>
  33 # ifndef THREAD_SET_STACK_GUARD
  34 /* Only exported for architectures that don't store the stack guard canary
  35    in thread local area.  */
  36 uintptr_t __stack_chk_guard attribute_relro;
  37 # endif
  38 # ifndef  THREAD_SET_POINTER_GUARD
  39 /* Only exported for architectures that don't store the pointer guard
  40    value in thread local area.  */
  41 uintptr_t __pointer_chk_guard_local
  42         attribute_relro attribute_hidden __attribute__ ((nocommon));
  43 # endif
  44 #endif
  45
  46 #ifdef HAVE_PTR_NTHREADS
  47 /* We need atomic operations.  */
  48 # include <atomic.h>
  49 #endif
  50
  51
  52 #ifndef SHARED
  53 # include <link.h>
  54 # include <dl-irel.h>
  55
  56 # ifdef ELF_MACHINE_IRELA
  57 #  define IREL_T        ElfW(Rela)
  58 #  define IPLT_START    __rela_iplt_start
  59 #  define IPLT_END      __rela_iplt_end
  60 #  define IREL          elf_irela
  61 # elif defined ELF_MACHINE_IREL
  62 #  define IREL_T        ElfW(Rel)
  63 #  define IPLT_START    __rel_iplt_start
  64 #  define IPLT_END      __rel_iplt_end
  65 #  define IREL          elf_irel
  66 # endif
  67
  68 static void
  69 apply_irel (void)
  70 {
  71 # ifdef IREL
  72   /* We use weak references for these so that we'll still work with a linker
  73      that doesn't define them.  Such a linker doesn't support IFUNC at all
  74      and so uses won't work, but a statically-linked program that doesn't
  75      use any IFUNC symbols won't have a problem.  */
  76   extern const IREL_T IPLT_START[] __attribute__ ((weak));
  77   extern const IREL_T IPLT_END[] __attribute__ ((weak));
  78   for (const IREL_T *ipltent = IPLT_START; ipltent < IPLT_END; ++ipltent)
  79     IREL (ipltent);
  80 # endif
  81 }
  82 #endif
  83
  84
  85 #ifdef LIBC_START_MAIN
  86 # ifdef LIBC_START_DISABLE_INLINE
  87 #  define STATIC static
  88 # else
  89 #  define STATIC static inline __attribute__ ((always_inline))
  90 # endif
  91 #else
  92 # define STATIC
  93 # define LIBC_START_MAIN __libc_start_main
  94 #endif
  95
  96 #ifdef MAIN_AUXVEC_ARG
  97 /* main gets passed a pointer to the auxiliary.  */
  98 # define MAIN_AUXVEC_DECL       , void *
  99 # define MAIN_AUXVEC_PARAM      , auxvec
 100 #else
 101 # define MAIN_AUXVEC_DECL
 102 # define MAIN_AUXVEC_PARAM
 103 #endif
 104
 105 #ifndef ARCH_INIT_CPU_FEATURES
 106 # define ARCH_INIT_CPU_FEATURES()
 107 #endif
 108
 109 #include <libc-start.h>
 110
 111 STATIC int LIBC_START_MAIN (int (*main) (int, char **, char **
 112                                          MAIN_AUXVEC_DECL),
 113                             int argc,
 114                             char **argv,
 115 #ifdef LIBC_START_MAIN_AUXVEC_ARG
 116                             ElfW(auxv_t) *auxvec,
 117 #endif
 118                             __typeof (main) init,
 119                             void (*fini) (void),
 120                             void (*rtld_fini) (void),
 121                             void *stack_end)
 122      __attribute__ ((noreturn));
 123
 124
 125 /* Note: the fini parameter is ignored here for shared library.  It
 126    is registered with __cxa_atexit.  This had the disadvantage that
 127    finalizers were called in more than one place.  */
 128 STATIC int
 129 LIBC_START_MAIN (int (*main) (int, char **, char ** MAIN_AUXVEC_DECL),
 130                  int argc, char **argv,
 131 #ifdef LIBC_START_MAIN_AUXVEC_ARG
 132                  ElfW(auxv_t) *auxvec,
 133 #endif
 134                  __typeof (main) init,
 135                  void (*fini) (void),
 136                  void (*rtld_fini) (void), void *stack_end)
 137 {
 138   /* Result of the 'main' function.  */
 139   int result;
 140
 141   __libc_multiple_libcs = &_dl_starting_up && !_dl_starting_up;
 142
 143 #ifndef SHARED
 144   _dl_relocate_static_pie ();
 145
 146   char **ev = &argv[argc + 1];
 147
 148   __environ = ev;
 149
 150   /* Store the lowest stack address.  This is done in ld.so if this is
 151      the code for the DSO.  */
 152   __libc_stack_end = stack_end;
 153
 154 # ifdef HAVE_AUX_VECTOR
 155   /* First process the auxiliary vector since we need to find the
 156      program header to locate an eventually present PT_TLS entry.  */
 157 #  ifndef LIBC_START_MAIN_AUXVEC_ARG
 158   ElfW(auxv_t) *auxvec;
 159   {
 160     char **evp = ev;
 161     while (*evp++ != NULL)
 162       ;
 163     auxvec = (ElfW(auxv_t) *) evp;
 164   }
 165 #  endif
 166   _dl_aux_init (auxvec);
 167   if (GL(dl_phdr) == NULL)
 168 # endif
 169     {
 170       /* Starting from binutils-2.23, the linker will define the
 171          magic symbol __ehdr_start to point to our own ELF header
 172          if it is visible in a segment that also includes the phdrs.
 173          So we can set up _dl_phdr and _dl_phnum even without any
 174          information from auxv.  */
 175
 176       extern const ElfW(Ehdr) __ehdr_start
 177         __attribute__ ((weak, visibility ("hidden")));
 178       if (&__ehdr_start != NULL)
 179         {
 180           assert (__ehdr_start.e_phentsize == sizeof *GL(dl_phdr));
 181           GL(dl_phdr) = (const void *) &__ehdr_start + __ehdr_start.e_phoff;
 182           GL(dl_phnum) = __ehdr_start.e_phnum;
 183         }
 184     }
 185
 186   /* Initialize very early so that tunables can use it.  */
 187   __libc_init_secure ();
 188
 189   __tunables_init (__environ);
 190
 191   ARCH_INIT_CPU_FEATURES ();
 192
 193   /* Perform IREL{,A} relocations.  */
 194   ARCH_SETUP_IREL ();
 195
 196   /* The stack guard goes into the TCB, so initialize it early.  */
 197   ARCH_SETUP_TLS ();
 198
 199   /* In some architectures, IREL{,A} relocations happen after TLS setup in
 200      order to let IFUNC resolvers benefit from TCB information, e.g. powerpc's
 201      hwcap and platform fields available in the TCB.  */
 202   ARCH_APPLY_IREL ();
 203
 204   /* Set up the stack checker's canary.  */
 205   uintptr_t stack_chk_guard = _dl_setup_stack_chk_guard (_dl_random);
 206 # ifdef THREAD_SET_STACK_GUARD
 207   THREAD_SET_STACK_GUARD (stack_chk_guard);
 208 # else
 209   __stack_chk_guard = stack_chk_guard;
 210 # endif
 211
 212 # ifdef DL_SYSDEP_OSCHECK
 213   if (!__libc_multiple_libcs)
 214     {
 215       /* This needs to run to initiliaze _dl_osversion before TLS
 216          setup might check it.  */
 217       DL_SYSDEP_OSCHECK (__libc_fatal);
 218     }
 219 # endif
 220
 221   /* Initialize libpthread if linked in.  */
 222   if (__pthread_initialize_minimal != NULL)
 223     __pthread_initialize_minimal ();
 224
 225   /* Set up the pointer guard value.  */
 226   uintptr_t pointer_chk_guard = _dl_setup_pointer_guard (_dl_random,
 227                                                          stack_chk_guard);
 228 # ifdef THREAD_SET_POINTER_GUARD
 229   THREAD_SET_POINTER_GUARD (pointer_chk_guard);
 230 # else
 231   __pointer_chk_guard_local = pointer_chk_guard;
 232 # endif
 233
 234 #endif /* !SHARED  */
 235
 236   /* Register the destructor of the dynamic linker if there is any.  */
 237   if (__glibc_likely (rtld_fini != NULL))
 238     __cxa_atexit ((void (*) (void *)) rtld_fini, NULL, NULL);
 239
 240 #ifndef SHARED
 241   /* Call the initializer of the libc.  This is only needed here if we
 242      are compiling for the static library in which case we haven't
 243      run the constructors in `_dl_start_user'.  */
 244   __libc_init_first (argc, argv, __environ);
 245
 246   /* Register the destructor of the program, if any.  */
 247   if (fini)
 248     __cxa_atexit ((void (*) (void *)) fini, NULL, NULL);
 249
 250   /* Some security at this point.  Prevent starting a SUID binary where
 251      the standard file descriptors are not opened.  We have to do this
 252      only for statically linked applications since otherwise the dynamic
 253      loader did the work already.  */
 254   if (__builtin_expect (__libc_enable_secure, 0))
 255     __libc_check_standard_fds ();
 256 #endif
 257
 258   /* Call the initializer of the program, if any.  */
 259 #ifdef SHARED
 260   if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS, 0))
 261     GLRO(dl_debug_printf) ("\ninitialize program: %s\n\n", argv[0]);
 262 #endif
 263   if (init)
 264     (*init) (argc, argv, __environ MAIN_AUXVEC_PARAM);
 265
 266 #ifdef SHARED
 267   /* Auditing checkpoint: we have a new object.  */
 268   if (__glibc_unlikely (GLRO(dl_naudit) > 0))
 269     {
 270       struct audit_ifaces *afct = GLRO(dl_audit);
 271       struct link_map *head = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
 272       for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
 273         {
 274           if (afct->preinit != NULL)
 275             afct->preinit (&head->l_audit[cnt].cookie);
 276
 277           afct = afct->next;
 278         }
 279     }
 280 #endif
 281
 282 #ifdef SHARED
 283   if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS))
 284     GLRO(dl_debug_printf) ("\ntransferring control: %s\n\n", argv[0]);
 285 #endif
 286
 287 #ifndef SHARED
 288   _dl_debug_initialize (0, LM_ID_BASE);
 289 #endif
 290 #ifdef HAVE_CLEANUP_JMP_BUF
 291   /* Memory for the cancellation buffer.  */
 292   struct pthread_unwind_buf unwind_buf;
 293
 294   int not_first_call;
 295   not_first_call = setjmp ((struct __jmp_buf_tag *) unwind_buf.cancel_jmp_buf);
 296   if (__glibc_likely (! not_first_call))
 297     {
 298       struct pthread *self = THREAD_SELF;
 299
 300       /* Store old info.  */
 301       unwind_buf.priv.data.prev = THREAD_GETMEM (self, cleanup_jmp_buf);
 302       unwind_buf.priv.data.cleanup = THREAD_GETMEM (self, cleanup);
 303
 304       /* Store the new cleanup handler info.  */
 305       THREAD_SETMEM (self, cleanup_jmp_buf, &unwind_buf);
 306
 307       /* Run the program.  */
 308       result = main (argc, argv, __environ MAIN_AUXVEC_PARAM);
 309     }
 310   else
 311     {
 312       /* Remove the thread-local data.  */
 313 # ifdef SHARED
 314       PTHFCT_CALL (ptr__nptl_deallocate_tsd, ());
 315 # else
 316       extern void __nptl_deallocate_tsd (void) __attribute ((weak));
 317       __nptl_deallocate_tsd ();
 318 # endif
 319
 320       /* One less thread.  Decrement the counter.  If it is zero we
 321          terminate the entire process.  */
 322       result = 0;
 323 # ifdef SHARED
 324       unsigned int *ptr = __libc_pthread_functions.ptr_nthreads;
 325 #  ifdef PTR_DEMANGLE
 326       PTR_DEMANGLE (ptr);
 327 #  endif
 328 # else
 329       extern unsigned int __nptl_nthreads __attribute ((weak));
 330       unsigned int *const ptr = &__nptl_nthreads;
 331 # endif
 332
 333       if (! atomic_decrement_and_test (ptr))
 334         /* Not much left to do but to exit the thread, not the process.  */
 335         __exit_thread ();
 336     }
 337 #else
 338   /* Nothing fancy, just call the function.  */
 339   result = main (argc, argv, __environ MAIN_AUXVEC_PARAM);
 340 #endif
 341
 342   exit (result);
 343 }