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   /* Initialize very early so that tunables can use it.  */
 289   __libc_init_secure ();
 290
 291   __tunables_init (__environ);
 292
 293   ARCH_INIT_CPU_FEATURES ();
 294
 295   /* Do static pie self relocation after tunables and cpu features
 296      are setup for ifunc resolvers. Before this point relocations
 297      must be avoided.  */
 298   _dl_relocate_static_pie ();
 299
 300   /* Perform IREL{,A} relocations.  */
 301   ARCH_SETUP_IREL ();
 302
 303   /* The stack guard goes into the TCB, so initialize it early.  */
 304   ARCH_SETUP_TLS ();
 305
 306   /* In some architectures, IREL{,A} relocations happen after TLS setup in
 307      order to let IFUNC resolvers benefit from TCB information, e.g. powerpc's
 308      hwcap and platform fields available in the TCB.  */
 309   ARCH_APPLY_IREL ();
 310
 311   /* Set up the stack checker's canary.  */
 312   uintptr_t stack_chk_guard = _dl_setup_stack_chk_guard (_dl_random);
 313 # ifdef THREAD_SET_STACK_GUARD
 314   THREAD_SET_STACK_GUARD (stack_chk_guard);
 315 # else
 316   __stack_chk_guard = stack_chk_guard;
 317 # endif
 318
 319 # ifdef DL_SYSDEP_OSCHECK
 320   {
 321     /* This needs to run to initiliaze _dl_osversion before TLS
 322        setup might check it.  */
 323     DL_SYSDEP_OSCHECK (__libc_fatal);
 324   }
 325 # endif
 326
 327   /* Initialize libpthread if linked in.  */
 328   if (__pthread_initialize_minimal != NULL)
 329     __pthread_initialize_minimal ();
 330
 331   /* Set up the pointer guard value.  */
 332   uintptr_t pointer_chk_guard = _dl_setup_pointer_guard (_dl_random,
 333                                                          stack_chk_guard);
 334 # ifdef THREAD_SET_POINTER_GUARD
 335   THREAD_SET_POINTER_GUARD (pointer_chk_guard);
 336 # else
 337   __pointer_chk_guard_local = pointer_chk_guard;
 338 # endif
 339
 340 #endif /* !SHARED  */
 341
 342   /* Register the destructor of the dynamic linker if there is any.  */
 343   if (__glibc_likely (rtld_fini != NULL))
 344     __cxa_atexit ((void (*) (void *)) rtld_fini, NULL, NULL);
 345
 346 #ifndef SHARED
 347   /* Perform early initialization.  In the shared case, this function
 348      is called from the dynamic loader as early as possible.  */
 349   __libc_early_init (true);
 350
 351   /* Call the initializer of the libc.  This is only needed here if we
 352      are compiling for the static library in which case we haven't
 353      run the constructors in `_dl_start_user'.  */
 354   __libc_init_first (argc, argv, __environ);
 355
 356   /* Register the destructor of the statically-linked program.  */
 357   __cxa_atexit (call_fini, NULL, NULL);
 358
 359   /* Some security at this point.  Prevent starting a SUID binary where
 360      the standard file descriptors are not opened.  We have to do this
 361      only for statically linked applications since otherwise the dynamic
 362      loader did the work already.  */
 363   if (__builtin_expect (__libc_enable_secure, 0))
 364     __libc_check_standard_fds ();
 365 #endif /* !SHARED */
 366
 367   /* Call the initializer of the program, if any.  */
 368 #ifdef SHARED
 369   if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS, 0))
 370     GLRO(dl_debug_printf) ("\ninitialize program: %s\n\n", argv[0]);
 371
 372   if (init != NULL)
 373     /* This is a legacy program which supplied its own init
 374        routine.  */
 375     (*init) (argc, argv, __environ MAIN_AUXVEC_PARAM);
 376   else
 377     /* This is a current program.  Use the dynamic segment to find
 378        constructors.  */
 379     call_init (argc, argv, __environ);
 380
 381   /* Auditing checkpoint: we have a new object.  */
 382   _dl_audit_preinit (GL(dl_ns)[LM_ID_BASE]._ns_loaded);
 383
 384   if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS))
 385     GLRO(dl_debug_printf) ("\ntransferring control: %s\n\n", argv[0]);
 386 #else /* !SHARED */
 387   call_init (argc, argv, __environ);
 388
 389   _dl_debug_initialize (0, LM_ID_BASE);
 390 #endif
 391
 392   __libc_start_call_main (main, argc, argv MAIN_AUXVEC_PARAM);
 393 }
 394
 395 /* Starting with glibc 2.34, the init parameter is always NULL.  Older
 396    libcs are not prepared to handle that.  The macro
 397    DEFINE_LIBC_START_MAIN_VERSION creates GLIBC_2.34 alias, so that
 398    newly linked binaries reflect that dependency.  The macros below
 399    expect that the exported function is called
 400    __libc_start_main_impl.  */
 401 #ifdef SHARED
 402 # define DEFINE_LIBC_START_MAIN_VERSION \
 403   DEFINE_LIBC_START_MAIN_VERSION_1 \
 404   strong_alias (__libc_start_main_impl, __libc_start_main_alias_2)      \
 405   versioned_symbol (libc, __libc_start_main_alias_2, __libc_start_main, \
 406                     GLIBC_2_34);
 407
 408 # if SHLIB_COMPAT(libc, GLIBC_2_0, GLIBC_2_34)
 409 #  define DEFINE_LIBC_START_MAIN_VERSION_1 \
 410   strong_alias (__libc_start_main_impl, __libc_start_main_alias_1)      \
 411   compat_symbol (libc, __libc_start_main_alias_1, __libc_start_main, GLIBC_2_0);
 412 #  else
 413 #  define DEFINE_LIBC_START_MAIN_VERSION_1
 414 # endif
 415 #else  /* !SHARED */
 416 /* Enable calling the function under its exported name.  */
 417 # define DEFINE_LIBC_START_MAIN_VERSION \
 418   strong_alias (__libc_start_main_impl, __libc_start_main)
 419 #endif
 420
 421 /* Only define the version information if LIBC_START_MAIN was not set.
 422    If there is a wrapper file, it must expand
 423    DEFINE_LIBC_START_MAIN_VERSION on its own.  */
 424 #if DO_DEFINE_LIBC_START_MAIN_VERSION
 425 DEFINE_LIBC_START_MAIN_VERSION
 426 #endif