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