elf/dl-sysdep.c

   1 /* Operating system support for run-time dynamic linker.  Generic Unix version.
   2    Copyright (C) 1995-2021 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 /* We conditionalize the whole of this file rather than simply eliding it
  20    from the static build, because other sysdeps/ versions of this file
  21    might define things needed by a static build.  */
  22
  23 #ifdef SHARED
  24
  25 #include <assert.h>
  26 #include <elf.h>
  27 #include <errno.h>
  28 #include <fcntl.h>
  29 #include <libintl.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <unistd.h>
  33 #include <sys/types.h>
  34 #include <sys/stat.h>
  35 #include <sys/mman.h>
  36 #include <ldsodefs.h>
  37 #include <_itoa.h>
  38 #include <fpu_control.h>
  39
  40 #include <entry.h>
  41 #include <dl-machine.h>
  42 #include <dl-procinfo.h>
  43 #include <dl-osinfo.h>
  44 #include <libc-internal.h>
  45 #include <tls.h>
  46
  47 #include <dl-tunables.h>
  48 #include <dl-auxv.h>
  49 #include <dl-hwcap-check.h>
  50
  51 extern char **_environ attribute_hidden;
  52 extern char _end[] attribute_hidden;
  53
  54 /* Protect SUID program against misuse of file descriptors.  */
  55 extern void __libc_check_standard_fds (void);
  56
  57 #ifdef NEED_DL_BASE_ADDR
  58 ElfW(Addr) _dl_base_addr;
  59 #endif
  60 int __libc_enable_secure attribute_relro = 0;
  61 rtld_hidden_data_def (__libc_enable_secure)
  62 /* This variable contains the lowest stack address ever used.  */
  63 void *__libc_stack_end attribute_relro = NULL;
  64 rtld_hidden_data_def(__libc_stack_end)
  65 void *_dl_random attribute_relro = NULL;
  66
  67 #ifndef DL_FIND_ARG_COMPONENTS
  68 # define DL_FIND_ARG_COMPONENTS(cookie, argc, argv, envp, auxp) \
  69   do {                                                                        \
  70     void **_tmp;                                                              \
  71     (argc) = *(long int *) cookie;                                            \
  72     (argv) = (char **) ((long int *) cookie + 1);                             \
  73     (envp) = (argv) + (argc) + 1;                                             \
  74     for (_tmp = (void **) (envp); *_tmp; ++_tmp)                              \
  75       continue;                                                               \
  76     (auxp) = (void *) ++_tmp;                                                 \
  77   } while (0)
  78 #endif
  79
  80 #ifndef DL_STACK_END
  81 # define DL_STACK_END(cookie) ((void *) (cookie))
  82 #endif
  83
  84 ElfW(Addr)
  85 _dl_sysdep_start (void **start_argptr,
  86                   void (*dl_main) (const ElfW(Phdr) *phdr, ElfW(Word) phnum,
  87                                    ElfW(Addr) *user_entry, ElfW(auxv_t) *auxv))
  88 {
  89   const ElfW(Phdr) *phdr = NULL;
  90   ElfW(Word) phnum = 0;
  91   ElfW(Addr) user_entry;
  92   ElfW(auxv_t) *av;
  93 #ifdef HAVE_AUX_SECURE
  94 # define set_seen(tag) (tag)    /* Evaluate for the side effects.  */
  95 # define set_seen_secure() ((void) 0)
  96 #else
  97   uid_t uid = 0;
  98   gid_t gid = 0;
  99   unsigned int seen = 0;
 100 # define set_seen_secure() (seen = -1)
 101 # ifdef HAVE_AUX_XID
 102 #  define set_seen(tag) (tag)   /* Evaluate for the side effects.  */
 103 # else
 104 #  define M(type) (1 << (type))
 105 #  define set_seen(tag) seen |= M ((tag)->a_type)
 106 # endif
 107 #endif
 108 #ifdef NEED_DL_SYSINFO
 109   uintptr_t new_sysinfo = 0;
 110 #endif
 111
 112   __libc_stack_end = DL_STACK_END (start_argptr);
 113   DL_FIND_ARG_COMPONENTS (start_argptr, _dl_argc, _dl_argv, _environ,
 114                           GLRO(dl_auxv));
 115
 116   user_entry = (ElfW(Addr)) ENTRY_POINT;
 117   GLRO(dl_platform) = NULL; /* Default to nothing known about the platform.  */
 118
 119   /* NB: Default to a constant CONSTANT_MINSIGSTKSZ.  */
 120   _Static_assert (__builtin_constant_p (CONSTANT_MINSIGSTKSZ),
 121                   "CONSTANT_MINSIGSTKSZ is constant");
 122   GLRO(dl_minsigstacksize) = CONSTANT_MINSIGSTKSZ;
 123
 124   for (av = GLRO(dl_auxv); av->a_type != AT_NULL; set_seen (av++))
 125     switch (av->a_type)
 126       {
 127       case AT_PHDR:
 128         phdr = (void *) av->a_un.a_val;
 129         break;
 130       case AT_PHNUM:
 131         phnum = av->a_un.a_val;
 132         break;
 133       case AT_PAGESZ:
 134         GLRO(dl_pagesize) = av->a_un.a_val;
 135         break;
 136       case AT_ENTRY:
 137         user_entry = av->a_un.a_val;
 138         break;
 139 #ifdef NEED_DL_BASE_ADDR
 140       case AT_BASE:
 141         _dl_base_addr = av->a_un.a_val;
 142         break;
 143 #endif
 144 #ifndef HAVE_AUX_SECURE
 145       case AT_UID:
 146       case AT_EUID:
 147         uid ^= av->a_un.a_val;
 148         break;
 149       case AT_GID:
 150       case AT_EGID:
 151         gid ^= av->a_un.a_val;
 152         break;
 153 #endif
 154       case AT_SECURE:
 155 #ifndef HAVE_AUX_SECURE
 156         seen = -1;
 157 #endif
 158         __libc_enable_secure = av->a_un.a_val;
 159         break;
 160       case AT_PLATFORM:
 161         GLRO(dl_platform) = (void *) av->a_un.a_val;
 162         break;
 163       case AT_HWCAP:
 164         GLRO(dl_hwcap) = (unsigned long int) av->a_un.a_val;
 165         break;
 166       case AT_HWCAP2:
 167         GLRO(dl_hwcap2) = (unsigned long int) av->a_un.a_val;
 168         break;
 169       case AT_CLKTCK:
 170         GLRO(dl_clktck) = av->a_un.a_val;
 171         break;
 172       case AT_FPUCW:
 173         GLRO(dl_fpu_control) = av->a_un.a_val;
 174         break;
 175 #ifdef NEED_DL_SYSINFO
 176       case AT_SYSINFO:
 177         new_sysinfo = av->a_un.a_val;
 178         break;
 179 #endif
 180 #ifdef NEED_DL_SYSINFO_DSO
 181       case AT_SYSINFO_EHDR:
 182         GLRO(dl_sysinfo_dso) = (void *) av->a_un.a_val;
 183         break;
 184 #endif
 185       case AT_RANDOM:
 186         _dl_random = (void *) av->a_un.a_val;
 187         break;
 188       case AT_MINSIGSTKSZ:
 189         GLRO(dl_minsigstacksize) = av->a_un.a_val;
 190         break;
 191       DL_PLATFORM_AUXV
 192       }
 193
 194   dl_hwcap_check ();
 195
 196 #ifndef HAVE_AUX_SECURE
 197   if (seen != -1)
 198     {
 199       /* Fill in the values we have not gotten from the kernel through the
 200          auxiliary vector.  */
 201 # ifndef HAVE_AUX_XID
 202 #  define SEE(UID, var, uid) \
 203    if ((seen & M (AT_##UID)) == 0) var ^= __get##uid ()
 204       SEE (UID, uid, uid);
 205       SEE (EUID, uid, euid);
 206       SEE (GID, gid, gid);
 207       SEE (EGID, gid, egid);
 208 # endif
 209
 210       /* If one of the two pairs of IDs does not match this is a setuid
 211          or setgid run.  */
 212       __libc_enable_secure = uid | gid;
 213     }
 214 #endif
 215
 216 #ifndef HAVE_AUX_PAGESIZE
 217   if (GLRO(dl_pagesize) == 0)
 218     GLRO(dl_pagesize) = __getpagesize ();
 219 #endif
 220
 221 #ifdef NEED_DL_SYSINFO
 222   if (new_sysinfo != 0)
 223     {
 224 # ifdef NEED_DL_SYSINFO_DSO
 225       /* Only set the sysinfo value if we also have the vsyscall DSO.  */
 226       if (GLRO(dl_sysinfo_dso) != 0)
 227 # endif
 228         GLRO(dl_sysinfo) = new_sysinfo;
 229     }
 230 #endif
 231
 232   __tunables_init (_environ);
 233
 234 #ifdef DL_SYSDEP_INIT
 235   DL_SYSDEP_INIT;
 236 #endif
 237
 238 #ifdef DL_PLATFORM_INIT
 239   DL_PLATFORM_INIT;
 240 #endif
 241
 242   /* Determine the length of the platform name.  */
 243   if (GLRO(dl_platform) != NULL)
 244     GLRO(dl_platformlen) = strlen (GLRO(dl_platform));
 245
 246   if (__sbrk (0) == _end)
 247     /* The dynamic linker was run as a program, and so the initial break
 248        starts just after our bss, at &_end.  The malloc in dl-minimal.c
 249        will consume the rest of this page, so tell the kernel to move the
 250        break up that far.  When the user program examines its break, it
 251        will see this new value and not clobber our data.  */
 252     __sbrk (GLRO(dl_pagesize)
 253             - ((_end - (char *) 0) & (GLRO(dl_pagesize) - 1)));
 254
 255   /* If this is a SUID program we make sure that FDs 0, 1, and 2 are
 256      allocated.  If necessary we are doing it ourself.  If it is not
 257      possible we stop the program.  */
 258   if (__builtin_expect (__libc_enable_secure, 0))
 259     __libc_check_standard_fds ();
 260
 261   (*dl_main) (phdr, phnum, &user_entry, GLRO(dl_auxv));
 262   return user_entry;
 263 }
 264
 265 void
 266 _dl_sysdep_start_cleanup (void)
 267 {
 268 }
 269
 270 void
 271 _dl_show_auxv (void)
 272 {
 273   char buf[64];
 274   ElfW(auxv_t) *av;
 275
 276   /* Terminate string.  */
 277   buf[63] = '\0';
 278
 279   /* The following code assumes that the AT_* values are encoded
 280      starting from 0 with AT_NULL, 1 for AT_IGNORE, and all other values
 281      close by (otherwise the array will be too large).  In case we have
 282      to support a platform where these requirements are not fulfilled
 283      some alternative implementation has to be used.  */
 284   for (av = GLRO(dl_auxv); av->a_type != AT_NULL; ++av)
 285     {
 286       static const struct
 287       {
 288         const char label[22];
 289         enum { unknown = 0, dec, hex, str, ignore } form : 8;
 290       } auxvars[] =
 291         {
 292           [AT_EXECFD - 2] =             { "EXECFD:            ", dec },
 293           [AT_EXECFN - 2] =             { "EXECFN:            ", str },
 294           [AT_PHDR - 2] =               { "PHDR:              0x", hex },
 295           [AT_PHENT - 2] =              { "PHENT:             ", dec },
 296           [AT_PHNUM - 2] =              { "PHNUM:             ", dec },
 297           [AT_PAGESZ - 2] =             { "PAGESZ:            ", dec },
 298           [AT_BASE - 2] =               { "BASE:              0x", hex },
 299           [AT_FLAGS - 2] =              { "FLAGS:             0x", hex },
 300           [AT_ENTRY - 2] =              { "ENTRY:             0x", hex },
 301           [AT_NOTELF - 2] =             { "NOTELF:            ", hex },
 302           [AT_UID - 2] =                { "UID:               ", dec },
 303           [AT_EUID - 2] =               { "EUID:              ", dec },
 304           [AT_GID - 2] =                { "GID:               ", dec },
 305           [AT_EGID - 2] =               { "EGID:              ", dec },
 306           [AT_PLATFORM - 2] =           { "PLATFORM:          ", str },
 307           [AT_HWCAP - 2] =              { "HWCAP:             ", hex },
 308           [AT_CLKTCK - 2] =             { "CLKTCK:            ", dec },
 309           [AT_FPUCW - 2] =              { "FPUCW:             ", hex },
 310           [AT_DCACHEBSIZE - 2] =        { "DCACHEBSIZE:       0x", hex },
 311           [AT_ICACHEBSIZE - 2] =        { "ICACHEBSIZE:       0x", hex },
 312           [AT_UCACHEBSIZE - 2] =        { "UCACHEBSIZE:       0x", hex },
 313           [AT_IGNOREPPC - 2] =          { "IGNOREPPC", ignore },
 314           [AT_SECURE - 2] =             { "SECURE:            ", dec },
 315           [AT_BASE_PLATFORM - 2] =      { "BASE_PLATFORM:     ", str },
 316           [AT_SYSINFO - 2] =            { "SYSINFO:           0x", hex },
 317           [AT_SYSINFO_EHDR - 2] =       { "SYSINFO_EHDR:      0x", hex },
 318           [AT_RANDOM - 2] =             { "RANDOM:            0x", hex },
 319           [AT_HWCAP2 - 2] =             { "HWCAP2:            0x", hex },
 320           [AT_MINSIGSTKSZ - 2] =        { "MINSIGSTKSZ        ", dec },
 321           [AT_L1I_CACHESIZE - 2] =      { "L1I_CACHESIZE:     ", dec },
 322           [AT_L1I_CACHEGEOMETRY - 2] =  { "L1I_CACHEGEOMETRY: 0x", hex },
 323           [AT_L1D_CACHESIZE - 2] =      { "L1D_CACHESIZE:     ", dec },
 324           [AT_L1D_CACHEGEOMETRY - 2] =  { "L1D_CACHEGEOMETRY: 0x", hex },
 325           [AT_L2_CACHESIZE - 2] =       { "L2_CACHESIZE:      ", dec },
 326           [AT_L2_CACHEGEOMETRY - 2] =   { "L2_CACHEGEOMETRY:  0x", hex },
 327           [AT_L3_CACHESIZE - 2] =       { "L3_CACHESIZE:      ", dec },
 328           [AT_L3_CACHEGEOMETRY - 2] =   { "L3_CACHEGEOMETRY:  0x", hex },
 329         };
 330       unsigned int idx = (unsigned int) (av->a_type - 2);
 331
 332       if ((unsigned int) av->a_type < 2u
 333           || (idx < sizeof (auxvars) / sizeof (auxvars[0])
 334               && auxvars[idx].form == ignore))
 335         continue;
 336
 337       assert (AT_NULL == 0);
 338       assert (AT_IGNORE == 1);
 339
 340       /* Some entries are handled in a special way per platform.  */
 341       if (_dl_procinfo (av->a_type, av->a_un.a_val) == 0)
 342         continue;
 343
 344       if (idx < sizeof (auxvars) / sizeof (auxvars[0])
 345           && auxvars[idx].form != unknown)
 346         {
 347           const char *val = (char *) av->a_un.a_val;
 348
 349           if (__builtin_expect (auxvars[idx].form, dec) == dec)
 350             val = _itoa ((unsigned long int) av->a_un.a_val,
 351                          buf + sizeof buf - 1, 10, 0);
 352           else if (__builtin_expect (auxvars[idx].form, hex) == hex)
 353             val = _itoa ((unsigned long int) av->a_un.a_val,
 354                          buf + sizeof buf - 1, 16, 0);
 355
 356           _dl_printf ("AT_%s%s\n", auxvars[idx].label, val);
 357
 358           continue;
 359         }
 360
 361       /* Unknown value: print a generic line.  */
 362       char buf2[17];
 363       buf2[sizeof (buf2) - 1] = '\0';
 364       const char *val2 = _itoa ((unsigned long int) av->a_un.a_val,
 365                                 buf2 + sizeof buf2 - 1, 16, 0);
 366       const char *val =  _itoa ((unsigned long int) av->a_type,
 367                                 buf + sizeof buf - 1, 16, 0);
 368       _dl_printf ("AT_??? (0x%s): 0x%s\n", val, val2);
 369     }
 370 }
 371
 372 #endif