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       size_t len;
 428       for (const char *p = dsocaps; p < dsocaps + dsocapslen; p += len + 1)
 429         {
 430           uint_fast8_t bit = *p++;
 431           len = strlen (p);
 432
 433           /* Skip entries that are not enabled in the mask word.  */
 434           if (__builtin_expect (mask & ((ElfW(Word)) 1 << bit), 1))
 435             {
 436               temp[m].str = p;
 437               temp[m].len = len;
 438               ++m;
 439             }
 440           else
 441             --cnt;
 442         }
 443     }
 444 #endif
 445   for (n = 0; masked != 0; ++n)
 446     if ((masked & (1ULL << n)) != 0)
 447       {
 448         temp[m].str = _dl_hwcap_string (n);
 449         temp[m].len = strlen (temp[m].str);
 450         masked ^= 1ULL << n;
 451         ++m;
 452       }
 453   if (platform != NULL)
 454     {
 455       temp[m].str = platform;
 456       temp[m].len = platform_len;
 457       ++m;
 458     }
 459
 460   temp[m].str = "tls";
 461   temp[m].len = 3;
 462   ++m;
 463
 464   assert (m == cnt);
 465
 466   /* Determine the total size of all strings together.  */
 467   if (cnt == 1)
 468     total = temp[0].len + 1;
 469   else
 470     {
 471       total = temp[0].len + temp[cnt - 1].len + 2;
 472       if (cnt > 2)
 473         {
 474           total <<= 1;
 475           for (n = 1; n + 1 < cnt; ++n)
 476             total += temp[n].len + 1;
 477           if (cnt > 3
 478               && (cnt >= sizeof (size_t) * 8
 479                   || total + (sizeof (*result) << 3)
 480                      >= (1UL << (sizeof (size_t) * 8 - cnt + 3))))
 481             _dl_signal_error (ENOMEM, NULL, NULL,
 482                               N_("cannot create capability list"));
 483
 484           total <<= cnt - 3;
 485         }
 486     }
 487
 488   /* The result structure: we use a very compressed way to store the
 489      various combinations of capability names.  */
 490   *sz = 1 << cnt;
 491   result = (struct r_strlenpair *) malloc (*sz * sizeof (*result) + total);
 492   if (result == NULL)
 493     _dl_signal_error (ENOMEM, NULL, NULL,
 494                       N_("cannot create capability list"));
 495
 496   if (cnt == 1)
 497     {
 498       result[0].str = (char *) (result + *sz);
 499       result[0].len = temp[0].len + 1;
 500       result[1].str = (char *) (result + *sz);
 501       result[1].len = 0;
 502       cp = __mempcpy ((char *) (result + *sz), temp[0].str, temp[0].len);
 503       *cp = '/';
 504       *sz = 2;
 505       *max_capstrlen = result[0].len;
 506
 507       return result;
 508     }
 509
 510   /* Fill in the information.  This follows the following scheme
 511      (indeces from TEMP for four strings):
 512         entry #0: 0, 1, 2, 3    binary: 1111
 513               #1: 0, 1, 3               1101
 514               #2: 0, 2, 3               1011
 515               #3: 0, 3                  1001
 516      This allows the representation of all possible combinations of
 517      capability names in the string.  First generate the strings.  */
 518   result[1].str = result[0].str = cp = (char *) (result + *sz);
 519 #define add(idx) \
 520       cp = __mempcpy (__mempcpy (cp, temp[idx].str, temp[idx].len), "/", 1);
 521   if (cnt == 2)
 522     {
 523       add (1);
 524       add (0);
 525     }
 526   else
 527     {
 528       n = 1 << (cnt - 1);
 529       do
 530         {
 531           n -= 2;
 532
 533           /* We always add the last string.  */
 534           add (cnt - 1);
 535
 536           /* Add the strings which have the bit set in N.  */
 537           for (m = cnt - 2; m > 0; --m)
 538             if ((n & (1 << m)) != 0)
 539               add (m);
 540
 541           /* Always add the first string.  */
 542           add (0);
 543         }
 544       while (n != 0);
 545     }
 546 #undef add
 547
 548   /* Now we are ready to install the string pointers and length.  */
 549   for (n = 0; n < (1UL << cnt); ++n)
 550     result[n].len = 0;
 551   n = cnt;
 552   do
 553     {
 554       size_t mask = 1 << --n;
 555
 556       rp = result;
 557       for (m = 1 << cnt; m > 0; ++rp)
 558         if ((--m & mask) != 0)
 559           rp->len += temp[n].len + 1;
 560     }
 561   while (n != 0);
 562
 563   /* The first half of the strings all include the first string.  */
 564   n = (1 << cnt) - 2;
 565   rp = &result[2];
 566   while (n != (1UL << (cnt - 1)))
 567     {
 568       if ((--n & 1) != 0)
 569         rp[0].str = rp[-2].str + rp[-2].len;
 570       else
 571         rp[0].str = rp[-1].str;
 572       ++rp;
 573     }
 574
 575   /* The second half starts right after the first part of the string of
 576      the corresponding entry in the first half.  */
 577   do
 578     {
 579       rp[0].str = rp[-(1 << (cnt - 1))].str + temp[cnt - 1].len + 1;
 580       ++rp;
 581     }
 582   while (--n != 0);
 583
 584   /* The maximum string length.  */
 585   *max_capstrlen = result[0].len;
 586
 587   return result;
 588 }