elf/dl-sysdep.c

   1 /* Operating system support for run-time dynamic linker.  Generic Unix version.
   2    Copyright (C) 1995-1998,2000-2010,2012
   3         Free Software Foundation, Inc.
   4    This file is part of the GNU C Library.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, see
  18    <http://www.gnu.org/licenses/>.  */
  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 <_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 char _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, 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, 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 - (char *) 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, _dl_auxv);
 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
 307           || (idx < sizeof (auxvars) / sizeof (auxvars[0])
 308               && auxvars[idx].form == ignore))
 309         continue;
 310
 311       assert (AT_NULL == 0);
 312       assert (AT_IGNORE == 1);
 313
 314       if (av->a_type == AT_HWCAP)
 315         {
 316           /* This is handled special.  */
 317           if (_dl_procinfo (av->a_un.a_val) == 0)
 318             continue;
 319         }
 320
 321       if (idx < sizeof (auxvars) / sizeof (auxvars[0])
 322           && auxvars[idx].form != unknown)
 323         {
 324           const char *val = (char *) av->a_un.a_val;
 325
 326           if (__builtin_expect (auxvars[idx].form, dec) == dec)
 327             val = _itoa ((unsigned long int) av->a_un.a_val,
 328                          buf + sizeof buf - 1, 10, 0);
 329           else if (__builtin_expect (auxvars[idx].form, hex) == hex)
 330             val = _itoa ((unsigned long int) av->a_un.a_val,
 331                          buf + sizeof buf - 1, 16, 0);
 332
 333           _dl_printf ("AT_%s%s\n", auxvars[idx].label, val);
 334
 335           continue;
 336         }
 337
 338       /* Unknown value: print a generic line.  */
 339       char buf2[17];
 340       buf2[sizeof (buf2) - 1] = '\0';
 341       const char *val2 = _itoa ((unsigned long int) av->a_un.a_val,
 342                                 buf2 + sizeof buf2 - 1, 16, 0);
 343       const char *val =  _itoa ((unsigned long int) av->a_type,
 344                                 buf + sizeof buf - 1, 16, 0);
 345       _dl_printf ("AT_??? (0x%s): 0x%s\n", val, val2);
 346     }
 347 }
 348
 349
 350 /* Return an array of useful/necessary hardware capability names.  */
 351 const struct r_strlenpair *
 352 internal_function
 353 _dl_important_hwcaps (const char *platform, size_t platform_len, size_t *sz,
 354                       size_t *max_capstrlen)
 355 {
 356   /* Determine how many important bits are set.  */
 357   uint64_t masked = GLRO(dl_hwcap) & GLRO(dl_hwcap_mask);
 358   size_t cnt = platform != NULL;
 359   size_t n, m;
 360   size_t total;
 361   struct r_strlenpair *temp;
 362   struct r_strlenpair *result;
 363   struct r_strlenpair *rp;
 364   char *cp;
 365
 366   /* Count the number of bits set in the masked value.  */
 367   for (n = 0; (~((1ULL << n) - 1) & masked) != 0; ++n)
 368     if ((masked & (1ULL << n)) != 0)
 369       ++cnt;
 370
 371 #if (defined NEED_DL_SYSINFO || defined NEED_DL_SYSINFO_DSO) && defined SHARED
 372   /* The system-supplied DSO can contain a note of type 2, vendor "GNU".
 373      This gives us a list of names to treat as fake hwcap bits.  */
 374
 375   const char *dsocaps = NULL;
 376   size_t dsocapslen = 0;
 377   if (GLRO(dl_sysinfo_map) != NULL)
 378     {
 379       const ElfW(Phdr) *const phdr = GLRO(dl_sysinfo_map)->l_phdr;
 380       const ElfW(Word) phnum = GLRO(dl_sysinfo_map)->l_phnum;
 381       for (uint_fast16_t i = 0; i < phnum; ++i)
 382         if (phdr[i].p_type == PT_NOTE)
 383           {
 384             const ElfW(Addr) start = (phdr[i].p_vaddr
 385                                       + GLRO(dl_sysinfo_map)->l_addr);
 386             const struct
 387             {
 388               ElfW(Word) vendorlen;
 389               ElfW(Word) datalen;
 390               ElfW(Word) type;
 391             } *note = (const void *) start;
 392             while ((ElfW(Addr)) (note + 1) - start < phdr[i].p_memsz)
 393               {
 394 #define ROUND(len) (((len) + sizeof (ElfW(Word)) - 1) & -sizeof (ElfW(Word)))
 395                 if (note->type == NT_GNU_HWCAP
 396                     && note->vendorlen == sizeof "GNU"
 397                     && !memcmp ((note + 1), "GNU", sizeof "GNU")
 398                     && note->datalen > 2 * sizeof (ElfW(Word)) + 2)
 399                   {
 400                     const ElfW(Word) *p = ((const void *) (note + 1)
 401                                            + ROUND (sizeof "GNU"));
 402                     cnt += *p++;
 403                     ++p;        /* Skip mask word.  */
 404                     dsocaps = (const char *) p;
 405                     dsocapslen = note->datalen - sizeof *p * 2;
 406                     break;
 407                   }
 408                 note = ((const void *) (note + 1)
 409                         + ROUND (note->vendorlen) + ROUND (note->datalen));
 410 #undef ROUND
 411               }
 412             if (dsocaps != NULL)
 413               break;
 414           }
 415     }
 416 #endif
 417
 418   /* For TLS enabled builds always add 'tls'.  */
 419   ++cnt;
 420
 421   /* Create temporary data structure to generate result table.  */
 422   temp = (struct r_strlenpair *) alloca (cnt * sizeof (*temp));
 423   m = 0;
 424 #if defined NEED_DL_SYSINFO || defined NEED_DL_SYSINFO_DSO
 425   if (dsocaps != NULL)
 426     {
 427       const ElfW(Word) mask = ((const ElfW(Word) *) dsocaps)[-1];
 428       GLRO(dl_hwcap) |= (uint64_t) mask << _DL_FIRST_EXTRA;
 429       /* Note that we add the dsocaps to the set already chosen by the
 430          LD_HWCAP_MASK environment variable (or default HWCAP_IMPORTANT).
 431          So there is no way to request ignoring an OS-supplied dsocap
 432          string and bit like you can ignore an OS-supplied HWCAP bit.  */
 433       GLRO(dl_hwcap_mask) |= (uint64_t) mask << _DL_FIRST_EXTRA;
 434       size_t len;
 435       for (const char *p = dsocaps; p < dsocaps + dsocapslen; p += len + 1)
 436         {
 437           uint_fast8_t bit = *p++;
 438           len = strlen (p);
 439
 440           /* Skip entries that are not enabled in the mask word.  */
 441           if (__builtin_expect (mask & ((ElfW(Word)) 1 << bit), 1))
 442             {
 443               temp[m].str = p;
 444               temp[m].len = len;
 445               ++m;
 446             }
 447           else
 448             --cnt;
 449         }
 450     }
 451 #endif
 452   for (n = 0; masked != 0; ++n)
 453     if ((masked & (1ULL << n)) != 0)
 454       {
 455         temp[m].str = _dl_hwcap_string (n);
 456         temp[m].len = strlen (temp[m].str);
 457         masked ^= 1ULL << n;
 458         ++m;
 459       }
 460   if (platform != NULL)
 461     {
 462       temp[m].str = platform;
 463       temp[m].len = platform_len;
 464       ++m;
 465     }
 466
 467   temp[m].str = "tls";
 468   temp[m].len = 3;
 469   ++m;
 470
 471   assert (m == cnt);
 472
 473   /* Determine the total size of all strings together.  */
 474   if (cnt == 1)
 475     total = temp[0].len + 1;
 476   else
 477     {
 478       total = temp[0].len + temp[cnt - 1].len + 2;
 479       if (cnt > 2)
 480         {
 481           total <<= 1;
 482           for (n = 1; n + 1 < cnt; ++n)
 483             total += temp[n].len + 1;
 484           if (cnt > 3
 485               && (cnt >= sizeof (size_t) * 8
 486                   || total + (sizeof (*result) << 3)
 487                      >= (1UL << (sizeof (size_t) * 8 - cnt + 3))))
 488             _dl_signal_error (ENOMEM, NULL, NULL,
 489                               N_("cannot create capability list"));
 490
 491           total <<= cnt - 3;
 492         }
 493     }
 494
 495   /* The result structure: we use a very compressed way to store the
 496      various combinations of capability names.  */
 497   *sz = 1 << cnt;
 498   result = (struct r_strlenpair *) malloc (*sz * sizeof (*result) + total);
 499   if (result == NULL)
 500     _dl_signal_error (ENOMEM, NULL, NULL,
 501                       N_("cannot create capability list"));
 502
 503   if (cnt == 1)
 504     {
 505       result[0].str = (char *) (result + *sz);
 506       result[0].len = temp[0].len + 1;
 507       result[1].str = (char *) (result + *sz);
 508       result[1].len = 0;
 509       cp = __mempcpy ((char *) (result + *sz), temp[0].str, temp[0].len);
 510       *cp = '/';
 511       *sz = 2;
 512       *max_capstrlen = result[0].len;
 513
 514       return result;
 515     }
 516
 517   /* Fill in the information.  This follows the following scheme
 518      (indeces from TEMP for four strings):
 519         entry #0: 0, 1, 2, 3    binary: 1111
 520               #1: 0, 1, 3               1101
 521               #2: 0, 2, 3               1011
 522               #3: 0, 3                  1001
 523      This allows the representation of all possible combinations of
 524      capability names in the string.  First generate the strings.  */
 525   result[1].str = result[0].str = cp = (char *) (result + *sz);
 526 #define add(idx) \
 527       cp = __mempcpy (__mempcpy (cp, temp[idx].str, temp[idx].len), "/", 1);
 528   if (cnt == 2)
 529     {
 530       add (1);
 531       add (0);
 532     }
 533   else
 534     {
 535       n = 1 << (cnt - 1);
 536       do
 537         {
 538           n -= 2;
 539
 540           /* We always add the last string.  */
 541           add (cnt - 1);
 542
 543           /* Add the strings which have the bit set in N.  */
 544           for (m = cnt - 2; m > 0; --m)
 545             if ((n & (1 << m)) != 0)
 546               add (m);
 547
 548           /* Always add the first string.  */
 549           add (0);
 550         }
 551       while (n != 0);
 552     }
 553 #undef add
 554
 555   /* Now we are ready to install the string pointers and length.  */
 556   for (n = 0; n < (1UL << cnt); ++n)
 557     result[n].len = 0;
 558   n = cnt;
 559   do
 560     {
 561       size_t mask = 1 << --n;
 562
 563       rp = result;
 564       for (m = 1 << cnt; m > 0; ++rp)
 565         if ((--m & mask) != 0)
 566           rp->len += temp[n].len + 1;
 567     }
 568   while (n != 0);
 569
 570   /* The first half of the strings all include the first string.  */
 571   n = (1 << cnt) - 2;
 572   rp = &result[2];
 573   while (n != (1UL << (cnt - 1)))
 574     {
 575       if ((--n & 1) != 0)
 576         rp[0].str = rp[-2].str + rp[-2].len;
 577       else
 578         rp[0].str = rp[-1].str;
 579       ++rp;
 580     }
 581
 582   /* The second half starts right after the first part of the string of
 583      the corresponding entry in the first half.  */
 584   do
 585     {
 586       rp[0].str = rp[-(1 << (cnt - 1))].str + temp[cnt - 1].len + 1;
 587       ++rp;
 588     }
 589   while (--n != 0);
 590
 591   /* The maximum string length.  */
 592   *max_capstrlen = result[0].len;
 593
 594   return result;
 595 }