elf/dl-load.c

   1 /* _dl_map_object -- Map in a shared object's segments from the file.
   2 Copyright (C) 1995, 1996 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 Library General Public License as
   7 published by the Free Software Foundation; either version 2 of the
   8 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 Library General Public License for more details.
  14
  15 You should have received a copy of the GNU Library General Public
  16 License along with the GNU C Library; see the file COPYING.LIB.  If
  17 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
  18 Cambridge, MA 02139, USA.  */
  19
  20 #include <link.h>
  21 #include <sys/types.h>
  22 #include <sys/mman.h>
  23 #include <string.h>
  24 #include <fcntl.h>
  25 #include <unistd.h>
  26 #include <stdlib.h>
  27 #include <errno.h>
  28 #include "dynamic-link.h"
  29
  30
  31 /* On some systems, no flag bits are given to specify file mapping.  */
  32 #ifndef MAP_FILE
  33 #define MAP_FILE        0
  34 #endif
  35
  36 /* The right way to map in the shared library files is MAP_COPY, which
  37    makes a virtual copy of the data at the time of the mmap call; this
  38    guarantees the mapped pages will be consistent even if the file is
  39    overwritten.  Some losing VM systems like Linux's lack MAP_COPY.  All we
  40    get is MAP_PRIVATE, which copies each page when it is modified; this
  41    means if the file is overwritten, we may at some point get some pages
  42    from the new version after starting with pages from the old version.  */
  43 #ifndef MAP_COPY
  44 #define MAP_COPY        MAP_PRIVATE
  45 #endif
  46
  47
  48 #include <endian.h>
  49 #if BYTE_ORDER == BIG_ENDIAN
  50 #define byteorder ELFDATA2MSB
  51 #define byteorder_name "big-endian"
  52 #elif BYTE_ORDER == LITTLE_ENDIAN
  53 #define byteorder ELFDATA2LSB
  54 #define byteorder_name "little-endian"
  55 #else
  56 #error "Unknown BYTE_ORDER " BYTE_ORDER
  57 #define byteorder ELFDATANONE
  58 #endif
  59
  60 #define STRING(x) #x
  61
  62 int _dl_zerofd = -1;
  63 size_t _dl_pagesize;
  64
  65
  66 /* Map in the shared object NAME, actually located in REALNAME, and already
  67    opened on FD.  */
  68
  69 struct link_map *
  70 _dl_map_object_from_fd (const char *name, int fd, char *realname,
  71                         struct link_map *loader, int l_type)
  72 {
  73   struct link_map *l;
  74   void *file_mapping = NULL;
  75   size_t mapping_size = 0;
  76
  77 #define LOSE(s) lose (0, (s))
  78   void lose (int code, const char *msg)
  79     {
  80       (void) __close (fd);
  81       if (file_mapping)
  82         __munmap (file_mapping, mapping_size);
  83       if (l)
  84         {
  85           /* Remove the stillborn object from the list and free it.  */
  86           if (l->l_prev)
  87             l->l_prev->l_next = l->l_next;
  88           if (l->l_next)
  89             l->l_next->l_prev = l->l_prev;
  90           free (l);
  91         }
  92       free (realname);
  93       _dl_signal_error (code, name, msg);
  94     }
  95
  96   inline caddr_t map_segment (ElfW(Addr) mapstart, size_t len,
  97                               int prot, int fixed, off_t offset)
  98     {
  99       caddr_t mapat = __mmap ((caddr_t) mapstart, len, prot,
 100                               fixed|MAP_COPY|MAP_FILE,
 101                               fd, offset);
 102       if (mapat == (caddr_t) -1)
 103         lose (errno, "failed to map segment from shared object");
 104       return mapat;
 105     }
 106
 107   /* Make sure LOCATION is mapped in.  */
 108   void *map (off_t location, size_t size)
 109     {
 110       if ((off_t) mapping_size <= location + (off_t) size)
 111         {
 112           void *result;
 113           if (file_mapping)
 114             __munmap (file_mapping, mapping_size);
 115           mapping_size = (location + size + 1 + _dl_pagesize - 1);
 116           mapping_size &= ~(_dl_pagesize - 1);
 117           result = __mmap (file_mapping, mapping_size, PROT_READ,
 118                            MAP_COPY|MAP_FILE, fd, 0);
 119           if (result == (void *) -1)
 120             lose (errno, "cannot map file data");
 121           file_mapping = result;
 122         }
 123       return file_mapping + location;
 124     }
 125
 126   const ElfW(Ehdr) *header;
 127   const ElfW(Phdr) *phdr;
 128   const ElfW(Phdr) *ph;
 129   int type;
 130
 131   /* Look again to see if the real name matched another already loaded.  */
 132   for (l = _dl_loaded; l; l = l->l_next)
 133     if (! strcmp (realname, l->l_name))
 134       {
 135         /* The object is already loaded.
 136            Just bump its reference count and return it.  */
 137         __close (fd);
 138         free (realname);
 139         ++l->l_opencount;
 140         return l;
 141       }
 142
 143   if (_dl_pagesize == 0)
 144     _dl_pagesize = __getpagesize ();
 145
 146   /* Map in the first page to read the header.  */
 147   header = map (0, sizeof *header);
 148
 149   /* Check the header for basic validity.  */
 150   if (*(Elf32_Word *) &header->e_ident !=
 151 #if BYTE_ORDER == LITTLE_ENDIAN
 152       ((ELFMAG0 << (EI_MAG0 * 8)) |
 153        (ELFMAG1 << (EI_MAG1 * 8)) |
 154        (ELFMAG2 << (EI_MAG2 * 8)) |
 155        (ELFMAG3 << (EI_MAG3 * 8)))
 156 #else
 157       ((ELFMAG0 << (EI_MAG3 * 8)) |
 158        (ELFMAG1 << (EI_MAG2 * 8)) |
 159        (ELFMAG2 << (EI_MAG1 * 8)) |
 160        (ELFMAG3 << (EI_MAG0 * 8)))
 161 #endif
 162       )
 163     LOSE ("invalid ELF header");
 164 #define ELF32_CLASS ELFCLASS32
 165 #define ELF64_CLASS ELFCLASS64
 166   if (header->e_ident[EI_CLASS] != ELFW(CLASS))
 167     LOSE ("ELF file class not " STRING(__ELF_WORDSIZE) "-bit");
 168   if (header->e_ident[EI_DATA] != byteorder)
 169     LOSE ("ELF file data encoding not " byteorder_name);
 170   if (header->e_ident[EI_VERSION] != EV_CURRENT)
 171     LOSE ("ELF file version ident not " STRING(EV_CURRENT));
 172   if (header->e_version != EV_CURRENT)
 173     LOSE ("ELF file version not " STRING(EV_CURRENT));
 174   if (! elf_machine_matches_host (header->e_machine))
 175     LOSE ("ELF file machine architecture not " ELF_MACHINE_NAME);
 176   if (header->e_phentsize != sizeof (ElfW(Phdr)))
 177     LOSE ("ELF file's phentsize not the expected size");
 178
 179   if (_dl_zerofd == -1)
 180     {
 181       _dl_zerofd = _dl_sysdep_open_zero_fill ();
 182       if (_dl_zerofd == -1)
 183         {
 184           __close (fd);
 185           _dl_signal_error (errno, NULL, "cannot open zero fill device");
 186         }
 187     }
 188
 189   /* Enter the new object in the list of loaded objects.  */
 190   l = _dl_new_object (realname, name, l_type);
 191   if (! l)
 192     lose (ENOMEM, "cannot create shared object descriptor");
 193   l->l_opencount = 1;
 194   l->l_loader = loader;
 195
 196   /* Extract the remaining details we need from the ELF header
 197      and then map in the program header table.  */
 198   l->l_entry = header->e_entry;
 199   type = header->e_type;
 200   l->l_phnum = header->e_phnum;
 201   phdr = map (header->e_phoff, l->l_phnum * sizeof (ElfW(Phdr)));
 202
 203   {
 204     /* Scan the program header table, collecting its load commands.  */
 205     struct loadcmd
 206       {
 207         ElfW(Addr) mapstart, mapend, dataend, allocend;
 208         off_t mapoff;
 209         int prot;
 210       } loadcmds[l->l_phnum], *c;
 211     size_t nloadcmds = 0;
 212
 213     l->l_ld = 0;
 214     l->l_phdr = 0;
 215     l->l_addr = 0;
 216     for (ph = phdr; ph < &phdr[l->l_phnum]; ++ph)
 217       switch (ph->p_type)
 218         {
 219           /* These entries tell us where to find things once the file's
 220              segments are mapped in.  We record the addresses it says
 221              verbatim, and later correct for the run-time load address.  */
 222         case PT_DYNAMIC:
 223           l->l_ld = (void *) ph->p_vaddr;
 224           break;
 225         case PT_PHDR:
 226           l->l_phdr = (void *) ph->p_vaddr;
 227           break;
 228
 229         case PT_LOAD:
 230           /* A load command tells us to map in part of the file.
 231              We record the load commands and process them all later.  */
 232           if (ph->p_align % _dl_pagesize != 0)
 233             LOSE ("ELF load command alignment not page-aligned");
 234           if ((ph->p_vaddr - ph->p_offset) % ph->p_align)
 235             LOSE ("ELF load command address/offset not properly aligned");
 236           {
 237             struct loadcmd *c = &loadcmds[nloadcmds++];
 238             c->mapstart = ph->p_vaddr & ~(ph->p_align - 1);
 239             c->mapend = ((ph->p_vaddr + ph->p_filesz + _dl_pagesize - 1)
 240                          & ~(_dl_pagesize - 1));
 241             c->dataend = ph->p_vaddr + ph->p_filesz;
 242             c->allocend = ph->p_vaddr + ph->p_memsz;
 243             c->mapoff = ph->p_offset & ~(ph->p_align - 1);
 244             c->prot = 0;
 245             if (ph->p_flags & PF_R)
 246               c->prot |= PROT_READ;
 247             if (ph->p_flags & PF_W)
 248               c->prot |= PROT_WRITE;
 249             if (ph->p_flags & PF_X)
 250               c->prot |= PROT_EXEC;
 251             break;
 252           }
 253         }
 254
 255     /* We are done reading the file's headers now.  Unmap them.  */
 256     __munmap (file_mapping, mapping_size);
 257
 258     /* Now process the load commands and map segments into memory.  */
 259     c = loadcmds;
 260
 261     if (type == ET_DYN || type == ET_REL)
 262       {
 263         /* This is a position-independent shared object.  We can let the
 264            kernel map it anywhere it likes, but we must have space for all
 265            the segments in their specified positions relative to the first.
 266            So we map the first segment without MAP_FIXED, but with its
 267            extent increased to cover all the segments.  Then we remove
 268            access from excess portion, and there is known sufficient space
 269            there to remap from the later segments.  */
 270         caddr_t mapat;
 271         mapat = map_segment (c->mapstart,
 272                              loadcmds[nloadcmds - 1].allocend - c->mapstart,
 273                              c->prot, 0, c->mapoff);
 274         l->l_addr = (ElfW(Addr)) mapat - c->mapstart;
 275
 276         /* Change protection on the excess portion to disallow all access;
 277            the portions we do not remap later will be inaccessible as if
 278            unallocated.  Then jump into the normal segment-mapping loop to
 279            handle the portion of the segment past the end of the file
 280            mapping.  */
 281         __mprotect ((caddr_t) (l->l_addr + c->mapend),
 282                     loadcmds[nloadcmds - 1].allocend - c->mapend,
 283                     0);
 284         goto postmap;
 285       }
 286
 287     while (c < &loadcmds[nloadcmds])
 288       {
 289         if (c->mapend > c->mapstart)
 290           /* Map the segment contents from the file.  */
 291           map_segment (l->l_addr + c->mapstart, c->mapend - c->mapstart,
 292                        c->prot, MAP_FIXED, c->mapoff);
 293
 294       postmap:
 295         if (c->allocend > c->dataend)
 296           {
 297             /* Extra zero pages should appear at the end of this segment,
 298                after the data mapped from the file.   */
 299             ElfW(Addr) zero, zeroend, zeropage;
 300
 301             zero = l->l_addr + c->dataend;
 302             zeroend = l->l_addr + c->allocend;
 303             zeropage = (zero + _dl_pagesize - 1) & ~(_dl_pagesize - 1);
 304
 305             if (zeroend < zeropage)
 306               /* All the extra data is in the last page of the segment.
 307                  We can just zero it.  */
 308               zeropage = zeroend;
 309
 310             if (zeropage > zero)
 311               {
 312                 /* Zero the final part of the last page of the segment.  */
 313                 if ((c->prot & PROT_WRITE) == 0)
 314                   {
 315                     /* Dag nab it.  */
 316                     if (__mprotect ((caddr_t) (zero & ~(_dl_pagesize - 1)),
 317                                     _dl_pagesize, c->prot|PROT_WRITE) < 0)
 318                       lose (errno, "cannot change memory protections");
 319                   }
 320                 memset ((void *) zero, 0, zeropage - zero);
 321                 if ((c->prot & PROT_WRITE) == 0)
 322                   __mprotect ((caddr_t) (zero & ~(_dl_pagesize - 1)),
 323                               _dl_pagesize, c->prot);
 324               }
 325
 326             if (zeroend > zeropage)
 327               {
 328                 /* Map the remaining zero pages in from the zero fill FD.  */
 329                 caddr_t mapat;
 330                 mapat = __mmap ((caddr_t) zeropage, zeroend - zeropage,
 331                                 c->prot, MAP_ANON|MAP_PRIVATE|MAP_FIXED,
 332                                 _dl_zerofd, 0);
 333                 if (mapat == (caddr_t) -1)
 334                   lose (errno, "cannot map zero-fill pages");
 335               }
 336           }
 337
 338         ++c;
 339       }
 340
 341     if (l->l_phdr == 0)
 342       {
 343         /* There was no PT_PHDR specified.  We need to find the phdr in the
 344            load image ourselves.  We assume it is in fact in the load image
 345            somewhere, and that the first load command starts at the
 346            beginning of the file and thus contains the ELF file header.  */
 347         ElfW(Addr) bof = l->l_addr + loadcmds[0].mapstart;
 348         assert (loadcmds[0].mapoff == 0);
 349         l->l_phdr = (void *) (bof + ((const ElfW(Ehdr) *) bof)->e_phoff);
 350       }
 351     else
 352       /* Adjust the PT_PHDR value by the runtime load address.  */
 353       (ElfW(Addr)) l->l_phdr += l->l_addr;
 354   }
 355
 356   /* We are done mapping in the file.  We no longer need the descriptor.  */
 357   __close (fd);
 358
 359   if (l->l_type == lt_library && type == ET_EXEC)
 360     l->l_type = lt_executable;
 361
 362   if (l->l_ld == 0)
 363     {
 364       if (type == ET_DYN)
 365         LOSE ("object file has no dynamic section");
 366     }
 367   else
 368     (ElfW(Addr)) l->l_ld += l->l_addr;
 369
 370   l->l_entry += l->l_addr;
 371
 372   elf_get_dynamic_info (l->l_ld, l->l_info);
 373   if (l->l_info[DT_HASH])
 374     _dl_setup_hash (l);
 375
 376   return l;
 377 }
 378 \f
 379 /* Try to open NAME in one of the directories in DIRPATH.
 380    Return the fd, or -1.  If successful, fill in *REALNAME
 381    with the malloc'd full directory name.  */
 382
 383 static int
 384 open_path (const char *name, size_t namelen,
 385            const char *dirpath,
 386            char **realname)
 387 {
 388   char *buf;
 389   const char *p;
 390   int fd;
 391
 392   p = dirpath;
 393   if (p == NULL || *p == '\0')
 394     {
 395       errno = ENOENT;
 396       return -1;
 397     }
 398
 399   buf = __alloca (strlen (dirpath) + 1 + namelen);
 400   do
 401     {
 402       size_t buflen;
 403
 404       dirpath = p;
 405       p = strpbrk (dirpath, ":;");
 406       if (p == NULL)
 407         p = strchr (dirpath, '\0');
 408
 409       if (p == dirpath)
 410         {
 411           /* Two adjacent colons, or a colon at the beginning or the end of
 412              the path means to search the current directory.  */
 413           (void) memcpy (buf, name, namelen);
 414           buflen = namelen;
 415         }
 416       else
 417         {
 418           /* Construct the pathname to try.  */
 419           (void) memcpy (buf, dirpath, p - dirpath);
 420           buf[p - dirpath] = '/';
 421           (void) memcpy (&buf[(p - dirpath) + 1], name, namelen);
 422           buflen = p - dirpath + 1 + namelen;
 423         }
 424
 425       fd = __open (buf, O_RDONLY);
 426       if (fd != -1)
 427         {
 428           *realname = malloc (buflen);
 429           if (*realname)
 430             {
 431               memcpy (*realname, buf, buflen);
 432               return fd;
 433             }
 434           else
 435             {
 436               /* No memory for the name, we certainly won't be able
 437                  to load and link it.  */
 438               __close (fd);
 439               return -1;
 440             }
 441         }
 442       if (errno != ENOENT && errno != EACCES)
 443         /* The file exists and is readable, but something went wrong.  */
 444         return -1;
 445     }
 446   while (*p++ != '\0');
 447
 448   return -1;
 449 }
 450
 451 /* Map in the shared object file NAME.  */
 452
 453 struct link_map *
 454 _dl_map_object (struct link_map *loader, const char *name, int type)
 455 {
 456   int fd;
 457   char *realname;
 458   struct link_map *l;
 459
 460   /* Look for this name among those already loaded.  */
 461   for (l = _dl_loaded; l; l = l->l_next)
 462     if (! strcmp (name, l->l_libname) || /* NAME was requested before.  */
 463         /* If the requested name matches the soname of a loaded object,
 464            use that object.  */
 465         (l->l_info[DT_SONAME] &&
 466          ! strcmp (name, (const char *) (l->addr +
 467                                          l->l_info[DT_SONAME]->d_un.d_ptr))))
 468       {
 469         /* The object is already loaded.
 470            Just bump its reference count and return it.  */
 471         ++l->l_opencount;
 472         return l;
 473       }
 474
 475   if (strchr (name, '/') == NULL)
 476     {
 477       /* Search for NAME in several places.  */
 478
 479       size_t namelen = strlen (name) + 1;
 480
 481       inline void trypath (const char *dirpath)
 482         {
 483           fd = open_path (name, namelen, dirpath, &realname);
 484         }
 485
 486       fd = -1;
 487
 488       /* First try the DT_RPATH of the dependent object that caused NAME
 489          to be loaded.  Then that object's dependent, and on up.  */
 490       for (l = loader; fd == -1 && l; l = l->l_loader)
 491         if (l && l->l_info[DT_RPATH])
 492           trypath ((const char *) (l->l_addr +
 493                                    l->l_info[DT_STRTAB]->d_un.d_ptr +
 494                                    l->l_info[DT_RPATH]->d_un.d_val));
 495       /* If dynamically linked, try the DT_RPATH of the executable itself.  */
 496       l = _dl_loaded;
 497       if (fd == -1 && l && l->l_type != lt_loaded && l->l_info[DT_RPATH])
 498         trypath ((const char *) (l->l_addr +
 499                                  l->l_info[DT_STRTAB]->d_un.d_ptr +
 500                                  l->l_info[DT_RPATH]->d_un.d_val));
 501       /* Try an environment variable (unless setuid).  */
 502       if (fd == -1 && ! _dl_secure)
 503         trypath (getenv ("LD_LIBRARY_PATH"));
 504       /* Finally, try the default path.  */
 505       if (fd == -1)
 506         {
 507           extern const char *_dl_rpath; /* Set in rtld.c. */
 508           trypath (_dl_rpath);
 509         }
 510     }
 511   else
 512     {
 513       fd = __open (name, O_RDONLY);
 514       if (fd != -1)
 515         {
 516           size_t len = strlen (name) + 1;
 517           realname = malloc (len);
 518           if (realname)
 519             memcpy (realname, name, len);
 520           else
 521             {
 522               __close (fd);
 523               fd = -1;
 524             }
 525         }
 526     }
 527
 528   if (fd == -1)
 529     _dl_signal_error (errno, name, "cannot open shared object file");
 530
 531   return _dl_map_object_from_fd (name, fd, realname, loader, type);
 532 }