csu/libc-start.c

   1 /* Copyright (C) 1998-2021 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 #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 # if BUILD_PIE_DEFAULT
 179         __attribute__ ((visibility ("hidden")));
 180 # else
 181         __attribute__ ((weak, visibility ("hidden")));
 182       if (&__ehdr_start != NULL)
 183 # endif
 184         {
 185           assert (__ehdr_start.e_phentsize == sizeof *GL(dl_phdr));
 186           GL(dl_phdr) = (const void *) &__ehdr_start + __ehdr_start.e_phoff;
 187           GL(dl_phnum) = __ehdr_start.e_phnum;
 188         }
 189     }
 190
 191   /* Initialize very early so that tunables can use it.  */
 192   __libc_init_secure ();
 193
 194   __tunables_init (__environ);
 195
 196   ARCH_INIT_CPU_FEATURES ();
 197
 198   /* Perform IREL{,A} relocations.  */
 199   ARCH_SETUP_IREL ();
 200
 201   /* The stack guard goes into the TCB, so initialize it early.  */
 202   ARCH_SETUP_TLS ();
 203
 204   /* In some architectures, IREL{,A} relocations happen after TLS setup in
 205      order to let IFUNC resolvers benefit from TCB information, e.g. powerpc's
 206      hwcap and platform fields available in the TCB.  */
 207   ARCH_APPLY_IREL ();
 208
 209   /* Set up the stack checker's canary.  */
 210   uintptr_t stack_chk_guard = _dl_setup_stack_chk_guard (_dl_random);
 211 # ifdef THREAD_SET_STACK_GUARD
 212   THREAD_SET_STACK_GUARD (stack_chk_guard);
 213 # else
 214   __stack_chk_guard = stack_chk_guard;
 215 # endif
 216
 217 # ifdef DL_SYSDEP_OSCHECK
 218   {
 219     /* This needs to run to initiliaze _dl_osversion before TLS
 220        setup might check it.  */
 221     DL_SYSDEP_OSCHECK (__libc_fatal);
 222   }
 223 # endif
 224
 225   /* Initialize libpthread if linked in.  */
 226   if (__pthread_initialize_minimal != NULL)
 227     __pthread_initialize_minimal ();
 228
 229   /* Set up the pointer guard value.  */
 230   uintptr_t pointer_chk_guard = _dl_setup_pointer_guard (_dl_random,
 231                                                          stack_chk_guard);
 232 # ifdef THREAD_SET_POINTER_GUARD
 233   THREAD_SET_POINTER_GUARD (pointer_chk_guard);
 234 # else
 235   __pointer_chk_guard_local = pointer_chk_guard;
 236 # endif
 237
 238 #endif /* !SHARED  */
 239
 240   /* Register the destructor of the dynamic linker if there is any.  */
 241   if (__glibc_likely (rtld_fini != NULL))
 242     __cxa_atexit ((void (*) (void *)) rtld_fini, NULL, NULL);
 243
 244 #ifndef SHARED
 245   /* Perform early initialization.  In the shared case, this function
 246      is called from the dynamic loader as early as possible.  */
 247   __libc_early_init (true);
 248
 249   /* Call the initializer of the libc.  This is only needed here if we
 250      are compiling for the static library in which case we haven't
 251      run the constructors in `_dl_start_user'.  */
 252   __libc_init_first (argc, argv, __environ);
 253
 254   /* Register the destructor of the program, if any.  */
 255   if (fini)
 256     __cxa_atexit ((void (*) (void *)) fini, NULL, NULL);
 257
 258   /* Some security at this point.  Prevent starting a SUID binary where
 259      the standard file descriptors are not opened.  We have to do this
 260      only for statically linked applications since otherwise the dynamic
 261      loader did the work already.  */
 262   if (__builtin_expect (__libc_enable_secure, 0))
 263     __libc_check_standard_fds ();
 264 #endif
 265
 266   /* Call the initializer of the program, if any.  */
 267 #ifdef SHARED
 268   if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS, 0))
 269     GLRO(dl_debug_printf) ("\ninitialize program: %s\n\n", argv[0]);
 270 #endif
 271   if (init)
 272     (*init) (argc, argv, __environ MAIN_AUXVEC_PARAM);
 273
 274 #ifdef SHARED
 275   /* Auditing checkpoint: we have a new object.  */
 276   if (__glibc_unlikely (GLRO(dl_naudit) > 0))
 277     {
 278       struct audit_ifaces *afct = GLRO(dl_audit);
 279       struct link_map *head = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
 280       for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
 281         {
 282           if (afct->preinit != NULL)
 283             afct->preinit (&link_map_audit_state (head, cnt)->cookie);
 284
 285           afct = afct->next;
 286         }
 287     }
 288 #endif
 289
 290 #ifdef SHARED
 291   if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS))
 292     GLRO(dl_debug_printf) ("\ntransferring control: %s\n\n", argv[0]);
 293 #endif
 294
 295 #ifndef SHARED
 296   _dl_debug_initialize (0, LM_ID_BASE);
 297 #endif
 298 #ifdef HAVE_CLEANUP_JMP_BUF
 299   /* Memory for the cancellation buffer.  */
 300   struct pthread_unwind_buf unwind_buf;
 301
 302   int not_first_call;
 303   DIAG_PUSH_NEEDS_COMMENT;
 304 #if __GNUC_PREREQ (7, 0)
 305   /* This call results in a -Wstringop-overflow warning because struct
 306      pthread_unwind_buf is smaller than jmp_buf.  setjmp and longjmp
 307      do not use anything beyond the common prefix (they never access
 308      the saved signal mask), so that is a false positive.  */
 309   DIAG_IGNORE_NEEDS_COMMENT (11, "-Wstringop-overflow=");
 310 #endif
 311   not_first_call = setjmp ((struct __jmp_buf_tag *) unwind_buf.cancel_jmp_buf);
 312   DIAG_POP_NEEDS_COMMENT;
 313   if (__glibc_likely (! not_first_call))
 314     {
 315       struct pthread *self = THREAD_SELF;
 316
 317       /* Store old info.  */
 318       unwind_buf.priv.data.prev = THREAD_GETMEM (self, cleanup_jmp_buf);
 319       unwind_buf.priv.data.cleanup = THREAD_GETMEM (self, cleanup);
 320
 321       /* Store the new cleanup handler info.  */
 322       THREAD_SETMEM (self, cleanup_jmp_buf, &unwind_buf);
 323
 324       /* Run the program.  */
 325       result = main (argc, argv, __environ MAIN_AUXVEC_PARAM);
 326     }
 327   else
 328     {
 329       /* Remove the thread-local data.  */
 330 # ifdef SHARED
 331       PTHFCT_CALL (ptr__nptl_deallocate_tsd, ());
 332 # else
 333       extern void __nptl_deallocate_tsd (void) __attribute ((weak));
 334       __nptl_deallocate_tsd ();
 335 # endif
 336
 337       /* One less thread.  Decrement the counter.  If it is zero we
 338          terminate the entire process.  */
 339       result = 0;
 340 # ifdef SHARED
 341       unsigned int *ptr = __libc_pthread_functions.ptr_nthreads;
 342 #  ifdef PTR_DEMANGLE
 343       PTR_DEMANGLE (ptr);
 344 #  endif
 345 # else
 346       extern unsigned int __nptl_nthreads __attribute ((weak));
 347       unsigned int *const ptr = &__nptl_nthreads;
 348 # endif
 349
 350       if (! atomic_decrement_and_test (ptr))
 351         /* Not much left to do but to exit the thread, not the process.  */
 352         __exit_thread ();
 353     }
 354 #else
 355   /* Nothing fancy, just call the function.  */
 356   result = main (argc, argv, __environ MAIN_AUXVEC_PARAM);
 357 #endif
 358
 359   exit (result);
 360 }