Use MAP_ANON instead of MAP_ANONYMOUS.
[kopensolaris-gnu/glibc.git] / elf / dl-load.c
1 /* Map in a shared object's segments from the file.
2    Copyright (C) 1995, 1996, 1997, 1998 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 not,
17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18    Boston, MA 02111-1307, USA.  */
19
20 #include <elf.h>
21 #include <errno.h>
22 #include <fcntl.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <unistd.h>
26 #include <elf/ldsodefs.h>
27 #include <sys/mman.h>
28 #include <sys/param.h>
29 #include <sys/stat.h>
30 #include <sys/types.h>
31 #include "dynamic-link.h"
32 #include <stdio-common/_itoa.h>
33
34 #include <dl-origin.h>
35
36
37 /* On some systems, no flag bits are given to specify file mapping.  */
38 #ifndef MAP_FILE
39 #define MAP_FILE        0
40 #endif
41
42 /* The right way to map in the shared library files is MAP_COPY, which
43    makes a virtual copy of the data at the time of the mmap call; this
44    guarantees the mapped pages will be consistent even if the file is
45    overwritten.  Some losing VM systems like Linux's lack MAP_COPY.  All we
46    get is MAP_PRIVATE, which copies each page when it is modified; this
47    means if the file is overwritten, we may at some point get some pages
48    from the new version after starting with pages from the old version.  */
49 #ifndef MAP_COPY
50 #define MAP_COPY        MAP_PRIVATE
51 #endif
52
53 /* Some systems link their relocatable objects for another base address
54    than 0.  We want to know the base address for these such that we can
55    subtract this address from the segment addresses during mapping.
56    This results in a more efficient address space usage.  Defaults to
57    zero for almost all systems.  */
58 #ifndef MAP_BASE_ADDR
59 #define MAP_BASE_ADDR(l)        0
60 #endif
61
62
63 #include <endian.h>
64 #if BYTE_ORDER == BIG_ENDIAN
65 #define byteorder ELFDATA2MSB
66 #define byteorder_name "big-endian"
67 #elif BYTE_ORDER == LITTLE_ENDIAN
68 #define byteorder ELFDATA2LSB
69 #define byteorder_name "little-endian"
70 #else
71 #error "Unknown BYTE_ORDER " BYTE_ORDER
72 #define byteorder ELFDATANONE
73 #endif
74
75 #define STRING(x) __STRING (x)
76
77 #ifdef MAP_ANON
78 /* The fd is not examined when using MAP_ANON.  */
79 #define ANONFD -1
80 #else
81 int _dl_zerofd = -1;
82 #define ANONFD _dl_zerofd
83 #endif
84
85 /* Handle situations where we have a preferred location in memory for
86    the shared objects.  */
87 #ifdef ELF_PREFERRED_ADDRESS_DATA
88 ELF_PREFERRED_ADDRESS_DATA;
89 #endif
90 #ifndef ELF_PREFERRED_ADDRESS
91 #define ELF_PREFERRED_ADDRESS(loader, maplength, mapstartpref) (mapstartpref)
92 #endif
93 #ifndef ELF_FIXED_ADDRESS
94 #define ELF_FIXED_ADDRESS(loader, mapstart) ((void) 0)
95 #endif
96
97 size_t _dl_pagesize;
98
99 extern const char *_dl_platform;
100 extern size_t _dl_platformlen;
101
102 /* This is the decomposed LD_LIBRARY_PATH search path.  */
103 static struct r_search_path_elem **env_path_list;
104
105 /* List of the hardware capabilities we might end up using.  */
106 static const struct r_strlenpair *capstr;
107 static size_t ncapstr;
108 static size_t max_capstrlen;
109
110
111 /* This function has no public prototype.  */
112 extern ssize_t __libc_read (int, void *, size_t);
113
114
115 /* Local version of `strdup' function.  */
116 static inline char *
117 local_strdup (const char *s)
118 {
119   size_t len = strlen (s) + 1;
120   void *new = malloc (len);
121
122   if (new == NULL)
123     return NULL;
124
125   return (char *) memcpy (new, s, len);
126 }
127
128 /* Return copy of argument with all recognized dynamic string tokens
129    ($ORIGIN and $PLATFORM for now) replaced.  On some platforms it
130    might not be possible to determine the path from which the object
131    belonging to the map is loaded.  In this case the path element
132    containing $ORIGIN is left out.  */
133 static char *
134 expand_dynamic_string_token (struct link_map *l, const char *s)
135 {
136   /* We make two runs over the string.  First we determine how large the
137      resulting string is and then we copy it over.  Since this is now
138      frequently executed operation we are looking here not for performance
139      but rather for code size.  */
140   const char *st, *sf;
141   size_t cnt = 0;
142   size_t origin_len;
143   size_t total;
144   char *result, *last_elem, *wp;
145
146   st = s;
147   sf = strchr (s, '$');
148   while (sf != NULL)
149     {
150       size_t len = 1;
151
152       if (((strncmp (&sf[1], "ORIGIN", 6) == 0 && (len = 7) != 0)
153            || (strncmp (&sf[1], "PLATFORM", 8) == 0 && (len = 9) != 0))
154           && (s[len] == '\0' || s[len] == '/' || s[len] == ':'))
155         ++cnt;
156
157       st = sf + len;
158       sf = strchr (st, '$');
159     }
160
161   /* If we do not have to replace anything simply copy the string.  */
162   if (cnt == 0)
163     return local_strdup (s);
164
165   /* Now we make a guess how many extra characters on top of the length
166      of S we need to represent the result.  We know that we have CNT
167      replacements.  Each at most can use
168         MAX (strlen (ORIGIN), strlen (_dl_platform))
169      minus 7 (which is the length of "$ORIGIN").
170
171      First get the origin string if it is not available yet.  This can
172      only happen for the map of the executable.  */
173   if (l->l_origin == NULL)
174     {
175       assert (l->l_name[0] == '\0');
176       l->l_origin = get_origin ();
177       origin_len = (l->l_origin && l->l_origin != (char *) -1
178                     ? strlen (l->l_origin) : 0);
179     }
180   else
181     origin_len = l->l_origin == (char *) -1 ? 0 : strlen (l->l_origin);
182
183   total = strlen (s) + cnt * (MAX (origin_len, _dl_platformlen) - 7);
184   result = (char *) malloc (total + 1);
185   if (result == NULL)
186     return NULL;
187
188   /* Now fill the result path.  While copying over the string we keep
189      track of the start of the last path element.  When we come accross
190      a DST we copy over the value or (if the value is not available)
191      leave the entire path element out.  */
192   last_elem = wp = result;
193   do
194     {
195       if (*s == '$')
196         {
197           const char *repl;
198           size_t len;
199
200           if (((strncmp (&s[1], "ORIGIN", 6) == 0 && (len = 7) != 0)
201                || (strncmp (&s[1], "PLATFORM", 8) == 0 && (len = 9) != 0))
202               && (s[len] == '\0' || s[len] == '/' || s[len] == ':'))
203             {
204               if ((repl = len == 7 ? l->l_origin : _dl_platform) != NULL
205                   && repl != (const char *) -1)
206                 {
207                   wp = __stpcpy (wp, repl);
208                   s += len;
209                 }
210               else
211                 {
212                   /* We cannot use this path element, the value of the
213                      replacement is unknown.  */
214                   wp = last_elem;
215                   s += len;
216                   while (*s != '\0' && *s != ':')
217                     ++s;
218                 }
219             }
220           else
221             /* No SDK we recognize.  */
222             *wp++ = *s++;
223         }
224       else if (*s == ':')
225         {
226           *wp++ = *s++;
227           last_elem = wp;
228         }
229       else
230         *wp++ = *s++;
231     }
232   while (*s != '\0');
233
234   *wp = '\0';
235
236   return result;
237 }
238
239 /* Add `name' to the list of names for a particular shared object.
240    `name' is expected to have been allocated with malloc and will
241    be freed if the shared object already has this name.
242    Returns false if the object already had this name.  */
243 static void
244 internal_function
245 add_name_to_object (struct link_map *l, const char *name)
246 {
247   struct libname_list *lnp, *lastp;
248   struct libname_list *newname;
249   size_t name_len;
250
251   lastp = NULL;
252   for (lnp = l->l_libname; lnp != NULL; lastp = lnp, lnp = lnp->next)
253     if (strcmp (name, lnp->name) == 0)
254       return;
255
256   name_len = strlen (name) + 1;
257   newname = malloc (sizeof *newname + name_len);
258   if (newname == NULL)
259     {
260       /* No more memory.  */
261       _dl_signal_error (ENOMEM, name, "cannot allocate name record");
262       return;
263     }
264   /* The object should have a libname set from _dl_new_object.  */
265   assert (lastp != NULL);
266
267   newname->name = memcpy (newname + 1, name, name_len);
268   newname->next = NULL;
269   lastp->next = newname;
270 }
271
272 /* All known directories in sorted order.  */
273 static struct r_search_path_elem *all_dirs;
274
275 /* Standard search directories.  */
276 static struct r_search_path_elem **rtld_search_dirs;
277
278 static size_t max_dirnamelen;
279
280 static inline struct r_search_path_elem **
281 fillin_rpath (char *rpath, struct r_search_path_elem **result, const char *sep,
282               const char **trusted, const char *what, const char *where)
283 {
284   char *cp;
285   size_t nelems = 0;
286
287   while ((cp = __strsep (&rpath, sep)) != NULL)
288     {
289       struct r_search_path_elem *dirp;
290       size_t len = strlen (cp);
291
292       /* `strsep' can pass an empty string.  This has to be
293          interpreted as `use the current directory'. */
294       if (len == 0)
295         {
296           static char curwd[] = "./";
297           cp = curwd;
298         }
299
300       /* Remove trailing slashes (except for "/").  */
301       while (len > 1 && cp[len - 1] == '/')
302         --len;
303
304       /* Make sure we don't use untrusted directories if we run SUID.  */
305       if (trusted != NULL)
306         {
307           const char **trun = trusted;
308
309           /* All trusted directories must be complete names.  */
310           if (cp[0] != '/')
311             continue;
312
313           while (*trun != NULL
314                  && (memcmp (*trun, cp, len) != 0
315                      || (*trun)[len] != '/'
316                      || (*trun)[len + 1] != '\0'))
317             ++trun;
318
319           if (*trun == NULL)
320             /* It's no trusted directory, skip it.  */
321             continue;
322         }
323
324       /* Now add one if there is none so far.  */
325       if (len > 0 && cp[len - 1] != '/')
326         cp[len++] = '/';
327
328       /* See if this directory is already known.  */
329       for (dirp = all_dirs; dirp != NULL; dirp = dirp->next)
330         if (dirp->dirnamelen == len && memcmp (cp, dirp->dirname, len) == 0)
331           break;
332
333       if (dirp != NULL)
334         {
335           /* It is available, see whether it's on our own list.  */
336           size_t cnt;
337           for (cnt = 0; cnt < nelems; ++cnt)
338             if (result[cnt] == dirp)
339               break;
340
341           if (cnt == nelems)
342             result[nelems++] = dirp;
343         }
344       else
345         {
346           size_t cnt;
347
348           /* It's a new directory.  Create an entry and add it.  */
349           dirp = (struct r_search_path_elem *)
350             malloc (sizeof (*dirp) + ncapstr * sizeof (enum r_dir_status));
351           if (dirp == NULL)
352             _dl_signal_error (ENOMEM, NULL,
353                               "cannot create cache for search path");
354
355           dirp->dirname = cp;
356           dirp->dirnamelen = len;
357
358           if (len > max_dirnamelen)
359             max_dirnamelen = len;
360
361           /* We have to make sure all the relative directories are never
362              ignored.  The current directory might change and all our
363              saved information would be void.  */
364           if (cp[0] != '/')
365             for (cnt = 0; cnt < ncapstr; ++cnt)
366               dirp->status[cnt] = existing;
367           else
368             for (cnt = 0; cnt < ncapstr; ++cnt)
369               dirp->status[cnt] = unknown;
370
371           dirp->what = what;
372           dirp->where = where;
373
374           dirp->next = all_dirs;
375           all_dirs = dirp;
376
377           /* Put it in the result array.  */
378           result[nelems++] = dirp;
379         }
380     }
381
382   /* Terminate the array.  */
383   result[nelems] = NULL;
384
385   return result;
386 }
387
388
389 static struct r_search_path_elem **
390 internal_function
391 decompose_rpath (const char *rpath, struct link_map *l)
392 {
393   /* Make a copy we can work with.  */
394   const char *where = l->l_name;
395   char *copy;
396   char *cp;
397   struct r_search_path_elem **result;
398   size_t nelems;
399
400   /* First see whether we must forget the RPATH from this object.  */
401   if (_dl_inhibit_rpath != NULL && !__libc_enable_secure)
402     {
403       const char *found = strstr (_dl_inhibit_rpath, where);
404       if (found != NULL)
405         {
406           size_t len = strlen (where);
407           if ((found == _dl_inhibit_rpath || found[-1] == ':')
408               && (found[len] == '\0' || found[len] == ':'))
409             {
410               /* This object is on the list of objects for which the RPATH
411                  must not be used.  */
412               result = (struct r_search_path_elem **)
413                 malloc (sizeof (*result));
414               if (result == NULL)
415                 _dl_signal_error (ENOMEM, NULL,
416                                   "cannot create cache for search path");
417               result[0] = NULL;
418
419               return result;
420             }
421         }
422     }
423
424   /* Make a writable copy.  At the same time expand possible dynamic
425      string tokens.  */
426   copy = expand_dynamic_string_token (l, rpath);
427   if (copy == NULL)
428     _dl_signal_error (ENOMEM, NULL, "cannot create RPATH copy");
429
430   /* Count the number of necessary elements in the result array.  */
431   nelems = 0;
432   for (cp = copy; *cp != '\0'; ++cp)
433     if (*cp == ':')
434       ++nelems;
435
436   /* Allocate room for the result.  NELEMS + 1 is an upper limit for the
437      number of necessary entries.  */
438   result = (struct r_search_path_elem **) malloc ((nelems + 1 + 1)
439                                                   * sizeof (*result));
440   if (result == NULL)
441     _dl_signal_error (ENOMEM, NULL, "cannot create cache for search path");
442
443   return fillin_rpath (copy, result, ":", NULL, "RPATH", where);
444 }
445
446
447 void
448 internal_function
449 _dl_init_paths (const char *llp)
450 {
451   static const char *system_dirs[] =
452   {
453 #include "trusted-dirs.h"
454     NULL
455   };
456   const char **strp;
457   struct r_search_path_elem *pelem, **aelem;
458   size_t round_size;
459 #ifdef PIC
460   struct link_map *l;
461 #endif
462
463   /* Fill in the information about the application's RPATH and the
464      directories addressed by the LD_LIBRARY_PATH environment variable.  */
465
466   /* Get the capabilities.  */
467   capstr = _dl_important_hwcaps (_dl_platform, _dl_platformlen,
468                                  &ncapstr, &max_capstrlen);
469
470   /* First set up the rest of the default search directory entries.  */
471   aelem = rtld_search_dirs = (struct r_search_path_elem **)
472     malloc ((ncapstr + 1) * sizeof (struct r_search_path_elem *));
473
474   round_size = ((2 * sizeof (struct r_search_path_elem) - 1
475                  + ncapstr * sizeof (enum r_dir_status))
476                 / sizeof (struct r_search_path_elem));
477
478   rtld_search_dirs[0] = (struct r_search_path_elem *)
479     malloc ((sizeof (system_dirs) / sizeof (system_dirs[0]) - 1)
480             * round_size * sizeof (struct r_search_path_elem));
481   if (rtld_search_dirs[0] == NULL)
482     _dl_signal_error (ENOMEM, NULL, "cannot create cache for search path");
483
484   pelem = all_dirs = rtld_search_dirs[0];
485   for (strp = system_dirs; *strp != NULL; ++strp, pelem += round_size)
486     {
487       size_t cnt;
488
489       *aelem++ = pelem;
490
491       pelem->next = *(strp + 1) == NULL ? NULL : (pelem + round_size);
492
493       pelem->what = "system search path";
494       pelem->where = NULL;
495
496       pelem->dirnamelen = strlen (pelem->dirname = *strp);
497       if (pelem->dirnamelen > max_dirnamelen)
498         max_dirnamelen = pelem->dirnamelen;
499
500       if (pelem->dirname[0] != '/')
501         for (cnt = 0; cnt < ncapstr; ++cnt)
502           pelem->status[cnt] = existing;
503       else
504         for (cnt = 0; cnt < ncapstr; ++cnt)
505           pelem->status[cnt] = unknown;
506     }
507   *aelem = NULL;
508
509 #ifdef PIC
510   /* This points to the map of the main object.  */
511   l = _dl_loaded;
512   if (l != NULL)
513     {
514       assert (l->l_type != lt_loaded);
515
516       if (l->l_info[DT_RPATH])
517         /* Allocate room for the search path and fill in information
518            from RPATH.  */
519         l->l_rpath_dirs =
520           decompose_rpath ((const char *)
521                            (l->l_addr + l->l_info[DT_STRTAB]->d_un.d_ptr
522                             + l->l_info[DT_RPATH]->d_un.d_val), l);
523       else
524         l->l_rpath_dirs = NULL;
525     }
526 #endif  /* PIC */
527
528   if (llp != NULL && *llp != '\0')
529     {
530       size_t nllp;
531       const char *cp = llp;
532
533       /* Decompose the LD_LIBRARY_PATH contents.  First determine how many
534          elements it has.  */
535       nllp = 1;
536       while (*cp)
537         {
538           if (*cp == ':' || *cp == ';')
539             ++nllp;
540           ++cp;
541         }
542
543       env_path_list = (struct r_search_path_elem **)
544         malloc ((nllp + 1) * sizeof (struct r_search_path_elem *));
545       if (env_path_list == NULL)
546         _dl_signal_error (ENOMEM, NULL,
547                           "cannot create cache for search path");
548
549       (void) fillin_rpath (local_strdup (llp), env_path_list, ":;",
550                            __libc_enable_secure ? system_dirs : NULL,
551                            "LD_LIBRARY_PATH", NULL);
552     }
553 }
554
555
556 /* Map in the shared object NAME, actually located in REALNAME, and already
557    opened on FD.  */
558
559 #ifndef EXTERNAL_MAP_FROM_FD
560 static
561 #endif
562 struct link_map *
563 _dl_map_object_from_fd (const char *name, int fd, char *realname,
564                         struct link_map *loader, int l_type)
565 {
566   struct link_map *l = NULL;
567
568 #define LOSE(s) lose (0, (s))
569   void lose (int code, const char *msg)
570     {
571       (void) __close (fd);
572       if (l)
573         {
574           /* Remove the stillborn object from the list and free it.  */
575           if (l->l_prev)
576             l->l_prev->l_next = l->l_next;
577           if (l->l_next)
578             l->l_next->l_prev = l->l_prev;
579           free (l);
580         }
581       free (realname);
582       _dl_signal_error (code, name, msg);
583     }
584
585   inline caddr_t map_segment (ElfW(Addr) mapstart, size_t len,
586                               int prot, int fixed, off_t offset)
587     {
588       caddr_t mapat = __mmap ((caddr_t) mapstart, len, prot,
589                               fixed|MAP_COPY|MAP_FILE,
590                               fd, offset);
591       if (mapat == MAP_FAILED)
592         lose (errno, "failed to map segment from shared object");
593       return mapat;
594     }
595
596   const ElfW(Ehdr) *header;
597   const ElfW(Phdr) *phdr;
598   const ElfW(Phdr) *ph;
599   size_t maplength;
600   int type;
601   char *readbuf;
602   ssize_t readlength;
603
604   /* Look again to see if the real name matched another already loaded.  */
605   for (l = _dl_loaded; l; l = l->l_next)
606     if (! strcmp (realname, l->l_name))
607       {
608         /* The object is already loaded.
609            Just bump its reference count and return it.  */
610         __close (fd);
611
612         /* If the name is not in the list of names for this object add
613            it.  */
614         free (realname);
615         add_name_to_object (l, name);
616         ++l->l_opencount;
617         return l;
618       }
619
620   /* Print debugging message.  */
621   if (_dl_debug_files)
622     _dl_debug_message (1, "file=", name, ";  generating link map\n", NULL);
623
624   /* Read the header directly.  */
625   readbuf = alloca (_dl_pagesize);
626   readlength = __libc_read (fd, readbuf, _dl_pagesize);
627   if (readlength < (ssize_t) sizeof(*header))
628     lose (errno, "cannot read file data");
629   header = (void *) readbuf;
630
631   /* Check the header for basic validity.  */
632   if (*(Elf32_Word *) &header->e_ident !=
633 #if BYTE_ORDER == LITTLE_ENDIAN
634       ((ELFMAG0 << (EI_MAG0 * 8)) |
635        (ELFMAG1 << (EI_MAG1 * 8)) |
636        (ELFMAG2 << (EI_MAG2 * 8)) |
637        (ELFMAG3 << (EI_MAG3 * 8)))
638 #else
639       ((ELFMAG0 << (EI_MAG3 * 8)) |
640        (ELFMAG1 << (EI_MAG2 * 8)) |
641        (ELFMAG2 << (EI_MAG1 * 8)) |
642        (ELFMAG3 << (EI_MAG0 * 8)))
643 #endif
644       )
645     LOSE ("invalid ELF header");
646 #define ELF32_CLASS ELFCLASS32
647 #define ELF64_CLASS ELFCLASS64
648   if (header->e_ident[EI_CLASS] != ELFW(CLASS))
649     LOSE ("ELF file class not " STRING(__ELF_NATIVE_CLASS) "-bit");
650   if (header->e_ident[EI_DATA] != byteorder)
651     LOSE ("ELF file data encoding not " byteorder_name);
652   if (header->e_ident[EI_VERSION] != EV_CURRENT)
653     LOSE ("ELF file version ident not " STRING(EV_CURRENT));
654   /* XXX We should be able so set system specific versions which are
655      allowed here.  */
656   if (header->e_ident[EI_OSABI] != ELFOSABI_SYSV)
657     LOSE ("ELF file OS ABI not " STRING(ELFOSABI_SYSV));
658   if (header->e_ident[EI_ABIVERSION] != 0)
659     LOSE ("ELF file ABI version not 0");
660   if (header->e_version != EV_CURRENT)
661     LOSE ("ELF file version not " STRING(EV_CURRENT));
662   if (! elf_machine_matches_host (header->e_machine))
663     LOSE ("ELF file machine architecture not " ELF_MACHINE_NAME);
664   if (header->e_phentsize != sizeof (ElfW(Phdr)))
665     LOSE ("ELF file's phentsize not the expected size");
666
667 #ifndef MAP_ANON
668 #define MAP_ANON 0
669   if (_dl_zerofd == -1)
670     {
671       _dl_zerofd = _dl_sysdep_open_zero_fill ();
672       if (_dl_zerofd == -1)
673         {
674           __close (fd);
675           _dl_signal_error (errno, NULL, "cannot open zero fill device");
676         }
677     }
678 #endif
679
680   /* Enter the new object in the list of loaded objects.  */
681   l = _dl_new_object (realname, name, l_type, loader);
682   if (! l)
683     lose (ENOMEM, "cannot create shared object descriptor");
684   l->l_opencount = 1;
685
686   /* Extract the remaining details we need from the ELF header
687      and then read in the program header table.  */
688   l->l_entry = header->e_entry;
689   type = header->e_type;
690   l->l_phnum = header->e_phnum;
691
692   maplength = header->e_phnum * sizeof (ElfW(Phdr));
693   if (header->e_phoff + maplength <= readlength)
694     phdr = (void *) (readbuf + header->e_phoff);
695   else
696     {
697       phdr = alloca (maplength);
698       __lseek (fd, SEEK_SET, header->e_phoff);
699       if (__libc_read (fd, (void *) phdr, maplength) != maplength)
700         lose (errno, "cannot read file data");
701     }
702
703   {
704     /* Scan the program header table, collecting its load commands.  */
705     struct loadcmd
706       {
707         ElfW(Addr) mapstart, mapend, dataend, allocend;
708         off_t mapoff;
709         int prot;
710       } loadcmds[l->l_phnum], *c;
711     size_t nloadcmds = 0;
712
713     l->l_ld = 0;
714     l->l_phdr = 0;
715     l->l_addr = 0;
716     for (ph = phdr; ph < &phdr[l->l_phnum]; ++ph)
717       switch (ph->p_type)
718         {
719           /* These entries tell us where to find things once the file's
720              segments are mapped in.  We record the addresses it says
721              verbatim, and later correct for the run-time load address.  */
722         case PT_DYNAMIC:
723           l->l_ld = (void *) ph->p_vaddr;
724           break;
725         case PT_PHDR:
726           l->l_phdr = (void *) ph->p_vaddr;
727           break;
728
729         case PT_LOAD:
730           /* A load command tells us to map in part of the file.
731              We record the load commands and process them all later.  */
732           if (ph->p_align % _dl_pagesize != 0)
733             LOSE ("ELF load command alignment not page-aligned");
734           if ((ph->p_vaddr - ph->p_offset) % ph->p_align)
735             LOSE ("ELF load command address/offset not properly aligned");
736           {
737             struct loadcmd *c = &loadcmds[nloadcmds++];
738             c->mapstart = ph->p_vaddr & ~(ph->p_align - 1);
739             c->mapend = ((ph->p_vaddr + ph->p_filesz + _dl_pagesize - 1)
740                          & ~(_dl_pagesize - 1));
741             c->dataend = ph->p_vaddr + ph->p_filesz;
742             c->allocend = ph->p_vaddr + ph->p_memsz;
743             c->mapoff = ph->p_offset & ~(ph->p_align - 1);
744             c->prot = 0;
745             if (ph->p_flags & PF_R)
746               c->prot |= PROT_READ;
747             if (ph->p_flags & PF_W)
748               c->prot |= PROT_WRITE;
749             if (ph->p_flags & PF_X)
750               c->prot |= PROT_EXEC;
751             break;
752           }
753         }
754
755     /* Now process the load commands and map segments into memory.  */
756     c = loadcmds;
757
758     /* Length of the sections to be loaded.  */
759     maplength = loadcmds[nloadcmds - 1].allocend - c->mapstart;
760
761     if (type == ET_DYN || type == ET_REL)
762       {
763         /* This is a position-independent shared object.  We can let the
764            kernel map it anywhere it likes, but we must have space for all
765            the segments in their specified positions relative to the first.
766            So we map the first segment without MAP_FIXED, but with its
767            extent increased to cover all the segments.  Then we remove
768            access from excess portion, and there is known sufficient space
769            there to remap from the later segments.
770
771            As a refinement, sometimes we have an address that we would
772            prefer to map such objects at; but this is only a preference,
773            the OS can do whatever it likes. */
774         caddr_t mapat;
775         ElfW(Addr) mappref;
776         mappref = (ELF_PREFERRED_ADDRESS (loader, maplength, c->mapstart)
777                    - MAP_BASE_ADDR (l));
778         mapat = map_segment (mappref, maplength, c->prot, 0, c->mapoff);
779         l->l_addr = (ElfW(Addr)) mapat - c->mapstart;
780
781         /* Change protection on the excess portion to disallow all access;
782            the portions we do not remap later will be inaccessible as if
783            unallocated.  Then jump into the normal segment-mapping loop to
784            handle the portion of the segment past the end of the file
785            mapping.  */
786         __mprotect ((caddr_t) (l->l_addr + c->mapend),
787                     loadcmds[nloadcmds - 1].allocend - c->mapend,
788                     0);
789
790         /* Remember which part of the address space this object uses.  */
791         l->l_map_start = c->mapstart + l->l_addr;
792         l->l_map_end = l->l_map_start + maplength;
793
794         goto postmap;
795       }
796     else
797       {
798         /* Notify ELF_PREFERRED_ADDRESS that we have to load this one
799            fixed.  */
800         ELF_FIXED_ADDRESS (loader, c->mapstart);
801       }
802
803     /* Remember which part of the address space this object uses.  */
804     l->l_map_start = c->mapstart + l->l_addr;
805     l->l_map_end = l->l_map_start + maplength;
806
807     while (c < &loadcmds[nloadcmds])
808       {
809         if (c->mapend > c->mapstart)
810           /* Map the segment contents from the file.  */
811           map_segment (l->l_addr + c->mapstart, c->mapend - c->mapstart,
812                        c->prot, MAP_FIXED, c->mapoff);
813
814       postmap:
815         if (c->allocend > c->dataend)
816           {
817             /* Extra zero pages should appear at the end of this segment,
818                after the data mapped from the file.   */
819             ElfW(Addr) zero, zeroend, zeropage;
820
821             zero = l->l_addr + c->dataend;
822             zeroend = l->l_addr + c->allocend;
823             zeropage = (zero + _dl_pagesize - 1) & ~(_dl_pagesize - 1);
824
825             if (zeroend < zeropage)
826               /* All the extra data is in the last page of the segment.
827                  We can just zero it.  */
828               zeropage = zeroend;
829
830             if (zeropage > zero)
831               {
832                 /* Zero the final part of the last page of the segment.  */
833                 if ((c->prot & PROT_WRITE) == 0)
834                   {
835                     /* Dag nab it.  */
836                     if (__mprotect ((caddr_t) (zero & ~(_dl_pagesize - 1)),
837                                     _dl_pagesize, c->prot|PROT_WRITE) < 0)
838                       lose (errno, "cannot change memory protections");
839                   }
840                 memset ((void *) zero, 0, zeropage - zero);
841                 if ((c->prot & PROT_WRITE) == 0)
842                   __mprotect ((caddr_t) (zero & ~(_dl_pagesize - 1)),
843                               _dl_pagesize, c->prot);
844               }
845
846             if (zeroend > zeropage)
847               {
848                 /* Map the remaining zero pages in from the zero fill FD.  */
849                 caddr_t mapat;
850                 mapat = __mmap ((caddr_t) zeropage, zeroend - zeropage,
851                                 c->prot, MAP_ANON|MAP_PRIVATE|MAP_FIXED,
852                                 ANONFD, 0);
853                 if (mapat == MAP_FAILED)
854                   lose (errno, "cannot map zero-fill pages");
855               }
856           }
857
858         ++c;
859       }
860
861     if (l->l_phdr == 0)
862       {
863         /* There was no PT_PHDR specified.  We need to find the phdr in the
864            load image ourselves.  We assume it is in fact in the load image
865            somewhere, and that the first load command starts at the
866            beginning of the file and thus contains the ELF file header.  */
867         ElfW(Addr) bof = l->l_addr + loadcmds[0].mapstart;
868         assert (loadcmds[0].mapoff == 0);
869         l->l_phdr = (void *) (bof + ((const ElfW(Ehdr) *) bof)->e_phoff);
870       }
871     else
872       /* Adjust the PT_PHDR value by the runtime load address.  */
873       (ElfW(Addr)) l->l_phdr += l->l_addr;
874   }
875
876   /* We are done mapping in the file.  We no longer need the descriptor.  */
877   __close (fd);
878
879   if (l->l_type == lt_library && type == ET_EXEC)
880     l->l_type = lt_executable;
881
882   if (l->l_ld == 0)
883     {
884       if (type == ET_DYN)
885         LOSE ("object file has no dynamic section");
886     }
887   else
888     (ElfW(Addr)) l->l_ld += l->l_addr;
889
890   l->l_entry += l->l_addr;
891
892   if (_dl_debug_files)
893     {
894       const size_t nibbles = sizeof (void *) * 2;
895       char buf1[nibbles + 1];
896       char buf2[nibbles + 1];
897       char buf3[nibbles + 1];
898
899       buf1[nibbles] = '\0';
900       buf2[nibbles] = '\0';
901       buf3[nibbles] = '\0';
902
903       memset (buf1, '0', nibbles);
904       memset (buf2, '0', nibbles);
905       memset (buf3, '0', nibbles);
906       _itoa_word ((unsigned long int) l->l_ld, &buf1[nibbles], 16, 0);
907       _itoa_word ((unsigned long int) l->l_addr, &buf2[nibbles], 16, 0);
908       _itoa_word (maplength, &buf3[nibbles], 16, 0);
909
910       _dl_debug_message (1, "  dynamic: 0x", buf1, "  base: 0x", buf2,
911                          "   size: 0x", buf3, "\n", NULL);
912       memset (buf1, '0', nibbles);
913       memset (buf2, '0', nibbles);
914       memset (buf3, ' ', nibbles);
915       _itoa_word ((unsigned long int) l->l_entry, &buf1[nibbles], 16, 0);
916       _itoa_word ((unsigned long int) l->l_phdr, &buf2[nibbles], 16, 0);
917       _itoa_word (l->l_phnum, &buf3[nibbles], 10, 0);
918       _dl_debug_message (1, "    entry: 0x", buf1, "  phdr: 0x", buf2,
919                          "  phnum:   ", buf3, "\n\n", NULL);
920     }
921
922   elf_get_dynamic_info (l->l_ld, l->l_info);
923   if (l->l_info[DT_HASH])
924     _dl_setup_hash (l);
925
926   /* If this object has DT_SYMBOLIC set modify now its scope.  We don't
927      have to do this for the main map.  */
928   if (l->l_info[DT_SYMBOLIC] && &l->l_searchlist != l->l_scope[0])
929     {
930       /* Create an appropriate searchlist.  It contains only this map.
931
932          XXX This is the definition of DT_SYMBOLIC in SysVr4.  The old
933          GNU ld.so implementation had a different interpretation which
934          is more reasonable.  We are prepared to add this possibility
935          back as part of a GNU extension of the ELF format.  */
936       l->l_symbolic_searchlist.r_list =
937         (struct link_map **) malloc (sizeof (struct link_map *));
938
939       if (l->l_symbolic_searchlist.r_list == NULL)
940         lose (ENOMEM, "cannot create searchlist");
941
942       l->l_symbolic_searchlist.r_list[0] = l;
943       l->l_symbolic_searchlist.r_nlist = 1;
944       l->l_symbolic_searchlist.r_duplist = l->l_symbolic_searchlist.r_list;
945       l->l_symbolic_searchlist.r_nduplist = 1;
946
947       /* Now move the existing entries one back.  */
948       memmove (&l->l_scope[1], &l->l_scope[0],
949                3 * sizeof (struct r_scope_elem *));
950
951       /* Now add the new entry.  */
952       l->l_scope[0] = &l->l_symbolic_searchlist;
953     }
954
955   return l;
956 }
957 \f
958 /* Print search path.  */
959 static void
960 print_search_path (struct r_search_path_elem **list,
961                    const char *what, const char *name)
962 {
963   char buf[max_dirnamelen + max_capstrlen];
964   int first = 1;
965
966   _dl_debug_message (1, " search path=", NULL);
967
968   while (*list != NULL && (*list)->what == what) /* Yes, ==.  */
969     {
970       char *endp = __mempcpy (buf, (*list)->dirname, (*list)->dirnamelen);
971       size_t cnt;
972
973       for (cnt = 0; cnt < ncapstr; ++cnt)
974         if ((*list)->status[cnt] != nonexisting)
975           {
976             char *cp = __mempcpy (endp, capstr[cnt].str, capstr[cnt].len);
977             if (cp == buf || (cp == buf + 1 && buf[0] == '/'))
978               cp[0] = '\0';
979             else
980               cp[-1] = '\0';
981             _dl_debug_message (0, first ? "" : ":", buf, NULL);
982             first = 0;
983           }
984
985       ++list;
986     }
987
988   if (name != NULL)
989     _dl_debug_message (0, "\t\t(", what, " from file ",
990                         name[0] ? name : _dl_argv[0], ")\n", NULL);
991   else
992     _dl_debug_message (0, "\t\t(", what, ")\n", NULL);
993 }
994 \f
995 /* Try to open NAME in one of the directories in DIRS.
996    Return the fd, or -1.  If successful, fill in *REALNAME
997    with the malloc'd full directory name.  */
998
999 static int
1000 open_path (const char *name, size_t namelen, int preloaded,
1001            struct r_search_path_elem **dirs,
1002            char **realname)
1003 {
1004   char *buf;
1005   int fd = -1;
1006   const char *current_what = NULL;
1007
1008   if (dirs == NULL || *dirs == NULL)
1009     {
1010       __set_errno (ENOENT);
1011       return -1;
1012     }
1013
1014   buf = __alloca (max_dirnamelen + max_capstrlen + namelen);
1015   do
1016     {
1017       struct r_search_path_elem *this_dir = *dirs;
1018       size_t buflen = 0;
1019       size_t cnt;
1020       char *edp;
1021
1022       /* If we are debugging the search for libraries print the path
1023          now if it hasn't happened now.  */
1024       if (_dl_debug_libs && current_what != this_dir->what)
1025         {
1026           current_what = this_dir->what;
1027           print_search_path (dirs, current_what, this_dir->where);
1028         }
1029
1030       edp = (char *) __mempcpy (buf, this_dir->dirname, this_dir->dirnamelen);
1031       for (cnt = 0; fd == -1 && cnt < ncapstr; ++cnt)
1032         {
1033           /* Skip this directory if we know it does not exist.  */
1034           if (this_dir->status[cnt] == nonexisting)
1035             continue;
1036
1037           buflen =
1038             ((char *) __mempcpy (__mempcpy (edp,
1039                                             capstr[cnt].str, capstr[cnt].len),
1040                                  name, namelen)
1041              - buf);
1042
1043           /* Print name we try if this is wanted.  */
1044           if (_dl_debug_libs)
1045             _dl_debug_message (1, "  trying file=", buf, "\n", NULL);
1046
1047           fd = __open (buf, O_RDONLY);
1048           if (this_dir->status[cnt] == unknown)
1049             {
1050               if (fd != -1)
1051                 this_dir->status[cnt] = existing;
1052               else
1053                 {
1054                   /* We failed to open machine dependent library.  Let's
1055                      test whether there is any directory at all.  */
1056                   struct stat st;
1057
1058                   buf[buflen - namelen - 1] = '\0';
1059
1060                   if (__xstat (_STAT_VER, buf, &st) != 0
1061                       || ! S_ISDIR (st.st_mode))
1062                     /* The directory does not exist or it is no directory.  */
1063                     this_dir->status[cnt] = nonexisting;
1064                   else
1065                     this_dir->status[cnt] = existing;
1066                 }
1067             }
1068
1069           if (fd != -1 && preloaded && __libc_enable_secure)
1070             {
1071               /* This is an extra security effort to make sure nobody can
1072                  preload broken shared objects which are in the trusted
1073                  directories and so exploit the bugs.  */
1074               struct stat st;
1075
1076               if (__fxstat (_STAT_VER, fd, &st) != 0
1077                   || (st.st_mode & S_ISUID) == 0)
1078                 {
1079                   /* The shared object cannot be tested for being SUID
1080                      or this bit is not set.  In this case we must not
1081                      use this object.  */
1082                   __close (fd);
1083                   fd = -1;
1084                   /* We simply ignore the file, signal this by setting
1085                      the error value which would have been set by `open'.  */
1086                   errno = ENOENT;
1087                 }
1088             }
1089         }
1090
1091       if (fd != -1)
1092         {
1093           *realname = malloc (buflen);
1094           if (*realname != NULL)
1095             {
1096               memcpy (*realname, buf, buflen);
1097               return fd;
1098             }
1099           else
1100             {
1101               /* No memory for the name, we certainly won't be able
1102                  to load and link it.  */
1103               __close (fd);
1104               return -1;
1105             }
1106         }
1107       if (errno != ENOENT && errno != EACCES)
1108         /* The file exists and is readable, but something went wrong.  */
1109         return -1;
1110     }
1111   while (*++dirs != NULL);
1112
1113   return -1;
1114 }
1115
1116 /* Map in the shared object file NAME.  */
1117
1118 struct link_map *
1119 internal_function
1120 _dl_map_object (struct link_map *loader, const char *name, int preloaded,
1121                 int type, int trace_mode)
1122 {
1123   int fd;
1124   char *realname;
1125   char *name_copy;
1126   struct link_map *l;
1127
1128   /* Look for this name among those already loaded.  */
1129   for (l = _dl_loaded; l; l = l->l_next)
1130     {
1131       /* If the requested name matches the soname of a loaded object,
1132          use that object.  Elide this check for names that have not
1133          yet been opened.  */
1134       if (l->l_opencount <= 0)
1135         continue;
1136       if (!_dl_name_match_p (name, l))
1137         {
1138           const char *soname;
1139
1140           if (l->l_info[DT_SONAME] == NULL)
1141             continue;
1142
1143           soname = (const char *) (l->l_addr
1144                                    + l->l_info[DT_STRTAB]->d_un.d_ptr
1145                                    + l->l_info[DT_SONAME]->d_un.d_val);
1146           if (strcmp (name, soname) != 0)
1147             continue;
1148
1149           /* We have a match on a new name -- cache it.  */
1150           add_name_to_object (l, soname);
1151         }
1152
1153       /* We have a match -- bump the reference count and return it.  */
1154       ++l->l_opencount;
1155       return l;
1156     }
1157
1158   /* Display information if we are debugging.  */
1159   if (_dl_debug_files && loader != NULL)
1160     _dl_debug_message (1, "\nfile=", name, ";  needed by ",
1161                        loader->l_name[0] ? loader->l_name : _dl_argv[0],
1162                        "\n", NULL);
1163
1164   if (strchr (name, '/') == NULL)
1165     {
1166       /* Search for NAME in several places.  */
1167
1168       size_t namelen = strlen (name) + 1;
1169
1170       if (_dl_debug_libs)
1171         _dl_debug_message (1, "find library=", name, "; searching\n", NULL);
1172
1173       fd = -1;
1174
1175       /* First try the DT_RPATH of the dependent object that caused NAME
1176          to be loaded.  Then that object's dependent, and on up.  */
1177       for (l = loader; fd == -1 && l; l = l->l_loader)
1178         if (l && l->l_info[DT_RPATH])
1179           {
1180             /* Make sure the cache information is available.  */
1181             if (l->l_rpath_dirs == NULL)
1182               {
1183                 size_t ptrval = (l->l_addr
1184                                  + l->l_info[DT_STRTAB]->d_un.d_ptr
1185                                  + l->l_info[DT_RPATH]->d_un.d_val);
1186                 l->l_rpath_dirs =
1187                   decompose_rpath ((const char *) ptrval, l);
1188               }
1189
1190             if (l->l_rpath_dirs != NULL)
1191               fd = open_path (name, namelen, preloaded, l->l_rpath_dirs,
1192                               &realname);
1193           }
1194
1195       /* If dynamically linked, try the DT_RPATH of the executable itself.  */
1196       l = _dl_loaded;
1197       if (fd == -1 && l && l->l_type != lt_loaded && l != loader
1198           && l->l_rpath_dirs != NULL)
1199         fd = open_path (name, namelen, preloaded, l->l_rpath_dirs, &realname);
1200
1201       /* Try the LD_LIBRARY_PATH environment variable.  */
1202       if (fd == -1 && env_path_list != NULL)
1203         fd = open_path (name, namelen, preloaded, env_path_list, &realname);
1204
1205       if (fd == -1)
1206         {
1207           /* Check the list of libraries in the file /etc/ld.so.cache,
1208              for compatibility with Linux's ldconfig program.  */
1209           extern const char *_dl_load_cache_lookup (const char *name);
1210           const char *cached = _dl_load_cache_lookup (name);
1211           if (cached)
1212             {
1213               fd = __open (cached, O_RDONLY);
1214               if (fd != -1)
1215                 {
1216                   realname = local_strdup (cached);
1217                   if (realname == NULL)
1218                     {
1219                       __close (fd);
1220                       fd = -1;
1221                     }
1222                 }
1223             }
1224         }
1225
1226       /* Finally, try the default path.  */
1227       if (fd == -1)
1228         fd = open_path (name, namelen, preloaded, rtld_search_dirs, &realname);
1229
1230       /* Add another newline when we a tracing the library loading.  */
1231       if (_dl_debug_libs)
1232         _dl_debug_message (1, "\n", NULL);
1233     }
1234   else
1235     {
1236       /* The path may contain dynamic string tokens.  */
1237       realname = (loader
1238                   ? expand_dynamic_string_token (loader, name)
1239                   : local_strdup (name));
1240       if (realname == NULL)
1241         fd = -1;
1242       else
1243         {
1244           fd = __open (realname, O_RDONLY);
1245           if (fd == -1)
1246             free (realname);
1247         }
1248     }
1249
1250   if (fd == -1)
1251     {
1252       if (trace_mode)
1253         {
1254           /* We haven't found an appropriate library.  But since we
1255              are only interested in the list of libraries this isn't
1256              so severe.  Fake an entry with all the information we
1257              have.  */
1258           static const ElfW(Symndx) dummy_bucket = STN_UNDEF;
1259
1260           /* Enter the new object in the list of loaded objects.  */
1261           if ((name_copy = local_strdup (name)) == NULL
1262               || (l = _dl_new_object (name_copy, name, type, loader)) == NULL)
1263             _dl_signal_error (ENOMEM, name,
1264                               "cannot create shared object descriptor");
1265           /* We use an opencount of 0 as a sign for the faked entry.  */
1266           l->l_opencount = 0;
1267           l->l_reserved = 0;
1268           l->l_buckets = &dummy_bucket;
1269           l->l_nbuckets = 1;
1270           l->l_relocated = 1;
1271
1272           return l;
1273         }
1274       else
1275         _dl_signal_error (errno, name, "cannot open shared object file");
1276     }
1277
1278   return _dl_map_object_from_fd (name, fd, realname, loader, type);
1279 }