csu/libc-start.c

   1 /* Perform initialization and invoke main.
   2    Copyright (C) 1998-2022 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 /* Note: This code is only part of the startup code proper for
  20    statically linked binaries.  For dynamically linked binaries, it
  21    resides in libc.so.  */
  22
  23 /* Mark symbols hidden in static PIE for early self relocation to work.  */
  24 #if BUILD_PIE_DEFAULT
  25 # pragma GCC visibility push(hidden)
  26 #endif
  27
  28 #include <assert.h>
  29 #include <stdlib.h>
  30 #include <stdio.h>
  31 #include <unistd.h>
  32 #include <ldsodefs.h>
  33 #include <libc-diag.h>
  34 #include <libc-internal.h>
  35 #include <elf/libc-early-init.h>
  36 #include <stdbool.h>
  37 #include <elf-initfini.h>
  38 #include <shlib-compat.h>
  39
  40 #include <elf/dl-tunables.h>
  41
  42 extern void __libc_init_first (int argc, char **argv, char **envp);
  43
  44 #include <tls.h>
  45 #ifndef SHARED
  46 # include <dl-osinfo.h>
  47 # ifndef THREAD_SET_STACK_GUARD
  48 /* Only exported for architectures that don't store the stack guard canary
  49    in thread local area.  */
  50 uintptr_t __stack_chk_guard attribute_relro;
  51 # endif
  52 # ifndef  THREAD_SET_POINTER_GUARD
  53 /* Only exported for architectures that don't store the pointer guard
  54    value in thread local area.  */
  55 uintptr_t __pointer_chk_guard_local attribute_relro attribute_hidden;
  56 # endif
  57 #endif
  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 # define DO_DEFINE_LIBC_START_MAIN_VERSION 0
  99 #else
 100 # define STATIC
 101 # define LIBC_START_MAIN __libc_start_main_impl
 102 # define DO_DEFINE_LIBC_START_MAIN_VERSION 1
 103 #endif
 104
 105 #ifdef MAIN_AUXVEC_ARG
 106 /* main gets passed a pointer to the auxiliary.  */
 107 # define MAIN_AUXVEC_DECL       , void *
 108 # define MAIN_AUXVEC_PARAM      , auxvec
 109 #else
 110 # define MAIN_AUXVEC_DECL
 111 # define MAIN_AUXVEC_PARAM
 112 #endif
 113
 114 #ifndef ARCH_INIT_CPU_FEATURES
 115 # define ARCH_INIT_CPU_FEATURES()
 116 #endif
 117
 118 /* Obtain the definition of __libc_start_call_main.  */
 119 #include <libc_start_call_main.h>
 120
 121 #ifdef SHARED
 122 /* Initialization for dynamic executables.  Find the main executable
 123    link map and run its init functions.  */
 124 static void
 125 call_init (int argc, char **argv, char **env)
 126 {
 127   /* Obtain the main map of the executable.  */
 128   struct link_map *l = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
 129
 130   /* DT_PREINIT_ARRAY is not processed here.  It is already handled in
 131      _dl_init in elf/dl-init.c.  Also see the call_init function in
 132      the same file.  */
 133
 134   if (ELF_INITFINI && l->l_info[DT_INIT] != NULL)
 135     DL_CALL_DT_INIT(l, l->l_addr + l->l_info[DT_INIT]->d_un.d_ptr,
 136                     argc, argv, env);
 137
 138   ElfW(Dyn) *init_array = l->l_info[DT_INIT_ARRAY];
 139   if (init_array != NULL)
 140     {
 141       unsigned int jm
 142         = l->l_info[DT_INIT_ARRAYSZ]->d_un.d_val / sizeof (ElfW(Addr));
 143       ElfW(Addr) *addrs = (void *) (init_array->d_un.d_ptr + l->l_addr);
 144       for (unsigned int j = 0; j < jm; ++j)
 145         ((dl_init_t) addrs[j]) (argc, argv, env);
 146     }
 147 }
 148
 149 #else /* !SHARED */
 150
 151 /* These magic symbols are provided by the linker.  */
 152 extern void (*__preinit_array_start []) (int, char **, char **)
 153   attribute_hidden;
 154 extern void (*__preinit_array_end []) (int, char **, char **)
 155   attribute_hidden;
 156 extern void (*__init_array_start []) (int, char **, char **)
 157   attribute_hidden;
 158 extern void (*__init_array_end []) (int, char **, char **)
 159   attribute_hidden;
 160 extern void (*__fini_array_start []) (void) attribute_hidden;
 161 extern void (*__fini_array_end []) (void) attribute_hidden;
 162
 163 # if ELF_INITFINI
 164 /* These function symbols are provided for the .init/.fini section entry
 165    points automagically by the linker.  */
 166 extern void _init (void);
 167 extern void _fini (void);
 168 # endif
 169
 170 /* Initialization for static executables.  There is no dynamic
 171    segment, so we access the symbols directly.  */
 172 static void
 173 call_init (int argc, char **argv, char **envp)
 174 {
 175   /* For static executables, preinit happens right before init.  */
 176   {
 177     const size_t size = __preinit_array_end - __preinit_array_start;
 178     size_t i;
 179     for (i = 0; i < size; i++)
 180       (*__preinit_array_start [i]) (argc, argv, envp);
 181   }
 182
 183 # if ELF_INITFINI
 184   _init ();
 185 # endif
 186
 187   const size_t size = __init_array_end - __init_array_start;
 188   for (size_t i = 0; i < size; i++)
 189       (*__init_array_start [i]) (argc, argv, envp);
 190 }
 191
 192 /* Likewise for the destructor.  */
 193 static void
 194 call_fini (void *unused)
 195 {
 196   size_t i = __fini_array_end - __fini_array_start;
 197   while (i-- > 0)
 198     (*__fini_array_start [i]) ();
 199
 200 # if ELF_INITFINI
 201   _fini ();
 202 # endif
 203 }
 204
 205 #endif /* !SHARED */
 206
 207 #include <libc-start.h>
 208
 209 STATIC int LIBC_START_MAIN (int (*main) (int, char **, char **
 210                                          MAIN_AUXVEC_DECL),
 211                             int argc,
 212                             char **argv,
 213 #ifdef LIBC_START_MAIN_AUXVEC_ARG
 214                             ElfW(auxv_t) *auxvec,
 215 #endif
 216                             __typeof (main) init,
 217                             void (*fini) (void),
 218                             void (*rtld_fini) (void),
 219                             void *stack_end)
 220      __attribute__ ((noreturn));
 221
 222
 223 /* Note: The init and fini parameters are no longer used.  fini is
 224    completely unused, init is still called if not NULL, but the
 225    current startup code always passes NULL.  (In the future, it would
 226    be possible to use fini to pass a version code if init is NULL, to
 227    indicate the link-time glibc without introducing a hard
 228    incompatibility for new programs with older glibc versions.)
 229
 230    For dynamically linked executables, the dynamic segment is used to
 231    locate constructors and destructors.  For statically linked
 232    executables, the relevant symbols are access directly.  */
 233 STATIC int
 234 LIBC_START_MAIN (int (*main) (int, char **, char ** MAIN_AUXVEC_DECL),
 235                  int argc, char **argv,
 236 #ifdef LIBC_START_MAIN_AUXVEC_ARG
 237                  ElfW(auxv_t) *auxvec,
 238 #endif
 239                  __typeof (main) init,
 240                  void (*fini) (void),
 241                  void (*rtld_fini) (void), void *stack_end)
 242 {
 243 #ifndef SHARED
 244   char **ev = &argv[argc + 1];
 245
 246   __environ = ev;
 247
 248   /* Store the lowest stack address.  This is done in ld.so if this is
 249      the code for the DSO.  */
 250   __libc_stack_end = stack_end;
 251
 252 # ifdef HAVE_AUX_VECTOR
 253   /* First process the auxiliary vector since we need to find the
 254      program header to locate an eventually present PT_TLS entry.  */
 255 #  ifndef LIBC_START_MAIN_AUXVEC_ARG
 256   ElfW(auxv_t) *auxvec;
 257   {
 258     char **evp = ev;
 259     while (*evp++ != NULL)
 260       ;
 261     auxvec = (ElfW(auxv_t) *) evp;
 262   }
 263 #  endif
 264   _dl_aux_init (auxvec);
 265   if (GL(dl_phdr) == NULL)
 266 # endif
 267     {
 268       /* Starting from binutils-2.23, the linker will define the
 269          magic symbol __ehdr_start to point to our own ELF header
 270          if it is visible in a segment that also includes the phdrs.
 271          So we can set up _dl_phdr and _dl_phnum even without any
 272          information from auxv.  */
 273
 274       extern const ElfW(Ehdr) __ehdr_start
 275 # if BUILD_PIE_DEFAULT
 276         __attribute__ ((visibility ("hidden")));
 277 # else
 278         __attribute__ ((weak, visibility ("hidden")));
 279       if (&__ehdr_start != NULL)
 280 # endif
 281         {
 282           assert (__ehdr_start.e_phentsize == sizeof *GL(dl_phdr));
 283           GL(dl_phdr) = (const void *) &__ehdr_start + __ehdr_start.e_phoff;
 284           GL(dl_phnum) = __ehdr_start.e_phnum;
 285         }
 286     }
 287
 288   __tunables_init (__environ);
 289
 290   ARCH_INIT_CPU_FEATURES ();
 291
 292   /* Do static pie self relocation after tunables and cpu features
 293      are setup for ifunc resolvers. Before this point relocations
 294      must be avoided.  */
 295   _dl_relocate_static_pie ();
 296
 297   /* Perform IREL{,A} relocations.  */
 298   ARCH_SETUP_IREL ();
 299
 300   /* The stack guard goes into the TCB, so initialize it early.  */
 301   ARCH_SETUP_TLS ();
 302
 303   /* In some architectures, IREL{,A} relocations happen after TLS setup in
 304      order to let IFUNC resolvers benefit from TCB information, e.g. powerpc's
 305      hwcap and platform fields available in the TCB.  */
 306   ARCH_APPLY_IREL ();
 307
 308   /* Set up the stack checker's canary.  */
 309   uintptr_t stack_chk_guard = _dl_setup_stack_chk_guard (_dl_random);
 310 # ifdef THREAD_SET_STACK_GUARD
 311   THREAD_SET_STACK_GUARD (stack_chk_guard);
 312 # else
 313   __stack_chk_guard = stack_chk_guard;
 314 # endif
 315
 316   /* Initialize libpthread if linked in.  */
 317   if (__pthread_initialize_minimal != NULL)
 318     __pthread_initialize_minimal ();
 319
 320   /* Set up the pointer guard value.  */
 321   uintptr_t pointer_chk_guard = _dl_setup_pointer_guard (_dl_random,
 322                                                          stack_chk_guard);
 323 # ifdef THREAD_SET_POINTER_GUARD
 324   THREAD_SET_POINTER_GUARD (pointer_chk_guard);
 325 # else
 326   __pointer_chk_guard_local = pointer_chk_guard;
 327 # endif
 328
 329 #endif /* !SHARED  */
 330
 331   /* Register the destructor of the dynamic linker if there is any.  */
 332   if (__glibc_likely (rtld_fini != NULL))
 333     __cxa_atexit ((void (*) (void *)) rtld_fini, NULL, NULL);
 334
 335 #ifndef SHARED
 336   /* Perform early initialization.  In the shared case, this function
 337      is called from the dynamic loader as early as possible.  */
 338   __libc_early_init (true);
 339
 340   /* Call the initializer of the libc.  This is only needed here if we
 341      are compiling for the static library in which case we haven't
 342      run the constructors in `_dl_start_user'.  */
 343   __libc_init_first (argc, argv, __environ);
 344
 345   /* Register the destructor of the statically-linked program.  */
 346   __cxa_atexit (call_fini, NULL, NULL);
 347
 348   /* Some security at this point.  Prevent starting a SUID binary where
 349      the standard file descriptors are not opened.  We have to do this
 350      only for statically linked applications since otherwise the dynamic
 351      loader did the work already.  */
 352   if (__builtin_expect (__libc_enable_secure, 0))
 353     __libc_check_standard_fds ();
 354 #endif /* !SHARED */
 355
 356   /* Call the initializer of the program, if any.  */
 357 #ifdef SHARED
 358   if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS, 0))
 359     GLRO(dl_debug_printf) ("\ninitialize program: %s\n\n", argv[0]);
 360
 361   if (init != NULL)
 362     /* This is a legacy program which supplied its own init
 363        routine.  */
 364     (*init) (argc, argv, __environ MAIN_AUXVEC_PARAM);
 365   else
 366     /* This is a current program.  Use the dynamic segment to find
 367        constructors.  */
 368     call_init (argc, argv, __environ);
 369
 370   /* Auditing checkpoint: we have a new object.  */
 371   _dl_audit_preinit (GL(dl_ns)[LM_ID_BASE]._ns_loaded);
 372
 373   if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS))
 374     GLRO(dl_debug_printf) ("\ntransferring control: %s\n\n", argv[0]);
 375 #else /* !SHARED */
 376   call_init (argc, argv, __environ);
 377
 378   _dl_debug_initialize (0, LM_ID_BASE);
 379 #endif
 380
 381   __libc_start_call_main (main, argc, argv MAIN_AUXVEC_PARAM);
 382 }
 383
 384 /* Starting with glibc 2.34, the init parameter is always NULL.  Older
 385    libcs are not prepared to handle that.  The macro
 386    DEFINE_LIBC_START_MAIN_VERSION creates GLIBC_2.34 alias, so that
 387    newly linked binaries reflect that dependency.  The macros below
 388    expect that the exported function is called
 389    __libc_start_main_impl.  */
 390 #ifdef SHARED
 391 # define DEFINE_LIBC_START_MAIN_VERSION \
 392   DEFINE_LIBC_START_MAIN_VERSION_1 \
 393   strong_alias (__libc_start_main_impl, __libc_start_main_alias_2)      \
 394   versioned_symbol (libc, __libc_start_main_alias_2, __libc_start_main, \
 395                     GLIBC_2_34);
 396
 397 # if SHLIB_COMPAT(libc, GLIBC_2_0, GLIBC_2_34)
 398 #  define DEFINE_LIBC_START_MAIN_VERSION_1 \
 399   strong_alias (__libc_start_main_impl, __libc_start_main_alias_1)      \
 400   compat_symbol (libc, __libc_start_main_alias_1, __libc_start_main, GLIBC_2_0);
 401 #  else
 402 #  define DEFINE_LIBC_START_MAIN_VERSION_1
 403 # endif
 404 #else  /* !SHARED */
 405 /* Enable calling the function under its exported name.  */
 406 # define DEFINE_LIBC_START_MAIN_VERSION \
 407   strong_alias (__libc_start_main_impl, __libc_start_main)
 408 #endif
 409
 410 /* Only define the version information if LIBC_START_MAIN was not set.
 411    If there is a wrapper file, it must expand
 412    DEFINE_LIBC_START_MAIN_VERSION on its own.  */
 413 #if DO_DEFINE_LIBC_START_MAIN_VERSION
 414 DEFINE_LIBC_START_MAIN_VERSION
 415 #endif