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