1 /* Map in a shared object's segments from the file.
2 Copyright (C) 1995-2017 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
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.
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.
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <http://www.gnu.org/licenses/>. */
28 #include <bits/wordsize.h>
30 #include <sys/param.h>
32 #include <sys/types.h>
33 #include "dynamic-link.h"
35 #include <stackinfo.h>
38 #include <stap-probe.h>
39 #include <libc-pointer-arith.h>
40 #include <array_length.h>
44 #include <dl-map-segments.h>
45 #include <dl-unmap-segments.h>
46 #include <dl-machine-reject-phdr.h>
47 #include <dl-sysdep-open.h>
51 #if BYTE_ORDER == BIG_ENDIAN
52 # define byteorder ELFDATA2MSB
53 #elif BYTE_ORDER == LITTLE_ENDIAN
54 # define byteorder ELFDATA2LSB
56 # error "Unknown BYTE_ORDER " BYTE_ORDER
57 # define byteorder ELFDATANONE
60 #define STRING(x) __STRING (x)
63 int __stack_prot attribute_hidden attribute_relro
64 #if _STACK_GROWS_DOWN && defined PROT_GROWSDOWN
66 #elif _STACK_GROWS_UP && defined PROT_GROWSUP
73 /* Type for the buffer we put the ELF header and hopefully the program
74 header. This buffer does not really have to be too large. In most
75 cases the program header follows the ELF header directly. If this
76 is not the case all bets are off and we can make the header
77 arbitrarily large and still won't get it read. This means the only
78 question is how large are the ELF and program header combined. The
79 ELF header 32-bit files is 52 bytes long and in 64-bit files is 64
80 bytes long. Each program header entry is again 32 and 56 bytes
81 long respectively. I.e., even with a file which has 10 program
82 header entries we only have to read 372B/624B respectively. Add to
83 this a bit of margin for program notes and reading 512B and 832B
84 for 32-bit and 64-bit files respecitvely is enough. If this
85 heuristic should really fail for some file the code in
86 `_dl_map_object_from_fd' knows how to recover. */
91 # define FILEBUF_SIZE 512
93 # define FILEBUF_SIZE 832
95 char buf
[FILEBUF_SIZE
] __attribute__ ((aligned (__alignof (ElfW(Ehdr
)))));
98 /* This is the decomposed LD_LIBRARY_PATH search path. */
99 static struct r_search_path_struct env_path_list attribute_relro
;
101 /* List of the hardware capabilities we might end up using. */
102 static const struct r_strlenpair
*capstr attribute_relro
;
103 static size_t ncapstr attribute_relro
;
104 static size_t max_capstrlen attribute_relro
;
107 /* Get the generated information about the trusted directories. Use
108 an array of concatenated strings to avoid relocations. See
109 gen-trusted-dirs.awk. */
110 #include "trusted-dirs.h"
112 static const char system_dirs
[] = SYSTEM_DIRS
;
113 static const size_t system_dirs_len
[] =
117 #define nsystem_dirs_len array_length (system_dirs_len)
120 is_trusted_path (const char *path
, size_t len
)
122 const char *trun
= system_dirs
;
124 for (size_t idx
= 0; idx
< nsystem_dirs_len
; ++idx
)
126 if (len
== system_dirs_len
[idx
] && memcmp (trun
, path
, len
) == 0)
130 trun
+= system_dirs_len
[idx
] + 1;
138 is_trusted_path_normalize (const char *path
, size_t len
)
149 char *npath
= (char *) alloca (len
+ 2);
151 while (*path
!= '\0')
157 if (path
[2] == '.' && (path
[3] == '/' || path
[3] == '\0'))
159 while (wnp
> npath
&& *--wnp
!= '/')
164 else if (path
[2] == '/' || path
[2] == '\0')
171 if (wnp
> npath
&& wnp
[-1] == '/')
181 if (wnp
== npath
|| wnp
[-1] != '/')
184 const char *trun
= system_dirs
;
186 for (size_t idx
= 0; idx
< nsystem_dirs_len
; ++idx
)
188 if (wnp
- npath
>= system_dirs_len
[idx
]
189 && memcmp (trun
, npath
, system_dirs_len
[idx
]) == 0)
193 trun
+= system_dirs_len
[idx
] + 1;
201 is_dst (const char *start
, const char *name
, const char *str
,
202 int is_path
, int secure
)
205 bool is_curly
= false;
214 while (name
[len
] == str
[len
] && name
[len
] != '\0')
219 if (name
[len
] != '}')
222 /* Point again at the beginning of the name. */
224 /* Skip over closing curly brace and adjust for the --name. */
227 else if (name
[len
] != '\0' && name
[len
] != '/'
228 && (!is_path
|| name
[len
] != ':'))
231 if (__glibc_unlikely (secure
)
232 && ((name
[len
] != '\0' && name
[len
] != '/'
233 && (!is_path
|| name
[len
] != ':'))
234 || (name
!= start
+ 1 && (!is_path
|| name
[-2] != ':'))))
242 _dl_dst_count (const char *name
, int is_path
)
244 const char *const start
= name
;
251 /* $ORIGIN is not expanded for SUID/GUID programs (except if it
252 is $ORIGIN alone) and it must always appear first in path. */
254 if ((len
= is_dst (start
, name
, "ORIGIN", is_path
,
255 __libc_enable_secure
)) != 0
256 || (len
= is_dst (start
, name
, "PLATFORM", is_path
, 0)) != 0
257 || (len
= is_dst (start
, name
, "LIB", is_path
, 0)) != 0)
260 name
= strchr (name
+ len
, '$');
262 while (name
!= NULL
);
269 _dl_dst_substitute (struct link_map
*l
, const char *name
, char *result
,
272 const char *const start
= name
;
274 /* Now fill the result path. While copying over the string we keep
275 track of the start of the last path element. When we come across
276 a DST we copy over the value or (if the value is not available)
277 leave the entire path element out. */
279 char *last_elem
= result
;
280 bool check_for_trusted
= false;
284 if (__glibc_unlikely (*name
== '$'))
286 const char *repl
= NULL
;
290 if ((len
= is_dst (start
, name
, "ORIGIN", is_path
,
291 __libc_enable_secure
)) != 0)
294 check_for_trusted
= (__libc_enable_secure
295 && l
->l_type
== lt_executable
);
297 else if ((len
= is_dst (start
, name
, "PLATFORM", is_path
, 0)) != 0)
298 repl
= GLRO(dl_platform
);
299 else if ((len
= is_dst (start
, name
, "LIB", is_path
, 0)) != 0)
302 if (repl
!= NULL
&& repl
!= (const char *) -1)
304 wp
= __stpcpy (wp
, repl
);
309 /* We cannot use this path element, the value of the
310 replacement is unknown. */
313 while (*name
!= '\0' && (!is_path
|| *name
!= ':'))
315 /* Also skip following colon if this is the first rpath
316 element, but keep an empty element at the end. */
317 if (wp
== result
&& is_path
&& *name
== ':' && name
[1] != '\0')
321 /* No DST we recognize. */
327 if (is_path
&& *name
== ':')
329 /* In SUID/SGID programs, after $ORIGIN expansion the
330 normalized path must be rooted in one of the trusted
332 if (__glibc_unlikely (check_for_trusted
)
333 && !is_trusted_path_normalize (last_elem
, wp
- last_elem
))
338 check_for_trusted
= false;
342 while (*name
!= '\0');
344 /* In SUID/SGID programs, after $ORIGIN expansion the normalized
345 path must be rooted in one of the trusted directories. */
346 if (__glibc_unlikely (check_for_trusted
)
347 && !is_trusted_path_normalize (last_elem
, wp
- last_elem
))
356 /* Return copy of argument with all recognized dynamic string tokens
357 ($ORIGIN and $PLATFORM for now) replaced. On some platforms it
358 might not be possible to determine the path from which the object
359 belonging to the map is loaded. In this case the path element
360 containing $ORIGIN is left out. */
362 expand_dynamic_string_token (struct link_map
*l
, const char *s
, int is_path
)
364 /* We make two runs over the string. First we determine how large the
365 resulting string is and then we copy it over. Since this is no
366 frequently executed operation we are looking here not for performance
367 but rather for code size. */
372 /* Determine the number of DST elements. */
373 cnt
= DL_DST_COUNT (s
, is_path
);
375 /* If we do not have to replace anything simply copy the string. */
376 if (__glibc_likely (cnt
== 0))
379 /* Determine the length of the substituted string. */
380 total
= DL_DST_REQUIRED (l
, s
, strlen (s
), cnt
);
382 /* Allocate the necessary memory. */
383 result
= (char *) malloc (total
+ 1);
387 return _dl_dst_substitute (l
, s
, result
, is_path
);
391 /* Add `name' to the list of names for a particular shared object.
392 `name' is expected to have been allocated with malloc and will
393 be freed if the shared object already has this name.
394 Returns false if the object already had this name. */
396 add_name_to_object (struct link_map
*l
, const char *name
)
398 struct libname_list
*lnp
, *lastp
;
399 struct libname_list
*newname
;
403 for (lnp
= l
->l_libname
; lnp
!= NULL
; lastp
= lnp
, lnp
= lnp
->next
)
404 if (strcmp (name
, lnp
->name
) == 0)
407 name_len
= strlen (name
) + 1;
408 newname
= (struct libname_list
*) malloc (sizeof *newname
+ name_len
);
411 /* No more memory. */
412 _dl_signal_error (ENOMEM
, name
, NULL
, N_("cannot allocate name record"));
415 /* The object should have a libname set from _dl_new_object. */
416 assert (lastp
!= NULL
);
418 newname
->name
= memcpy (newname
+ 1, name
, name_len
);
419 newname
->next
= NULL
;
420 newname
->dont_free
= 0;
421 lastp
->next
= newname
;
424 /* Standard search directories. */
425 static struct r_search_path_struct rtld_search_dirs attribute_relro
;
427 static size_t max_dirnamelen
;
429 static struct r_search_path_elem
**
430 fillin_rpath (char *rpath
, struct r_search_path_elem
**result
, const char *sep
,
431 int check_trusted
, const char *what
, const char *where
,
438 while ((cp
= __strsep (&rpath
, sep
)) != NULL
)
440 struct r_search_path_elem
*dirp
;
442 to_free
= cp
= expand_dynamic_string_token (l
, cp
, 1);
444 size_t len
= strlen (cp
);
446 /* `strsep' can pass an empty string. This has to be
447 interpreted as `use the current directory'. */
450 static const char curwd
[] = "./";
454 /* Remove trailing slashes (except for "/"). */
455 while (len
> 1 && cp
[len
- 1] == '/')
458 /* Now add one if there is none so far. */
459 if (len
> 0 && cp
[len
- 1] != '/')
462 /* Make sure we don't use untrusted directories if we run SUID. */
463 if (__glibc_unlikely (check_trusted
) && !is_trusted_path (cp
, len
))
469 /* See if this directory is already known. */
470 for (dirp
= GL(dl_all_dirs
); dirp
!= NULL
; dirp
= dirp
->next
)
471 if (dirp
->dirnamelen
== len
&& memcmp (cp
, dirp
->dirname
, len
) == 0)
476 /* It is available, see whether it's on our own list. */
478 for (cnt
= 0; cnt
< nelems
; ++cnt
)
479 if (result
[cnt
] == dirp
)
483 result
[nelems
++] = dirp
;
488 enum r_dir_status init_val
;
489 size_t where_len
= where
? strlen (where
) + 1 : 0;
491 /* It's a new directory. Create an entry and add it. */
492 dirp
= (struct r_search_path_elem
*)
493 malloc (sizeof (*dirp
) + ncapstr
* sizeof (enum r_dir_status
)
494 + where_len
+ len
+ 1);
496 _dl_signal_error (ENOMEM
, NULL
, NULL
,
497 N_("cannot create cache for search path"));
499 dirp
->dirname
= ((char *) dirp
+ sizeof (*dirp
)
500 + ncapstr
* sizeof (enum r_dir_status
));
501 *((char *) __mempcpy ((char *) dirp
->dirname
, cp
, len
)) = '\0';
502 dirp
->dirnamelen
= len
;
504 if (len
> max_dirnamelen
)
505 max_dirnamelen
= len
;
507 /* We have to make sure all the relative directories are
508 never ignored. The current directory might change and
509 all our saved information would be void. */
510 init_val
= cp
[0] != '/' ? existing
: unknown
;
511 for (cnt
= 0; cnt
< ncapstr
; ++cnt
)
512 dirp
->status
[cnt
] = init_val
;
515 if (__glibc_likely (where
!= NULL
))
516 dirp
->where
= memcpy ((char *) dirp
+ sizeof (*dirp
) + len
+ 1
517 + (ncapstr
* sizeof (enum r_dir_status
)),
522 dirp
->next
= GL(dl_all_dirs
);
523 GL(dl_all_dirs
) = dirp
;
525 /* Put it in the result array. */
526 result
[nelems
++] = dirp
;
531 /* Terminate the array. */
532 result
[nelems
] = NULL
;
539 decompose_rpath (struct r_search_path_struct
*sps
,
540 const char *rpath
, struct link_map
*l
, const char *what
)
542 /* Make a copy we can work with. */
543 const char *where
= l
->l_name
;
546 struct r_search_path_elem
**result
;
548 /* Initialize to please the compiler. */
549 const char *errstring
= NULL
;
551 /* First see whether we must forget the RUNPATH and RPATH from this
553 if (__glibc_unlikely (GLRO(dl_inhibit_rpath
) != NULL
)
554 && !__libc_enable_secure
)
556 const char *inhp
= GLRO(dl_inhibit_rpath
);
560 const char *wp
= where
;
562 while (*inhp
== *wp
&& *wp
!= '\0')
568 if (*wp
== '\0' && (*inhp
== '\0' || *inhp
== ':'))
570 /* This object is on the list of objects for which the
571 RUNPATH and RPATH must not be used. */
572 sps
->dirs
= (void *) -1;
576 while (*inhp
!= '\0')
580 while (*inhp
!= '\0');
583 /* Make a writable copy. */
584 copy
= __strdup (rpath
);
587 errstring
= N_("cannot create RUNPATH/RPATH copy");
591 /* Ignore empty rpaths. */
595 sps
->dirs
= (struct r_search_path_elem
**) -1;
599 /* Count the number of necessary elements in the result array. */
601 for (cp
= copy
; *cp
!= '\0'; ++cp
)
605 /* Allocate room for the result. NELEMS + 1 is an upper limit for the
606 number of necessary entries. */
607 result
= (struct r_search_path_elem
**) malloc ((nelems
+ 1 + 1)
612 errstring
= N_("cannot create cache for search path");
614 _dl_signal_error (ENOMEM
, NULL
, NULL
, errstring
);
617 fillin_rpath (copy
, result
, ":", 0, what
, where
, l
);
619 /* Free the copied RPATH string. `fillin_rpath' make own copies if
624 /* The caller will change this value if we haven't used a real malloc. */
629 /* Make sure cached path information is stored in *SP
630 and return true if there are any paths to search there. */
632 cache_rpath (struct link_map
*l
,
633 struct r_search_path_struct
*sp
,
637 if (sp
->dirs
== (void *) -1)
640 if (sp
->dirs
!= NULL
)
643 if (l
->l_info
[tag
] == NULL
)
645 /* There is no path. */
646 sp
->dirs
= (void *) -1;
650 /* Make sure the cache information is available. */
651 return decompose_rpath (sp
, (const char *) (D_PTR (l
, l_info
[DT_STRTAB
])
652 + l
->l_info
[tag
]->d_un
.d_val
),
658 _dl_init_paths (const char *llp
)
662 struct r_search_path_elem
*pelem
, **aelem
;
664 struct link_map
__attribute__ ((unused
)) *l
= NULL
;
665 /* Initialize to please the compiler. */
666 const char *errstring
= NULL
;
668 /* Fill in the information about the application's RPATH and the
669 directories addressed by the LD_LIBRARY_PATH environment variable. */
671 /* Get the capabilities. */
672 capstr
= _dl_important_hwcaps (GLRO(dl_platform
), GLRO(dl_platformlen
),
673 &ncapstr
, &max_capstrlen
);
675 /* First set up the rest of the default search directory entries. */
676 aelem
= rtld_search_dirs
.dirs
= (struct r_search_path_elem
**)
677 malloc ((nsystem_dirs_len
+ 1) * sizeof (struct r_search_path_elem
*));
678 if (rtld_search_dirs
.dirs
== NULL
)
680 errstring
= N_("cannot create search path array");
682 _dl_signal_error (ENOMEM
, NULL
, NULL
, errstring
);
685 round_size
= ((2 * sizeof (struct r_search_path_elem
) - 1
686 + ncapstr
* sizeof (enum r_dir_status
))
687 / sizeof (struct r_search_path_elem
));
689 rtld_search_dirs
.dirs
[0] = malloc (nsystem_dirs_len
* round_size
690 * sizeof (*rtld_search_dirs
.dirs
[0]));
691 if (rtld_search_dirs
.dirs
[0] == NULL
)
693 errstring
= N_("cannot create cache for search path");
697 rtld_search_dirs
.malloced
= 0;
698 pelem
= GL(dl_all_dirs
) = rtld_search_dirs
.dirs
[0];
708 pelem
->what
= "system search path";
711 pelem
->dirname
= strp
;
712 pelem
->dirnamelen
= system_dirs_len
[idx
];
713 strp
+= system_dirs_len
[idx
] + 1;
715 /* System paths must be absolute. */
716 assert (pelem
->dirname
[0] == '/');
717 for (cnt
= 0; cnt
< ncapstr
; ++cnt
)
718 pelem
->status
[cnt
] = unknown
;
720 pelem
->next
= (++idx
== nsystem_dirs_len
? NULL
: (pelem
+ round_size
));
724 while (idx
< nsystem_dirs_len
);
726 max_dirnamelen
= SYSTEM_DIRS_MAX_LEN
;
730 /* This points to the map of the main object. */
731 l
= GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
;
734 assert (l
->l_type
!= lt_loaded
);
736 if (l
->l_info
[DT_RUNPATH
])
738 /* Allocate room for the search path and fill in information
740 decompose_rpath (&l
->l_runpath_dirs
,
741 (const void *) (D_PTR (l
, l_info
[DT_STRTAB
])
742 + l
->l_info
[DT_RUNPATH
]->d_un
.d_val
),
744 /* During rtld init the memory is allocated by the stub malloc,
745 prevent any attempt to free it by the normal malloc. */
746 l
->l_runpath_dirs
.malloced
= 0;
748 /* The RPATH is ignored. */
749 l
->l_rpath_dirs
.dirs
= (void *) -1;
753 l
->l_runpath_dirs
.dirs
= (void *) -1;
755 if (l
->l_info
[DT_RPATH
])
757 /* Allocate room for the search path and fill in information
759 decompose_rpath (&l
->l_rpath_dirs
,
760 (const void *) (D_PTR (l
, l_info
[DT_STRTAB
])
761 + l
->l_info
[DT_RPATH
]->d_un
.d_val
),
763 /* During rtld init the memory is allocated by the stub
764 malloc, prevent any attempt to free it by the normal
766 l
->l_rpath_dirs
.malloced
= 0;
769 l
->l_rpath_dirs
.dirs
= (void *) -1;
774 if (llp
!= NULL
&& *llp
!= '\0')
777 const char *cp
= llp
;
782 size_t cnt
= DL_DST_COUNT (llp
, 1);
783 if (__glibc_likely (cnt
== 0))
784 llp_tmp
= strdupa (llp
);
787 /* Determine the length of the substituted string. */
788 size_t total
= DL_DST_REQUIRED (l
, llp
, strlen (llp
), cnt
);
790 /* Allocate the necessary memory. */
791 llp_tmp
= (char *) alloca (total
+ 1);
792 llp_tmp
= _dl_dst_substitute (l
, llp
, llp_tmp
, 1);
795 llp_tmp
= strdupa (llp
);
798 /* Decompose the LD_LIBRARY_PATH contents. First determine how many
803 if (*cp
== ':' || *cp
== ';')
808 env_path_list
.dirs
= (struct r_search_path_elem
**)
809 malloc ((nllp
+ 1) * sizeof (struct r_search_path_elem
*));
810 if (env_path_list
.dirs
== NULL
)
812 errstring
= N_("cannot create cache for search path");
816 (void) fillin_rpath (llp_tmp
, env_path_list
.dirs
, ":;",
817 __libc_enable_secure
, "LD_LIBRARY_PATH",
820 if (env_path_list
.dirs
[0] == NULL
)
822 free (env_path_list
.dirs
);
823 env_path_list
.dirs
= (void *) -1;
826 env_path_list
.malloced
= 0;
829 env_path_list
.dirs
= (void *) -1;
834 __attribute__ ((noreturn
, noinline
))
835 lose (int code
, int fd
, const char *name
, char *realname
, struct link_map
*l
,
836 const char *msg
, struct r_debug
*r
, Lmid_t nsid
)
838 /* The file might already be closed. */
841 if (l
!= NULL
&& l
->l_origin
!= (char *) -1l)
842 free ((char *) l
->l_origin
);
848 r
->r_state
= RT_CONSISTENT
;
850 LIBC_PROBE (map_failed
, 2, nsid
, r
);
853 _dl_signal_error (code
, name
, NULL
, msg
);
857 /* Map in the shared object NAME, actually located in REALNAME, and already
860 #ifndef EXTERNAL_MAP_FROM_FD
864 _dl_map_object_from_fd (const char *name
, const char *origname
, int fd
,
865 struct filebuf
*fbp
, char *realname
,
866 struct link_map
*loader
, int l_type
, int mode
,
867 void **stack_endp
, Lmid_t nsid
)
869 struct link_map
*l
= NULL
;
870 const ElfW(Ehdr
) *header
;
871 const ElfW(Phdr
) *phdr
;
872 const ElfW(Phdr
) *ph
;
875 /* Initialize to keep the compiler happy. */
876 const char *errstring
= NULL
;
878 struct r_debug
*r
= _dl_debug_initialize (0, nsid
);
879 bool make_consistent
= false;
881 /* Get file information. */
883 if (__glibc_unlikely (!_dl_get_file_id (fd
, &id
)))
885 errstring
= N_("cannot stat shared object");
889 lose (errval
, fd
, name
, realname
, l
, errstring
,
890 make_consistent
? r
: NULL
, nsid
);
893 /* Look again to see if the real name matched another already loaded. */
894 for (l
= GL(dl_ns
)[nsid
]._ns_loaded
; l
!= NULL
; l
= l
->l_next
)
895 if (!l
->l_removed
&& _dl_file_id_match_p (&l
->l_file_id
, &id
))
897 /* The object is already loaded.
898 Just bump its reference count and return it. */
901 /* If the name is not in the list of names for this object add
904 add_name_to_object (l
, name
);
910 /* When loading into a namespace other than the base one we must
911 avoid loading ld.so since there can only be one copy. Ever. */
912 if (__glibc_unlikely (nsid
!= LM_ID_BASE
)
913 && (_dl_file_id_match_p (&id
, &GL(dl_rtld_map
).l_file_id
)
914 || _dl_name_match_p (name
, &GL(dl_rtld_map
))))
916 /* This is indeed ld.so. Create a new link_map which refers to
917 the real one for almost everything. */
918 l
= _dl_new_object (realname
, name
, l_type
, loader
, mode
, nsid
);
922 /* Refer to the real descriptor. */
923 l
->l_real
= &GL(dl_rtld_map
);
925 /* No need to bump the refcount of the real object, ld.so will
926 never be unloaded. */
929 /* Add the map for the mirrored object to the object list. */
930 _dl_add_to_namespace_list (l
, nsid
);
936 if (mode
& RTLD_NOLOAD
)
938 /* We are not supposed to load the object unless it is already
939 loaded. So return now. */
945 /* Print debugging message. */
946 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_FILES
))
947 _dl_debug_printf ("file=%s [%lu]; generating link map\n", name
, nsid
);
949 /* This is the ELF header. We read it in `open_verify'. */
950 header
= (void *) fbp
->buf
;
954 if (_dl_zerofd
== -1)
956 _dl_zerofd
= _dl_sysdep_open_zero_fill ();
957 if (_dl_zerofd
== -1)
961 _dl_signal_error (errno
, NULL
, NULL
,
962 N_("cannot open zero fill device"));
967 /* Signal that we are going to add new objects. */
968 if (r
->r_state
== RT_CONSISTENT
)
971 /* Auditing checkpoint: we are going to add new objects. */
972 if ((mode
& __RTLD_AUDIT
) == 0
973 && __glibc_unlikely (GLRO(dl_naudit
) > 0))
975 struct link_map
*head
= GL(dl_ns
)[nsid
]._ns_loaded
;
976 /* Do not call the functions for any auditing object. */
977 if (head
->l_auditing
== 0)
979 struct audit_ifaces
*afct
= GLRO(dl_audit
);
980 for (unsigned int cnt
= 0; cnt
< GLRO(dl_naudit
); ++cnt
)
982 if (afct
->activity
!= NULL
)
983 afct
->activity (&head
->l_audit
[cnt
].cookie
, LA_ACT_ADD
);
991 /* Notify the debugger we have added some objects. We need to
992 call _dl_debug_initialize in a static program in case dynamic
993 linking has not been used before. */
996 LIBC_PROBE (map_start
, 2, nsid
, r
);
997 make_consistent
= true;
1000 assert (r
->r_state
== RT_ADD
);
1002 /* Enter the new object in the list of loaded objects. */
1003 l
= _dl_new_object (realname
, name
, l_type
, loader
, mode
, nsid
);
1004 if (__glibc_unlikely (l
== NULL
))
1009 errstring
= N_("cannot create shared object descriptor");
1010 goto call_lose_errno
;
1013 /* Extract the remaining details we need from the ELF header
1014 and then read in the program header table. */
1015 l
->l_entry
= header
->e_entry
;
1016 type
= header
->e_type
;
1017 l
->l_phnum
= header
->e_phnum
;
1019 maplength
= header
->e_phnum
* sizeof (ElfW(Phdr
));
1020 if (header
->e_phoff
+ maplength
<= (size_t) fbp
->len
)
1021 phdr
= (void *) (fbp
->buf
+ header
->e_phoff
);
1024 phdr
= alloca (maplength
);
1025 __lseek (fd
, header
->e_phoff
, SEEK_SET
);
1026 if ((size_t) __libc_read (fd
, (void *) phdr
, maplength
) != maplength
)
1028 errstring
= N_("cannot read file data");
1029 goto call_lose_errno
;
1033 /* On most platforms presume that PT_GNU_STACK is absent and the stack is
1034 * executable. Other platforms default to a nonexecutable stack and don't
1035 * need PT_GNU_STACK to do so. */
1036 uint_fast16_t stack_flags
= DEFAULT_STACK_PERMS
;
1039 /* Scan the program header table, collecting its load commands. */
1040 struct loadcmd loadcmds
[l
->l_phnum
];
1041 size_t nloadcmds
= 0;
1042 bool has_holes
= false;
1044 /* The struct is initialized to zero so this is not necessary:
1048 for (ph
= phdr
; ph
< &phdr
[l
->l_phnum
]; ++ph
)
1051 /* These entries tell us where to find things once the file's
1052 segments are mapped in. We record the addresses it says
1053 verbatim, and later correct for the run-time load address. */
1057 /* Debuginfo only files from "objcopy --only-keep-debug"
1058 contain a PT_DYNAMIC segment with p_filesz == 0. Skip
1059 such a segment to avoid a crash later. */
1060 l
->l_ld
= (void *) ph
->p_vaddr
;
1061 l
->l_ldnum
= ph
->p_memsz
/ sizeof (ElfW(Dyn
));
1066 l
->l_phdr
= (void *) ph
->p_vaddr
;
1070 /* A load command tells us to map in part of the file.
1071 We record the load commands and process them all later. */
1072 if (__glibc_unlikely ((ph
->p_align
& (GLRO(dl_pagesize
) - 1)) != 0))
1074 errstring
= N_("ELF load command alignment not page-aligned");
1077 if (__glibc_unlikely (((ph
->p_vaddr
- ph
->p_offset
)
1078 & (ph
->p_align
- 1)) != 0))
1081 = N_("ELF load command address/offset not properly aligned");
1085 struct loadcmd
*c
= &loadcmds
[nloadcmds
++];
1086 c
->mapstart
= ALIGN_DOWN (ph
->p_vaddr
, GLRO(dl_pagesize
));
1087 c
->mapend
= ALIGN_UP (ph
->p_vaddr
+ ph
->p_filesz
, GLRO(dl_pagesize
));
1088 c
->dataend
= ph
->p_vaddr
+ ph
->p_filesz
;
1089 c
->allocend
= ph
->p_vaddr
+ ph
->p_memsz
;
1090 c
->mapoff
= ALIGN_DOWN (ph
->p_offset
, GLRO(dl_pagesize
));
1092 /* Determine whether there is a gap between the last segment
1094 if (nloadcmds
> 1 && c
[-1].mapend
!= c
->mapstart
)
1097 /* Optimize a common case. */
1098 #if (PF_R | PF_W | PF_X) == 7 && (PROT_READ | PROT_WRITE | PROT_EXEC) == 7
1099 c
->prot
= (PF_TO_PROT
1100 >> ((ph
->p_flags
& (PF_R
| PF_W
| PF_X
)) * 4)) & 0xf;
1103 if (ph
->p_flags
& PF_R
)
1104 c
->prot
|= PROT_READ
;
1105 if (ph
->p_flags
& PF_W
)
1106 c
->prot
|= PROT_WRITE
;
1107 if (ph
->p_flags
& PF_X
)
1108 c
->prot
|= PROT_EXEC
;
1113 if (ph
->p_memsz
== 0)
1114 /* Nothing to do for an empty segment. */
1117 l
->l_tls_blocksize
= ph
->p_memsz
;
1118 l
->l_tls_align
= ph
->p_align
;
1119 if (ph
->p_align
== 0)
1120 l
->l_tls_firstbyte_offset
= 0;
1122 l
->l_tls_firstbyte_offset
= ph
->p_vaddr
& (ph
->p_align
- 1);
1123 l
->l_tls_initimage_size
= ph
->p_filesz
;
1124 /* Since we don't know the load address yet only store the
1125 offset. We will adjust it later. */
1126 l
->l_tls_initimage
= (void *) ph
->p_vaddr
;
1128 /* If not loading the initial set of shared libraries,
1129 check whether we should permit loading a TLS segment. */
1130 if (__glibc_likely (l
->l_type
== lt_library
)
1131 /* If GL(dl_tls_dtv_slotinfo_list) == NULL, then rtld.c did
1132 not set up TLS data structures, so don't use them now. */
1133 || __glibc_likely (GL(dl_tls_dtv_slotinfo_list
) != NULL
))
1135 /* Assign the next available module ID. */
1136 l
->l_tls_modid
= _dl_next_tls_modid ();
1141 /* We are loading the executable itself when the dynamic
1142 linker was executed directly. The setup will happen
1143 later. Otherwise, the TLS data structures are already
1144 initialized, and we assigned a TLS modid above. */
1145 assert (l
->l_prev
== NULL
|| (mode
& __RTLD_AUDIT
) != 0);
1147 assert (false && "TLS not initialized in static application");
1152 stack_flags
= ph
->p_flags
;
1156 l
->l_relro_addr
= ph
->p_vaddr
;
1157 l
->l_relro_size
= ph
->p_memsz
;
1161 if (__glibc_unlikely (nloadcmds
== 0))
1163 /* This only happens for a bogus object that will be caught with
1164 another error below. But we don't want to go through the
1165 calculations below using NLOADCMDS - 1. */
1166 errstring
= N_("object file has no loadable segments");
1170 if (__glibc_unlikely (type
!= ET_DYN
)
1171 && __glibc_unlikely ((mode
& __RTLD_OPENEXEC
) == 0))
1173 /* This object is loaded at a fixed address. This must never
1174 happen for objects loaded with dlopen. */
1175 errstring
= N_("cannot dynamically load executable");
1179 /* Length of the sections to be loaded. */
1180 maplength
= loadcmds
[nloadcmds
- 1].allocend
- loadcmds
[0].mapstart
;
1182 /* Now process the load commands and map segments into memory.
1183 This is responsible for filling in:
1184 l_map_start, l_map_end, l_addr, l_contiguous, l_text_end, l_phdr
1186 errstring
= _dl_map_segments (l
, fd
, header
, type
, loadcmds
, nloadcmds
,
1187 maplength
, has_holes
, loader
);
1188 if (__glibc_unlikely (errstring
!= NULL
))
1194 if (__glibc_unlikely (type
== ET_DYN
))
1196 errstring
= N_("object file has no dynamic section");
1201 l
->l_ld
= (ElfW(Dyn
) *) ((ElfW(Addr
)) l
->l_ld
+ l
->l_addr
);
1203 elf_get_dynamic_info (l
, NULL
);
1205 /* Make sure we are not dlopen'ing an object that has the
1206 DF_1_NOOPEN flag set. */
1207 if (__glibc_unlikely (l
->l_flags_1
& DF_1_NOOPEN
)
1208 && (mode
& __RTLD_DLOPEN
))
1210 /* We are not supposed to load this object. Free all resources. */
1211 _dl_unmap_segments (l
);
1213 if (!l
->l_libname
->dont_free
)
1214 free (l
->l_libname
);
1216 if (l
->l_phdr_allocated
)
1217 free ((void *) l
->l_phdr
);
1219 errstring
= N_("shared object cannot be dlopen()ed");
1223 if (l
->l_phdr
== NULL
)
1225 /* The program header is not contained in any of the segments.
1226 We have to allocate memory ourself and copy it over from out
1228 ElfW(Phdr
) *newp
= (ElfW(Phdr
) *) malloc (header
->e_phnum
1229 * sizeof (ElfW(Phdr
)));
1232 errstring
= N_("cannot allocate memory for program header");
1233 goto call_lose_errno
;
1236 l
->l_phdr
= memcpy (newp
, phdr
,
1237 (header
->e_phnum
* sizeof (ElfW(Phdr
))));
1238 l
->l_phdr_allocated
= 1;
1241 /* Adjust the PT_PHDR value by the runtime load address. */
1242 l
->l_phdr
= (ElfW(Phdr
) *) ((ElfW(Addr
)) l
->l_phdr
+ l
->l_addr
);
1244 if (__glibc_unlikely ((stack_flags
&~ GL(dl_stack_flags
)) & PF_X
))
1246 if (__glibc_unlikely (__check_caller (RETURN_ADDRESS (0), allow_ldso
) != 0))
1248 errstring
= N_("invalid caller");
1252 /* The stack is presently not executable, but this module
1253 requires that it be executable. We must change the
1254 protection of the variable which contains the flags used in
1255 the mprotect calls. */
1257 if ((mode
& (__RTLD_DLOPEN
| __RTLD_AUDIT
)) == __RTLD_DLOPEN
)
1259 const uintptr_t p
= (uintptr_t) &__stack_prot
& -GLRO(dl_pagesize
);
1260 const size_t s
= (uintptr_t) (&__stack_prot
+ 1) - p
;
1262 struct link_map
*const m
= &GL(dl_rtld_map
);
1263 const uintptr_t relro_end
= ((m
->l_addr
+ m
->l_relro_addr
1265 & -GLRO(dl_pagesize
));
1266 if (__glibc_likely (p
+ s
<= relro_end
))
1268 /* The variable lies in the region protected by RELRO. */
1269 if (__mprotect ((void *) p
, s
, PROT_READ
|PROT_WRITE
) < 0)
1271 errstring
= N_("cannot change memory protections");
1272 goto call_lose_errno
;
1274 __stack_prot
|= PROT_READ
|PROT_WRITE
|PROT_EXEC
;
1275 __mprotect ((void *) p
, s
, PROT_READ
);
1278 __stack_prot
|= PROT_READ
|PROT_WRITE
|PROT_EXEC
;
1282 __stack_prot
|= PROT_READ
|PROT_WRITE
|PROT_EXEC
;
1284 #ifdef check_consistency
1285 check_consistency ();
1288 errval
= (*GL(dl_make_stack_executable_hook
)) (stack_endp
);
1292 cannot enable executable stack as shared object requires");
1297 /* Adjust the address of the TLS initialization image. */
1298 if (l
->l_tls_initimage
!= NULL
)
1299 l
->l_tls_initimage
= (char *) l
->l_tls_initimage
+ l
->l_addr
;
1301 /* We are done mapping in the file. We no longer need the descriptor. */
1302 if (__glibc_unlikely (__close (fd
) != 0))
1304 errstring
= N_("cannot close file descriptor");
1305 goto call_lose_errno
;
1307 /* Signal that we closed the file. */
1310 /* If this is ET_EXEC, we should have loaded it as lt_executable. */
1311 assert (type
!= ET_EXEC
|| l
->l_type
== lt_executable
);
1313 l
->l_entry
+= l
->l_addr
;
1315 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_FILES
))
1316 _dl_debug_printf ("\
1317 dynamic: 0x%0*lx base: 0x%0*lx size: 0x%0*Zx\n\
1318 entry: 0x%0*lx phdr: 0x%0*lx phnum: %*u\n\n",
1319 (int) sizeof (void *) * 2,
1320 (unsigned long int) l
->l_ld
,
1321 (int) sizeof (void *) * 2,
1322 (unsigned long int) l
->l_addr
,
1323 (int) sizeof (void *) * 2, maplength
,
1324 (int) sizeof (void *) * 2,
1325 (unsigned long int) l
->l_entry
,
1326 (int) sizeof (void *) * 2,
1327 (unsigned long int) l
->l_phdr
,
1328 (int) sizeof (void *) * 2, l
->l_phnum
);
1330 /* Set up the symbol hash table. */
1333 /* If this object has DT_SYMBOLIC set modify now its scope. We don't
1334 have to do this for the main map. */
1335 if ((mode
& RTLD_DEEPBIND
) == 0
1336 && __glibc_unlikely (l
->l_info
[DT_SYMBOLIC
] != NULL
)
1337 && &l
->l_searchlist
!= l
->l_scope
[0])
1339 /* Create an appropriate searchlist. It contains only this map.
1340 This is the definition of DT_SYMBOLIC in SysVr4. */
1341 l
->l_symbolic_searchlist
.r_list
[0] = l
;
1342 l
->l_symbolic_searchlist
.r_nlist
= 1;
1344 /* Now move the existing entries one back. */
1345 memmove (&l
->l_scope
[1], &l
->l_scope
[0],
1346 (l
->l_scope_max
- 1) * sizeof (l
->l_scope
[0]));
1348 /* Now add the new entry. */
1349 l
->l_scope
[0] = &l
->l_symbolic_searchlist
;
1352 /* Remember whether this object must be initialized first. */
1353 if (l
->l_flags_1
& DF_1_INITFIRST
)
1354 GL(dl_initfirst
) = l
;
1356 /* Finally the file information. */
1360 /* When auditing is used the recorded names might not include the
1361 name by which the DSO is actually known. Add that as well. */
1362 if (__glibc_unlikely (origname
!= NULL
))
1363 add_name_to_object (l
, origname
);
1365 /* Audit modules only exist when linking is dynamic so ORIGNAME
1366 cannot be non-NULL. */
1367 assert (origname
== NULL
);
1370 /* When we profile the SONAME might be needed for something else but
1371 loading. Add it right away. */
1372 if (__glibc_unlikely (GLRO(dl_profile
) != NULL
)
1373 && l
->l_info
[DT_SONAME
] != NULL
)
1374 add_name_to_object (l
, ((const char *) D_PTR (l
, l_info
[DT_STRTAB
])
1375 + l
->l_info
[DT_SONAME
]->d_un
.d_val
));
1377 #ifdef DL_AFTER_LOAD
1381 /* Now that the object is fully initialized add it to the object list. */
1382 _dl_add_to_namespace_list (l
, nsid
);
1385 /* Auditing checkpoint: we have a new object. */
1386 if (__glibc_unlikely (GLRO(dl_naudit
) > 0)
1387 && !GL(dl_ns
)[l
->l_ns
]._ns_loaded
->l_auditing
)
1389 struct audit_ifaces
*afct
= GLRO(dl_audit
);
1390 for (unsigned int cnt
= 0; cnt
< GLRO(dl_naudit
); ++cnt
)
1392 if (afct
->objopen
!= NULL
)
1394 l
->l_audit
[cnt
].bindflags
1395 = afct
->objopen (l
, nsid
, &l
->l_audit
[cnt
].cookie
);
1397 l
->l_audit_any_plt
|= l
->l_audit
[cnt
].bindflags
!= 0;
1408 /* Print search path. */
1410 print_search_path (struct r_search_path_elem
**list
,
1411 const char *what
, const char *name
)
1413 char buf
[max_dirnamelen
+ max_capstrlen
];
1416 _dl_debug_printf (" search path=");
1418 while (*list
!= NULL
&& (*list
)->what
== what
) /* Yes, ==. */
1420 char *endp
= __mempcpy (buf
, (*list
)->dirname
, (*list
)->dirnamelen
);
1423 for (cnt
= 0; cnt
< ncapstr
; ++cnt
)
1424 if ((*list
)->status
[cnt
] != nonexisting
)
1426 char *cp
= __mempcpy (endp
, capstr
[cnt
].str
, capstr
[cnt
].len
);
1427 if (cp
== buf
|| (cp
== buf
+ 1 && buf
[0] == '/'))
1432 _dl_debug_printf_c (first
? "%s" : ":%s", buf
);
1440 _dl_debug_printf_c ("\t\t(%s from file %s)\n", what
,
1441 DSO_FILENAME (name
));
1443 _dl_debug_printf_c ("\t\t(%s)\n", what
);
1446 /* Open a file and verify it is an ELF file for this architecture. We
1447 ignore only ELF files for other architectures. Non-ELF files and
1448 ELF files with different header information cause fatal errors since
1449 this could mean there is something wrong in the installation and the
1450 user might want to know about this.
1452 If FD is not -1, then the file is already open and FD refers to it.
1453 In that case, FD is consumed for both successful and error returns. */
1455 open_verify (const char *name
, int fd
,
1456 struct filebuf
*fbp
, struct link_map
*loader
,
1457 int whatcode
, int mode
, bool *found_other_class
, bool free_name
)
1459 /* This is the expected ELF header. */
1460 #define ELF32_CLASS ELFCLASS32
1461 #define ELF64_CLASS ELFCLASS64
1462 #ifndef VALID_ELF_HEADER
1463 # define VALID_ELF_HEADER(hdr,exp,size) (memcmp (hdr, exp, size) == 0)
1464 # define VALID_ELF_OSABI(osabi) (osabi == ELFOSABI_SYSV)
1465 # define VALID_ELF_ABIVERSION(osabi,ver) (ver == 0)
1466 #elif defined MORE_ELF_HEADER_DATA
1467 MORE_ELF_HEADER_DATA
;
1469 static const unsigned char expected
[EI_NIDENT
] =
1471 [EI_MAG0
] = ELFMAG0
,
1472 [EI_MAG1
] = ELFMAG1
,
1473 [EI_MAG2
] = ELFMAG2
,
1474 [EI_MAG3
] = ELFMAG3
,
1475 [EI_CLASS
] = ELFW(CLASS
),
1476 [EI_DATA
] = byteorder
,
1477 [EI_VERSION
] = EV_CURRENT
,
1478 [EI_OSABI
] = ELFOSABI_SYSV
,
1483 ElfW(Word
) vendorlen
;
1487 } expected_note
= { 4, 16, 1, "GNU" };
1488 /* Initialize it to make the compiler happy. */
1489 const char *errstring
= NULL
;
1493 /* Give the auditing libraries a chance. */
1494 if (__glibc_unlikely (GLRO(dl_naudit
) > 0) && whatcode
!= 0
1495 && loader
->l_auditing
== 0)
1497 const char *original_name
= name
;
1498 struct audit_ifaces
*afct
= GLRO(dl_audit
);
1499 for (unsigned int cnt
= 0; cnt
< GLRO(dl_naudit
); ++cnt
)
1501 if (afct
->objsearch
!= NULL
)
1503 name
= afct
->objsearch (name
, &loader
->l_audit
[cnt
].cookie
,
1506 /* Ignore the path. */
1513 if (fd
!= -1 && name
!= original_name
&& strcmp (name
, original_name
))
1515 /* An audit library changed what we're supposed to open,
1516 so FD no longer matches it. */
1524 /* Open the file. We always open files read-only. */
1525 fd
= __open (name
, O_RDONLY
| O_CLOEXEC
);
1530 ElfW(Phdr
) *phdr
, *ph
;
1531 ElfW(Word
) *abi_note
;
1532 unsigned int osversion
;
1535 /* We successfully opened the file. Now verify it is a file
1539 assert (sizeof (fbp
->buf
) > sizeof (ElfW(Ehdr
)));
1540 /* Read in the header. */
1543 ssize_t retlen
= __libc_read (fd
, fbp
->buf
+ fbp
->len
,
1544 sizeof (fbp
->buf
) - fbp
->len
);
1549 while (__glibc_unlikely (fbp
->len
< sizeof (ElfW(Ehdr
))));
1551 /* This is where the ELF header is loaded. */
1552 ehdr
= (ElfW(Ehdr
) *) fbp
->buf
;
1554 /* Now run the tests. */
1555 if (__glibc_unlikely (fbp
->len
< (ssize_t
) sizeof (ElfW(Ehdr
))))
1558 errstring
= (errval
== 0
1559 ? N_("file too short") : N_("cannot read file data"));
1563 char *realname
= (char *) name
;
1564 name
= strdupa (realname
);
1567 lose (errval
, fd
, name
, NULL
, NULL
, errstring
, NULL
, 0);
1570 /* See whether the ELF header is what we expect. */
1571 if (__glibc_unlikely (! VALID_ELF_HEADER (ehdr
->e_ident
, expected
,
1573 || !VALID_ELF_ABIVERSION (ehdr
->e_ident
[EI_OSABI
],
1574 ehdr
->e_ident
[EI_ABIVERSION
])
1575 || memcmp (&ehdr
->e_ident
[EI_PAD
],
1577 EI_NIDENT
- EI_PAD
) != 0))
1579 /* Something is wrong. */
1580 const Elf32_Word
*magp
= (const void *) ehdr
->e_ident
;
1582 #if BYTE_ORDER == LITTLE_ENDIAN
1583 ((ELFMAG0
<< (EI_MAG0
* 8)) |
1584 (ELFMAG1
<< (EI_MAG1
* 8)) |
1585 (ELFMAG2
<< (EI_MAG2
* 8)) |
1586 (ELFMAG3
<< (EI_MAG3
* 8)))
1588 ((ELFMAG0
<< (EI_MAG3
* 8)) |
1589 (ELFMAG1
<< (EI_MAG2
* 8)) |
1590 (ELFMAG2
<< (EI_MAG1
* 8)) |
1591 (ELFMAG3
<< (EI_MAG0
* 8)))
1594 errstring
= N_("invalid ELF header");
1595 else if (ehdr
->e_ident
[EI_CLASS
] != ELFW(CLASS
))
1597 /* This is not a fatal error. On architectures where
1598 32-bit and 64-bit binaries can be run this might
1600 *found_other_class
= true;
1603 else if (ehdr
->e_ident
[EI_DATA
] != byteorder
)
1605 if (BYTE_ORDER
== BIG_ENDIAN
)
1606 errstring
= N_("ELF file data encoding not big-endian");
1608 errstring
= N_("ELF file data encoding not little-endian");
1610 else if (ehdr
->e_ident
[EI_VERSION
] != EV_CURRENT
)
1612 = N_("ELF file version ident does not match current one");
1613 /* XXX We should be able so set system specific versions which are
1615 else if (!VALID_ELF_OSABI (ehdr
->e_ident
[EI_OSABI
]))
1616 errstring
= N_("ELF file OS ABI invalid");
1617 else if (!VALID_ELF_ABIVERSION (ehdr
->e_ident
[EI_OSABI
],
1618 ehdr
->e_ident
[EI_ABIVERSION
]))
1619 errstring
= N_("ELF file ABI version invalid");
1620 else if (memcmp (&ehdr
->e_ident
[EI_PAD
], &expected
[EI_PAD
],
1621 EI_NIDENT
- EI_PAD
) != 0)
1622 errstring
= N_("nonzero padding in e_ident");
1624 /* Otherwise we don't know what went wrong. */
1625 errstring
= N_("internal error");
1630 if (__glibc_unlikely (ehdr
->e_version
!= EV_CURRENT
))
1632 errstring
= N_("ELF file version does not match current one");
1635 if (! __glibc_likely (elf_machine_matches_host (ehdr
)))
1637 else if (__glibc_unlikely (ehdr
->e_type
!= ET_DYN
1638 && ehdr
->e_type
!= ET_EXEC
))
1640 errstring
= N_("only ET_DYN and ET_EXEC can be loaded");
1643 else if (__glibc_unlikely (ehdr
->e_type
== ET_EXEC
1644 && (mode
& __RTLD_OPENEXEC
) == 0))
1646 /* BZ #16634. It is an error to dlopen ET_EXEC (unless
1647 __RTLD_OPENEXEC is explicitly set). We return error here
1648 so that code in _dl_map_object_from_fd does not try to set
1649 l_tls_modid for this module. */
1651 errstring
= N_("cannot dynamically load executable");
1654 else if (__glibc_unlikely (ehdr
->e_phentsize
!= sizeof (ElfW(Phdr
))))
1656 errstring
= N_("ELF file's phentsize not the expected size");
1660 maplength
= ehdr
->e_phnum
* sizeof (ElfW(Phdr
));
1661 if (ehdr
->e_phoff
+ maplength
<= (size_t) fbp
->len
)
1662 phdr
= (void *) (fbp
->buf
+ ehdr
->e_phoff
);
1665 phdr
= alloca (maplength
);
1666 __lseek (fd
, ehdr
->e_phoff
, SEEK_SET
);
1667 if ((size_t) __libc_read (fd
, (void *) phdr
, maplength
) != maplength
)
1671 errstring
= N_("cannot read file data");
1676 if (__glibc_unlikely (elf_machine_reject_phdr_p
1677 (phdr
, ehdr
->e_phnum
, fbp
->buf
, fbp
->len
,
1681 /* Check .note.ABI-tag if present. */
1682 for (ph
= phdr
; ph
< &phdr
[ehdr
->e_phnum
]; ++ph
)
1683 if (ph
->p_type
== PT_NOTE
&& ph
->p_filesz
>= 32 && ph
->p_align
>= 4)
1685 ElfW(Addr
) size
= ph
->p_filesz
;
1686 /* NB: Some PT_NOTE segment may have alignment value of 0
1687 or 1. gABI specifies that PT_NOTE segments should be
1688 aligned to 4 bytes in 32-bit objects and to 8 bytes in
1689 64-bit objects. As a Linux extension, we also support
1690 4 byte alignment in 64-bit objects. If p_align is less
1691 than 4, we treate alignment as 4 bytes since some note
1692 segments have 0 or 1 byte alignment. */
1693 ElfW(Addr
) align
= ph
->p_align
;
1696 else if (align
!= 4 && align
!= 8)
1699 if (ph
->p_offset
+ size
<= (size_t) fbp
->len
)
1700 abi_note
= (void *) (fbp
->buf
+ ph
->p_offset
);
1703 abi_note
= alloca (size
);
1704 __lseek (fd
, ph
->p_offset
, SEEK_SET
);
1705 if (__libc_read (fd
, (void *) abi_note
, size
) != size
)
1709 while (memcmp (abi_note
, &expected_note
, sizeof (expected_note
)))
1711 ElfW(Addr
) note_size
1712 = ELF_NOTE_NEXT_OFFSET (abi_note
[0], abi_note
[1],
1715 if (size
- 32 < note_size
)
1721 abi_note
= (void *) abi_note
+ note_size
;
1727 osversion
= (abi_note
[5] & 0xff) * 65536
1728 + (abi_note
[6] & 0xff) * 256
1729 + (abi_note
[7] & 0xff);
1730 if (abi_note
[4] != __ABI_TAG_OS
1731 || (GLRO(dl_osversion
) && GLRO(dl_osversion
) < osversion
))
1735 __set_errno (ENOENT
);
1746 /* Try to open NAME in one of the directories in *DIRSP.
1747 Return the fd, or -1. If successful, fill in *REALNAME
1748 with the malloc'd full directory name. If it turns out
1749 that none of the directories in *DIRSP exists, *DIRSP is
1750 replaced with (void *) -1, and the old value is free()d
1751 if MAY_FREE_DIRS is true. */
1754 open_path (const char *name
, size_t namelen
, int mode
,
1755 struct r_search_path_struct
*sps
, char **realname
,
1756 struct filebuf
*fbp
, struct link_map
*loader
, int whatcode
,
1757 bool *found_other_class
)
1759 struct r_search_path_elem
**dirs
= sps
->dirs
;
1762 const char *current_what
= NULL
;
1765 if (__glibc_unlikely (dirs
== NULL
))
1766 /* We're called before _dl_init_paths when loading the main executable
1767 given on the command line when rtld is run directly. */
1770 buf
= alloca (max_dirnamelen
+ max_capstrlen
+ namelen
);
1773 struct r_search_path_elem
*this_dir
= *dirs
;
1780 /* If we are debugging the search for libraries print the path
1781 now if it hasn't happened now. */
1782 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_LIBS
)
1783 && current_what
!= this_dir
->what
)
1785 current_what
= this_dir
->what
;
1786 print_search_path (dirs
, current_what
, this_dir
->where
);
1789 edp
= (char *) __mempcpy (buf
, this_dir
->dirname
, this_dir
->dirnamelen
);
1790 for (cnt
= 0; fd
== -1 && cnt
< ncapstr
; ++cnt
)
1792 /* Skip this directory if we know it does not exist. */
1793 if (this_dir
->status
[cnt
] == nonexisting
)
1797 ((char *) __mempcpy (__mempcpy (edp
, capstr
[cnt
].str
,
1802 /* Print name we try if this is wanted. */
1803 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_LIBS
))
1804 _dl_debug_printf (" trying file=%s\n", buf
);
1806 fd
= open_verify (buf
, -1, fbp
, loader
, whatcode
, mode
,
1807 found_other_class
, false);
1808 if (this_dir
->status
[cnt
] == unknown
)
1811 this_dir
->status
[cnt
] = existing
;
1812 /* Do not update the directory information when loading
1813 auditing code. We must try to disturb the program as
1814 little as possible. */
1815 else if (loader
== NULL
1816 || GL(dl_ns
)[loader
->l_ns
]._ns_loaded
->l_auditing
== 0)
1818 /* We failed to open machine dependent library. Let's
1819 test whether there is any directory at all. */
1822 buf
[buflen
- namelen
- 1] = '\0';
1824 if (__xstat64 (_STAT_VER
, buf
, &st
) != 0
1825 || ! S_ISDIR (st
.st_mode
))
1826 /* The directory does not exist or it is no directory. */
1827 this_dir
->status
[cnt
] = nonexisting
;
1829 this_dir
->status
[cnt
] = existing
;
1833 /* Remember whether we found any existing directory. */
1834 here_any
|= this_dir
->status
[cnt
] != nonexisting
;
1836 if (fd
!= -1 && __glibc_unlikely (mode
& __RTLD_SECURE
)
1837 && __libc_enable_secure
)
1839 /* This is an extra security effort to make sure nobody can
1840 preload broken shared objects which are in the trusted
1841 directories and so exploit the bugs. */
1844 if (__fxstat64 (_STAT_VER
, fd
, &st
) != 0
1845 || (st
.st_mode
& S_ISUID
) == 0)
1847 /* The shared object cannot be tested for being SUID
1848 or this bit is not set. In this case we must not
1852 /* We simply ignore the file, signal this by setting
1853 the error value which would have been set by `open'. */
1861 *realname
= (char *) malloc (buflen
);
1862 if (*realname
!= NULL
)
1864 memcpy (*realname
, buf
, buflen
);
1869 /* No memory for the name, we certainly won't be able
1870 to load and link it. */
1875 if (here_any
&& (err
= errno
) != ENOENT
&& err
!= EACCES
)
1876 /* The file exists and is readable, but something went wrong. */
1879 /* Remember whether we found anything. */
1882 while (*++dirs
!= NULL
);
1884 /* Remove the whole path if none of the directories exists. */
1885 if (__glibc_unlikely (! any
))
1887 /* Paths which were allocated using the minimal malloc() in ld.so
1888 must not be freed using the general free() in libc. */
1892 /* rtld_search_dirs and env_path_list are attribute_relro, therefore
1893 avoid writing into it. */
1894 if (sps
!= &rtld_search_dirs
&& sps
!= &env_path_list
)
1895 sps
->dirs
= (void *) -1;
1901 /* Map in the shared object file NAME. */
1904 _dl_map_object (struct link_map
*loader
, const char *name
,
1905 int type
, int trace_mode
, int mode
, Lmid_t nsid
)
1908 const char *origname
= NULL
;
1915 assert (nsid
< GL(dl_nns
));
1917 /* Look for this name among those already loaded. */
1918 for (l
= GL(dl_ns
)[nsid
]._ns_loaded
; l
; l
= l
->l_next
)
1920 /* If the requested name matches the soname of a loaded object,
1921 use that object. Elide this check for names that have not
1923 if (__glibc_unlikely ((l
->l_faked
| l
->l_removed
) != 0))
1925 if (!_dl_name_match_p (name
, l
))
1929 if (__glibc_likely (l
->l_soname_added
)
1930 || l
->l_info
[DT_SONAME
] == NULL
)
1933 soname
= ((const char *) D_PTR (l
, l_info
[DT_STRTAB
])
1934 + l
->l_info
[DT_SONAME
]->d_un
.d_val
);
1935 if (strcmp (name
, soname
) != 0)
1938 /* We have a match on a new name -- cache it. */
1939 add_name_to_object (l
, soname
);
1940 l
->l_soname_added
= 1;
1943 /* We have a match. */
1947 /* Display information if we are debugging. */
1948 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_FILES
)
1950 _dl_debug_printf ((mode
& __RTLD_CALLMAP
) == 0
1951 ? "\nfile=%s [%lu]; needed by %s [%lu]\n"
1952 : "\nfile=%s [%lu]; dynamically loaded by %s [%lu]\n",
1953 name
, nsid
, DSO_FILENAME (loader
->l_name
), loader
->l_ns
);
1956 /* Give the auditing libraries a chance to change the name before we
1958 if (__glibc_unlikely (GLRO(dl_naudit
) > 0)
1959 && (loader
== NULL
|| loader
->l_auditing
== 0))
1961 struct audit_ifaces
*afct
= GLRO(dl_audit
);
1962 for (unsigned int cnt
= 0; cnt
< GLRO(dl_naudit
); ++cnt
)
1964 if (afct
->objsearch
!= NULL
)
1966 const char *before
= name
;
1967 name
= afct
->objsearch (name
, &loader
->l_audit
[cnt
].cookie
,
1971 /* Do not try anything further. */
1975 if (before
!= name
&& strcmp (before
, name
) != 0)
1977 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_FILES
))
1978 _dl_debug_printf ("audit changed filename %s -> %s\n",
1981 if (origname
== NULL
)
1991 /* Will be true if we found a DSO which is of the other ELF class. */
1992 bool found_other_class
= false;
1994 if (strchr (name
, '/') == NULL
)
1996 /* Search for NAME in several places. */
1998 size_t namelen
= strlen (name
) + 1;
2000 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_LIBS
))
2001 _dl_debug_printf ("find library=%s [%lu]; searching\n", name
, nsid
);
2005 /* When the object has the RUNPATH information we don't use any
2007 if (loader
== NULL
|| loader
->l_info
[DT_RUNPATH
] == NULL
)
2009 /* This is the executable's map (if there is one). Make sure that
2010 we do not look at it twice. */
2011 struct link_map
*main_map
= GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
;
2012 bool did_main_map
= false;
2014 /* First try the DT_RPATH of the dependent object that caused NAME
2015 to be loaded. Then that object's dependent, and on up. */
2016 for (l
= loader
; l
; l
= l
->l_loader
)
2017 if (cache_rpath (l
, &l
->l_rpath_dirs
, DT_RPATH
, "RPATH"))
2019 fd
= open_path (name
, namelen
, mode
,
2021 &realname
, &fb
, loader
, LA_SER_RUNPATH
,
2022 &found_other_class
);
2026 did_main_map
|= l
== main_map
;
2029 /* If dynamically linked, try the DT_RPATH of the executable
2030 itself. NB: we do this for lookups in any namespace. */
2031 if (fd
== -1 && !did_main_map
2032 && main_map
!= NULL
&& main_map
->l_type
!= lt_loaded
2033 && cache_rpath (main_map
, &main_map
->l_rpath_dirs
, DT_RPATH
,
2035 fd
= open_path (name
, namelen
, mode
,
2036 &main_map
->l_rpath_dirs
,
2037 &realname
, &fb
, loader
?: main_map
, LA_SER_RUNPATH
,
2038 &found_other_class
);
2041 /* Try the LD_LIBRARY_PATH environment variable. */
2042 if (fd
== -1 && env_path_list
.dirs
!= (void *) -1)
2043 fd
= open_path (name
, namelen
, mode
, &env_path_list
,
2045 loader
?: GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
,
2046 LA_SER_LIBPATH
, &found_other_class
);
2048 /* Look at the RUNPATH information for this binary. */
2049 if (fd
== -1 && loader
!= NULL
2050 && cache_rpath (loader
, &loader
->l_runpath_dirs
,
2051 DT_RUNPATH
, "RUNPATH"))
2052 fd
= open_path (name
, namelen
, mode
,
2053 &loader
->l_runpath_dirs
, &realname
, &fb
, loader
,
2054 LA_SER_RUNPATH
, &found_other_class
);
2058 realname
= _dl_sysdep_open_object (name
, namelen
, &fd
);
2059 if (realname
!= NULL
)
2061 fd
= open_verify (realname
, fd
,
2062 &fb
, loader
?: GL(dl_ns
)[nsid
]._ns_loaded
,
2063 LA_SER_CONFIG
, mode
, &found_other_class
,
2072 && (__glibc_likely ((mode
& __RTLD_SECURE
) == 0)
2073 || ! __libc_enable_secure
)
2074 && __glibc_likely (GLRO(dl_inhibit_cache
) == 0))
2076 /* Check the list of libraries in the file /etc/ld.so.cache,
2077 for compatibility with Linux's ldconfig program. */
2078 char *cached
= _dl_load_cache_lookup (name
);
2082 // XXX Correct to unconditionally default to namespace 0?
2084 ?: GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
2090 /* If the loader has the DF_1_NODEFLIB flag set we must not
2091 use a cache entry from any of these directories. */
2092 if (__glibc_unlikely (l
->l_flags_1
& DF_1_NODEFLIB
))
2094 const char *dirp
= system_dirs
;
2095 unsigned int cnt
= 0;
2099 if (memcmp (cached
, dirp
, system_dirs_len
[cnt
]) == 0)
2101 /* The prefix matches. Don't use the entry. */
2107 dirp
+= system_dirs_len
[cnt
] + 1;
2110 while (cnt
< nsystem_dirs_len
);
2115 fd
= open_verify (cached
, -1,
2116 &fb
, loader
?: GL(dl_ns
)[nsid
]._ns_loaded
,
2117 LA_SER_CONFIG
, mode
, &found_other_class
,
2119 if (__glibc_likely (fd
!= -1))
2128 /* Finally, try the default path. */
2130 && ((l
= loader
?: GL(dl_ns
)[nsid
]._ns_loaded
) == NULL
2131 || __glibc_likely (!(l
->l_flags_1
& DF_1_NODEFLIB
)))
2132 && rtld_search_dirs
.dirs
!= (void *) -1)
2133 fd
= open_path (name
, namelen
, mode
, &rtld_search_dirs
,
2134 &realname
, &fb
, l
, LA_SER_DEFAULT
, &found_other_class
);
2136 /* Add another newline when we are tracing the library loading. */
2137 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_LIBS
))
2138 _dl_debug_printf ("\n");
2142 /* The path may contain dynamic string tokens. */
2144 ? expand_dynamic_string_token (loader
, name
, 0)
2146 if (realname
== NULL
)
2150 fd
= open_verify (realname
, -1, &fb
,
2151 loader
?: GL(dl_ns
)[nsid
]._ns_loaded
, 0, mode
,
2152 &found_other_class
, true);
2153 if (__glibc_unlikely (fd
== -1))
2161 /* In case the LOADER information has only been provided to get to
2162 the appropriate RUNPATH/RPATH information we do not need it
2164 if (mode
& __RTLD_CALLMAP
)
2167 if (__glibc_unlikely (fd
== -1))
2170 && __glibc_likely ((GLRO(dl_debug_mask
) & DL_DEBUG_PRELINK
) == 0))
2172 /* We haven't found an appropriate library. But since we
2173 are only interested in the list of libraries this isn't
2174 so severe. Fake an entry with all the information we
2176 static const Elf_Symndx dummy_bucket
= STN_UNDEF
;
2178 /* Allocate a new object map. */
2179 if ((name_copy
= __strdup (name
)) == NULL
2180 || (l
= _dl_new_object (name_copy
, name
, type
, loader
,
2181 mode
, nsid
)) == NULL
)
2184 _dl_signal_error (ENOMEM
, name
, NULL
,
2185 N_("cannot create shared object descriptor"));
2187 /* Signal that this is a faked entry. */
2189 /* Since the descriptor is initialized with zero we do not
2191 l->l_reserved = 0; */
2192 l
->l_buckets
= &dummy_bucket
;
2196 /* Enter the object in the object list. */
2197 _dl_add_to_namespace_list (l
, nsid
);
2201 else if (found_other_class
)
2202 _dl_signal_error (0, name
, NULL
,
2203 ELFW(CLASS
) == ELFCLASS32
2204 ? N_("wrong ELF class: ELFCLASS64")
2205 : N_("wrong ELF class: ELFCLASS32"));
2207 _dl_signal_error (errno
, name
, NULL
,
2208 N_("cannot open shared object file"));
2211 void *stack_end
= __libc_stack_end
;
2212 return _dl_map_object_from_fd (name
, origname
, fd
, &fb
, realname
, loader
,
2213 type
, mode
, &stack_end
, nsid
);
2216 struct add_path_state
2225 add_path (struct add_path_state
*p
, const struct r_search_path_struct
*sps
,
2228 if (sps
->dirs
!= (void *) -1)
2230 struct r_search_path_elem
**dirs
= sps
->dirs
;
2233 const struct r_search_path_elem
*const r
= *dirs
++;
2237 p
->si
->dls_size
+= MAX (2, r
->dirnamelen
);
2241 Dl_serpath
*const sp
= &p
->si
->dls_serpath
[p
->idx
++];
2242 sp
->dls_name
= p
->allocptr
;
2243 if (r
->dirnamelen
< 2)
2244 *p
->allocptr
++ = r
->dirnamelen
? '/' : '.';
2246 p
->allocptr
= __mempcpy (p
->allocptr
,
2247 r
->dirname
, r
->dirnamelen
- 1);
2248 *p
->allocptr
++ = '\0';
2249 sp
->dls_flags
= flags
;
2252 while (*dirs
!= NULL
);
2257 _dl_rtld_di_serinfo (struct link_map
*loader
, Dl_serinfo
*si
, bool counting
)
2265 struct add_path_state p
=
2267 .counting
= counting
,
2270 .allocptr
= (char *) &si
->dls_serpath
[si
->dls_cnt
]
2273 # define add_path(p, sps, flags) add_path(p, sps, 0) /* XXX */
2275 /* When the object has the RUNPATH information we don't use any RPATHs. */
2276 if (loader
->l_info
[DT_RUNPATH
] == NULL
)
2278 /* First try the DT_RPATH of the dependent object that caused NAME
2279 to be loaded. Then that object's dependent, and on up. */
2281 struct link_map
*l
= loader
;
2284 if (cache_rpath (l
, &l
->l_rpath_dirs
, DT_RPATH
, "RPATH"))
2285 add_path (&p
, &l
->l_rpath_dirs
, XXX_RPATH
);
2290 /* If dynamically linked, try the DT_RPATH of the executable itself. */
2291 if (loader
->l_ns
== LM_ID_BASE
)
2293 l
= GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
;
2294 if (l
!= NULL
&& l
->l_type
!= lt_loaded
&& l
!= loader
)
2295 if (cache_rpath (l
, &l
->l_rpath_dirs
, DT_RPATH
, "RPATH"))
2296 add_path (&p
, &l
->l_rpath_dirs
, XXX_RPATH
);
2300 /* Try the LD_LIBRARY_PATH environment variable. */
2301 add_path (&p
, &env_path_list
, XXX_ENV
);
2303 /* Look at the RUNPATH information for this binary. */
2304 if (cache_rpath (loader
, &loader
->l_runpath_dirs
, DT_RUNPATH
, "RUNPATH"))
2305 add_path (&p
, &loader
->l_runpath_dirs
, XXX_RUNPATH
);
2308 Here is where ld.so.cache gets checked, but we don't have
2309 a way to indicate that in the results for Dl_serinfo. */
2311 /* Finally, try the default path. */
2312 if (!(loader
->l_flags_1
& DF_1_NODEFLIB
))
2313 add_path (&p
, &rtld_search_dirs
, XXX_default
);
2316 /* Count the struct size before the string area, which we didn't
2317 know before we completed dls_cnt. */
2318 si
->dls_size
+= (char *) &si
->dls_serpath
[si
->dls_cnt
] - (char *) si
;