elf/dl-sysdep.c

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