elf/dl-sysdep.c

   1 /* Operating system support for run-time dynamic linker.  Generic Unix version.
   2    Copyright (C) 1995-1998, 2000-2008, 2009 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, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 #include <assert.h>
  21 #include <elf.h>
  22 #include <errno.h>
  23 #include <fcntl.h>
  24 #include <libintl.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <unistd.h>
  28 #include <sys/types.h>
  29 #include <sys/stat.h>
  30 #include <sys/mman.h>
  31 #include <ldsodefs.h>
  32 #include <stdio-common/_itoa.h>
  33 #include <fpu_control.h>
  34
  35 #include <entry.h>
  36 #include <dl-machine.h>
  37 #include <dl-procinfo.h>
  38 #include <dl-osinfo.h>
  39 #include <hp-timing.h>
  40 #include <tls.h>
  41
  42 #ifdef _DL_FIRST_PLATFORM
  43 # define _DL_FIRST_EXTRA (_DL_FIRST_PLATFORM + _DL_PLATFORMS_COUNT)
  44 #else
  45 # define _DL_FIRST_EXTRA _DL_HWCAP_COUNT
  46 #endif
  47
  48 extern char **_environ attribute_hidden;
  49 extern void _end attribute_hidden;
  50
  51 /* Protect SUID program against misuse of file descriptors.  */
  52 extern void __libc_check_standard_fds (void);
  53
  54 #ifdef NEED_DL_BASE_ADDR
  55 ElfW(Addr) _dl_base_addr;
  56 #endif
  57 int __libc_enable_secure attribute_relro = 0;
  58 INTVARDEF(__libc_enable_secure)
  59 int __libc_multiple_libcs = 0;  /* Defining this here avoids the inclusion
  60                                    of init-first.  */
  61 /* This variable contains the lowest stack address ever used.  */
  62 void *__libc_stack_end attribute_relro = NULL;
  63 rtld_hidden_data_def(__libc_stack_end)
  64 static ElfW(auxv_t) *_dl_auxv attribute_relro;
  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))
  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, INTUSE(_dl_argv), _environ,
 114                           _dl_auxv);
 115
 116   user_entry = (ElfW(Addr)) ENTRY_POINT;
 117   GLRO(dl_platform) = NULL; /* Default to nothing known about the platform.  */
 118
 119   for (av = _dl_auxv; av->a_type != AT_NULL; set_seen (av++))
 120     switch (av->a_type)
 121       {
 122       case AT_PHDR:
 123         phdr = (void *) av->a_un.a_val;
 124         break;
 125       case AT_PHNUM:
 126         phnum = av->a_un.a_val;
 127         break;
 128       case AT_PAGESZ:
 129         GLRO(dl_pagesize) = av->a_un.a_val;
 130         break;
 131       case AT_ENTRY:
 132         user_entry = av->a_un.a_val;
 133         break;
 134 #ifdef NEED_DL_BASE_ADDR
 135       case AT_BASE:
 136         _dl_base_addr = av->a_un.a_val;
 137         break;
 138 #endif
 139 #ifndef HAVE_AUX_SECURE
 140       case AT_UID:
 141       case AT_EUID:
 142         uid ^= av->a_un.a_val;
 143         break;
 144       case AT_GID:
 145       case AT_EGID:
 146         gid ^= av->a_un.a_val;
 147         break;
 148 #endif
 149       case AT_SECURE:
 150 #ifndef HAVE_AUX_SECURE
 151         seen = -1;
 152 #endif
 153         INTUSE(__libc_enable_secure) = av->a_un.a_val;
 154         break;
 155       case AT_PLATFORM:
 156         GLRO(dl_platform) = (void *) av->a_un.a_val;
 157         break;
 158       case AT_HWCAP:
 159         GLRO(dl_hwcap) = (unsigned long int) av->a_un.a_val;
 160         break;
 161       case AT_CLKTCK:
 162         GLRO(dl_clktck) = av->a_un.a_val;
 163         break;
 164       case AT_FPUCW:
 165         GLRO(dl_fpu_control) = av->a_un.a_val;
 166         break;
 167 #ifdef NEED_DL_SYSINFO
 168       case AT_SYSINFO:
 169         new_sysinfo = av->a_un.a_val;
 170         break;
 171 #endif
 172 #if defined NEED_DL_SYSINFO || defined NEED_DL_SYSINFO_DSO
 173       case AT_SYSINFO_EHDR:
 174         GLRO(dl_sysinfo_dso) = (void *) av->a_un.a_val;
 175         break;
 176 #endif
 177       case AT_RANDOM:
 178         _dl_random = (void *) av->a_un.a_val;
 179         break;
 180 #ifdef DL_PLATFORM_AUXV
 181       DL_PLATFORM_AUXV
 182 #endif
 183       }
 184
 185 #ifndef HAVE_AUX_SECURE
 186   if (seen != -1)
 187     {
 188       /* Fill in the values we have not gotten from the kernel through the
 189          auxiliary vector.  */
 190 # ifndef HAVE_AUX_XID
 191 #  define SEE(UID, var, uid) \
 192    if ((seen & M (AT_##UID)) == 0) var ^= __get##uid ()
 193       SEE (UID, uid, uid);
 194       SEE (EUID, uid, euid);
 195       SEE (GID, gid, gid);
 196       SEE (EGID, gid, egid);
 197 # endif
 198
 199       /* If one of the two pairs of IDs does not match this is a setuid
 200          or setgid run.  */
 201       INTUSE(__libc_enable_secure) = uid | gid;
 202     }
 203 #endif
 204
 205 #ifndef HAVE_AUX_PAGESIZE
 206   if (GLRO(dl_pagesize) == 0)
 207     GLRO(dl_pagesize) = __getpagesize ();
 208 #endif
 209
 210 #if defined NEED_DL_SYSINFO
 211   /* Only set the sysinfo value if we also have the vsyscall DSO.  */
 212   if (GLRO(dl_sysinfo_dso) != 0 && new_sysinfo)
 213     GLRO(dl_sysinfo) = new_sysinfo;
 214 #endif
 215
 216 #ifdef DL_SYSDEP_INIT
 217   DL_SYSDEP_INIT;
 218 #endif
 219
 220 #ifdef DL_PLATFORM_INIT
 221   DL_PLATFORM_INIT;
 222 #endif
 223
 224   /* Determine the length of the platform name.  */
 225   if (GLRO(dl_platform) != NULL)
 226     GLRO(dl_platformlen) = strlen (GLRO(dl_platform));
 227
 228   if (__sbrk (0) == &_end)
 229     /* The dynamic linker was run as a program, and so the initial break
 230        starts just after our bss, at &_end.  The malloc in dl-minimal.c
 231        will consume the rest of this page, so tell the kernel to move the
 232        break up that far.  When the user program examines its break, it
 233        will see this new value and not clobber our data.  */
 234     __sbrk (GLRO(dl_pagesize)
 235             - ((&_end - (void *) 0) & (GLRO(dl_pagesize) - 1)));
 236
 237   /* If this is a SUID program we make sure that FDs 0, 1, and 2 are
 238      allocated.  If necessary we are doing it ourself.  If it is not
 239      possible we stop the program.  */
 240   if (__builtin_expect (INTUSE(__libc_enable_secure), 0))
 241     __libc_check_standard_fds ();
 242
 243   (*dl_main) (phdr, phnum, &user_entry);
 244   return user_entry;
 245 }
 246
 247 void
 248 internal_function
 249 _dl_sysdep_start_cleanup (void)
 250 {
 251 }
 252
 253 void
 254 internal_function
 255 _dl_show_auxv (void)
 256 {
 257   char buf[64];
 258   ElfW(auxv_t) *av;
 259
 260   /* Terminate string.  */
 261   buf[63] = '\0';
 262
 263   /* The following code assumes that the AT_* values are encoded
 264      starting from 0 with AT_NULL, 1 for AT_IGNORE, and all other values
 265      close by (otherwise the array will be too large).  In case we have
 266      to support a platform where these requirements are not fulfilled
 267      some alternative implementation has to be used.  */
 268   for (av = _dl_auxv; av->a_type != AT_NULL; ++av)
 269     {
 270       static const struct
 271       {
 272         const char label[17];
 273         enum { unknown = 0, dec, hex, str, ignore } form : 8;
 274       } auxvars[] =
 275         {
 276           [AT_EXECFD - 2] =             { "EXECFD:       ", dec },
 277           [AT_EXECFN - 2] =             { "EXECFN:       ", str },
 278           [AT_PHDR - 2] =               { "PHDR:         0x", hex },
 279           [AT_PHENT - 2] =              { "PHENT:        ", dec },
 280           [AT_PHNUM - 2] =              { "PHNUM:        ", dec },
 281           [AT_PAGESZ - 2] =             { "PAGESZ:       ", dec },
 282           [AT_BASE - 2] =               { "BASE:         0x", hex },
 283           [AT_FLAGS - 2] =              { "FLAGS:        0x", hex },
 284           [AT_ENTRY - 2] =              { "ENTRY:        0x", hex },
 285           [AT_NOTELF - 2] =             { "NOTELF:       ", hex },
 286           [AT_UID - 2] =                { "UID:          ", dec },
 287           [AT_EUID - 2] =               { "EUID:         ", dec },
 288           [AT_GID - 2] =                { "GID:          ", dec },
 289           [AT_EGID - 2] =               { "EGID:         ", dec },
 290           [AT_PLATFORM - 2] =           { "PLATFORM:     ", str },
 291           [AT_HWCAP - 2] =              { "HWCAP:        ", hex },
 292           [AT_CLKTCK - 2] =             { "CLKTCK:       ", dec },
 293           [AT_FPUCW - 2] =              { "FPUCW:        ", hex },
 294           [AT_DCACHEBSIZE - 2] =        { "DCACHEBSIZE:  0x", hex },
 295           [AT_ICACHEBSIZE - 2] =        { "ICACHEBSIZE:  0x", hex },
 296           [AT_UCACHEBSIZE - 2] =        { "UCACHEBSIZE:  0x", hex },
 297           [AT_IGNOREPPC - 2] =          { "IGNOREPPC", ignore },
 298           [AT_SECURE - 2] =             { "SECURE:       ", dec },
 299           [AT_BASE_PLATFORM - 2] =      { "BASE_PLATFORM:", str },
 300           [AT_SYSINFO - 2] =            { "SYSINFO:      0x", hex },
 301           [AT_SYSINFO_EHDR - 2] =       { "SYSINFO_EHDR: 0x", hex },
 302           [AT_RANDOM - 2] =             { "RANDOM:       0x", hex },
 303         };
 304       unsigned int idx = (unsigned int) (av->a_type - 2);
 305
 306       if ((unsigned int) av->a_type < 2u || auxvars[idx].form == ignore)
 307         continue;
 308
 309       assert (AT_NULL == 0);
 310       assert (AT_IGNORE == 1);
 311
 312       if (av->a_type == AT_HWCAP)
 313         {
 314           /* This is handled special.  */
 315           if (_dl_procinfo (av->a_un.a_val) == 0)
 316             continue;
 317         }
 318
 319       if (idx < sizeof (auxvars) / sizeof (auxvars[0])
 320           && auxvars[idx].form != unknown)
 321         {
 322           const char *val = (char *) av->a_un.a_val;
 323
 324           if (__builtin_expect (auxvars[idx].form, dec) == dec)
 325             val = _itoa ((unsigned long int) av->a_un.a_val,
 326                          buf + sizeof buf - 1, 10, 0);
 327           else if (__builtin_expect (auxvars[idx].form, hex) == hex)
 328             val = _itoa ((unsigned long int) av->a_un.a_val,
 329                          buf + sizeof buf - 1, 16, 0);
 330
 331           _dl_printf ("AT_%s%s\n", auxvars[idx].label, val);
 332
 333           continue;
 334         }
 335
 336       /* Unknown value: print a generic line.  */
 337       char buf2[17];
 338       buf2[sizeof (buf2) - 1] = '\0';
 339       const char *val2 = _itoa ((unsigned long int) av->a_un.a_val,
 340                                 buf2 + sizeof buf2 - 1, 16, 0);
 341       const char *val =  _itoa ((unsigned long int) av->a_type,
 342                                 buf + sizeof buf - 1, 16, 0);
 343       _dl_printf ("AT_??? (0x%s): 0x%s\n", val, val2);
 344     }
 345 }
 346
 347
 348 /* Return an array of useful/necessary hardware capability names.  */
 349 const struct r_strlenpair *
 350 internal_function
 351 _dl_important_hwcaps (const char *platform, size_t platform_len, size_t *sz,
 352                       size_t *max_capstrlen)
 353 {
 354   /* Determine how many important bits are set.  */
 355   uint64_t masked = GLRO(dl_hwcap) & GLRO(dl_hwcap_mask);
 356   size_t cnt = platform != NULL;
 357   size_t n, m;
 358   size_t total;
 359   struct r_strlenpair *temp;
 360   struct r_strlenpair *result;
 361   struct r_strlenpair *rp;
 362   char *cp;
 363
 364   /* Count the number of bits set in the masked value.  */
 365   for (n = 0; (~((1ULL << n) - 1) & masked) != 0; ++n)
 366     if ((masked & (1ULL << n)) != 0)
 367       ++cnt;
 368
 369 #if (defined NEED_DL_SYSINFO || defined NEED_DL_SYSINFO_DSO) && defined SHARED
 370   /* The system-supplied DSO can contain a note of type 2, vendor "GNU".
 371      This gives us a list of names to treat as fake hwcap bits.  */
 372
 373   const char *dsocaps = NULL;
 374   size_t dsocapslen = 0;
 375   if (GLRO(dl_sysinfo_map) != NULL)
 376     {
 377       const ElfW(Phdr) *const phdr = GLRO(dl_sysinfo_map)->l_phdr;
 378       const ElfW(Word) phnum = GLRO(dl_sysinfo_map)->l_phnum;
 379       for (uint_fast16_t i = 0; i < phnum; ++i)
 380         if (phdr[i].p_type == PT_NOTE)
 381           {
 382             const ElfW(Addr) start = (phdr[i].p_vaddr
 383                                       + GLRO(dl_sysinfo_map)->l_addr);
 384             const struct
 385             {
 386               ElfW(Word) vendorlen;
 387               ElfW(Word) datalen;
 388               ElfW(Word) type;
 389             } *note = (const void *) start;
 390             while ((ElfW(Addr)) (note + 1) - start < phdr[i].p_memsz)
 391               {
 392 #define ROUND(len) (((len) + sizeof (ElfW(Word)) - 1) & -sizeof (ElfW(Word)))
 393                 if (note->type == 2
 394                     && note->vendorlen == sizeof "GNU"
 395                     && !memcmp ((note + 1), "GNU", sizeof "GNU")
 396                     && note->datalen > 2 * sizeof (ElfW(Word)) + 2)
 397                   {
 398                     const ElfW(Word) *p = ((const void *) (note + 1)
 399                                            + ROUND (sizeof "GNU"));
 400                     cnt += *p++;
 401                     ++p;        /* Skip mask word.  */
 402                     dsocaps = (const char *) p;
 403                     dsocapslen = note->datalen - sizeof *p * 2;
 404                     break;
 405                   }
 406                 note = ((const void *) (note + 1)
 407                         + ROUND (note->vendorlen) + ROUND (note->datalen));
 408 #undef ROUND
 409               }
 410             if (dsocaps != NULL)
 411               break;
 412           }
 413     }
 414 #endif
 415
 416   /* For TLS enabled builds always add 'tls'.  */
 417   ++cnt;
 418
 419   /* Create temporary data structure to generate result table.  */
 420   temp = (struct r_strlenpair *) alloca (cnt * sizeof (*temp));
 421   m = 0;
 422 #if defined NEED_DL_SYSINFO || defined NEED_DL_SYSINFO_DSO
 423   if (dsocaps != NULL)
 424     {
 425       const ElfW(Word) mask = ((const ElfW(Word) *) dsocaps)[-1];
 426       GLRO(dl_hwcap) |= (uint64_t) mask << _DL_FIRST_EXTRA;
 427       /* Note that we add the dsocaps to the set already chosen by the
 428          LD_HWCAP_MASK environment variable (or default HWCAP_IMPORTANT).
 429          So there is no way to request ignoring an OS-supplied dsocap
 430          string and bit like you can ignore an OS-supplied HWCAP bit.  */
 431       GLRO(dl_hwcap_mask) |= (uint64_t) mask << _DL_FIRST_EXTRA;
 432       size_t len;
 433       for (const char *p = dsocaps; p < dsocaps + dsocapslen; p += len + 1)
 434         {
 435           uint_fast8_t bit = *p++;
 436           len = strlen (p);
 437
 438           /* Skip entries that are not enabled in the mask word.  */
 439           if (__builtin_expect (mask & ((ElfW(Word)) 1 << bit), 1))
 440             {
 441               temp[m].str = p;
 442               temp[m].len = len;
 443               ++m;
 444             }
 445           else
 446             --cnt;
 447         }
 448     }
 449 #endif
 450   for (n = 0; masked != 0; ++n)
 451     if ((masked & (1ULL << n)) != 0)
 452       {
 453         temp[m].str = _dl_hwcap_string (n);
 454         temp[m].len = strlen (temp[m].str);
 455         masked ^= 1ULL << n;
 456         ++m;
 457       }
 458   if (platform != NULL)
 459     {
 460       temp[m].str = platform;
 461       temp[m].len = platform_len;
 462       ++m;
 463     }
 464
 465   temp[m].str = "tls";
 466   temp[m].len = 3;
 467   ++m;
 468
 469   assert (m == cnt);
 470
 471   /* Determine the total size of all strings together.  */
 472   if (cnt == 1)
 473     total = temp[0].len + 1;
 474   else
 475     {
 476       total = temp[0].len + temp[cnt - 1].len + 2;
 477       if (cnt > 2)
 478         {
 479           total <<= 1;
 480           for (n = 1; n + 1 < cnt; ++n)
 481             total += temp[n].len + 1;
 482           if (cnt > 3
 483               && (cnt >= sizeof (size_t) * 8
 484                   || total + (sizeof (*result) << 3)
 485                      >= (1UL << (sizeof (size_t) * 8 - cnt + 3))))
 486             _dl_signal_error (ENOMEM, NULL, NULL,
 487                               N_("cannot create capability list"));
 488
 489           total <<= cnt - 3;
 490         }
 491     }
 492
 493   /* The result structure: we use a very compressed way to store the
 494      various combinations of capability names.  */
 495   *sz = 1 << cnt;
 496   result = (struct r_strlenpair *) malloc (*sz * sizeof (*result) + total);
 497   if (result == NULL)
 498     _dl_signal_error (ENOMEM, NULL, NULL,
 499                       N_("cannot create capability list"));
 500
 501   if (cnt == 1)
 502     {
 503       result[0].str = (char *) (result + *sz);
 504       result[0].len = temp[0].len + 1;
 505       result[1].str = (char *) (result + *sz);
 506       result[1].len = 0;
 507       cp = __mempcpy ((char *) (result + *sz), temp[0].str, temp[0].len);
 508       *cp = '/';
 509       *sz = 2;
 510       *max_capstrlen = result[0].len;
 511
 512       return result;
 513     }
 514
 515   /* Fill in the information.  This follows the following scheme
 516      (indeces from TEMP for four strings):
 517         entry #0: 0, 1, 2, 3    binary: 1111
 518               #1: 0, 1, 3               1101
 519               #2: 0, 2, 3               1011
 520               #3: 0, 3                  1001
 521      This allows the representation of all possible combinations of
 522      capability names in the string.  First generate the strings.  */
 523   result[1].str = result[0].str = cp = (char *) (result + *sz);
 524 #define add(idx) \
 525       cp = __mempcpy (__mempcpy (cp, temp[idx].str, temp[idx].len), "/", 1);
 526   if (cnt == 2)
 527     {
 528       add (1);
 529       add (0);
 530     }
 531   else
 532     {
 533       n = 1 << (cnt - 1);
 534       do
 535         {
 536           n -= 2;
 537
 538           /* We always add the last string.  */
 539           add (cnt - 1);
 540
 541           /* Add the strings which have the bit set in N.  */
 542           for (m = cnt - 2; m > 0; --m)
 543             if ((n & (1 << m)) != 0)
 544               add (m);
 545
 546           /* Always add the first string.  */
 547           add (0);
 548         }
 549       while (n != 0);
 550     }
 551 #undef add
 552
 553   /* Now we are ready to install the string pointers and length.  */
 554   for (n = 0; n < (1UL << cnt); ++n)
 555     result[n].len = 0;
 556   n = cnt;
 557   do
 558     {
 559       size_t mask = 1 << --n;
 560
 561       rp = result;
 562       for (m = 1 << cnt; m > 0; ++rp)
 563         if ((--m & mask) != 0)
 564           rp->len += temp[n].len + 1;
 565     }
 566   while (n != 0);
 567
 568   /* The first half of the strings all include the first string.  */
 569   n = (1 << cnt) - 2;
 570   rp = &result[2];
 571   while (n != (1UL << (cnt - 1)))
 572     {
 573       if ((--n & 1) != 0)
 574         rp[0].str = rp[-2].str + rp[-2].len;
 575       else
 576         rp[0].str = rp[-1].str;
 577       ++rp;
 578     }
 579
 580   /* The second half starts right after the first part of the string of
 581      the corresponding entry in the first half.  */
 582   do
 583     {
 584       rp[0].str = rp[-(1 << (cnt - 1))].str + temp[cnt - 1].len + 1;
 585       ++rp;
 586     }
 587   while (--n != 0);
 588
 589   /* The maximum string length.  */
 590   *max_capstrlen = result[0].len;
 591
 592   return result;
 593 }