csu/libc-start.c

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