elf/dl-sysdep.c

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