1 /* Map in a shared object's segments from the file.
2 Copyright (C) 1995-2019 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>
34 /* Type for the buffer we put the ELF header and hopefully the program
35 header. This buffer does not really have to be too large. In most
36 cases the program header follows the ELF header directly. If this
37 is not the case all bets are off and we can make the header
38 arbitrarily large and still won't get it read. This means the only
39 question is how large are the ELF and program header combined. The
40 ELF header 32-bit files is 52 bytes long and in 64-bit files is 64
41 bytes long. Each program header entry is again 32 and 56 bytes
42 long respectively. I.e., even with a file which has 10 program
43 header entries we only have to read 372B/624B respectively. Add to
44 this a bit of margin for program notes and reading 512B and 832B
45 for 32-bit and 64-bit files respecitvely is enough. If this
46 heuristic should really fail for some file the code in
47 `_dl_map_object_from_fd' knows how to recover. */
52 # define FILEBUF_SIZE 512
54 # define FILEBUF_SIZE 832
56 char buf
[FILEBUF_SIZE
] __attribute__ ((aligned (__alignof (ElfW(Ehdr
)))));
59 #include "dynamic-link.h"
61 #include <stackinfo.h>
63 #include <stap-probe.h>
64 #include <libc-pointer-arith.h>
65 #include <array_length.h>
69 #include <dl-map-segments.h>
70 #include <dl-unmap-segments.h>
71 #include <dl-machine-reject-phdr.h>
72 #include <dl-sysdep-open.h>
74 #include <not-cancel.h>
77 #if BYTE_ORDER == BIG_ENDIAN
78 # define byteorder ELFDATA2MSB
79 #elif BYTE_ORDER == LITTLE_ENDIAN
80 # define byteorder ELFDATA2LSB
82 # error "Unknown BYTE_ORDER " BYTE_ORDER
83 # define byteorder ELFDATANONE
86 #define STRING(x) __STRING (x)
89 int __stack_prot attribute_hidden attribute_relro
90 #if _STACK_GROWS_DOWN && defined PROT_GROWSDOWN
92 #elif _STACK_GROWS_UP && defined PROT_GROWSUP
99 /* This is the decomposed LD_LIBRARY_PATH search path. */
100 static struct r_search_path_struct env_path_list attribute_relro
;
102 /* List of the hardware capabilities we might end up using. */
103 static const struct r_strlenpair
*capstr attribute_relro
;
104 static size_t ncapstr attribute_relro
;
105 static size_t max_capstrlen attribute_relro
;
108 /* Get the generated information about the trusted directories. Use
109 an array of concatenated strings to avoid relocations. See
110 gen-trusted-dirs.awk. */
111 #include "trusted-dirs.h"
113 static const char system_dirs
[] = SYSTEM_DIRS
;
114 static const size_t system_dirs_len
[] =
118 #define nsystem_dirs_len array_length (system_dirs_len)
121 is_trusted_path_normalize (const char *path
, size_t len
)
126 char *npath
= (char *) alloca (len
+ 2);
128 while (*path
!= '\0')
134 if (path
[2] == '.' && (path
[3] == '/' || path
[3] == '\0'))
136 while (wnp
> npath
&& *--wnp
!= '/')
141 else if (path
[2] == '/' || path
[2] == '\0')
148 if (wnp
> npath
&& wnp
[-1] == '/')
158 if (wnp
== npath
|| wnp
[-1] != '/')
161 const char *trun
= system_dirs
;
163 for (size_t idx
= 0; idx
< nsystem_dirs_len
; ++idx
)
165 if (wnp
- npath
>= system_dirs_len
[idx
]
166 && memcmp (trun
, npath
, system_dirs_len
[idx
]) == 0)
170 trun
+= system_dirs_len
[idx
] + 1;
176 /* Given a substring starting at INPUT, just after the DST '$' start
177 token, determine if INPUT contains DST token REF, following the
178 ELF gABI rules for DSTs:
180 * Longest possible sequence using the rules (greedy).
182 * Must start with a $ (enforced by caller).
184 * Must follow $ with one underscore or ASCII [A-Za-z] (caller
185 follows these rules for REF) or '{' (start curly quoted name).
187 * Must follow first two characters with zero or more [A-Za-z0-9_]
188 (enforced by caller) or '}' (end curly quoted name).
190 If the sequence is a DST matching REF then the length of the DST
191 (excluding the $ sign but including curly braces, if any) is
192 returned, otherwise 0. */
194 is_dst (const char *input
, const char *ref
)
196 bool is_curly
= false;
198 /* Is a ${...} input sequence? */
205 /* Check for matching name, following closing curly brace (if
206 required), or trailing characters which are part of an
208 size_t rlen
= strlen (ref
);
209 if (strncmp (input
, ref
, rlen
) != 0
210 || (is_curly
&& input
[rlen
] != '}')
211 || ((input
[rlen
] >= 'A' && input
[rlen
] <= 'Z')
212 || (input
[rlen
] >= 'a' && input
[rlen
] <= 'z')
213 || (input
[rlen
] >= '0' && input
[rlen
] <= '9')
214 || (input
[rlen
] == '_')))
218 /* Count the two curly braces. */
224 /* INPUT should be the start of a path e.g DT_RPATH or name e.g.
225 DT_NEEDED. The return value is the number of known DSTs found. We
226 count all known DSTs regardless of __libc_enable_secure; the caller
227 is responsible for enforcing the security of the substitution rules
228 (usually _dl_dst_substitute). */
230 _dl_dst_count (const char *input
)
234 input
= strchr (input
, '$');
236 /* Most likely there is no DST. */
237 if (__glibc_likely (input
== NULL
))
245 /* All DSTs must follow ELF gABI rules, see is_dst (). */
246 if ((len
= is_dst (input
, "ORIGIN")) != 0
247 || (len
= is_dst (input
, "PLATFORM")) != 0
248 || (len
= is_dst (input
, "LIB")) != 0)
251 /* There may be more than one DST in the input. */
252 input
= strchr (input
+ len
, '$');
254 while (input
!= NULL
);
259 /* Process INPUT for DSTs and store in RESULT using the information
260 from link map L to resolve the DSTs. This function only handles one
261 path at a time and does not handle colon-separated path lists (see
262 fillin_rpath ()). Lastly the size of result in bytes should be at
263 least equal to the value returned by DL_DST_REQUIRED. Note that it
264 is possible for a DT_NEEDED, DT_AUXILIARY, and DT_FILTER entries to
265 have colons, but we treat those as literal colons here, not as path
268 _dl_dst_substitute (struct link_map
*l
, const char *input
, char *result
)
270 /* Copy character-by-character from input into the working pointer
271 looking for any DSTs. We track the start of input and if we are
272 going to check for trusted paths, all of which are part of $ORIGIN
273 handling in SUID/SGID cases (see below). In some cases, like when
274 a DST cannot be replaced, we may set result to an empty string and
277 const char *start
= input
;
278 bool check_for_trusted
= false;
282 if (__glibc_unlikely (*input
== '$'))
284 const char *repl
= NULL
;
288 if ((len
= is_dst (input
, "ORIGIN")) != 0)
290 /* For SUID/GUID programs we normally ignore the path with
291 $ORIGIN in DT_RUNPATH, or DT_RPATH. However, there is
292 one exception to this rule, and it is:
294 * $ORIGIN appears as the first path element, and is
295 the only string in the path or is immediately
296 followed by a path separator and the rest of the
301 * The path is rooted in a trusted directory.
303 This exception allows such programs to reference
304 shared libraries in subdirectories of trusted
305 directories. The use case is one of general
306 organization and deployment flexibility.
307 Trusted directories are usually such paths as "/lib64"
308 or "/usr/lib64", and the usual RPATHs take the form of
309 [$ORIGIN/../$LIB/somedir]. */
310 if (__glibc_unlikely (__libc_enable_secure
)
311 && !(input
== start
+ 1
312 && (input
[len
] == '\0' || input
[len
] == '/')))
313 repl
= (const char *) -1;
317 check_for_trusted
= (__libc_enable_secure
318 && l
->l_type
== lt_executable
);
320 else if ((len
= is_dst (input
, "PLATFORM")) != 0)
321 repl
= GLRO(dl_platform
);
322 else if ((len
= is_dst (input
, "LIB")) != 0)
325 if (repl
!= NULL
&& repl
!= (const char *) -1)
327 wp
= __stpcpy (wp
, repl
);
332 /* We found a valid DST that we know about, but we could
333 not find a replacement value for it, therefore we
334 cannot use this path and discard it. */
339 /* No DST we recognize. */
347 while (*input
!= '\0');
349 /* In SUID/SGID programs, after $ORIGIN expansion the normalized
350 path must be rooted in one of the trusted directories. The $LIB
351 and $PLATFORM DST cannot in any way be manipulated by the caller
352 because they are fixed values that are set by the dynamic loader
353 and therefore any paths using just $LIB or $PLATFORM need not be
354 checked for trust, the authors of the binaries themselves are
355 trusted to have designed this correctly. Only $ORIGIN is tested in
356 this way because it may be manipulated in some ways with hard
358 if (__glibc_unlikely (check_for_trusted
)
359 && !is_trusted_path_normalize (result
, wp
- result
))
371 /* Return a malloc allocated copy of INPUT with all recognized DSTs
372 replaced. On some platforms it might not be possible to determine the
373 path from which the object belonging to the map is loaded. In this
374 case the path containing the DST is left out. On error NULL
377 expand_dynamic_string_token (struct link_map
*l
, const char *input
)
379 /* We make two runs over the string. First we determine how large the
380 resulting string is and then we copy it over. Since this is no
381 frequently executed operation we are looking here not for performance
382 but rather for code size. */
387 /* Determine the number of DSTs. */
388 cnt
= _dl_dst_count (input
);
390 /* If we do not have to replace anything simply copy the string. */
391 if (__glibc_likely (cnt
== 0))
392 return __strdup (input
);
394 /* Determine the length of the substituted string. */
395 total
= DL_DST_REQUIRED (l
, input
, strlen (input
), cnt
);
397 /* Allocate the necessary memory. */
398 result
= (char *) malloc (total
+ 1);
402 return _dl_dst_substitute (l
, input
, result
);
406 /* Add `name' to the list of names for a particular shared object.
407 `name' is expected to have been allocated with malloc and will
408 be freed if the shared object already has this name.
409 Returns false if the object already had this name. */
411 add_name_to_object (struct link_map
*l
, const char *name
)
413 struct libname_list
*lnp
, *lastp
;
414 struct libname_list
*newname
;
418 for (lnp
= l
->l_libname
; lnp
!= NULL
; lastp
= lnp
, lnp
= lnp
->next
)
419 if (strcmp (name
, lnp
->name
) == 0)
422 name_len
= strlen (name
) + 1;
423 newname
= (struct libname_list
*) malloc (sizeof *newname
+ name_len
);
426 /* No more memory. */
427 _dl_signal_error (ENOMEM
, name
, NULL
, N_("cannot allocate name record"));
430 /* The object should have a libname set from _dl_new_object. */
431 assert (lastp
!= NULL
);
433 newname
->name
= memcpy (newname
+ 1, name
, name_len
);
434 newname
->next
= NULL
;
435 newname
->dont_free
= 0;
436 lastp
->next
= newname
;
439 /* Standard search directories. */
440 static struct r_search_path_struct rtld_search_dirs attribute_relro
;
442 static size_t max_dirnamelen
;
444 static struct r_search_path_elem
**
445 fillin_rpath (char *rpath
, struct r_search_path_elem
**result
, const char *sep
,
446 const char *what
, const char *where
, struct link_map
*l
)
451 while ((cp
= __strsep (&rpath
, sep
)) != NULL
)
453 struct r_search_path_elem
*dirp
;
454 char *to_free
= NULL
;
457 /* `strsep' can pass an empty string. */
460 to_free
= cp
= expand_dynamic_string_token (l
, cp
);
462 /* expand_dynamic_string_token can return NULL in case of empty
463 path or memory allocation failure. */
467 /* Compute the length after dynamic string token expansion and
468 ignore empty paths. */
476 /* Remove trailing slashes (except for "/"). */
477 while (len
> 1 && cp
[len
- 1] == '/')
480 /* Now add one if there is none so far. */
481 if (len
> 0 && cp
[len
- 1] != '/')
485 /* See if this directory is already known. */
486 for (dirp
= GL(dl_all_dirs
); dirp
!= NULL
; dirp
= dirp
->next
)
487 if (dirp
->dirnamelen
== len
&& memcmp (cp
, dirp
->dirname
, len
) == 0)
492 /* It is available, see whether it's on our own list. */
494 for (cnt
= 0; cnt
< nelems
; ++cnt
)
495 if (result
[cnt
] == dirp
)
499 result
[nelems
++] = dirp
;
504 enum r_dir_status init_val
;
505 size_t where_len
= where
? strlen (where
) + 1 : 0;
507 /* It's a new directory. Create an entry and add it. */
508 dirp
= (struct r_search_path_elem
*)
509 malloc (sizeof (*dirp
) + ncapstr
* sizeof (enum r_dir_status
)
510 + where_len
+ len
+ 1);
512 _dl_signal_error (ENOMEM
, NULL
, NULL
,
513 N_("cannot create cache for search path"));
515 dirp
->dirname
= ((char *) dirp
+ sizeof (*dirp
)
516 + ncapstr
* sizeof (enum r_dir_status
));
517 *((char *) __mempcpy ((char *) dirp
->dirname
, cp
, len
)) = '\0';
518 dirp
->dirnamelen
= len
;
520 if (len
> max_dirnamelen
)
521 max_dirnamelen
= len
;
523 /* We have to make sure all the relative directories are
524 never ignored. The current directory might change and
525 all our saved information would be void. */
526 init_val
= cp
[0] != '/' ? existing
: unknown
;
527 for (cnt
= 0; cnt
< ncapstr
; ++cnt
)
528 dirp
->status
[cnt
] = init_val
;
531 if (__glibc_likely (where
!= NULL
))
532 dirp
->where
= memcpy ((char *) dirp
+ sizeof (*dirp
) + len
+ 1
533 + (ncapstr
* sizeof (enum r_dir_status
)),
538 dirp
->next
= GL(dl_all_dirs
);
539 GL(dl_all_dirs
) = dirp
;
541 /* Put it in the result array. */
542 result
[nelems
++] = dirp
;
547 /* Terminate the array. */
548 result
[nelems
] = NULL
;
555 decompose_rpath (struct r_search_path_struct
*sps
,
556 const char *rpath
, struct link_map
*l
, const char *what
)
558 /* Make a copy we can work with. */
559 const char *where
= l
->l_name
;
561 struct r_search_path_elem
**result
;
563 /* Initialize to please the compiler. */
564 const char *errstring
= NULL
;
566 /* First see whether we must forget the RUNPATH and RPATH from this
568 if (__glibc_unlikely (GLRO(dl_inhibit_rpath
) != NULL
)
569 && !__libc_enable_secure
)
571 const char *inhp
= GLRO(dl_inhibit_rpath
);
575 const char *wp
= where
;
577 while (*inhp
== *wp
&& *wp
!= '\0')
583 if (*wp
== '\0' && (*inhp
== '\0' || *inhp
== ':'))
585 /* This object is on the list of objects for which the
586 RUNPATH and RPATH must not be used. */
587 sps
->dirs
= (void *) -1;
591 while (*inhp
!= '\0')
595 while (*inhp
!= '\0');
598 /* Ignore empty rpaths. */
601 sps
->dirs
= (struct r_search_path_elem
**) -1;
605 /* Make a writable copy. */
606 char *copy
= __strdup (rpath
);
609 errstring
= N_("cannot create RUNPATH/RPATH copy");
613 /* Count the number of necessary elements in the result array. */
615 for (cp
= copy
; *cp
!= '\0'; ++cp
)
619 /* Allocate room for the result. NELEMS + 1 is an upper limit for the
620 number of necessary entries. */
621 result
= (struct r_search_path_elem
**) malloc ((nelems
+ 1 + 1)
626 errstring
= N_("cannot create cache for search path");
628 _dl_signal_error (ENOMEM
, NULL
, NULL
, errstring
);
631 fillin_rpath (copy
, result
, ":", what
, where
, l
);
633 /* Free the copied RPATH string. `fillin_rpath' make own copies if
637 /* There is no path after expansion. */
638 if (result
[0] == NULL
)
641 sps
->dirs
= (struct r_search_path_elem
**) -1;
646 /* The caller will change this value if we haven't used a real malloc. */
651 /* Make sure cached path information is stored in *SP
652 and return true if there are any paths to search there. */
654 cache_rpath (struct link_map
*l
,
655 struct r_search_path_struct
*sp
,
659 if (sp
->dirs
== (void *) -1)
662 if (sp
->dirs
!= NULL
)
665 if (l
->l_info
[tag
] == NULL
)
667 /* There is no path. */
668 sp
->dirs
= (void *) -1;
672 /* Make sure the cache information is available. */
673 return decompose_rpath (sp
, (const char *) (D_PTR (l
, l_info
[DT_STRTAB
])
674 + l
->l_info
[tag
]->d_un
.d_val
),
680 _dl_init_paths (const char *llp
)
684 struct r_search_path_elem
*pelem
, **aelem
;
686 struct link_map
__attribute__ ((unused
)) *l
= NULL
;
687 /* Initialize to please the compiler. */
688 const char *errstring
= NULL
;
690 /* Fill in the information about the application's RPATH and the
691 directories addressed by the LD_LIBRARY_PATH environment variable. */
693 /* Get the capabilities. */
694 capstr
= _dl_important_hwcaps (GLRO(dl_platform
), GLRO(dl_platformlen
),
695 &ncapstr
, &max_capstrlen
);
697 /* First set up the rest of the default search directory entries. */
698 aelem
= rtld_search_dirs
.dirs
= (struct r_search_path_elem
**)
699 malloc ((nsystem_dirs_len
+ 1) * sizeof (struct r_search_path_elem
*));
700 if (rtld_search_dirs
.dirs
== NULL
)
702 errstring
= N_("cannot create search path array");
704 _dl_signal_error (ENOMEM
, NULL
, NULL
, errstring
);
707 round_size
= ((2 * sizeof (struct r_search_path_elem
) - 1
708 + ncapstr
* sizeof (enum r_dir_status
))
709 / sizeof (struct r_search_path_elem
));
711 rtld_search_dirs
.dirs
[0] = malloc (nsystem_dirs_len
* round_size
712 * sizeof (*rtld_search_dirs
.dirs
[0]));
713 if (rtld_search_dirs
.dirs
[0] == NULL
)
715 errstring
= N_("cannot create cache for search path");
719 rtld_search_dirs
.malloced
= 0;
720 pelem
= GL(dl_all_dirs
) = rtld_search_dirs
.dirs
[0];
730 pelem
->what
= "system search path";
733 pelem
->dirname
= strp
;
734 pelem
->dirnamelen
= system_dirs_len
[idx
];
735 strp
+= system_dirs_len
[idx
] + 1;
737 /* System paths must be absolute. */
738 assert (pelem
->dirname
[0] == '/');
739 for (cnt
= 0; cnt
< ncapstr
; ++cnt
)
740 pelem
->status
[cnt
] = unknown
;
742 pelem
->next
= (++idx
== nsystem_dirs_len
? NULL
: (pelem
+ round_size
));
746 while (idx
< nsystem_dirs_len
);
748 max_dirnamelen
= SYSTEM_DIRS_MAX_LEN
;
752 /* This points to the map of the main object. */
753 l
= GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
;
756 assert (l
->l_type
!= lt_loaded
);
758 if (l
->l_info
[DT_RUNPATH
])
760 /* Allocate room for the search path and fill in information
762 decompose_rpath (&l
->l_runpath_dirs
,
763 (const void *) (D_PTR (l
, l_info
[DT_STRTAB
])
764 + l
->l_info
[DT_RUNPATH
]->d_un
.d_val
),
766 /* During rtld init the memory is allocated by the stub malloc,
767 prevent any attempt to free it by the normal malloc. */
768 l
->l_runpath_dirs
.malloced
= 0;
770 /* The RPATH is ignored. */
771 l
->l_rpath_dirs
.dirs
= (void *) -1;
775 l
->l_runpath_dirs
.dirs
= (void *) -1;
777 if (l
->l_info
[DT_RPATH
])
779 /* Allocate room for the search path and fill in information
781 decompose_rpath (&l
->l_rpath_dirs
,
782 (const void *) (D_PTR (l
, l_info
[DT_STRTAB
])
783 + l
->l_info
[DT_RPATH
]->d_un
.d_val
),
785 /* During rtld init the memory is allocated by the stub
786 malloc, prevent any attempt to free it by the normal
788 l
->l_rpath_dirs
.malloced
= 0;
791 l
->l_rpath_dirs
.dirs
= (void *) -1;
796 if (llp
!= NULL
&& *llp
!= '\0')
798 char *llp_tmp
= strdupa (llp
);
800 /* Decompose the LD_LIBRARY_PATH contents. First determine how many
803 for (const char *cp
= llp_tmp
; *cp
!= '\0'; ++cp
)
804 if (*cp
== ':' || *cp
== ';')
807 env_path_list
.dirs
= (struct r_search_path_elem
**)
808 malloc ((nllp
+ 1) * sizeof (struct r_search_path_elem
*));
809 if (env_path_list
.dirs
== NULL
)
811 errstring
= N_("cannot create cache for search path");
815 (void) fillin_rpath (llp_tmp
, env_path_list
.dirs
, ":;",
816 "LD_LIBRARY_PATH", NULL
, l
);
818 if (env_path_list
.dirs
[0] == NULL
)
820 free (env_path_list
.dirs
);
821 env_path_list
.dirs
= (void *) -1;
824 env_path_list
.malloced
= 0;
827 env_path_list
.dirs
= (void *) -1;
832 __attribute__ ((noreturn
, noinline
))
833 lose (int code
, int fd
, const char *name
, char *realname
, struct link_map
*l
,
834 const char *msg
, struct r_debug
*r
, Lmid_t nsid
)
836 /* The file might already be closed. */
838 (void) __close_nocancel (fd
);
839 if (l
!= NULL
&& l
->l_origin
!= (char *) -1l)
840 free ((char *) l
->l_origin
);
846 r
->r_state
= RT_CONSISTENT
;
848 LIBC_PROBE (map_failed
, 2, nsid
, r
);
851 _dl_signal_error (code
, name
, NULL
, msg
);
855 /* Map in the shared object NAME, actually located in REALNAME, and already
858 #ifndef EXTERNAL_MAP_FROM_FD
862 _dl_map_object_from_fd (const char *name
, const char *origname
, int fd
,
863 struct filebuf
*fbp
, char *realname
,
864 struct link_map
*loader
, int l_type
, int mode
,
865 void **stack_endp
, Lmid_t nsid
)
867 struct link_map
*l
= NULL
;
868 const ElfW(Ehdr
) *header
;
869 const ElfW(Phdr
) *phdr
;
870 const ElfW(Phdr
) *ph
;
873 /* Initialize to keep the compiler happy. */
874 const char *errstring
= NULL
;
876 struct r_debug
*r
= _dl_debug_initialize (0, nsid
);
877 bool make_consistent
= false;
879 /* Get file information. */
881 if (__glibc_unlikely (!_dl_get_file_id (fd
, &id
)))
883 errstring
= N_("cannot stat shared object");
887 lose (errval
, fd
, name
, realname
, l
, errstring
,
888 make_consistent
? r
: NULL
, nsid
);
891 /* Look again to see if the real name matched another already loaded. */
892 for (l
= GL(dl_ns
)[nsid
]._ns_loaded
; l
!= NULL
; l
= l
->l_next
)
893 if (!l
->l_removed
&& _dl_file_id_match_p (&l
->l_file_id
, &id
))
895 /* The object is already loaded.
896 Just bump its reference count and return it. */
897 __close_nocancel (fd
);
899 /* If the name is not in the list of names for this object add
902 add_name_to_object (l
, name
);
908 /* When loading into a namespace other than the base one we must
909 avoid loading ld.so since there can only be one copy. Ever. */
910 if (__glibc_unlikely (nsid
!= LM_ID_BASE
)
911 && (_dl_file_id_match_p (&id
, &GL(dl_rtld_map
).l_file_id
)
912 || _dl_name_match_p (name
, &GL(dl_rtld_map
))))
914 /* This is indeed ld.so. Create a new link_map which refers to
915 the real one for almost everything. */
916 l
= _dl_new_object (realname
, name
, l_type
, loader
, mode
, nsid
);
920 /* Refer to the real descriptor. */
921 l
->l_real
= &GL(dl_rtld_map
);
923 /* No need to bump the refcount of the real object, ld.so will
924 never be unloaded. */
925 __close_nocancel (fd
);
927 /* Add the map for the mirrored object to the object list. */
928 _dl_add_to_namespace_list (l
, nsid
);
934 if (mode
& RTLD_NOLOAD
)
936 /* We are not supposed to load the object unless it is already
937 loaded. So return now. */
939 __close_nocancel (fd
);
943 /* Print debugging message. */
944 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_FILES
))
945 _dl_debug_printf ("file=%s [%lu]; generating link map\n", name
, nsid
);
947 /* This is the ELF header. We read it in `open_verify'. */
948 header
= (void *) fbp
->buf
;
950 /* Signal that we are going to add new objects. */
951 if (r
->r_state
== RT_CONSISTENT
)
954 /* Auditing checkpoint: we are going to add new objects. */
955 if ((mode
& __RTLD_AUDIT
) == 0
956 && __glibc_unlikely (GLRO(dl_naudit
) > 0))
958 struct link_map
*head
= GL(dl_ns
)[nsid
]._ns_loaded
;
959 /* Do not call the functions for any auditing object. */
960 if (head
->l_auditing
== 0)
962 struct audit_ifaces
*afct
= GLRO(dl_audit
);
963 for (unsigned int cnt
= 0; cnt
< GLRO(dl_naudit
); ++cnt
)
965 if (afct
->activity
!= NULL
)
966 afct
->activity (&head
->l_audit
[cnt
].cookie
, LA_ACT_ADD
);
974 /* Notify the debugger we have added some objects. We need to
975 call _dl_debug_initialize in a static program in case dynamic
976 linking has not been used before. */
979 LIBC_PROBE (map_start
, 2, nsid
, r
);
980 make_consistent
= true;
983 assert (r
->r_state
== RT_ADD
);
985 /* Enter the new object in the list of loaded objects. */
986 l
= _dl_new_object (realname
, name
, l_type
, loader
, mode
, nsid
);
987 if (__glibc_unlikely (l
== NULL
))
992 errstring
= N_("cannot create shared object descriptor");
993 goto call_lose_errno
;
996 /* Extract the remaining details we need from the ELF header
997 and then read in the program header table. */
998 l
->l_entry
= header
->e_entry
;
999 type
= header
->e_type
;
1000 l
->l_phnum
= header
->e_phnum
;
1002 maplength
= header
->e_phnum
* sizeof (ElfW(Phdr
));
1003 if (header
->e_phoff
+ maplength
<= (size_t) fbp
->len
)
1004 phdr
= (void *) (fbp
->buf
+ header
->e_phoff
);
1007 phdr
= alloca (maplength
);
1008 __lseek (fd
, header
->e_phoff
, SEEK_SET
);
1009 if ((size_t) __read_nocancel (fd
, (void *) phdr
, maplength
) != maplength
)
1011 errstring
= N_("cannot read file data");
1012 goto call_lose_errno
;
1016 /* On most platforms presume that PT_GNU_STACK is absent and the stack is
1017 * executable. Other platforms default to a nonexecutable stack and don't
1018 * need PT_GNU_STACK to do so. */
1019 uint_fast16_t stack_flags
= DEFAULT_STACK_PERMS
;
1022 /* Scan the program header table, collecting its load commands. */
1023 struct loadcmd loadcmds
[l
->l_phnum
];
1024 size_t nloadcmds
= 0;
1025 bool has_holes
= false;
1027 /* The struct is initialized to zero so this is not necessary:
1031 for (ph
= phdr
; ph
< &phdr
[l
->l_phnum
]; ++ph
)
1034 /* These entries tell us where to find things once the file's
1035 segments are mapped in. We record the addresses it says
1036 verbatim, and later correct for the run-time load address. */
1040 /* Debuginfo only files from "objcopy --only-keep-debug"
1041 contain a PT_DYNAMIC segment with p_filesz == 0. Skip
1042 such a segment to avoid a crash later. */
1043 l
->l_ld
= (void *) ph
->p_vaddr
;
1044 l
->l_ldnum
= ph
->p_memsz
/ sizeof (ElfW(Dyn
));
1049 l
->l_phdr
= (void *) ph
->p_vaddr
;
1053 /* A load command tells us to map in part of the file.
1054 We record the load commands and process them all later. */
1055 if (__glibc_unlikely ((ph
->p_align
& (GLRO(dl_pagesize
) - 1)) != 0))
1057 errstring
= N_("ELF load command alignment not page-aligned");
1060 if (__glibc_unlikely (((ph
->p_vaddr
- ph
->p_offset
)
1061 & (ph
->p_align
- 1)) != 0))
1064 = N_("ELF load command address/offset not properly aligned");
1068 struct loadcmd
*c
= &loadcmds
[nloadcmds
++];
1069 c
->mapstart
= ALIGN_DOWN (ph
->p_vaddr
, GLRO(dl_pagesize
));
1070 c
->mapend
= ALIGN_UP (ph
->p_vaddr
+ ph
->p_filesz
, GLRO(dl_pagesize
));
1071 c
->dataend
= ph
->p_vaddr
+ ph
->p_filesz
;
1072 c
->allocend
= ph
->p_vaddr
+ ph
->p_memsz
;
1073 c
->mapoff
= ALIGN_DOWN (ph
->p_offset
, GLRO(dl_pagesize
));
1075 /* Determine whether there is a gap between the last segment
1077 if (nloadcmds
> 1 && c
[-1].mapend
!= c
->mapstart
)
1080 /* Optimize a common case. */
1081 #if (PF_R | PF_W | PF_X) == 7 && (PROT_READ | PROT_WRITE | PROT_EXEC) == 7
1082 c
->prot
= (PF_TO_PROT
1083 >> ((ph
->p_flags
& (PF_R
| PF_W
| PF_X
)) * 4)) & 0xf;
1086 if (ph
->p_flags
& PF_R
)
1087 c
->prot
|= PROT_READ
;
1088 if (ph
->p_flags
& PF_W
)
1089 c
->prot
|= PROT_WRITE
;
1090 if (ph
->p_flags
& PF_X
)
1091 c
->prot
|= PROT_EXEC
;
1096 if (ph
->p_memsz
== 0)
1097 /* Nothing to do for an empty segment. */
1100 l
->l_tls_blocksize
= ph
->p_memsz
;
1101 l
->l_tls_align
= ph
->p_align
;
1102 if (ph
->p_align
== 0)
1103 l
->l_tls_firstbyte_offset
= 0;
1105 l
->l_tls_firstbyte_offset
= ph
->p_vaddr
& (ph
->p_align
- 1);
1106 l
->l_tls_initimage_size
= ph
->p_filesz
;
1107 /* Since we don't know the load address yet only store the
1108 offset. We will adjust it later. */
1109 l
->l_tls_initimage
= (void *) ph
->p_vaddr
;
1111 /* If not loading the initial set of shared libraries,
1112 check whether we should permit loading a TLS segment. */
1113 if (__glibc_likely (l
->l_type
== lt_library
)
1114 /* If GL(dl_tls_dtv_slotinfo_list) == NULL, then rtld.c did
1115 not set up TLS data structures, so don't use them now. */
1116 || __glibc_likely (GL(dl_tls_dtv_slotinfo_list
) != NULL
))
1118 /* Assign the next available module ID. */
1119 l
->l_tls_modid
= _dl_next_tls_modid ();
1124 /* We are loading the executable itself when the dynamic
1125 linker was executed directly. The setup will happen
1126 later. Otherwise, the TLS data structures are already
1127 initialized, and we assigned a TLS modid above. */
1128 assert (l
->l_prev
== NULL
|| (mode
& __RTLD_AUDIT
) != 0);
1130 assert (false && "TLS not initialized in static application");
1135 stack_flags
= ph
->p_flags
;
1139 l
->l_relro_addr
= ph
->p_vaddr
;
1140 l
->l_relro_size
= ph
->p_memsz
;
1144 if (_dl_process_pt_note (l
, ph
, fd
, fbp
))
1146 errstring
= N_("cannot process note segment");
1152 if (__glibc_unlikely (nloadcmds
== 0))
1154 /* This only happens for a bogus object that will be caught with
1155 another error below. But we don't want to go through the
1156 calculations below using NLOADCMDS - 1. */
1157 errstring
= N_("object file has no loadable segments");
1161 /* dlopen of an executable is not valid because it is not possible
1162 to perform proper relocations, handle static TLS, or run the
1163 ELF constructors. For PIE, the check needs the dynamic
1164 section, so there is another check below. */
1165 if (__glibc_unlikely (type
!= ET_DYN
)
1166 && __glibc_unlikely ((mode
& __RTLD_OPENEXEC
) == 0))
1168 /* This object is loaded at a fixed address. This must never
1169 happen for objects loaded with dlopen. */
1170 errstring
= N_("cannot dynamically load executable");
1174 /* Length of the sections to be loaded. */
1175 maplength
= loadcmds
[nloadcmds
- 1].allocend
- loadcmds
[0].mapstart
;
1177 /* Now process the load commands and map segments into memory.
1178 This is responsible for filling in:
1179 l_map_start, l_map_end, l_addr, l_contiguous, l_text_end, l_phdr
1181 errstring
= _dl_map_segments (l
, fd
, header
, type
, loadcmds
, nloadcmds
,
1182 maplength
, has_holes
, loader
);
1183 if (__glibc_unlikely (errstring
!= NULL
))
1189 if (__glibc_unlikely (type
== ET_DYN
))
1191 errstring
= N_("object file has no dynamic section");
1196 l
->l_ld
= (ElfW(Dyn
) *) ((ElfW(Addr
)) l
->l_ld
+ l
->l_addr
);
1198 elf_get_dynamic_info (l
, NULL
);
1200 /* Make sure we are not dlopen'ing an object that has the
1201 DF_1_NOOPEN flag set, or a PIE object. */
1202 if ((__glibc_unlikely (l
->l_flags_1
& DF_1_NOOPEN
)
1203 && (mode
& __RTLD_DLOPEN
))
1204 || (__glibc_unlikely (l
->l_flags_1
& DF_1_PIE
)
1205 && __glibc_unlikely ((mode
& __RTLD_OPENEXEC
) == 0)))
1207 /* We are not supposed to load this object. Free all resources. */
1208 _dl_unmap_segments (l
);
1210 if (!l
->l_libname
->dont_free
)
1211 free (l
->l_libname
);
1213 if (l
->l_phdr_allocated
)
1214 free ((void *) l
->l_phdr
);
1216 if (l
->l_flags_1
& DF_1_PIE
)
1218 = N_("cannot dynamically load position-independent executable");
1220 errstring
= N_("shared object cannot be dlopen()ed");
1224 if (l
->l_phdr
== NULL
)
1226 /* The program header is not contained in any of the segments.
1227 We have to allocate memory ourself and copy it over from out
1229 ElfW(Phdr
) *newp
= (ElfW(Phdr
) *) malloc (header
->e_phnum
1230 * sizeof (ElfW(Phdr
)));
1233 errstring
= N_("cannot allocate memory for program header");
1234 goto call_lose_errno
;
1237 l
->l_phdr
= memcpy (newp
, phdr
,
1238 (header
->e_phnum
* sizeof (ElfW(Phdr
))));
1239 l
->l_phdr_allocated
= 1;
1242 /* Adjust the PT_PHDR value by the runtime load address. */
1243 l
->l_phdr
= (ElfW(Phdr
) *) ((ElfW(Addr
)) l
->l_phdr
+ l
->l_addr
);
1245 if (__glibc_unlikely ((stack_flags
&~ GL(dl_stack_flags
)) & PF_X
))
1247 /* The stack is presently not executable, but this module
1248 requires that it be executable. We must change the
1249 protection of the variable which contains the flags used in
1250 the mprotect calls. */
1252 if ((mode
& (__RTLD_DLOPEN
| __RTLD_AUDIT
)) == __RTLD_DLOPEN
)
1254 const uintptr_t p
= (uintptr_t) &__stack_prot
& -GLRO(dl_pagesize
);
1255 const size_t s
= (uintptr_t) (&__stack_prot
+ 1) - p
;
1257 struct link_map
*const m
= &GL(dl_rtld_map
);
1258 const uintptr_t relro_end
= ((m
->l_addr
+ m
->l_relro_addr
1260 & -GLRO(dl_pagesize
));
1261 if (__glibc_likely (p
+ s
<= relro_end
))
1263 /* The variable lies in the region protected by RELRO. */
1264 if (__mprotect ((void *) p
, s
, PROT_READ
|PROT_WRITE
) < 0)
1266 errstring
= N_("cannot change memory protections");
1267 goto call_lose_errno
;
1269 __stack_prot
|= PROT_READ
|PROT_WRITE
|PROT_EXEC
;
1270 __mprotect ((void *) p
, s
, PROT_READ
);
1273 __stack_prot
|= PROT_READ
|PROT_WRITE
|PROT_EXEC
;
1277 __stack_prot
|= PROT_READ
|PROT_WRITE
|PROT_EXEC
;
1279 #ifdef check_consistency
1280 check_consistency ();
1283 errval
= (*GL(dl_make_stack_executable_hook
)) (stack_endp
);
1287 cannot enable executable stack as shared object requires");
1292 /* Adjust the address of the TLS initialization image. */
1293 if (l
->l_tls_initimage
!= NULL
)
1294 l
->l_tls_initimage
= (char *) l
->l_tls_initimage
+ l
->l_addr
;
1296 /* We are done mapping in the file. We no longer need the descriptor. */
1297 if (__glibc_unlikely (__close_nocancel (fd
) != 0))
1299 errstring
= N_("cannot close file descriptor");
1300 goto call_lose_errno
;
1302 /* Signal that we closed the file. */
1305 /* If this is ET_EXEC, we should have loaded it as lt_executable. */
1306 assert (type
!= ET_EXEC
|| l
->l_type
== lt_executable
);
1308 l
->l_entry
+= l
->l_addr
;
1310 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_FILES
))
1311 _dl_debug_printf ("\
1312 dynamic: 0x%0*lx base: 0x%0*lx size: 0x%0*Zx\n\
1313 entry: 0x%0*lx phdr: 0x%0*lx phnum: %*u\n\n",
1314 (int) sizeof (void *) * 2,
1315 (unsigned long int) l
->l_ld
,
1316 (int) sizeof (void *) * 2,
1317 (unsigned long int) l
->l_addr
,
1318 (int) sizeof (void *) * 2, maplength
,
1319 (int) sizeof (void *) * 2,
1320 (unsigned long int) l
->l_entry
,
1321 (int) sizeof (void *) * 2,
1322 (unsigned long int) l
->l_phdr
,
1323 (int) sizeof (void *) * 2, l
->l_phnum
);
1325 /* Set up the symbol hash table. */
1328 /* If this object has DT_SYMBOLIC set modify now its scope. We don't
1329 have to do this for the main map. */
1330 if ((mode
& RTLD_DEEPBIND
) == 0
1331 && __glibc_unlikely (l
->l_info
[DT_SYMBOLIC
] != NULL
)
1332 && &l
->l_searchlist
!= l
->l_scope
[0])
1334 /* Create an appropriate searchlist. It contains only this map.
1335 This is the definition of DT_SYMBOLIC in SysVr4. */
1336 l
->l_symbolic_searchlist
.r_list
[0] = l
;
1337 l
->l_symbolic_searchlist
.r_nlist
= 1;
1339 /* Now move the existing entries one back. */
1340 memmove (&l
->l_scope
[1], &l
->l_scope
[0],
1341 (l
->l_scope_max
- 1) * sizeof (l
->l_scope
[0]));
1343 /* Now add the new entry. */
1344 l
->l_scope
[0] = &l
->l_symbolic_searchlist
;
1347 /* Remember whether this object must be initialized first. */
1348 if (l
->l_flags_1
& DF_1_INITFIRST
)
1349 GL(dl_initfirst
) = l
;
1351 /* Finally the file information. */
1355 /* When auditing is used the recorded names might not include the
1356 name by which the DSO is actually known. Add that as well. */
1357 if (__glibc_unlikely (origname
!= NULL
))
1358 add_name_to_object (l
, origname
);
1360 /* Audit modules only exist when linking is dynamic so ORIGNAME
1361 cannot be non-NULL. */
1362 assert (origname
== NULL
);
1365 /* When we profile the SONAME might be needed for something else but
1366 loading. Add it right away. */
1367 if (__glibc_unlikely (GLRO(dl_profile
) != NULL
)
1368 && l
->l_info
[DT_SONAME
] != NULL
)
1369 add_name_to_object (l
, ((const char *) D_PTR (l
, l_info
[DT_STRTAB
])
1370 + l
->l_info
[DT_SONAME
]->d_un
.d_val
));
1372 #ifdef DL_AFTER_LOAD
1376 /* Now that the object is fully initialized add it to the object list. */
1377 _dl_add_to_namespace_list (l
, nsid
);
1380 /* Auditing checkpoint: we have a new object. */
1381 if (__glibc_unlikely (GLRO(dl_naudit
) > 0)
1382 && !GL(dl_ns
)[l
->l_ns
]._ns_loaded
->l_auditing
)
1384 struct audit_ifaces
*afct
= GLRO(dl_audit
);
1385 for (unsigned int cnt
= 0; cnt
< GLRO(dl_naudit
); ++cnt
)
1387 if (afct
->objopen
!= NULL
)
1389 l
->l_audit
[cnt
].bindflags
1390 = afct
->objopen (l
, nsid
, &l
->l_audit
[cnt
].cookie
);
1392 l
->l_audit_any_plt
|= l
->l_audit
[cnt
].bindflags
!= 0;
1403 /* Print search path. */
1405 print_search_path (struct r_search_path_elem
**list
,
1406 const char *what
, const char *name
)
1408 char buf
[max_dirnamelen
+ max_capstrlen
];
1411 _dl_debug_printf (" search path=");
1413 while (*list
!= NULL
&& (*list
)->what
== what
) /* Yes, ==. */
1415 char *endp
= __mempcpy (buf
, (*list
)->dirname
, (*list
)->dirnamelen
);
1418 for (cnt
= 0; cnt
< ncapstr
; ++cnt
)
1419 if ((*list
)->status
[cnt
] != nonexisting
)
1421 char *cp
= __mempcpy (endp
, capstr
[cnt
].str
, capstr
[cnt
].len
);
1422 if (cp
== buf
|| (cp
== buf
+ 1 && buf
[0] == '/'))
1427 _dl_debug_printf_c (first
? "%s" : ":%s", buf
);
1435 _dl_debug_printf_c ("\t\t(%s from file %s)\n", what
,
1436 DSO_FILENAME (name
));
1438 _dl_debug_printf_c ("\t\t(%s)\n", what
);
1441 /* Open a file and verify it is an ELF file for this architecture. We
1442 ignore only ELF files for other architectures. Non-ELF files and
1443 ELF files with different header information cause fatal errors since
1444 this could mean there is something wrong in the installation and the
1445 user might want to know about this.
1447 If FD is not -1, then the file is already open and FD refers to it.
1448 In that case, FD is consumed for both successful and error returns. */
1450 open_verify (const char *name
, int fd
,
1451 struct filebuf
*fbp
, struct link_map
*loader
,
1452 int whatcode
, int mode
, bool *found_other_class
, bool free_name
)
1454 /* This is the expected ELF header. */
1455 #define ELF32_CLASS ELFCLASS32
1456 #define ELF64_CLASS ELFCLASS64
1457 #ifndef VALID_ELF_HEADER
1458 # define VALID_ELF_HEADER(hdr,exp,size) (memcmp (hdr, exp, size) == 0)
1459 # define VALID_ELF_OSABI(osabi) (osabi == ELFOSABI_SYSV)
1460 # define VALID_ELF_ABIVERSION(osabi,ver) (ver == 0)
1461 #elif defined MORE_ELF_HEADER_DATA
1462 MORE_ELF_HEADER_DATA
;
1464 static const unsigned char expected
[EI_NIDENT
] =
1466 [EI_MAG0
] = ELFMAG0
,
1467 [EI_MAG1
] = ELFMAG1
,
1468 [EI_MAG2
] = ELFMAG2
,
1469 [EI_MAG3
] = ELFMAG3
,
1470 [EI_CLASS
] = ELFW(CLASS
),
1471 [EI_DATA
] = byteorder
,
1472 [EI_VERSION
] = EV_CURRENT
,
1473 [EI_OSABI
] = ELFOSABI_SYSV
,
1478 ElfW(Word
) vendorlen
;
1482 } expected_note
= { 4, 16, 1, "GNU" };
1483 /* Initialize it to make the compiler happy. */
1484 const char *errstring
= NULL
;
1488 /* Give the auditing libraries a chance. */
1489 if (__glibc_unlikely (GLRO(dl_naudit
) > 0) && whatcode
!= 0
1490 && loader
->l_auditing
== 0)
1492 const char *original_name
= name
;
1493 struct audit_ifaces
*afct
= GLRO(dl_audit
);
1494 for (unsigned int cnt
= 0; cnt
< GLRO(dl_naudit
); ++cnt
)
1496 if (afct
->objsearch
!= NULL
)
1498 name
= afct
->objsearch (name
, &loader
->l_audit
[cnt
].cookie
,
1501 /* Ignore the path. */
1508 if (fd
!= -1 && name
!= original_name
&& strcmp (name
, original_name
))
1510 /* An audit library changed what we're supposed to open,
1511 so FD no longer matches it. */
1512 __close_nocancel (fd
);
1519 /* Open the file. We always open files read-only. */
1520 fd
= __open64_nocancel (name
, O_RDONLY
| O_CLOEXEC
);
1525 ElfW(Phdr
) *phdr
, *ph
;
1526 ElfW(Word
) *abi_note
;
1527 ElfW(Word
) *abi_note_malloced
= NULL
;
1528 unsigned int osversion
;
1531 /* We successfully opened the file. Now verify it is a file
1535 assert (sizeof (fbp
->buf
) > sizeof (ElfW(Ehdr
)));
1536 /* Read in the header. */
1539 ssize_t retlen
= __read_nocancel (fd
, fbp
->buf
+ fbp
->len
,
1540 sizeof (fbp
->buf
) - fbp
->len
);
1545 while (__glibc_unlikely (fbp
->len
< sizeof (ElfW(Ehdr
))));
1547 /* This is where the ELF header is loaded. */
1548 ehdr
= (ElfW(Ehdr
) *) fbp
->buf
;
1550 /* Now run the tests. */
1551 if (__glibc_unlikely (fbp
->len
< (ssize_t
) sizeof (ElfW(Ehdr
))))
1554 errstring
= (errval
== 0
1555 ? N_("file too short") : N_("cannot read file data"));
1559 char *realname
= (char *) name
;
1560 name
= strdupa (realname
);
1563 lose (errval
, fd
, name
, NULL
, NULL
, errstring
, NULL
, 0);
1566 /* See whether the ELF header is what we expect. */
1567 if (__glibc_unlikely (! VALID_ELF_HEADER (ehdr
->e_ident
, expected
,
1569 || !VALID_ELF_ABIVERSION (ehdr
->e_ident
[EI_OSABI
],
1570 ehdr
->e_ident
[EI_ABIVERSION
])
1571 || memcmp (&ehdr
->e_ident
[EI_PAD
],
1573 EI_NIDENT
- EI_PAD
) != 0))
1575 /* Something is wrong. */
1576 const Elf32_Word
*magp
= (const void *) ehdr
->e_ident
;
1578 #if BYTE_ORDER == LITTLE_ENDIAN
1579 ((ELFMAG0
<< (EI_MAG0
* 8))
1580 | (ELFMAG1
<< (EI_MAG1
* 8))
1581 | (ELFMAG2
<< (EI_MAG2
* 8))
1582 | (ELFMAG3
<< (EI_MAG3
* 8)))
1584 ((ELFMAG0
<< (EI_MAG3
* 8))
1585 | (ELFMAG1
<< (EI_MAG2
* 8))
1586 | (ELFMAG2
<< (EI_MAG1
* 8))
1587 | (ELFMAG3
<< (EI_MAG0
* 8)))
1590 errstring
= N_("invalid ELF header");
1591 else if (ehdr
->e_ident
[EI_CLASS
] != ELFW(CLASS
))
1593 /* This is not a fatal error. On architectures where
1594 32-bit and 64-bit binaries can be run this might
1596 *found_other_class
= true;
1599 else if (ehdr
->e_ident
[EI_DATA
] != byteorder
)
1601 if (BYTE_ORDER
== BIG_ENDIAN
)
1602 errstring
= N_("ELF file data encoding not big-endian");
1604 errstring
= N_("ELF file data encoding not little-endian");
1606 else if (ehdr
->e_ident
[EI_VERSION
] != EV_CURRENT
)
1608 = N_("ELF file version ident does not match current one");
1609 /* XXX We should be able so set system specific versions which are
1611 else if (!VALID_ELF_OSABI (ehdr
->e_ident
[EI_OSABI
]))
1612 errstring
= N_("ELF file OS ABI invalid");
1613 else if (!VALID_ELF_ABIVERSION (ehdr
->e_ident
[EI_OSABI
],
1614 ehdr
->e_ident
[EI_ABIVERSION
]))
1615 errstring
= N_("ELF file ABI version invalid");
1616 else if (memcmp (&ehdr
->e_ident
[EI_PAD
], &expected
[EI_PAD
],
1617 EI_NIDENT
- EI_PAD
) != 0)
1618 errstring
= N_("nonzero padding in e_ident");
1620 /* Otherwise we don't know what went wrong. */
1621 errstring
= N_("internal error");
1626 if (__glibc_unlikely (ehdr
->e_version
!= EV_CURRENT
))
1628 errstring
= N_("ELF file version does not match current one");
1631 if (! __glibc_likely (elf_machine_matches_host (ehdr
)))
1633 else if (__glibc_unlikely (ehdr
->e_type
!= ET_DYN
1634 && ehdr
->e_type
!= ET_EXEC
))
1636 errstring
= N_("only ET_DYN and ET_EXEC can be loaded");
1639 else if (__glibc_unlikely (ehdr
->e_type
== ET_EXEC
1640 && (mode
& __RTLD_OPENEXEC
) == 0))
1642 /* BZ #16634. It is an error to dlopen ET_EXEC (unless
1643 __RTLD_OPENEXEC is explicitly set). We return error here
1644 so that code in _dl_map_object_from_fd does not try to set
1645 l_tls_modid for this module. */
1647 errstring
= N_("cannot dynamically load executable");
1650 else if (__glibc_unlikely (ehdr
->e_phentsize
!= sizeof (ElfW(Phdr
))))
1652 errstring
= N_("ELF file's phentsize not the expected size");
1656 maplength
= ehdr
->e_phnum
* sizeof (ElfW(Phdr
));
1657 if (ehdr
->e_phoff
+ maplength
<= (size_t) fbp
->len
)
1658 phdr
= (void *) (fbp
->buf
+ ehdr
->e_phoff
);
1661 phdr
= alloca (maplength
);
1662 __lseek (fd
, ehdr
->e_phoff
, SEEK_SET
);
1663 if ((size_t) __read_nocancel (fd
, (void *) phdr
, maplength
)
1668 errstring
= N_("cannot read file data");
1673 if (__glibc_unlikely (elf_machine_reject_phdr_p
1674 (phdr
, ehdr
->e_phnum
, fbp
->buf
, fbp
->len
,
1678 /* Check .note.ABI-tag if present. */
1679 for (ph
= phdr
; ph
< &phdr
[ehdr
->e_phnum
]; ++ph
)
1680 if (ph
->p_type
== PT_NOTE
&& ph
->p_filesz
>= 32 && ph
->p_align
>= 4)
1682 ElfW(Addr
) size
= ph
->p_filesz
;
1683 /* NB: Some PT_NOTE segment may have alignment value of 0
1684 or 1. gABI specifies that PT_NOTE segments should be
1685 aligned to 4 bytes in 32-bit objects and to 8 bytes in
1686 64-bit objects. As a Linux extension, we also support
1687 4 byte alignment in 64-bit objects. If p_align is less
1688 than 4, we treate alignment as 4 bytes since some note
1689 segments have 0 or 1 byte alignment. */
1690 ElfW(Addr
) align
= ph
->p_align
;
1693 else if (align
!= 4 && align
!= 8)
1696 if (ph
->p_offset
+ size
<= (size_t) fbp
->len
)
1697 abi_note
= (void *) (fbp
->buf
+ ph
->p_offset
);
1700 /* Note: __libc_use_alloca is not usable here, because
1701 thread info may not have been set up yet. */
1702 if (size
< __MAX_ALLOCA_CUTOFF
)
1703 abi_note
= alloca (size
);
1706 /* There could be multiple PT_NOTEs. */
1707 abi_note_malloced
= realloc (abi_note_malloced
, size
);
1708 if (abi_note_malloced
== NULL
)
1711 abi_note
= abi_note_malloced
;
1713 __lseek (fd
, ph
->p_offset
, SEEK_SET
);
1714 if (__read_nocancel (fd
, (void *) abi_note
, size
) != size
)
1716 free (abi_note_malloced
);
1721 while (memcmp (abi_note
, &expected_note
, sizeof (expected_note
)))
1723 ElfW(Addr
) note_size
1724 = ELF_NOTE_NEXT_OFFSET (abi_note
[0], abi_note
[1],
1727 if (size
- 32 < note_size
)
1733 abi_note
= (void *) abi_note
+ note_size
;
1739 osversion
= (abi_note
[5] & 0xff) * 65536
1740 + (abi_note
[6] & 0xff) * 256
1741 + (abi_note
[7] & 0xff);
1742 if (abi_note
[4] != __ABI_TAG_OS
1743 || (GLRO(dl_osversion
) && GLRO(dl_osversion
) < osversion
))
1746 __close_nocancel (fd
);
1747 __set_errno (ENOENT
);
1753 free (abi_note_malloced
);
1759 /* Try to open NAME in one of the directories in *DIRSP.
1760 Return the fd, or -1. If successful, fill in *REALNAME
1761 with the malloc'd full directory name. If it turns out
1762 that none of the directories in *DIRSP exists, *DIRSP is
1763 replaced with (void *) -1, and the old value is free()d
1764 if MAY_FREE_DIRS is true. */
1767 open_path (const char *name
, size_t namelen
, int mode
,
1768 struct r_search_path_struct
*sps
, char **realname
,
1769 struct filebuf
*fbp
, struct link_map
*loader
, int whatcode
,
1770 bool *found_other_class
)
1772 struct r_search_path_elem
**dirs
= sps
->dirs
;
1775 const char *current_what
= NULL
;
1778 if (__glibc_unlikely (dirs
== NULL
))
1779 /* We're called before _dl_init_paths when loading the main executable
1780 given on the command line when rtld is run directly. */
1783 buf
= alloca (max_dirnamelen
+ max_capstrlen
+ namelen
);
1786 struct r_search_path_elem
*this_dir
= *dirs
;
1793 /* If we are debugging the search for libraries print the path
1794 now if it hasn't happened now. */
1795 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_LIBS
)
1796 && current_what
!= this_dir
->what
)
1798 current_what
= this_dir
->what
;
1799 print_search_path (dirs
, current_what
, this_dir
->where
);
1802 edp
= (char *) __mempcpy (buf
, this_dir
->dirname
, this_dir
->dirnamelen
);
1803 for (cnt
= 0; fd
== -1 && cnt
< ncapstr
; ++cnt
)
1805 /* Skip this directory if we know it does not exist. */
1806 if (this_dir
->status
[cnt
] == nonexisting
)
1810 ((char *) __mempcpy (__mempcpy (edp
, capstr
[cnt
].str
,
1815 /* Print name we try if this is wanted. */
1816 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_LIBS
))
1817 _dl_debug_printf (" trying file=%s\n", buf
);
1819 fd
= open_verify (buf
, -1, fbp
, loader
, whatcode
, mode
,
1820 found_other_class
, false);
1821 if (this_dir
->status
[cnt
] == unknown
)
1824 this_dir
->status
[cnt
] = existing
;
1825 /* Do not update the directory information when loading
1826 auditing code. We must try to disturb the program as
1827 little as possible. */
1828 else if (loader
== NULL
1829 || GL(dl_ns
)[loader
->l_ns
]._ns_loaded
->l_auditing
== 0)
1831 /* We failed to open machine dependent library. Let's
1832 test whether there is any directory at all. */
1835 buf
[buflen
- namelen
- 1] = '\0';
1837 if (__xstat64 (_STAT_VER
, buf
, &st
) != 0
1838 || ! S_ISDIR (st
.st_mode
))
1839 /* The directory does not exist or it is no directory. */
1840 this_dir
->status
[cnt
] = nonexisting
;
1842 this_dir
->status
[cnt
] = existing
;
1846 /* Remember whether we found any existing directory. */
1847 here_any
|= this_dir
->status
[cnt
] != nonexisting
;
1849 if (fd
!= -1 && __glibc_unlikely (mode
& __RTLD_SECURE
)
1850 && __libc_enable_secure
)
1852 /* This is an extra security effort to make sure nobody can
1853 preload broken shared objects which are in the trusted
1854 directories and so exploit the bugs. */
1857 if (__fxstat64 (_STAT_VER
, fd
, &st
) != 0
1858 || (st
.st_mode
& S_ISUID
) == 0)
1860 /* The shared object cannot be tested for being SUID
1861 or this bit is not set. In this case we must not
1863 __close_nocancel (fd
);
1865 /* We simply ignore the file, signal this by setting
1866 the error value which would have been set by `open'. */
1874 *realname
= (char *) malloc (buflen
);
1875 if (*realname
!= NULL
)
1877 memcpy (*realname
, buf
, buflen
);
1882 /* No memory for the name, we certainly won't be able
1883 to load and link it. */
1884 __close_nocancel (fd
);
1888 if (here_any
&& (err
= errno
) != ENOENT
&& err
!= EACCES
)
1889 /* The file exists and is readable, but something went wrong. */
1892 /* Remember whether we found anything. */
1895 while (*++dirs
!= NULL
);
1897 /* Remove the whole path if none of the directories exists. */
1898 if (__glibc_unlikely (! any
))
1900 /* Paths which were allocated using the minimal malloc() in ld.so
1901 must not be freed using the general free() in libc. */
1905 /* rtld_search_dirs and env_path_list are attribute_relro, therefore
1906 avoid writing into it. */
1907 if (sps
!= &rtld_search_dirs
&& sps
!= &env_path_list
)
1908 sps
->dirs
= (void *) -1;
1914 /* Map in the shared object file NAME. */
1917 _dl_map_object (struct link_map
*loader
, const char *name
,
1918 int type
, int trace_mode
, int mode
, Lmid_t nsid
)
1921 const char *origname
= NULL
;
1928 assert (nsid
< GL(dl_nns
));
1930 /* Look for this name among those already loaded. */
1931 for (l
= GL(dl_ns
)[nsid
]._ns_loaded
; l
; l
= l
->l_next
)
1933 /* If the requested name matches the soname of a loaded object,
1934 use that object. Elide this check for names that have not
1936 if (__glibc_unlikely ((l
->l_faked
| l
->l_removed
) != 0))
1938 if (!_dl_name_match_p (name
, l
))
1942 if (__glibc_likely (l
->l_soname_added
)
1943 || l
->l_info
[DT_SONAME
] == NULL
)
1946 soname
= ((const char *) D_PTR (l
, l_info
[DT_STRTAB
])
1947 + l
->l_info
[DT_SONAME
]->d_un
.d_val
);
1948 if (strcmp (name
, soname
) != 0)
1951 /* We have a match on a new name -- cache it. */
1952 add_name_to_object (l
, soname
);
1953 l
->l_soname_added
= 1;
1956 /* We have a match. */
1960 /* Display information if we are debugging. */
1961 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_FILES
)
1963 _dl_debug_printf ((mode
& __RTLD_CALLMAP
) == 0
1964 ? "\nfile=%s [%lu]; needed by %s [%lu]\n"
1965 : "\nfile=%s [%lu]; dynamically loaded by %s [%lu]\n",
1966 name
, nsid
, DSO_FILENAME (loader
->l_name
), loader
->l_ns
);
1969 /* Give the auditing libraries a chance to change the name before we
1971 if (__glibc_unlikely (GLRO(dl_naudit
) > 0)
1972 && (loader
== NULL
|| loader
->l_auditing
== 0))
1974 struct audit_ifaces
*afct
= GLRO(dl_audit
);
1975 for (unsigned int cnt
= 0; cnt
< GLRO(dl_naudit
); ++cnt
)
1977 if (afct
->objsearch
!= NULL
)
1979 const char *before
= name
;
1980 name
= afct
->objsearch (name
, &loader
->l_audit
[cnt
].cookie
,
1984 /* Do not try anything further. */
1988 if (before
!= name
&& strcmp (before
, name
) != 0)
1990 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_FILES
))
1991 _dl_debug_printf ("audit changed filename %s -> %s\n",
1994 if (origname
== NULL
)
2004 /* Will be true if we found a DSO which is of the other ELF class. */
2005 bool found_other_class
= false;
2007 if (strchr (name
, '/') == NULL
)
2009 /* Search for NAME in several places. */
2011 size_t namelen
= strlen (name
) + 1;
2013 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_LIBS
))
2014 _dl_debug_printf ("find library=%s [%lu]; searching\n", name
, nsid
);
2018 /* When the object has the RUNPATH information we don't use any
2020 if (loader
== NULL
|| loader
->l_info
[DT_RUNPATH
] == NULL
)
2022 /* This is the executable's map (if there is one). Make sure that
2023 we do not look at it twice. */
2024 struct link_map
*main_map
= GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
;
2025 bool did_main_map
= false;
2027 /* First try the DT_RPATH of the dependent object that caused NAME
2028 to be loaded. Then that object's dependent, and on up. */
2029 for (l
= loader
; l
; l
= l
->l_loader
)
2030 if (cache_rpath (l
, &l
->l_rpath_dirs
, DT_RPATH
, "RPATH"))
2032 fd
= open_path (name
, namelen
, mode
,
2034 &realname
, &fb
, loader
, LA_SER_RUNPATH
,
2035 &found_other_class
);
2039 did_main_map
|= l
== main_map
;
2042 /* If dynamically linked, try the DT_RPATH of the executable
2043 itself. NB: we do this for lookups in any namespace. */
2044 if (fd
== -1 && !did_main_map
2045 && main_map
!= NULL
&& main_map
->l_type
!= lt_loaded
2046 && cache_rpath (main_map
, &main_map
->l_rpath_dirs
, DT_RPATH
,
2048 fd
= open_path (name
, namelen
, mode
,
2049 &main_map
->l_rpath_dirs
,
2050 &realname
, &fb
, loader
?: main_map
, LA_SER_RUNPATH
,
2051 &found_other_class
);
2054 /* Try the LD_LIBRARY_PATH environment variable. */
2055 if (fd
== -1 && env_path_list
.dirs
!= (void *) -1)
2056 fd
= open_path (name
, namelen
, mode
, &env_path_list
,
2058 loader
?: GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
,
2059 LA_SER_LIBPATH
, &found_other_class
);
2061 /* Look at the RUNPATH information for this binary. */
2062 if (fd
== -1 && loader
!= NULL
2063 && cache_rpath (loader
, &loader
->l_runpath_dirs
,
2064 DT_RUNPATH
, "RUNPATH"))
2065 fd
= open_path (name
, namelen
, mode
,
2066 &loader
->l_runpath_dirs
, &realname
, &fb
, loader
,
2067 LA_SER_RUNPATH
, &found_other_class
);
2071 realname
= _dl_sysdep_open_object (name
, namelen
, &fd
);
2072 if (realname
!= NULL
)
2074 fd
= open_verify (realname
, fd
,
2075 &fb
, loader
?: GL(dl_ns
)[nsid
]._ns_loaded
,
2076 LA_SER_CONFIG
, mode
, &found_other_class
,
2085 && (__glibc_likely ((mode
& __RTLD_SECURE
) == 0)
2086 || ! __libc_enable_secure
)
2087 && __glibc_likely (GLRO(dl_inhibit_cache
) == 0))
2089 /* Check the list of libraries in the file /etc/ld.so.cache,
2090 for compatibility with Linux's ldconfig program. */
2091 char *cached
= _dl_load_cache_lookup (name
);
2095 // XXX Correct to unconditionally default to namespace 0?
2097 ?: GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
2103 /* If the loader has the DF_1_NODEFLIB flag set we must not
2104 use a cache entry from any of these directories. */
2105 if (__glibc_unlikely (l
->l_flags_1
& DF_1_NODEFLIB
))
2107 const char *dirp
= system_dirs
;
2108 unsigned int cnt
= 0;
2112 if (memcmp (cached
, dirp
, system_dirs_len
[cnt
]) == 0)
2114 /* The prefix matches. Don't use the entry. */
2120 dirp
+= system_dirs_len
[cnt
] + 1;
2123 while (cnt
< nsystem_dirs_len
);
2128 fd
= open_verify (cached
, -1,
2129 &fb
, loader
?: GL(dl_ns
)[nsid
]._ns_loaded
,
2130 LA_SER_CONFIG
, mode
, &found_other_class
,
2132 if (__glibc_likely (fd
!= -1))
2141 /* Finally, try the default path. */
2143 && ((l
= loader
?: GL(dl_ns
)[nsid
]._ns_loaded
) == NULL
2144 || __glibc_likely (!(l
->l_flags_1
& DF_1_NODEFLIB
)))
2145 && rtld_search_dirs
.dirs
!= (void *) -1)
2146 fd
= open_path (name
, namelen
, mode
, &rtld_search_dirs
,
2147 &realname
, &fb
, l
, LA_SER_DEFAULT
, &found_other_class
);
2149 /* Add another newline when we are tracing the library loading. */
2150 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_LIBS
))
2151 _dl_debug_printf ("\n");
2155 /* The path may contain dynamic string tokens. */
2157 ? expand_dynamic_string_token (loader
, name
)
2159 if (realname
== NULL
)
2163 fd
= open_verify (realname
, -1, &fb
,
2164 loader
?: GL(dl_ns
)[nsid
]._ns_loaded
, 0, mode
,
2165 &found_other_class
, true);
2166 if (__glibc_unlikely (fd
== -1))
2174 /* In case the LOADER information has only been provided to get to
2175 the appropriate RUNPATH/RPATH information we do not need it
2177 if (mode
& __RTLD_CALLMAP
)
2180 if (__glibc_unlikely (fd
== -1))
2183 && __glibc_likely ((GLRO(dl_debug_mask
) & DL_DEBUG_PRELINK
) == 0))
2185 /* We haven't found an appropriate library. But since we
2186 are only interested in the list of libraries this isn't
2187 so severe. Fake an entry with all the information we
2189 static const Elf_Symndx dummy_bucket
= STN_UNDEF
;
2191 /* Allocate a new object map. */
2192 if ((name_copy
= __strdup (name
)) == NULL
2193 || (l
= _dl_new_object (name_copy
, name
, type
, loader
,
2194 mode
, nsid
)) == NULL
)
2197 _dl_signal_error (ENOMEM
, name
, NULL
,
2198 N_("cannot create shared object descriptor"));
2200 /* Signal that this is a faked entry. */
2202 /* Since the descriptor is initialized with zero we do not
2204 l->l_reserved = 0; */
2205 l
->l_buckets
= &dummy_bucket
;
2209 /* Enter the object in the object list. */
2210 _dl_add_to_namespace_list (l
, nsid
);
2214 else if (found_other_class
)
2215 _dl_signal_error (0, name
, NULL
,
2216 ELFW(CLASS
) == ELFCLASS32
2217 ? N_("wrong ELF class: ELFCLASS64")
2218 : N_("wrong ELF class: ELFCLASS32"));
2220 _dl_signal_error (errno
, name
, NULL
,
2221 N_("cannot open shared object file"));
2224 void *stack_end
= __libc_stack_end
;
2225 return _dl_map_object_from_fd (name
, origname
, fd
, &fb
, realname
, loader
,
2226 type
, mode
, &stack_end
, nsid
);
2229 struct add_path_state
2238 add_path (struct add_path_state
*p
, const struct r_search_path_struct
*sps
,
2241 if (sps
->dirs
!= (void *) -1)
2243 struct r_search_path_elem
**dirs
= sps
->dirs
;
2246 const struct r_search_path_elem
*const r
= *dirs
++;
2250 p
->si
->dls_size
+= MAX (2, r
->dirnamelen
);
2254 Dl_serpath
*const sp
= &p
->si
->dls_serpath
[p
->idx
++];
2255 sp
->dls_name
= p
->allocptr
;
2256 if (r
->dirnamelen
< 2)
2257 *p
->allocptr
++ = r
->dirnamelen
? '/' : '.';
2259 p
->allocptr
= __mempcpy (p
->allocptr
,
2260 r
->dirname
, r
->dirnamelen
- 1);
2261 *p
->allocptr
++ = '\0';
2262 sp
->dls_flags
= flags
;
2265 while (*dirs
!= NULL
);
2270 _dl_rtld_di_serinfo (struct link_map
*loader
, Dl_serinfo
*si
, bool counting
)
2278 struct add_path_state p
=
2280 .counting
= counting
,
2283 .allocptr
= (char *) &si
->dls_serpath
[si
->dls_cnt
]
2286 # define add_path(p, sps, flags) add_path(p, sps, 0) /* XXX */
2288 /* When the object has the RUNPATH information we don't use any RPATHs. */
2289 if (loader
->l_info
[DT_RUNPATH
] == NULL
)
2291 /* First try the DT_RPATH of the dependent object that caused NAME
2292 to be loaded. Then that object's dependent, and on up. */
2294 struct link_map
*l
= loader
;
2297 if (cache_rpath (l
, &l
->l_rpath_dirs
, DT_RPATH
, "RPATH"))
2298 add_path (&p
, &l
->l_rpath_dirs
, XXX_RPATH
);
2303 /* If dynamically linked, try the DT_RPATH of the executable itself. */
2304 if (loader
->l_ns
== LM_ID_BASE
)
2306 l
= GL(dl_ns
)[LM_ID_BASE
]._ns_loaded
;
2307 if (l
!= NULL
&& l
->l_type
!= lt_loaded
&& l
!= loader
)
2308 if (cache_rpath (l
, &l
->l_rpath_dirs
, DT_RPATH
, "RPATH"))
2309 add_path (&p
, &l
->l_rpath_dirs
, XXX_RPATH
);
2313 /* Try the LD_LIBRARY_PATH environment variable. */
2314 add_path (&p
, &env_path_list
, XXX_ENV
);
2316 /* Look at the RUNPATH information for this binary. */
2317 if (cache_rpath (loader
, &loader
->l_runpath_dirs
, DT_RUNPATH
, "RUNPATH"))
2318 add_path (&p
, &loader
->l_runpath_dirs
, XXX_RUNPATH
);
2321 Here is where ld.so.cache gets checked, but we don't have
2322 a way to indicate that in the results for Dl_serinfo. */
2324 /* Finally, try the default path. */
2325 if (!(loader
->l_flags_1
& DF_1_NODEFLIB
))
2326 add_path (&p
, &rtld_search_dirs
, XXX_default
);
2329 /* Count the struct size before the string area, which we didn't
2330 know before we completed dls_cnt. */
2331 si
->dls_size
+= (char *) &si
->dls_serpath
[si
->dls_cnt
] - (char *) si
;