elf/dl-sysdep.c

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