2 * Copyright 1996, 1997, 1998, 1999, 2000 John D. Polstra.
3 * Copyright 2003 Alexander Kabaev <kan@FreeBSD.ORG>.
4 * Copyright 2009-2012 Konstantin Belousov <kib@FreeBSD.ORG>.
5 * Copyright 2012 John Marino <draco@marino.st>.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 * Dynamic linker for ELF.
34 * John Polstra <jdp@polstra.com>.
38 #error "GCC is needed to compile this file"
41 #include <sys/param.h>
42 #include <sys/mount.h>
45 #include <sys/sysctl.h>
47 #include <sys/utsname.h>
48 #include <sys/ktrace.h>
49 #include <sys/resident.h>
52 #include <machine/tls.h>
67 #include "rtld_printf.h"
70 #define PATH_RTLD "/usr/libexec/ld-elf.so.2"
71 #define LD_ARY_CACHE 16
74 typedef void (*func_ptr_type
)();
75 typedef void * (*path_enum_proc
) (const char *path
, size_t len
, void *arg
);
78 * Function declarations.
80 static const char *_getenv_ld(const char *id
);
81 static void die(void) __dead2
;
82 static void digest_dynamic1(Obj_Entry
*, int, const Elf_Dyn
**,
83 const Elf_Dyn
**, const Elf_Dyn
**);
84 static void digest_dynamic2(Obj_Entry
*, const Elf_Dyn
*, const Elf_Dyn
*,
86 static void digest_dynamic(Obj_Entry
*, int);
87 static Obj_Entry
*digest_phdr(const Elf_Phdr
*, int, caddr_t
, const char *);
88 static Obj_Entry
*dlcheck(void *);
89 static Obj_Entry
*dlopen_object(const char *name
, int fd
, Obj_Entry
*refobj
,
90 int lo_flags
, int mode
, RtldLockState
*lockstate
);
91 static Obj_Entry
*do_load_object(int, const char *, char *, struct stat
*, int);
92 static int do_search_info(const Obj_Entry
*obj
, int, struct dl_serinfo
*);
93 static bool donelist_check(DoneList
*, const Obj_Entry
*);
94 static void errmsg_restore(char *);
95 static char *errmsg_save(void);
96 static void *fill_search_info(const char *, size_t, void *);
97 static char *find_library(const char *, const Obj_Entry
*, int *);
98 static const char *gethints(bool);
99 static void init_dag(Obj_Entry
*);
100 static void init_rtld(caddr_t
, Elf_Auxinfo
**);
101 static void initlist_add_neededs(Needed_Entry
*, Objlist
*);
102 static void initlist_add_objects(Obj_Entry
*, Obj_Entry
**, Objlist
*);
103 static void linkmap_add(Obj_Entry
*);
104 static void linkmap_delete(Obj_Entry
*);
105 static void load_filtees(Obj_Entry
*, int flags
, RtldLockState
*);
106 static void unload_filtees(Obj_Entry
*);
107 static int load_needed_objects(Obj_Entry
*, int);
108 static int load_preload_objects(void);
109 static Obj_Entry
*load_object(const char *, int fd
, const Obj_Entry
*, int);
110 static void map_stacks_exec(RtldLockState
*);
111 static Obj_Entry
*obj_from_addr(const void *);
112 static void objlist_call_fini(Objlist
*, Obj_Entry
*, RtldLockState
*);
113 static void objlist_call_init(Objlist
*, RtldLockState
*);
114 static void objlist_clear(Objlist
*);
115 static Objlist_Entry
*objlist_find(Objlist
*, const Obj_Entry
*);
116 static void objlist_init(Objlist
*);
117 static void objlist_push_head(Objlist
*, Obj_Entry
*);
118 static void objlist_push_tail(Objlist
*, Obj_Entry
*);
119 static void objlist_put_after(Objlist
*, Obj_Entry
*, Obj_Entry
*);
120 static void objlist_remove(Objlist
*, Obj_Entry
*);
121 static int parse_libdir(const char *);
122 static void *path_enumerate(const char *, path_enum_proc
, void *);
123 static int relocate_object_dag(Obj_Entry
*root
, bool bind_now
,
124 Obj_Entry
*rtldobj
, int flags
, RtldLockState
*lockstate
);
125 static int relocate_object(Obj_Entry
*obj
, bool bind_now
, Obj_Entry
*rtldobj
,
126 int flags
, RtldLockState
*lockstate
);
127 static int relocate_objects(Obj_Entry
*, bool, Obj_Entry
*, int,
129 static int resolve_objects_ifunc(Obj_Entry
*first
, bool bind_now
,
130 int flags
, RtldLockState
*lockstate
);
131 static int rtld_dirname(const char *, char *);
132 static int rtld_dirname_abs(const char *, char *);
133 static void *rtld_dlopen(const char *name
, int fd
, int mode
);
134 static void rtld_exit(void);
135 static char *search_library_path(const char *, const char *);
136 static char *search_library_pathfds(const char *, const char *, int *);
137 static const void **get_program_var_addr(const char *, RtldLockState
*);
138 static void set_program_var(const char *, const void *);
139 static int symlook_default(SymLook
*, const Obj_Entry
*refobj
);
140 static int symlook_global(SymLook
*, DoneList
*);
141 static void symlook_init_from_req(SymLook
*, const SymLook
*);
142 static int symlook_list(SymLook
*, const Objlist
*, DoneList
*);
143 static int symlook_needed(SymLook
*, const Needed_Entry
*, DoneList
*);
144 static int symlook_obj1_sysv(SymLook
*, const Obj_Entry
*);
145 static int symlook_obj1_gnu(SymLook
*, const Obj_Entry
*);
146 static void trace_loaded_objects(Obj_Entry
*);
147 static void unlink_object(Obj_Entry
*);
148 static void unload_object(Obj_Entry
*);
149 static void unref_dag(Obj_Entry
*);
150 static void ref_dag(Obj_Entry
*);
151 static char *origin_subst_one(char *, const char *, const char *, bool);
152 static char *origin_subst(char *, const char *);
153 static void preinit_main(void);
154 static int rtld_verify_versions(const Objlist
*);
155 static int rtld_verify_object_versions(Obj_Entry
*);
156 static void object_add_name(Obj_Entry
*, const char *);
157 static int object_match_name(const Obj_Entry
*, const char *);
158 static void ld_utrace_log(int, void *, void *, size_t, int, const char *);
159 static void rtld_fill_dl_phdr_info(const Obj_Entry
*obj
,
160 struct dl_phdr_info
*phdr_info
);
161 static uint_fast32_t gnu_hash (const char *);
162 static bool matched_symbol(SymLook
*, const Obj_Entry
*, Sym_Match_Result
*,
163 const unsigned long);
165 void r_debug_state(struct r_debug
*, struct link_map
*) __noinline
;
166 void _r_debug_postinit(struct link_map
*) __noinline
;
171 static char *error_message
; /* Message for dlerror(), or NULL */
172 struct r_debug r_debug
; /* for GDB; */
173 static bool libmap_disable
; /* Disable libmap */
174 static bool ld_loadfltr
; /* Immediate filters processing */
175 static char *libmap_override
; /* Maps to use in addition to libmap.conf */
176 static bool trust
; /* False for setuid and setgid programs */
177 static bool dangerous_ld_env
; /* True if environment variables have been
178 used to affect the libraries loaded */
179 static const char *ld_bind_now
; /* Environment variable for immediate binding */
180 static const char *ld_debug
; /* Environment variable for debugging */
181 static const char *ld_library_path
; /* Environment variable for search path */
182 static const char *ld_library_dirs
; /* Env variable for library descriptors */
183 static char *ld_preload
; /* Environment variable for libraries to
185 static const char *ld_elf_hints_path
; /* Env var. for alternative hints path */
186 static const char *ld_tracing
; /* Called from ldd to print libs */
187 static const char *ld_utrace
; /* Use utrace() to log events. */
188 static int (*rtld_functrace
)( /* Optional function call tracing hook */
189 const char *caller_obj
,
190 const char *callee_obj
,
191 const char *callee_func
,
193 static const Obj_Entry
*rtld_functrace_obj
; /* Object thereof */
194 static Obj_Entry
*obj_list
; /* Head of linked list of shared objects */
195 static Obj_Entry
**obj_tail
; /* Link field of last object in list */
196 static Obj_Entry
**preload_tail
;
197 static Obj_Entry
*obj_main
; /* The main program shared object */
198 static Obj_Entry obj_rtld
; /* The dynamic linker shared object */
199 static unsigned int obj_count
; /* Number of objects in obj_list */
200 static unsigned int obj_loads
; /* Number of objects in obj_list */
202 static int ld_resident
; /* Non-zero if resident */
203 static const char *ld_ary
[LD_ARY_CACHE
];
205 static Objlist initlist
;
207 static Objlist list_global
= /* Objects dlopened with RTLD_GLOBAL */
208 STAILQ_HEAD_INITIALIZER(list_global
);
209 static Objlist list_main
= /* Objects loaded at program startup */
210 STAILQ_HEAD_INITIALIZER(list_main
);
211 static Objlist list_fini
= /* Objects needing fini() calls */
212 STAILQ_HEAD_INITIALIZER(list_fini
);
214 static Elf_Sym sym_zero
; /* For resolving undefined weak refs. */
215 const char *__ld_sharedlib_base
;
217 #define GDB_STATE(s,m) r_debug.r_state = s; r_debug_state(&r_debug,m);
219 extern Elf_Dyn _DYNAMIC
;
220 #pragma weak _DYNAMIC
221 #ifndef RTLD_IS_DYNAMIC
222 #define RTLD_IS_DYNAMIC() (&_DYNAMIC != NULL)
225 #ifdef ENABLE_OSRELDATE
229 static int stack_prot
= PROT_READ
| PROT_WRITE
| RTLD_DEFAULT_STACK_EXEC
;
231 static int max_stack_flags
;
235 * Global declarations normally provided by crt1. The dynamic linker is
236 * not built with crt1, so we have to provide them ourselves.
242 * Used to pass argc, argv to init functions.
248 * Globals to control TLS allocation.
250 size_t tls_last_offset
; /* Static TLS offset of last module */
251 size_t tls_last_size
; /* Static TLS size of last module */
252 size_t tls_static_space
; /* Static TLS space allocated */
253 int tls_dtv_generation
= 1; /* Used to detect when dtv size changes */
254 int tls_max_index
= 1; /* Largest module index allocated */
257 * Fill in a DoneList with an allocation large enough to hold all of
258 * the currently-loaded objects. Keep this as a macro since it calls
259 * alloca and we want that to occur within the scope of the caller.
261 #define donelist_init(dlp) \
262 ((dlp)->objs = alloca(obj_count * sizeof (dlp)->objs[0]), \
263 assert((dlp)->objs != NULL), \
264 (dlp)->num_alloc = obj_count, \
267 #define UTRACE_DLOPEN_START 1
268 #define UTRACE_DLOPEN_STOP 2
269 #define UTRACE_DLCLOSE_START 3
270 #define UTRACE_DLCLOSE_STOP 4
271 #define UTRACE_LOAD_OBJECT 5
272 #define UTRACE_UNLOAD_OBJECT 6
273 #define UTRACE_ADD_RUNDEP 7
274 #define UTRACE_PRELOAD_FINISHED 8
275 #define UTRACE_INIT_CALL 9
276 #define UTRACE_FINI_CALL 10
279 char sig
[4]; /* 'RTLD' */
282 void *mapbase
; /* Used for 'parent' and 'init/fini' */
284 int refcnt
; /* Used for 'mode' */
285 char name
[MAXPATHLEN
];
288 #define LD_UTRACE(e, h, mb, ms, r, n) do { \
289 if (ld_utrace != NULL) \
290 ld_utrace_log(e, h, mb, ms, r, n); \
294 ld_utrace_log(int event
, void *handle
, void *mapbase
, size_t mapsize
,
295 int refcnt
, const char *name
)
297 struct utrace_rtld ut
;
305 ut
.mapbase
= mapbase
;
306 ut
.mapsize
= mapsize
;
308 bzero(ut
.name
, sizeof(ut
.name
));
310 strlcpy(ut
.name
, name
, sizeof(ut
.name
));
311 utrace(&ut
, sizeof(ut
));
315 * Main entry point for dynamic linking. The first argument is the
316 * stack pointer. The stack is expected to be laid out as described
317 * in the SVR4 ABI specification, Intel 386 Processor Supplement.
318 * Specifically, the stack pointer points to a word containing
319 * ARGC. Following that in the stack is a null-terminated sequence
320 * of pointers to argument strings. Then comes a null-terminated
321 * sequence of pointers to environment strings. Finally, there is a
322 * sequence of "auxiliary vector" entries.
324 * The second argument points to a place to store the dynamic linker's
325 * exit procedure pointer and the third to a place to store the main
328 * The return value is the main program's entry point.
331 _rtld(Elf_Addr
*sp
, func_ptr_type
*exit_proc
, Obj_Entry
**objp
)
333 Elf_Auxinfo
*aux_info
[AT_COUNT
];
341 Objlist_Entry
*entry
;
343 Obj_Entry
*last_interposer
;
345 /* marino: DO NOT MOVE THESE VARIABLES TO _rtld
346 Obj_Entry **preload_tail;
348 from global to here. It will break the DWARF2 unwind scheme.
352 * On entry, the dynamic linker itself has not been relocated yet.
353 * Be very careful not to reference any global data until after
354 * init_rtld has returned. It is OK to reference file-scope statics
355 * and string constants, and to call static and global functions.
358 /* Find the auxiliary vector on the stack. */
361 sp
+= argc
+ 1; /* Skip over arguments and NULL terminator */
365 * If we aren't already resident we have to dig out some more info.
366 * Note that auxinfo does not exist when we are resident.
368 * I'm not sure about the ld_resident check. It seems to read zero
369 * prior to relocation, which is what we want. When running from a
370 * resident copy everything will be relocated so we are definitely
373 if (ld_resident
== 0) {
374 while (*sp
++ != 0) /* Skip over environment, and NULL terminator */
376 aux
= (Elf_Auxinfo
*) sp
;
378 /* Digest the auxiliary vector. */
379 for (i
= 0; i
< AT_COUNT
; i
++)
381 for (auxp
= aux
; auxp
->a_type
!= AT_NULL
; auxp
++) {
382 if (auxp
->a_type
< AT_COUNT
)
383 aux_info
[auxp
->a_type
] = auxp
;
386 /* Initialize and relocate ourselves. */
387 assert(aux_info
[AT_BASE
] != NULL
);
388 init_rtld((caddr_t
) aux_info
[AT_BASE
]->a_un
.a_ptr
, aux_info
);
391 ld_index
= 0; /* don't use old env cache in case we are resident */
392 __progname
= obj_rtld
.path
;
393 argv0
= argv
[0] != NULL
? argv
[0] : "(null)";
398 trust
= !issetugid();
400 ld_bind_now
= _getenv_ld("LD_BIND_NOW");
402 * If the process is tainted, then we un-set the dangerous environment
403 * variables. The process will be marked as tainted until setuid(2)
404 * is called. If any child process calls setuid(2) we do not want any
405 * future processes to honor the potentially un-safe variables.
408 if ( unsetenv("LD_DEBUG")
409 || unsetenv("LD_PRELOAD")
410 || unsetenv("LD_LIBRARY_PATH")
411 || unsetenv("LD_LIBRARY_PATH_FDS")
412 || unsetenv("LD_ELF_HINTS_PATH")
413 || unsetenv("LD_LIBMAP")
414 || unsetenv("LD_LIBMAP_DISABLE")
415 || unsetenv("LD_LOADFLTR")
416 || unsetenv("LD_SHAREDLIB_BASE")
418 _rtld_error("environment corrupt; aborting");
422 __ld_sharedlib_base
= _getenv_ld("LD_SHAREDLIB_BASE");
423 ld_debug
= _getenv_ld("LD_DEBUG");
424 libmap_disable
= _getenv_ld("LD_LIBMAP_DISABLE") != NULL
;
425 libmap_override
= (char *)_getenv_ld("LD_LIBMAP");
426 ld_library_path
= _getenv_ld("LD_LIBRARY_PATH");
427 ld_library_dirs
= _getenv_ld("LD_LIBRARY_PATH_FDS");
428 ld_preload
= (char *)_getenv_ld("LD_PRELOAD");
429 ld_elf_hints_path
= _getenv_ld("LD_ELF_HINTS_PATH");
430 ld_loadfltr
= _getenv_ld("LD_LOADFLTR") != NULL
;
431 dangerous_ld_env
= (ld_library_path
!= NULL
)
432 || (ld_preload
!= NULL
)
433 || (ld_elf_hints_path
!= NULL
)
435 || (libmap_override
!= NULL
)
438 ld_tracing
= _getenv_ld("LD_TRACE_LOADED_OBJECTS");
439 ld_utrace
= _getenv_ld("LD_UTRACE");
441 if ((ld_elf_hints_path
== NULL
) || strlen(ld_elf_hints_path
) == 0)
442 ld_elf_hints_path
= _PATH_ELF_HINTS
;
444 if (ld_debug
!= NULL
&& *ld_debug
!= '\0')
446 dbg("%s is initialized, base address = %p", __progname
,
447 (caddr_t
) aux_info
[AT_BASE
]->a_un
.a_ptr
);
448 dbg("RTLD dynamic = %p", obj_rtld
.dynamic
);
449 dbg("RTLD pltgot = %p", obj_rtld
.pltgot
);
451 dbg("initializing thread locks");
455 * If we are resident we can skip work that we have already done.
456 * Note that the stack is reset and there is no Elf_Auxinfo
457 * when running from a resident image, and the static globals setup
458 * between here and resident_skip will have already been setup.
464 * Load the main program, or process its program header if it is
467 if (aux_info
[AT_EXECFD
] != NULL
) { /* Load the main program. */
468 int fd
= aux_info
[AT_EXECFD
]->a_un
.a_val
;
469 dbg("loading main program");
470 obj_main
= map_object(fd
, argv0
, NULL
);
472 if (obj_main
== NULL
)
475 max_stack_flags
= obj_main
->stack_flags
;
477 } else { /* Main program already loaded. */
478 const Elf_Phdr
*phdr
;
482 dbg("processing main program's program header");
483 assert(aux_info
[AT_PHDR
] != NULL
);
484 phdr
= (const Elf_Phdr
*) aux_info
[AT_PHDR
]->a_un
.a_ptr
;
485 assert(aux_info
[AT_PHNUM
] != NULL
);
486 phnum
= aux_info
[AT_PHNUM
]->a_un
.a_val
;
487 assert(aux_info
[AT_PHENT
] != NULL
);
488 assert(aux_info
[AT_PHENT
]->a_un
.a_val
== sizeof(Elf_Phdr
));
489 assert(aux_info
[AT_ENTRY
] != NULL
);
490 entry
= (caddr_t
) aux_info
[AT_ENTRY
]->a_un
.a_ptr
;
491 if ((obj_main
= digest_phdr(phdr
, phnum
, entry
, argv0
)) == NULL
)
495 char buf
[MAXPATHLEN
];
496 if (aux_info
[AT_EXECPATH
] != NULL
) {
499 kexecpath
= aux_info
[AT_EXECPATH
]->a_un
.a_ptr
;
500 dbg("AT_EXECPATH %p %s", kexecpath
, kexecpath
);
501 if (kexecpath
[0] == '/')
502 obj_main
->path
= kexecpath
;
503 else if (getcwd(buf
, sizeof(buf
)) == NULL
||
504 strlcat(buf
, "/", sizeof(buf
)) >= sizeof(buf
) ||
505 strlcat(buf
, kexecpath
, sizeof(buf
)) >= sizeof(buf
))
506 obj_main
->path
= xstrdup(argv0
);
508 obj_main
->path
= xstrdup(buf
);
510 char resolved
[MAXPATHLEN
];
511 dbg("No AT_EXECPATH");
512 if (argv0
[0] == '/') {
513 if (realpath(argv0
, resolved
) != NULL
)
514 obj_main
->path
= xstrdup(resolved
);
516 obj_main
->path
= xstrdup(argv0
);
518 if (getcwd(buf
, sizeof(buf
)) != NULL
519 && strlcat(buf
, "/", sizeof(buf
)) < sizeof(buf
)
520 && strlcat(buf
, argv0
, sizeof (buf
)) < sizeof(buf
)
521 && access(buf
, R_OK
) == 0
522 && realpath(buf
, resolved
) != NULL
)
523 obj_main
->path
= xstrdup(resolved
);
525 obj_main
->path
= xstrdup(argv0
);
528 dbg("obj_main path %s", obj_main
->path
);
529 obj_main
->mainprog
= true;
531 if (aux_info
[AT_STACKPROT
] != NULL
&&
532 aux_info
[AT_STACKPROT
]->a_un
.a_val
!= 0)
533 stack_prot
= aux_info
[AT_STACKPROT
]->a_un
.a_val
;
536 * Get the actual dynamic linker pathname from the executable if
537 * possible. (It should always be possible.) That ensures that
538 * gdb will find the right dynamic linker even if a non-standard
541 if (obj_main
->interp
!= NULL
&&
542 strcmp(obj_main
->interp
, obj_rtld
.path
) != 0) {
544 obj_rtld
.path
= xstrdup(obj_main
->interp
);
545 __progname
= obj_rtld
.path
;
548 digest_dynamic(obj_main
, 0);
549 dbg("%s valid_hash_sysv %d valid_hash_gnu %d dynsymcount %d",
550 obj_main
->path
, obj_main
->valid_hash_sysv
, obj_main
->valid_hash_gnu
,
551 obj_main
->dynsymcount
);
553 linkmap_add(obj_main
);
554 linkmap_add(&obj_rtld
);
556 /* Link the main program into the list of objects. */
557 *obj_tail
= obj_main
;
558 obj_tail
= &obj_main
->next
;
562 /* Initialize a fake symbol for resolving undefined weak references. */
563 sym_zero
.st_info
= ELF_ST_INFO(STB_GLOBAL
, STT_NOTYPE
);
564 sym_zero
.st_shndx
= SHN_UNDEF
;
565 sym_zero
.st_value
= -(uintptr_t)obj_main
->relocbase
;
568 libmap_disable
= (bool)lm_init(libmap_override
);
570 dbg("loading LD_PRELOAD libraries");
571 if (load_preload_objects() == -1)
573 preload_tail
= obj_tail
;
575 dbg("loading needed objects");
576 if (load_needed_objects(obj_main
, 0) == -1)
579 /* Make a list of all objects loaded at startup. */
580 last_interposer
= obj_main
;
581 for (obj
= obj_list
; obj
!= NULL
; obj
= obj
->next
) {
582 if (obj
->z_interpose
&& obj
!= obj_main
) {
583 objlist_put_after(&list_main
, last_interposer
, obj
);
584 last_interposer
= obj
;
586 objlist_push_tail(&list_main
, obj
);
591 dbg("checking for required versions");
592 if (rtld_verify_versions(&list_main
) == -1 && !ld_tracing
)
597 if (ld_tracing
) { /* We're done */
598 trace_loaded_objects(obj_main
);
602 if (ld_resident
) /* XXX clean this up! */
605 if (_getenv_ld("LD_DUMP_REL_PRE") != NULL
) {
606 dump_relocations(obj_main
);
610 /* setup TLS for main thread */
611 dbg("initializing initial thread local storage");
612 STAILQ_FOREACH(entry
, &list_main
, link
) {
614 * Allocate all the initial objects out of the static TLS
615 * block even if they didn't ask for it.
617 allocate_tls_offset(entry
->obj
);
620 tls_static_space
= tls_last_offset
+ RTLD_STATIC_TLS_EXTRA
;
623 * Do not try to allocate the TLS here, let libc do it itself.
624 * (crt1 for the program will call _init_tls())
627 if (relocate_objects(obj_main
,
628 ld_bind_now
!= NULL
&& *ld_bind_now
!= '\0',
629 &obj_rtld
, SYMLOOK_EARLY
, NULL
) == -1)
632 dbg("doing copy relocations");
633 if (do_copy_relocations(obj_main
) == -1)
638 if (_getenv_ld("LD_RESIDENT_UNREGISTER_NOW")) {
639 if (exec_sys_unregister(-1) < 0) {
640 dbg("exec_sys_unregister failed %d\n", errno
);
643 dbg("exec_sys_unregister success\n");
647 if (_getenv_ld("LD_DUMP_REL_POST") != NULL
) {
648 dump_relocations(obj_main
);
652 dbg("initializing key program variables");
653 set_program_var("__progname", argv
[0] != NULL
? basename(argv
[0]) : "");
654 set_program_var("environ", env
);
655 set_program_var("__elf_aux_vector", aux
);
657 if (_getenv_ld("LD_RESIDENT_REGISTER_NOW")) {
658 extern void resident_start(void);
660 if (exec_sys_register(resident_start
) < 0) {
661 dbg("exec_sys_register failed %d\n", errno
);
664 dbg("exec_sys_register success\n");
668 /* Make a list of init functions to call. */
669 objlist_init(&initlist
);
670 initlist_add_objects(obj_list
, preload_tail
, &initlist
);
672 r_debug_state(NULL
, &obj_main
->linkmap
); /* say hello to gdb! */
674 map_stacks_exec(NULL
);
676 dbg("resolving ifuncs");
678 RtldLockState lockstate
;
680 wlock_acquire(rtld_bind_lock
, &lockstate
);
681 if (resolve_objects_ifunc(
683 (ld_bind_now
!= NULL
&& *ld_bind_now
!= '\0'),
688 lock_release(rtld_bind_lock
, &lockstate
);
692 * Do NOT call the initlist here, give libc a chance to set up
693 * the initial TLS segment. crt1 will then call _rtld_call_init().
696 dbg("transferring control to program entry point = %p", obj_main
->entry
);
698 /* Return the exit procedure and the program entry point. */
699 *exit_proc
= rtld_exit
;
701 return (func_ptr_type
) obj_main
->entry
;
705 * Call the initialization list for dynamically loaded libraries.
706 * (called from crt1.c).
709 _rtld_call_init(void)
711 RtldLockState lockstate
;
714 if (!obj_main
->note_present
&& obj_main
->valid_hash_gnu
) {
716 * The use of a linker script with a PHDRS directive that does not include
717 * PT_NOTE will block the crt_no_init note. In this case we'll look for the
718 * recently added GNU hash dynamic tag which gets built by default. It is
719 * extremely unlikely to find a pre-3.1 binary without a PT_NOTE header and
720 * a gnu hash tag. If gnu hash found, consider binary to use new crt code.
722 obj_main
->crt_no_init
= true;
723 dbg("Setting crt_no_init without presence of PT_NOTE header");
726 wlock_acquire(rtld_bind_lock
, &lockstate
);
727 if (obj_main
->crt_no_init
)
731 * Make sure we don't call the main program's init and fini functions
732 * for binaries linked with old crt1 which calls _init itself.
734 obj_main
->init
= obj_main
->fini
= (Elf_Addr
)NULL
;
735 obj_main
->init_array
= obj_main
->fini_array
= (Elf_Addr
)NULL
;
737 objlist_call_init(&initlist
, &lockstate
);
738 _r_debug_postinit(&obj_main
->linkmap
);
739 objlist_clear(&initlist
);
740 dbg("loading filtees");
741 for (obj
= obj_list
->next
; obj
!= NULL
; obj
= obj
->next
) {
742 if (ld_loadfltr
|| obj
->z_loadfltr
)
743 load_filtees(obj
, 0, &lockstate
);
745 lock_release(rtld_bind_lock
, &lockstate
);
749 rtld_resolve_ifunc(const Obj_Entry
*obj
, const Elf_Sym
*def
)
754 ptr
= (void *)make_function_pointer(def
, obj
);
755 target
= ((Elf_Addr (*)(void))ptr
)();
756 return ((void *)target
);
760 _rtld_bind(Obj_Entry
*obj
, Elf_Size reloff
, void *stack
)
764 const Obj_Entry
*defobj
;
767 RtldLockState lockstate
;
769 rlock_acquire(rtld_bind_lock
, &lockstate
);
770 if (sigsetjmp(lockstate
.env
, 0) != 0)
771 lock_upgrade(rtld_bind_lock
, &lockstate
);
773 rel
= (const Elf_Rel
*) ((caddr_t
) obj
->pltrel
+ reloff
);
775 rel
= (const Elf_Rel
*) ((caddr_t
) obj
->pltrela
+ reloff
);
777 where
= (Elf_Addr
*) (obj
->relocbase
+ rel
->r_offset
);
778 def
= find_symdef(ELF_R_SYM(rel
->r_info
), obj
, &defobj
, true, NULL
,
782 if (ELF_ST_TYPE(def
->st_info
) == STT_GNU_IFUNC
)
783 target
= (Elf_Addr
)rtld_resolve_ifunc(defobj
, def
);
785 target
= (Elf_Addr
)(defobj
->relocbase
+ def
->st_value
);
787 dbg("\"%s\" in \"%s\" ==> %p in \"%s\"",
788 defobj
->strtab
+ def
->st_name
, basename(obj
->path
),
789 (void *)target
, basename(defobj
->path
));
792 * If we have a function call tracing hook, and the
793 * hook would like to keep tracing this one function,
794 * prevent the relocation so we will wind up here
795 * the next time again.
797 * We don't want to functrace calls from the functracer
798 * to avoid recursive loops.
800 if (rtld_functrace
!= NULL
&& obj
!= rtld_functrace_obj
) {
801 if (rtld_functrace(obj
->path
,
803 defobj
->strtab
+ def
->st_name
,
805 lock_release(rtld_bind_lock
, &lockstate
);
811 * Write the new contents for the jmpslot. Note that depending on
812 * architecture, the value which we need to return back to the
813 * lazy binding trampoline may or may not be the target
814 * address. The value returned from reloc_jmpslot() is the value
815 * that the trampoline needs.
817 target
= reloc_jmpslot(where
, target
, defobj
, obj
, rel
);
818 lock_release(rtld_bind_lock
, &lockstate
);
823 * Error reporting function. Use it like printf. If formats the message
824 * into a buffer, and sets things up so that the next call to dlerror()
825 * will return the message.
828 _rtld_error(const char *fmt
, ...)
830 static char buf
[512];
834 rtld_vsnprintf(buf
, sizeof buf
, fmt
, ap
);
840 * Return a dynamically-allocated copy of the current error message, if any.
845 return error_message
== NULL
? NULL
: xstrdup(error_message
);
849 * Restore the current error message from a copy which was previously saved
850 * by errmsg_save(). The copy is freed.
853 errmsg_restore(char *saved_msg
)
855 if (saved_msg
== NULL
)
856 error_message
= NULL
;
858 _rtld_error("%s", saved_msg
);
864 basename(const char *name
)
866 const char *p
= strrchr(name
, '/');
867 return p
!= NULL
? p
+ 1 : name
;
870 static struct utsname uts
;
873 origin_subst_one(char *real
, const char *kw
, const char *subst
,
876 char *p
, *p1
, *res
, *resp
;
877 int subst_len
, kw_len
, subst_count
, old_len
, new_len
;
882 * First, count the number of the keyword occurrences, to
883 * preallocate the final string.
885 for (p
= real
, subst_count
= 0;; p
= p1
+ kw_len
, subst_count
++) {
892 * If the keyword is not found, just return.
894 if (subst_count
== 0)
895 return (may_free
? real
: xstrdup(real
));
898 * There is indeed something to substitute. Calculate the
899 * length of the resulting string, and allocate it.
901 subst_len
= strlen(subst
);
902 old_len
= strlen(real
);
903 new_len
= old_len
+ (subst_len
- kw_len
) * subst_count
;
904 res
= xmalloc(new_len
+ 1);
907 * Now, execute the substitution loop.
909 for (p
= real
, resp
= res
, *resp
= '\0';;) {
912 /* Copy the prefix before keyword. */
913 memcpy(resp
, p
, p1
- p
);
915 /* Keyword replacement. */
916 memcpy(resp
, subst
, subst_len
);
924 /* Copy to the end of string and finish. */
932 origin_subst(char *real
, const char *origin_path
)
934 char *res1
, *res2
, *res3
, *res4
;
936 if (uts
.sysname
[0] == '\0') {
937 if (uname(&uts
) != 0) {
938 _rtld_error("utsname failed: %d", errno
);
942 res1
= origin_subst_one(real
, "$ORIGIN", origin_path
, false);
943 res2
= origin_subst_one(res1
, "$OSNAME", uts
.sysname
, true);
944 res3
= origin_subst_one(res2
, "$OSREL", uts
.release
, true);
945 res4
= origin_subst_one(res3
, "$PLATFORM", uts
.machine
, true);
952 const char *msg
= dlerror();
956 rtld_fdputstr(STDERR_FILENO
, msg
);
957 rtld_fdputchar(STDERR_FILENO
, '\n');
962 * Process a shared object's DYNAMIC section, and save the important
963 * information in its Obj_Entry structure.
966 digest_dynamic1(Obj_Entry
*obj
, int early
, const Elf_Dyn
**dyn_rpath
,
967 const Elf_Dyn
**dyn_soname
, const Elf_Dyn
**dyn_runpath
)
970 Needed_Entry
**needed_tail
= &obj
->needed
;
971 Needed_Entry
**needed_filtees_tail
= &obj
->needed_filtees
;
972 Needed_Entry
**needed_aux_filtees_tail
= &obj
->needed_aux_filtees
;
973 const Elf_Hashelt
*hashtab
;
974 const Elf32_Word
*hashval
;
975 Elf32_Word bkt
, nmaskwords
;
978 int plttype
= DT_REL
;
984 obj
->bind_now
= false;
985 for (dynp
= obj
->dynamic
; dynp
->d_tag
!= DT_NULL
; dynp
++) {
986 switch (dynp
->d_tag
) {
989 obj
->rel
= (const Elf_Rel
*) (obj
->relocbase
+ dynp
->d_un
.d_ptr
);
993 obj
->relsize
= dynp
->d_un
.d_val
;
997 assert(dynp
->d_un
.d_val
== sizeof(Elf_Rel
));
1001 obj
->pltrel
= (const Elf_Rel
*)
1002 (obj
->relocbase
+ dynp
->d_un
.d_ptr
);
1006 obj
->pltrelsize
= dynp
->d_un
.d_val
;
1010 obj
->rela
= (const Elf_Rela
*) (obj
->relocbase
+ dynp
->d_un
.d_ptr
);
1014 obj
->relasize
= dynp
->d_un
.d_val
;
1018 assert(dynp
->d_un
.d_val
== sizeof(Elf_Rela
));
1022 plttype
= dynp
->d_un
.d_val
;
1023 assert(dynp
->d_un
.d_val
== DT_REL
|| plttype
== DT_RELA
);
1027 obj
->symtab
= (const Elf_Sym
*)
1028 (obj
->relocbase
+ dynp
->d_un
.d_ptr
);
1032 assert(dynp
->d_un
.d_val
== sizeof(Elf_Sym
));
1036 obj
->strtab
= (const char *) (obj
->relocbase
+ dynp
->d_un
.d_ptr
);
1040 obj
->strsize
= dynp
->d_un
.d_val
;
1044 obj
->verneed
= (const Elf_Verneed
*) (obj
->relocbase
+
1049 obj
->verneednum
= dynp
->d_un
.d_val
;
1053 obj
->verdef
= (const Elf_Verdef
*) (obj
->relocbase
+
1058 obj
->verdefnum
= dynp
->d_un
.d_val
;
1062 obj
->versyms
= (const Elf_Versym
*)(obj
->relocbase
+
1068 hashtab
= (const Elf_Hashelt
*)(obj
->relocbase
+
1070 obj
->nbuckets
= hashtab
[0];
1071 obj
->nchains
= hashtab
[1];
1072 obj
->buckets
= hashtab
+ 2;
1073 obj
->chains
= obj
->buckets
+ obj
->nbuckets
;
1074 obj
->valid_hash_sysv
= obj
->nbuckets
> 0 && obj
->nchains
> 0 &&
1075 obj
->buckets
!= NULL
;
1081 hashtab
= (const Elf_Hashelt
*)(obj
->relocbase
+
1083 obj
->nbuckets_gnu
= hashtab
[0];
1084 obj
->symndx_gnu
= hashtab
[1];
1085 nmaskwords
= hashtab
[2];
1086 bloom_size32
= (__ELF_WORD_SIZE
/ 32) * nmaskwords
;
1087 /* Number of bitmask words is required to be power of 2 */
1088 nmw_power2
= ((nmaskwords
& (nmaskwords
- 1)) == 0);
1089 obj
->maskwords_bm_gnu
= nmaskwords
- 1;
1090 obj
->shift2_gnu
= hashtab
[3];
1091 obj
->bloom_gnu
= (Elf_Addr
*) (hashtab
+ 4);
1092 obj
->buckets_gnu
= hashtab
+ 4 + bloom_size32
;
1093 obj
->chain_zero_gnu
= obj
->buckets_gnu
+ obj
->nbuckets_gnu
-
1095 obj
->valid_hash_gnu
= nmw_power2
&& obj
->nbuckets_gnu
> 0 &&
1096 obj
->buckets_gnu
!= NULL
;
1102 Needed_Entry
*nep
= NEW(Needed_Entry
);
1103 nep
->name
= dynp
->d_un
.d_val
;
1108 needed_tail
= &nep
->next
;
1114 Needed_Entry
*nep
= NEW(Needed_Entry
);
1115 nep
->name
= dynp
->d_un
.d_val
;
1119 *needed_filtees_tail
= nep
;
1120 needed_filtees_tail
= &nep
->next
;
1126 Needed_Entry
*nep
= NEW(Needed_Entry
);
1127 nep
->name
= dynp
->d_un
.d_val
;
1131 *needed_aux_filtees_tail
= nep
;
1132 needed_aux_filtees_tail
= &nep
->next
;
1137 obj
->pltgot
= (Elf_Addr
*) (obj
->relocbase
+ dynp
->d_un
.d_ptr
);
1141 obj
->textrel
= true;
1145 obj
->symbolic
= true;
1150 * We have to wait until later to process this, because we
1151 * might not have gotten the address of the string table yet.
1161 *dyn_runpath
= dynp
;
1165 obj
->init
= (Elf_Addr
) (obj
->relocbase
+ dynp
->d_un
.d_ptr
);
1168 case DT_PREINIT_ARRAY
:
1169 obj
->preinit_array
= (Elf_Addr
)(obj
->relocbase
+ dynp
->d_un
.d_ptr
);
1172 case DT_PREINIT_ARRAYSZ
:
1173 obj
->preinit_array_num
= dynp
->d_un
.d_val
/ sizeof(Elf_Addr
);
1177 obj
->init_array
= (Elf_Addr
)(obj
->relocbase
+ dynp
->d_un
.d_ptr
);
1180 case DT_INIT_ARRAYSZ
:
1181 obj
->init_array_num
= dynp
->d_un
.d_val
/ sizeof(Elf_Addr
);
1185 obj
->fini
= (Elf_Addr
)(obj
->relocbase
+ dynp
->d_un
.d_ptr
);
1189 obj
->fini_array
= (Elf_Addr
)(obj
->relocbase
+ dynp
->d_un
.d_ptr
);
1192 case DT_FINI_ARRAYSZ
:
1193 obj
->fini_array_num
= dynp
->d_un
.d_val
/ sizeof(Elf_Addr
);
1197 /* XXX - not implemented yet */
1199 dbg("Filling in DT_DEBUG entry");
1200 ((Elf_Dyn
*)dynp
)->d_un
.d_ptr
= (Elf_Addr
) &r_debug
;
1204 if ((dynp
->d_un
.d_val
& DF_ORIGIN
) && trust
)
1205 obj
->z_origin
= true;
1206 if (dynp
->d_un
.d_val
& DF_SYMBOLIC
)
1207 obj
->symbolic
= true;
1208 if (dynp
->d_un
.d_val
& DF_TEXTREL
)
1209 obj
->textrel
= true;
1210 if (dynp
->d_un
.d_val
& DF_BIND_NOW
)
1211 obj
->bind_now
= true;
1212 /*if (dynp->d_un.d_val & DF_STATIC_TLS)
1217 if (dynp
->d_un
.d_val
& DF_1_NOOPEN
)
1218 obj
->z_noopen
= true;
1219 if ((dynp
->d_un
.d_val
& DF_1_ORIGIN
) && trust
)
1220 obj
->z_origin
= true;
1221 /*if (dynp->d_un.d_val & DF_1_GLOBAL)
1223 if (dynp
->d_un
.d_val
& DF_1_BIND_NOW
)
1224 obj
->bind_now
= true;
1225 if (dynp
->d_un
.d_val
& DF_1_NODELETE
)
1226 obj
->z_nodelete
= true;
1227 if (dynp
->d_un
.d_val
& DF_1_LOADFLTR
)
1228 obj
->z_loadfltr
= true;
1229 if (dynp
->d_un
.d_val
& DF_1_INTERPOSE
)
1230 obj
->z_interpose
= true;
1231 if (dynp
->d_un
.d_val
& DF_1_NODEFLIB
)
1232 obj
->z_nodeflib
= true;
1237 dbg("Ignoring d_tag %ld = %#lx", (long)dynp
->d_tag
,
1244 obj
->traced
= false;
1246 if (plttype
== DT_RELA
) {
1247 obj
->pltrela
= (const Elf_Rela
*) obj
->pltrel
;
1249 obj
->pltrelasize
= obj
->pltrelsize
;
1250 obj
->pltrelsize
= 0;
1253 /* Determine size of dynsym table (equal to nchains of sysv hash) */
1254 if (obj
->valid_hash_sysv
)
1255 obj
->dynsymcount
= obj
->nchains
;
1256 else if (obj
->valid_hash_gnu
) {
1257 obj
->dynsymcount
= 0;
1258 for (bkt
= 0; bkt
< obj
->nbuckets_gnu
; bkt
++) {
1259 if (obj
->buckets_gnu
[bkt
] == 0)
1261 hashval
= &obj
->chain_zero_gnu
[obj
->buckets_gnu
[bkt
]];
1264 while ((*hashval
++ & 1u) == 0);
1266 obj
->dynsymcount
+= obj
->symndx_gnu
;
1271 digest_dynamic2(Obj_Entry
*obj
, const Elf_Dyn
*dyn_rpath
,
1272 const Elf_Dyn
*dyn_soname
, const Elf_Dyn
*dyn_runpath
)
1275 if (obj
->z_origin
&& obj
->origin_path
== NULL
) {
1276 obj
->origin_path
= xmalloc(PATH_MAX
);
1277 if (rtld_dirname_abs(obj
->path
, obj
->origin_path
) == -1)
1281 if (dyn_runpath
!= NULL
) {
1282 obj
->runpath
= (char *)obj
->strtab
+ dyn_runpath
->d_un
.d_val
;
1284 obj
->runpath
= origin_subst(obj
->runpath
, obj
->origin_path
);
1286 else if (dyn_rpath
!= NULL
) {
1287 obj
->rpath
= (char *)obj
->strtab
+ dyn_rpath
->d_un
.d_val
;
1289 obj
->rpath
= origin_subst(obj
->rpath
, obj
->origin_path
);
1292 if (dyn_soname
!= NULL
)
1293 object_add_name(obj
, obj
->strtab
+ dyn_soname
->d_un
.d_val
);
1297 digest_dynamic(Obj_Entry
*obj
, int early
)
1299 const Elf_Dyn
*dyn_rpath
;
1300 const Elf_Dyn
*dyn_soname
;
1301 const Elf_Dyn
*dyn_runpath
;
1303 digest_dynamic1(obj
, early
, &dyn_rpath
, &dyn_soname
, &dyn_runpath
);
1304 digest_dynamic2(obj
, dyn_rpath
, dyn_soname
, dyn_runpath
);
1308 * Process a shared object's program header. This is used only for the
1309 * main program, when the kernel has already loaded the main program
1310 * into memory before calling the dynamic linker. It creates and
1311 * returns an Obj_Entry structure.
1314 digest_phdr(const Elf_Phdr
*phdr
, int phnum
, caddr_t entry
, const char *path
)
1317 const Elf_Phdr
*phlimit
= phdr
+ phnum
;
1319 Elf_Addr note_start
, note_end
;
1323 for (ph
= phdr
; ph
< phlimit
; ph
++) {
1324 if (ph
->p_type
!= PT_PHDR
)
1328 obj
->phsize
= ph
->p_memsz
;
1329 obj
->relocbase
= (caddr_t
)phdr
- ph
->p_vaddr
;
1333 obj
->stack_flags
= PF_X
| PF_R
| PF_W
;
1335 for (ph
= phdr
; ph
< phlimit
; ph
++) {
1336 switch (ph
->p_type
) {
1339 obj
->interp
= (const char *)(ph
->p_vaddr
+ obj
->relocbase
);
1343 if (nsegs
== 0) { /* First load segment */
1344 obj
->vaddrbase
= trunc_page(ph
->p_vaddr
);
1345 obj
->mapbase
= obj
->vaddrbase
+ obj
->relocbase
;
1346 obj
->textsize
= round_page(ph
->p_vaddr
+ ph
->p_memsz
) -
1348 } else { /* Last load segment */
1349 obj
->mapsize
= round_page(ph
->p_vaddr
+ ph
->p_memsz
) -
1356 obj
->dynamic
= (const Elf_Dyn
*)(ph
->p_vaddr
+ obj
->relocbase
);
1361 obj
->tlssize
= ph
->p_memsz
;
1362 obj
->tlsalign
= ph
->p_align
;
1363 obj
->tlsinitsize
= ph
->p_filesz
;
1364 obj
->tlsinit
= (void*)(ph
->p_vaddr
+ obj
->relocbase
);
1368 obj
->stack_flags
= ph
->p_flags
;
1372 obj
->relro_page
= obj
->relocbase
+ trunc_page(ph
->p_vaddr
);
1373 obj
->relro_size
= round_page(ph
->p_memsz
);
1377 obj
->note_present
= true;
1378 note_start
= (Elf_Addr
)obj
->relocbase
+ ph
->p_vaddr
;
1379 note_end
= note_start
+ ph
->p_filesz
;
1380 digest_notes(obj
, note_start
, note_end
);
1385 _rtld_error("%s: too few PT_LOAD segments", path
);
1394 digest_notes(Obj_Entry
*obj
, Elf_Addr note_start
, Elf_Addr note_end
)
1396 const Elf_Note
*note
;
1397 const char *note_name
;
1400 for (note
= (const Elf_Note
*)note_start
; (Elf_Addr
)note
< note_end
;
1401 note
= (const Elf_Note
*)((const char *)(note
+ 1) +
1402 roundup2(note
->n_namesz
, sizeof(Elf32_Addr
)) +
1403 roundup2(note
->n_descsz
, sizeof(Elf32_Addr
)))) {
1404 if (note
->n_namesz
!= sizeof(NOTE_VENDOR
) ||
1405 note
->n_descsz
!= sizeof(int32_t))
1407 if (note
->n_type
!= ABI_NOTETYPE
&&
1408 note
->n_type
!= CRT_NOINIT_NOTETYPE
)
1410 note_name
= (const char *)(note
+ 1);
1411 if (strncmp(NOTE_VENDOR
, note_name
, sizeof(NOTE_VENDOR
)) != 0)
1413 switch (note
->n_type
) {
1415 /* DragonFly osrel note */
1416 p
= (uintptr_t)(note
+ 1);
1417 p
+= roundup2(note
->n_namesz
, sizeof(Elf32_Addr
));
1418 obj
->osrel
= *(const int32_t *)(p
);
1419 dbg("note osrel %d", obj
->osrel
);
1421 case CRT_NOINIT_NOTETYPE
:
1422 /* DragonFly 'crt does not call init' note */
1423 obj
->crt_no_init
= true;
1424 dbg("note crt_no_init");
1431 dlcheck(void *handle
)
1435 for (obj
= obj_list
; obj
!= NULL
; obj
= obj
->next
)
1436 if (obj
== (Obj_Entry
*) handle
)
1439 if (obj
== NULL
|| obj
->refcount
== 0 || obj
->dl_refcount
== 0) {
1440 _rtld_error("Invalid shared object handle %p", handle
);
1447 * If the given object is already in the donelist, return true. Otherwise
1448 * add the object to the list and return false.
1451 donelist_check(DoneList
*dlp
, const Obj_Entry
*obj
)
1455 for (i
= 0; i
< dlp
->num_used
; i
++)
1456 if (dlp
->objs
[i
] == obj
)
1459 * Our donelist allocation should always be sufficient. But if
1460 * our threads locking isn't working properly, more shared objects
1461 * could have been loaded since we allocated the list. That should
1462 * never happen, but we'll handle it properly just in case it does.
1464 if (dlp
->num_used
< dlp
->num_alloc
)
1465 dlp
->objs
[dlp
->num_used
++] = obj
;
1470 * Hash function for symbol table lookup. Don't even think about changing
1471 * this. It is specified by the System V ABI.
1474 elf_hash(const char *name
)
1476 const unsigned char *p
= (const unsigned char *) name
;
1477 unsigned long h
= 0;
1480 while (*p
!= '\0') {
1481 h
= (h
<< 4) + *p
++;
1482 if ((g
= h
& 0xf0000000) != 0)
1490 * The GNU hash function is the Daniel J. Bernstein hash clipped to 32 bits
1491 * unsigned in case it's implemented with a wider type.
1493 static uint_fast32_t
1494 gnu_hash(const char *s
)
1500 for (c
= *s
; c
!= '\0'; c
= *++s
)
1502 return (h
& 0xffffffff);
1507 * Find the library with the given name, and return its full pathname.
1508 * The returned string is dynamically allocated. Generates an error
1509 * message and returns NULL if the library cannot be found.
1511 * If the second argument is non-NULL, then it refers to an already-
1512 * loaded shared object, whose library search path will be searched.
1514 * If a library is successfully located via LD_LIBRARY_PATH_FDS, its
1515 * descriptor (which is close-on-exec) will be passed out via the third
1518 * The search order is:
1519 * DT_RPATH in the referencing file _unless_ DT_RUNPATH is present (1)
1520 * DT_RPATH of the main object if DSO without defined DT_RUNPATH (1)
1522 * DT_RUNPATH in the referencing file
1523 * ldconfig hints (if -z nodefaultlib, filter out default library directories
1525 * /lib:/usr/lib _unless_ the referencing file is linked with -z nodefaultlib
1527 * (1) Handled in digest_dynamic2 - rpath left NULL if runpath defined.
1530 find_library(const char *xname
, const Obj_Entry
*refobj
, int *fdp
)
1534 bool nodeflib
, objgiven
;
1536 objgiven
= refobj
!= NULL
;
1537 if (strchr(xname
, '/') != NULL
) { /* Hard coded pathname */
1538 if (xname
[0] != '/' && !trust
) {
1539 _rtld_error("Absolute pathname required for shared object \"%s\"",
1543 if (objgiven
&& refobj
->z_origin
) {
1544 return (origin_subst(__DECONST(char *, xname
),
1545 refobj
->origin_path
));
1547 return (xstrdup(xname
));
1551 if (libmap_disable
|| !objgiven
||
1552 (name
= lm_find(refobj
->path
, xname
)) == NULL
)
1553 name
= (char *)xname
;
1555 dbg(" Searching for \"%s\"", name
);
1557 nodeflib
= objgiven
? refobj
->z_nodeflib
: false;
1559 (pathname
= search_library_path(name
, refobj
->rpath
)) != NULL
) ||
1560 (objgiven
&& refobj
->runpath
== NULL
&& refobj
!= obj_main
&&
1561 (pathname
= search_library_path(name
, obj_main
->rpath
)) != NULL
) ||
1562 (pathname
= search_library_path(name
, ld_library_path
)) != NULL
||
1564 (pathname
= search_library_path(name
, refobj
->runpath
)) != NULL
) ||
1565 (pathname
= search_library_pathfds(name
, ld_library_dirs
, fdp
)) != NULL
||
1566 (pathname
= search_library_path(name
, gethints(nodeflib
))) != NULL
||
1567 (objgiven
&& !nodeflib
&&
1568 (pathname
= search_library_path(name
, STANDARD_LIBRARY_PATH
)) != NULL
))
1571 if (objgiven
&& refobj
->path
!= NULL
) {
1572 _rtld_error("Shared object \"%s\" not found, required by \"%s\"",
1573 name
, basename(refobj
->path
));
1575 _rtld_error("Shared object \"%s\" not found", name
);
1581 * Given a symbol number in a referencing object, find the corresponding
1582 * definition of the symbol. Returns a pointer to the symbol, or NULL if
1583 * no definition was found. Returns a pointer to the Obj_Entry of the
1584 * defining object via the reference parameter DEFOBJ_OUT.
1587 find_symdef(unsigned long symnum
, const Obj_Entry
*refobj
,
1588 const Obj_Entry
**defobj_out
, int flags
, SymCache
*cache
,
1589 RtldLockState
*lockstate
)
1593 const Obj_Entry
*defobj
;
1599 * If we have already found this symbol, get the information from
1602 if (symnum
>= refobj
->dynsymcount
)
1603 return NULL
; /* Bad object */
1604 if (cache
!= NULL
&& cache
[symnum
].sym
!= NULL
) {
1605 *defobj_out
= cache
[symnum
].obj
;
1606 return cache
[symnum
].sym
;
1609 ref
= refobj
->symtab
+ symnum
;
1610 name
= refobj
->strtab
+ ref
->st_name
;
1615 * We don't have to do a full scale lookup if the symbol is local.
1616 * We know it will bind to the instance in this load module; to
1617 * which we already have a pointer (ie ref). By not doing a lookup,
1618 * we not only improve performance, but it also avoids unresolvable
1619 * symbols when local symbols are not in the hash table.
1621 * This might occur for TLS module relocations, which simply use
1624 if (ELF_ST_BIND(ref
->st_info
) != STB_LOCAL
) {
1625 if (ELF_ST_TYPE(ref
->st_info
) == STT_SECTION
) {
1626 _rtld_error("%s: Bogus symbol table entry %lu", refobj
->path
,
1629 symlook_init(&req
, name
);
1631 req
.ventry
= fetch_ventry(refobj
, symnum
);
1632 req
.lockstate
= lockstate
;
1633 res
= symlook_default(&req
, refobj
);
1636 defobj
= req
.defobj_out
;
1644 * If we found no definition and the reference is weak, treat the
1645 * symbol as having the value zero.
1647 if (def
== NULL
&& ELF_ST_BIND(ref
->st_info
) == STB_WEAK
) {
1653 *defobj_out
= defobj
;
1654 /* Record the information in the cache to avoid subsequent lookups. */
1655 if (cache
!= NULL
) {
1656 cache
[symnum
].sym
= def
;
1657 cache
[symnum
].obj
= defobj
;
1660 if (refobj
!= &obj_rtld
)
1661 _rtld_error("%s: Undefined symbol \"%s\"", refobj
->path
, name
);
1667 * Return the search path from the ldconfig hints file, reading it if
1668 * necessary. If nostdlib is true, then the default search paths are
1669 * not added to result.
1671 * Returns NULL if there are problems with the hints file,
1672 * or if the search path there is empty.
1675 gethints(bool nostdlib
)
1677 static char *hints
, *filtered_path
;
1678 struct elfhints_hdr hdr
;
1679 struct fill_search_info_args sargs
, hargs
;
1680 struct dl_serinfo smeta
, hmeta
, *SLPinfo
, *hintinfo
;
1681 struct dl_serpath
*SLPpath
, *hintpath
;
1683 unsigned int SLPndx
, hintndx
, fndx
, fcount
;
1688 /* First call, read the hints file */
1689 if (hints
== NULL
) {
1690 /* Keep from trying again in case the hints file is bad. */
1693 if ((fd
= open(ld_elf_hints_path
, O_RDONLY
| O_CLOEXEC
)) == -1)
1695 if (read(fd
, &hdr
, sizeof hdr
) != sizeof hdr
||
1696 hdr
.magic
!= ELFHINTS_MAGIC
||
1701 p
= xmalloc(hdr
.dirlistlen
+ 1);
1702 if (lseek(fd
, hdr
.strtab
+ hdr
.dirlist
, SEEK_SET
) == -1 ||
1703 read(fd
, p
, hdr
.dirlistlen
+ 1) !=
1704 (ssize_t
)hdr
.dirlistlen
+ 1) {
1714 * If caller agreed to receive list which includes the default
1715 * paths, we are done. Otherwise, if we still have not
1716 * calculated filtered result, do it now.
1719 return (hints
[0] != '\0' ? hints
: NULL
);
1720 if (filtered_path
!= NULL
)
1724 * Obtain the list of all configured search paths, and the
1725 * list of the default paths.
1727 * First estimate the size of the results.
1729 smeta
.dls_size
= __offsetof(struct dl_serinfo
, dls_serpath
);
1731 hmeta
.dls_size
= __offsetof(struct dl_serinfo
, dls_serpath
);
1734 sargs
.request
= RTLD_DI_SERINFOSIZE
;
1735 sargs
.serinfo
= &smeta
;
1736 hargs
.request
= RTLD_DI_SERINFOSIZE
;
1737 hargs
.serinfo
= &hmeta
;
1739 path_enumerate(STANDARD_LIBRARY_PATH
, fill_search_info
, &sargs
);
1740 path_enumerate(p
, fill_search_info
, &hargs
);
1742 SLPinfo
= xmalloc(smeta
.dls_size
);
1743 hintinfo
= xmalloc(hmeta
.dls_size
);
1746 * Next fetch both sets of paths.
1748 sargs
.request
= RTLD_DI_SERINFO
;
1749 sargs
.serinfo
= SLPinfo
;
1750 sargs
.serpath
= &SLPinfo
->dls_serpath
[0];
1751 sargs
.strspace
= (char *)&SLPinfo
->dls_serpath
[smeta
.dls_cnt
];
1753 hargs
.request
= RTLD_DI_SERINFO
;
1754 hargs
.serinfo
= hintinfo
;
1755 hargs
.serpath
= &hintinfo
->dls_serpath
[0];
1756 hargs
.strspace
= (char *)&hintinfo
->dls_serpath
[hmeta
.dls_cnt
];
1758 path_enumerate(STANDARD_LIBRARY_PATH
, fill_search_info
, &sargs
);
1759 path_enumerate(p
, fill_search_info
, &hargs
);
1762 * Now calculate the difference between two sets, by excluding
1763 * standard paths from the full set.
1767 filtered_path
= xmalloc(hdr
.dirlistlen
+ 1);
1768 hintpath
= &hintinfo
->dls_serpath
[0];
1769 for (hintndx
= 0; hintndx
< hmeta
.dls_cnt
; hintndx
++, hintpath
++) {
1771 SLPpath
= &SLPinfo
->dls_serpath
[0];
1773 * Check each standard path against current.
1775 for (SLPndx
= 0; SLPndx
< smeta
.dls_cnt
; SLPndx
++, SLPpath
++) {
1776 /* matched, skip the path */
1777 if (!strcmp(hintpath
->dls_name
, SLPpath
->dls_name
)) {
1785 * Not matched against any standard path, add the path
1786 * to result. Separate consecutive paths with ':'.
1789 filtered_path
[fndx
] = ':';
1793 flen
= strlen(hintpath
->dls_name
);
1794 strncpy((filtered_path
+ fndx
), hintpath
->dls_name
, flen
);
1797 filtered_path
[fndx
] = '\0';
1803 return (filtered_path
[0] != '\0' ? filtered_path
: NULL
);
1807 init_dag(Obj_Entry
*root
)
1809 const Needed_Entry
*needed
;
1810 const Objlist_Entry
*elm
;
1813 if (root
->dag_inited
)
1815 donelist_init(&donelist
);
1817 /* Root object belongs to own DAG. */
1818 objlist_push_tail(&root
->dldags
, root
);
1819 objlist_push_tail(&root
->dagmembers
, root
);
1820 donelist_check(&donelist
, root
);
1823 * Add dependencies of root object to DAG in breadth order
1824 * by exploiting the fact that each new object get added
1825 * to the tail of the dagmembers list.
1827 STAILQ_FOREACH(elm
, &root
->dagmembers
, link
) {
1828 for (needed
= elm
->obj
->needed
; needed
!= NULL
; needed
= needed
->next
) {
1829 if (needed
->obj
== NULL
|| donelist_check(&donelist
, needed
->obj
))
1831 objlist_push_tail(&needed
->obj
->dldags
, root
);
1832 objlist_push_tail(&root
->dagmembers
, needed
->obj
);
1835 root
->dag_inited
= true;
1839 process_nodelete(Obj_Entry
*root
)
1841 const Objlist_Entry
*elm
;
1844 * Walk over object DAG and process every dependent object that
1845 * is marked as DF_1_NODELETE. They need to grow their own DAG,
1846 * which then should have its reference upped separately.
1848 STAILQ_FOREACH(elm
, &root
->dagmembers
, link
) {
1849 if (elm
->obj
!= NULL
&& elm
->obj
->z_nodelete
&&
1850 !elm
->obj
->ref_nodel
) {
1851 dbg("obj %s nodelete", elm
->obj
->path
);
1854 elm
->obj
->ref_nodel
= true;
1860 * Initialize the dynamic linker. The argument is the address at which
1861 * the dynamic linker has been mapped into memory. The primary task of
1862 * this function is to relocate the dynamic linker.
1865 init_rtld(caddr_t mapbase
, Elf_Auxinfo
**aux_info
)
1867 Obj_Entry objtmp
; /* Temporary rtld object */
1868 const Elf_Ehdr
*ehdr
;
1869 const Elf_Dyn
*dyn_rpath
;
1870 const Elf_Dyn
*dyn_soname
;
1871 const Elf_Dyn
*dyn_runpath
;
1874 * Conjure up an Obj_Entry structure for the dynamic linker.
1876 * The "path" member can't be initialized yet because string constants
1877 * cannot yet be accessed. Below we will set it correctly.
1879 memset(&objtmp
, 0, sizeof(objtmp
));
1882 objtmp
.mapbase
= mapbase
;
1884 objtmp
.relocbase
= mapbase
;
1886 if (RTLD_IS_DYNAMIC()) {
1887 objtmp
.dynamic
= rtld_dynamic(&objtmp
);
1888 digest_dynamic1(&objtmp
, 1, &dyn_rpath
, &dyn_soname
, &dyn_runpath
);
1889 assert(objtmp
.needed
== NULL
);
1890 assert(!objtmp
.textrel
);
1893 * Temporarily put the dynamic linker entry into the object list, so
1894 * that symbols can be found.
1897 relocate_objects(&objtmp
, true, &objtmp
, 0, NULL
);
1899 ehdr
= (Elf_Ehdr
*)mapbase
;
1900 objtmp
.phdr
= (Elf_Phdr
*)((char *)mapbase
+ ehdr
->e_phoff
);
1901 objtmp
.phsize
= ehdr
->e_phnum
* sizeof(objtmp
.phdr
[0]);
1903 /* Initialize the object list. */
1904 obj_tail
= &obj_list
;
1906 /* Now that non-local variables can be accesses, copy out obj_rtld. */
1907 memcpy(&obj_rtld
, &objtmp
, sizeof(obj_rtld
));
1909 #ifdef ENABLE_OSRELDATE
1910 if (aux_info
[AT_OSRELDATE
] != NULL
)
1911 osreldate
= aux_info
[AT_OSRELDATE
]->a_un
.a_val
;
1914 digest_dynamic2(&obj_rtld
, dyn_rpath
, dyn_soname
, dyn_runpath
);
1916 /* Replace the path with a dynamically allocated copy. */
1917 obj_rtld
.path
= xstrdup(PATH_RTLD
);
1919 r_debug
.r_brk
= r_debug_state
;
1920 r_debug
.r_state
= RT_CONSISTENT
;
1924 * Add the init functions from a needed object list (and its recursive
1925 * needed objects) to "list". This is not used directly; it is a helper
1926 * function for initlist_add_objects(). The write lock must be held
1927 * when this function is called.
1930 initlist_add_neededs(Needed_Entry
*needed
, Objlist
*list
)
1932 /* Recursively process the successor needed objects. */
1933 if (needed
->next
!= NULL
)
1934 initlist_add_neededs(needed
->next
, list
);
1936 /* Process the current needed object. */
1937 if (needed
->obj
!= NULL
)
1938 initlist_add_objects(needed
->obj
, &needed
->obj
->next
, list
);
1942 * Scan all of the DAGs rooted in the range of objects from "obj" to
1943 * "tail" and add their init functions to "list". This recurses over
1944 * the DAGs and ensure the proper init ordering such that each object's
1945 * needed libraries are initialized before the object itself. At the
1946 * same time, this function adds the objects to the global finalization
1947 * list "list_fini" in the opposite order. The write lock must be
1948 * held when this function is called.
1951 initlist_add_objects(Obj_Entry
*obj
, Obj_Entry
**tail
, Objlist
*list
)
1954 if (obj
->init_scanned
|| obj
->init_done
)
1956 obj
->init_scanned
= true;
1958 /* Recursively process the successor objects. */
1959 if (&obj
->next
!= tail
)
1960 initlist_add_objects(obj
->next
, tail
, list
);
1962 /* Recursively process the needed objects. */
1963 if (obj
->needed
!= NULL
)
1964 initlist_add_neededs(obj
->needed
, list
);
1965 if (obj
->needed_filtees
!= NULL
)
1966 initlist_add_neededs(obj
->needed_filtees
, list
);
1967 if (obj
->needed_aux_filtees
!= NULL
)
1968 initlist_add_neededs(obj
->needed_aux_filtees
, list
);
1970 /* Add the object to the init list. */
1971 if (obj
->preinit_array
!= (Elf_Addr
)NULL
|| obj
->init
!= (Elf_Addr
)NULL
||
1972 obj
->init_array
!= (Elf_Addr
)NULL
)
1973 objlist_push_tail(list
, obj
);
1975 /* Add the object to the global fini list in the reverse order. */
1976 if ((obj
->fini
!= (Elf_Addr
)NULL
|| obj
->fini_array
!= (Elf_Addr
)NULL
)
1977 && !obj
->on_fini_list
) {
1978 objlist_push_head(&list_fini
, obj
);
1979 obj
->on_fini_list
= true;
1984 #define FPTR_TARGET(f) ((Elf_Addr) (f))
1988 free_needed_filtees(Needed_Entry
*n
)
1990 Needed_Entry
*needed
, *needed1
;
1992 for (needed
= n
; needed
!= NULL
; needed
= needed
->next
) {
1993 if (needed
->obj
!= NULL
) {
1994 dlclose(needed
->obj
);
1998 for (needed
= n
; needed
!= NULL
; needed
= needed1
) {
1999 needed1
= needed
->next
;
2005 unload_filtees(Obj_Entry
*obj
)
2008 free_needed_filtees(obj
->needed_filtees
);
2009 obj
->needed_filtees
= NULL
;
2010 free_needed_filtees(obj
->needed_aux_filtees
);
2011 obj
->needed_aux_filtees
= NULL
;
2012 obj
->filtees_loaded
= false;
2016 load_filtee1(Obj_Entry
*obj
, Needed_Entry
*needed
, int flags
,
2017 RtldLockState
*lockstate
)
2020 for (; needed
!= NULL
; needed
= needed
->next
) {
2021 needed
->obj
= dlopen_object(obj
->strtab
+ needed
->name
, -1, obj
,
2022 flags
, ((ld_loadfltr
|| obj
->z_loadfltr
) ? RTLD_NOW
: RTLD_LAZY
) |
2023 RTLD_LOCAL
, lockstate
);
2028 load_filtees(Obj_Entry
*obj
, int flags
, RtldLockState
*lockstate
)
2031 lock_restart_for_upgrade(lockstate
);
2032 if (!obj
->filtees_loaded
) {
2033 load_filtee1(obj
, obj
->needed_filtees
, flags
, lockstate
);
2034 load_filtee1(obj
, obj
->needed_aux_filtees
, flags
, lockstate
);
2035 obj
->filtees_loaded
= true;
2040 process_needed(Obj_Entry
*obj
, Needed_Entry
*needed
, int flags
)
2044 for (; needed
!= NULL
; needed
= needed
->next
) {
2045 obj1
= needed
->obj
= load_object(obj
->strtab
+ needed
->name
, -1, obj
,
2046 flags
& ~RTLD_LO_NOLOAD
);
2047 if (obj1
== NULL
&& !ld_tracing
&& (flags
& RTLD_LO_FILTEES
) == 0)
2054 * Given a shared object, traverse its list of needed objects, and load
2055 * each of them. Returns 0 on success. Generates an error message and
2056 * returns -1 on failure.
2059 load_needed_objects(Obj_Entry
*first
, int flags
)
2063 for (obj
= first
; obj
!= NULL
; obj
= obj
->next
) {
2064 if (process_needed(obj
, obj
->needed
, flags
) == -1)
2071 load_preload_objects(void)
2073 char *p
= ld_preload
;
2075 static const char delim
[] = " \t:;";
2080 p
+= strspn(p
, delim
);
2081 while (*p
!= '\0') {
2082 size_t len
= strcspn(p
, delim
);
2089 obj
= load_object(p
, -1, NULL
, 0);
2091 return -1; /* XXX - cleanup */
2092 obj
->z_interpose
= true;
2095 p
+= strspn(p
, delim
);
2097 /* Check for the magic tracing function */
2098 symlook_init(&req
, RTLD_FUNCTRACE
);
2099 res
= symlook_obj(&req
, obj
);
2101 rtld_functrace
= (void *)(req
.defobj_out
->relocbase
+
2102 req
.sym_out
->st_value
);
2103 rtld_functrace_obj
= req
.defobj_out
;
2106 LD_UTRACE(UTRACE_PRELOAD_FINISHED
, NULL
, NULL
, 0, 0, NULL
);
2111 printable_path(const char *path
)
2114 return (path
== NULL
? "<unknown>" : path
);
2118 * Load a shared object into memory, if it is not already loaded. The
2119 * object may be specified by name or by user-supplied file descriptor
2120 * fd_u. In the later case, the fd_u descriptor is not closed, but its
2123 * Returns a pointer to the Obj_Entry for the object. Returns NULL
2127 load_object(const char *name
, int fd_u
, const Obj_Entry
*refobj
, int flags
)
2136 for (obj
= obj_list
->next
; obj
!= NULL
; obj
= obj
->next
) {
2137 if (object_match_name(obj
, name
))
2141 path
= find_library(name
, refobj
, &fd
);
2149 * search_library_pathfds() opens a fresh file descriptor for the
2150 * library, so there is no need to dup().
2152 } else if (fd_u
== -1) {
2154 * If we didn't find a match by pathname, or the name is not
2155 * supplied, open the file and check again by device and inode.
2156 * This avoids false mismatches caused by multiple links or ".."
2159 * To avoid a race, we open the file and use fstat() rather than
2162 if ((fd
= open(path
, O_RDONLY
| O_CLOEXEC
)) == -1) {
2163 _rtld_error("Cannot open \"%s\"", path
);
2168 fd
= fcntl(fd_u
, F_DUPFD_CLOEXEC
, 0);
2170 _rtld_error("Cannot dup fd");
2175 if (fstat(fd
, &sb
) == -1) {
2176 _rtld_error("Cannot fstat \"%s\"", printable_path(path
));
2181 for (obj
= obj_list
->next
; obj
!= NULL
; obj
= obj
->next
)
2182 if (obj
->ino
== sb
.st_ino
&& obj
->dev
== sb
.st_dev
)
2184 if (obj
!= NULL
&& name
!= NULL
) {
2185 object_add_name(obj
, name
);
2190 if (flags
& RTLD_LO_NOLOAD
) {
2196 /* First use of this object, so we must map it in */
2197 obj
= do_load_object(fd
, name
, path
, &sb
, flags
);
2206 do_load_object(int fd
, const char *name
, char *path
, struct stat
*sbp
,
2213 * but first, make sure that environment variables haven't been
2214 * used to circumvent the noexec flag on a filesystem.
2216 if (dangerous_ld_env
) {
2217 if (fstatfs(fd
, &fs
) != 0) {
2218 _rtld_error("Cannot fstatfs \"%s\"", printable_path(path
));
2221 if (fs
.f_flags
& MNT_NOEXEC
) {
2222 _rtld_error("Cannot execute objects on %s\n", fs
.f_mntonname
);
2226 dbg("loading \"%s\"", printable_path(path
));
2227 obj
= map_object(fd
, printable_path(path
), sbp
);
2232 * If DT_SONAME is present in the object, digest_dynamic2 already
2233 * added it to the object names.
2236 object_add_name(obj
, name
);
2238 digest_dynamic(obj
, 0);
2239 dbg("%s valid_hash_sysv %d valid_hash_gnu %d dynsymcount %d", obj
->path
,
2240 obj
->valid_hash_sysv
, obj
->valid_hash_gnu
, obj
->dynsymcount
);
2241 if (obj
->z_noopen
&& (flags
& (RTLD_LO_DLOPEN
| RTLD_LO_TRACE
)) ==
2243 dbg("refusing to load non-loadable \"%s\"", obj
->path
);
2244 _rtld_error("Cannot dlopen non-loadable %s", obj
->path
);
2245 munmap(obj
->mapbase
, obj
->mapsize
);
2251 obj_tail
= &obj
->next
;
2254 linkmap_add(obj
); /* for GDB & dlinfo() */
2256 max_stack_flags
|= obj
->stack_flags
;
2259 dbg(" %p .. %p: %s", obj
->mapbase
,
2260 obj
->mapbase
+ obj
->mapsize
- 1, obj
->path
);
2262 dbg(" WARNING: %s has impure text", obj
->path
);
2263 LD_UTRACE(UTRACE_LOAD_OBJECT
, obj
, obj
->mapbase
, obj
->mapsize
, 0,
2270 obj_from_addr(const void *addr
)
2274 for (obj
= obj_list
; obj
!= NULL
; obj
= obj
->next
) {
2275 if (addr
< (void *) obj
->mapbase
)
2277 if (addr
< (void *) (obj
->mapbase
+ obj
->mapsize
))
2284 * If the main program is defined with a .preinit_array section, call
2285 * each function in order. This must occur before the initialization
2286 * of any shared object or the main program.
2291 Elf_Addr
*preinit_addr
;
2294 preinit_addr
= (Elf_Addr
*)obj_main
->preinit_array
;
2295 if (preinit_addr
== NULL
)
2298 for (index
= 0; index
< obj_main
->preinit_array_num
; index
++) {
2299 if (preinit_addr
[index
] != 0 && preinit_addr
[index
] != 1) {
2300 dbg("calling preinit function for %s at %p", obj_main
->path
,
2301 (void *)preinit_addr
[index
]);
2302 LD_UTRACE(UTRACE_INIT_CALL
, obj_main
, (void *)preinit_addr
[index
],
2303 0, 0, obj_main
->path
);
2304 call_init_pointer(obj_main
, preinit_addr
[index
]);
2310 * Call the finalization functions for each of the objects in "list"
2311 * belonging to the DAG of "root" and referenced once. If NULL "root"
2312 * is specified, every finalization function will be called regardless
2313 * of the reference count and the list elements won't be freed. All of
2314 * the objects are expected to have non-NULL fini functions.
2317 objlist_call_fini(Objlist
*list
, Obj_Entry
*root
, RtldLockState
*lockstate
)
2321 Elf_Addr
*fini_addr
;
2324 assert(root
== NULL
|| root
->refcount
== 1);
2327 * Preserve the current error message since a fini function might
2328 * call into the dynamic linker and overwrite it.
2330 saved_msg
= errmsg_save();
2332 STAILQ_FOREACH(elm
, list
, link
) {
2333 if (root
!= NULL
&& (elm
->obj
->refcount
!= 1 ||
2334 objlist_find(&root
->dagmembers
, elm
->obj
) == NULL
))
2337 /* Remove object from fini list to prevent recursive invocation. */
2338 STAILQ_REMOVE(list
, elm
, Struct_Objlist_Entry
, link
);
2340 * XXX: If a dlopen() call references an object while the
2341 * fini function is in progress, we might end up trying to
2342 * unload the referenced object in dlclose() or the object
2343 * won't be unloaded although its fini function has been
2346 lock_release(rtld_bind_lock
, lockstate
);
2349 * It is legal to have both DT_FINI and DT_FINI_ARRAY defined.
2350 * When this happens, DT_FINI_ARRAY is processed first.
2351 * It is also processed backwards. It is possible to encounter
2352 * DT_FINI_ARRAY elements with values of 0 or 1, but they need
2355 fini_addr
= (Elf_Addr
*)elm
->obj
->fini_array
;
2356 if (fini_addr
!= NULL
&& elm
->obj
->fini_array_num
> 0) {
2357 for (index
= elm
->obj
->fini_array_num
- 1; index
>= 0; index
--) {
2358 if (fini_addr
[index
] != 0 && fini_addr
[index
] != 1) {
2359 dbg("calling fini array function for %s at %p",
2360 elm
->obj
->path
, (void *)fini_addr
[index
]);
2361 LD_UTRACE(UTRACE_FINI_CALL
, elm
->obj
,
2362 (void *)fini_addr
[index
], 0, 0, elm
->obj
->path
);
2363 call_initfini_pointer(elm
->obj
, fini_addr
[index
]);
2367 if (elm
->obj
->fini
!= (Elf_Addr
)NULL
) {
2368 dbg("calling fini function for %s at %p", elm
->obj
->path
,
2369 (void *)elm
->obj
->fini
);
2370 LD_UTRACE(UTRACE_FINI_CALL
, elm
->obj
, (void *)elm
->obj
->fini
,
2371 0, 0, elm
->obj
->path
);
2372 call_initfini_pointer(elm
->obj
, elm
->obj
->fini
);
2374 wlock_acquire(rtld_bind_lock
, lockstate
);
2375 /* No need to free anything if process is going down. */
2379 * We must restart the list traversal after every fini call
2380 * because a dlclose() call from the fini function or from
2381 * another thread might have modified the reference counts.
2385 } while (elm
!= NULL
);
2386 errmsg_restore(saved_msg
);
2390 * Call the initialization functions for each of the objects in
2391 * "list". All of the objects are expected to have non-NULL init
2395 objlist_call_init(Objlist
*list
, RtldLockState
*lockstate
)
2400 Elf_Addr
*init_addr
;
2404 * Clean init_scanned flag so that objects can be rechecked and
2405 * possibly initialized earlier if any of vectors called below
2406 * cause the change by using dlopen.
2408 for (obj
= obj_list
; obj
!= NULL
; obj
= obj
->next
)
2409 obj
->init_scanned
= false;
2412 * Preserve the current error message since an init function might
2413 * call into the dynamic linker and overwrite it.
2415 saved_msg
= errmsg_save();
2416 STAILQ_FOREACH(elm
, list
, link
) {
2417 if (elm
->obj
->init_done
) /* Initialized early. */
2421 * Race: other thread might try to use this object before current
2422 * one completes the initilization. Not much can be done here
2423 * without better locking.
2425 elm
->obj
->init_done
= true;
2426 lock_release(rtld_bind_lock
, lockstate
);
2429 * It is legal to have both DT_INIT and DT_INIT_ARRAY defined.
2430 * When this happens, DT_INIT is processed first.
2431 * It is possible to encounter DT_INIT_ARRAY elements with values
2432 * of 0 or 1, but they need to be ignored.
2434 if (elm
->obj
->init
!= (Elf_Addr
)NULL
) {
2435 dbg("calling init function for %s at %p", elm
->obj
->path
,
2436 (void *)elm
->obj
->init
);
2437 LD_UTRACE(UTRACE_INIT_CALL
, elm
->obj
, (void *)elm
->obj
->init
,
2438 0, 0, elm
->obj
->path
);
2439 call_initfini_pointer(elm
->obj
, elm
->obj
->init
);
2441 init_addr
= (Elf_Addr
*)elm
->obj
->init_array
;
2442 if (init_addr
!= NULL
) {
2443 for (index
= 0; index
< elm
->obj
->init_array_num
; index
++) {
2444 if (init_addr
[index
] != 0 && init_addr
[index
] != 1) {
2445 dbg("calling init array function for %s at %p", elm
->obj
->path
,
2446 (void *)init_addr
[index
]);
2447 LD_UTRACE(UTRACE_INIT_CALL
, elm
->obj
,
2448 (void *)init_addr
[index
], 0, 0, elm
->obj
->path
);
2449 call_init_pointer(elm
->obj
, init_addr
[index
]);
2453 wlock_acquire(rtld_bind_lock
, lockstate
);
2455 errmsg_restore(saved_msg
);
2459 objlist_clear(Objlist
*list
)
2463 while (!STAILQ_EMPTY(list
)) {
2464 elm
= STAILQ_FIRST(list
);
2465 STAILQ_REMOVE_HEAD(list
, link
);
2470 static Objlist_Entry
*
2471 objlist_find(Objlist
*list
, const Obj_Entry
*obj
)
2475 STAILQ_FOREACH(elm
, list
, link
)
2476 if (elm
->obj
== obj
)
2482 objlist_init(Objlist
*list
)
2488 objlist_push_head(Objlist
*list
, Obj_Entry
*obj
)
2492 elm
= NEW(Objlist_Entry
);
2494 STAILQ_INSERT_HEAD(list
, elm
, link
);
2498 objlist_push_tail(Objlist
*list
, Obj_Entry
*obj
)
2502 elm
= NEW(Objlist_Entry
);
2504 STAILQ_INSERT_TAIL(list
, elm
, link
);
2508 objlist_put_after(Objlist
*list
, Obj_Entry
*listobj
, Obj_Entry
*obj
)
2510 Objlist_Entry
*elm
, *listelm
;
2512 STAILQ_FOREACH(listelm
, list
, link
) {
2513 if (listelm
->obj
== listobj
)
2516 elm
= NEW(Objlist_Entry
);
2518 if (listelm
!= NULL
)
2519 STAILQ_INSERT_AFTER(list
, listelm
, elm
, link
);
2521 STAILQ_INSERT_TAIL(list
, elm
, link
);
2525 objlist_remove(Objlist
*list
, Obj_Entry
*obj
)
2529 if ((elm
= objlist_find(list
, obj
)) != NULL
) {
2530 STAILQ_REMOVE(list
, elm
, Struct_Objlist_Entry
, link
);
2536 * Relocate dag rooted in the specified object.
2537 * Returns 0 on success, or -1 on failure.
2541 relocate_object_dag(Obj_Entry
*root
, bool bind_now
, Obj_Entry
*rtldobj
,
2542 int flags
, RtldLockState
*lockstate
)
2548 STAILQ_FOREACH(elm
, &root
->dagmembers
, link
) {
2549 error
= relocate_object(elm
->obj
, bind_now
, rtldobj
, flags
,
2558 * Prepare for, or clean after, relocating an object marked with
2559 * DT_TEXTREL or DF_TEXTREL. Before relocating, all read-only
2560 * segments are remapped read-write. After relocations are done, the
2561 * segment's permissions are returned back to the modes specified in
2562 * the phdrs. If any relocation happened, or always for wired
2563 * program, COW is triggered.
2566 reloc_textrel_prot(Obj_Entry
*obj
, bool before
)
2573 for (l
= obj
->phsize
/ sizeof(*ph
), ph
= obj
->phdr
; l
> 0;
2575 if (ph
->p_type
!= PT_LOAD
|| (ph
->p_flags
& PF_W
) != 0)
2577 base
= obj
->relocbase
+ trunc_page(ph
->p_vaddr
);
2578 sz
= round_page(ph
->p_vaddr
+ ph
->p_filesz
) -
2579 trunc_page(ph
->p_vaddr
);
2580 prot
= convert_prot(ph
->p_flags
) | (before
? PROT_WRITE
: 0);
2582 * Make sure modified text segments are included in the
2583 * core dump since we modified it. This unfortunately causes the
2584 * entire text segment to core-out but we don't have much of a
2585 * choice. We could try to only reenable core dumps on pages
2586 * in which relocations occured but that is likely most of the text
2587 * pages anyway, and even that would not work because the rest of
2588 * the text pages would wind up as a read-only OBJT_DEFAULT object
2589 * (created due to our modifications) backed by the original OBJT_VNODE
2590 * object, and the ELF coredump code is currently only able to dump
2591 * vnode records for pure vnode-backed mappings, not vnode backings
2592 * to memory objects.
2594 if (before
== false)
2595 madvise(base
, sz
, MADV_CORE
);
2596 if (mprotect(base
, sz
, prot
) == -1) {
2597 _rtld_error("%s: Cannot write-%sable text segment: %s",
2598 obj
->path
, before
? "en" : "dis",
2599 rtld_strerror(errno
));
2607 * Relocate single object.
2608 * Returns 0 on success, or -1 on failure.
2611 relocate_object(Obj_Entry
*obj
, bool bind_now
, Obj_Entry
*rtldobj
,
2612 int flags
, RtldLockState
*lockstate
)
2617 obj
->relocated
= true;
2619 dbg("relocating \"%s\"", obj
->path
);
2621 if (obj
->symtab
== NULL
|| obj
->strtab
== NULL
||
2622 !(obj
->valid_hash_sysv
|| obj
->valid_hash_gnu
)) {
2623 _rtld_error("%s: Shared object has no run-time symbol table",
2628 /* There are relocations to the write-protected text segment. */
2629 if (obj
->textrel
&& reloc_textrel_prot(obj
, true) != 0)
2632 /* Process the non-PLT non-IFUNC relocations. */
2633 if (reloc_non_plt(obj
, rtldobj
, flags
, lockstate
))
2636 /* Re-protected the text segment. */
2637 if (obj
->textrel
&& reloc_textrel_prot(obj
, false) != 0)
2640 /* Set the special PLT or GOT entries. */
2643 /* Process the PLT relocations. */
2644 if (reloc_plt(obj
) == -1)
2646 /* Relocate the jump slots if we are doing immediate binding. */
2647 if (obj
->bind_now
|| bind_now
)
2648 if (reloc_jmpslots(obj
, flags
, lockstate
) == -1)
2652 * Process the non-PLT IFUNC relocations. The relocations are
2653 * processed in two phases, because IFUNC resolvers may
2654 * reference other symbols, which must be readily processed
2655 * before resolvers are called.
2657 if (obj
->non_plt_gnu_ifunc
&&
2658 reloc_non_plt(obj
, rtldobj
, flags
| SYMLOOK_IFUNC
, lockstate
))
2662 * Set up the magic number and version in the Obj_Entry. These
2663 * were checked in the crt1.o from the original ElfKit, so we
2664 * set them for backward compatibility.
2666 obj
->magic
= RTLD_MAGIC
;
2667 obj
->version
= RTLD_VERSION
;
2670 * Set relocated data to read-only status if protection specified
2673 if (obj
->relro_size
) {
2674 if (mprotect(obj
->relro_page
, obj
->relro_size
, PROT_READ
) == -1) {
2675 _rtld_error("%s: Cannot enforce relro relocation: %s",
2676 obj
->path
, rtld_strerror(errno
));
2684 * Relocate newly-loaded shared objects. The argument is a pointer to
2685 * the Obj_Entry for the first such object. All objects from the first
2686 * to the end of the list of objects are relocated. Returns 0 on success,
2690 relocate_objects(Obj_Entry
*first
, bool bind_now
, Obj_Entry
*rtldobj
,
2691 int flags
, RtldLockState
*lockstate
)
2696 for (error
= 0, obj
= first
; obj
!= NULL
; obj
= obj
->next
) {
2697 error
= relocate_object(obj
, bind_now
, rtldobj
, flags
,
2706 * The handling of R_MACHINE_IRELATIVE relocations and jumpslots
2707 * referencing STT_GNU_IFUNC symbols is postponed till the other
2708 * relocations are done. The indirect functions specified as
2709 * ifunc are allowed to call other symbols, so we need to have
2710 * objects relocated before asking for resolution from indirects.
2712 * The R_MACHINE_IRELATIVE slots are resolved in greedy fashion,
2713 * instead of the usual lazy handling of PLT slots. It is
2714 * consistent with how GNU does it.
2717 resolve_object_ifunc(Obj_Entry
*obj
, bool bind_now
, int flags
,
2718 RtldLockState
*lockstate
)
2720 if (obj
->irelative
&& reloc_iresolve(obj
, lockstate
) == -1)
2722 if ((obj
->bind_now
|| bind_now
) && obj
->gnu_ifunc
&&
2723 reloc_gnu_ifunc(obj
, flags
, lockstate
) == -1)
2729 resolve_objects_ifunc(Obj_Entry
*first
, bool bind_now
, int flags
,
2730 RtldLockState
*lockstate
)
2734 for (obj
= first
; obj
!= NULL
; obj
= obj
->next
) {
2735 if (resolve_object_ifunc(obj
, bind_now
, flags
, lockstate
) == -1)
2742 initlist_objects_ifunc(Objlist
*list
, bool bind_now
, int flags
,
2743 RtldLockState
*lockstate
)
2747 STAILQ_FOREACH(elm
, list
, link
) {
2748 if (resolve_object_ifunc(elm
->obj
, bind_now
, flags
,
2756 * Cleanup procedure. It will be called (by the atexit mechanism) just
2757 * before the process exits.
2762 RtldLockState lockstate
;
2764 wlock_acquire(rtld_bind_lock
, &lockstate
);
2766 objlist_call_fini(&list_fini
, NULL
, &lockstate
);
2767 /* No need to remove the items from the list, since we are exiting. */
2768 if (!libmap_disable
)
2770 lock_release(rtld_bind_lock
, &lockstate
);
2774 * Iterate over a search path, translate each element, and invoke the
2775 * callback on the result.
2778 path_enumerate(const char *path
, path_enum_proc callback
, void *arg
)
2784 path
+= strspn(path
, ":;");
2785 while (*path
!= '\0') {
2789 len
= strcspn(path
, ":;");
2790 trans
= lm_findn(NULL
, path
, len
);
2792 res
= callback(trans
, strlen(trans
), arg
);
2794 res
= callback(path
, len
, arg
);
2800 path
+= strspn(path
, ":;");
2806 struct try_library_args
{
2814 try_library_path(const char *dir
, size_t dirlen
, void *param
)
2816 struct try_library_args
*arg
;
2819 if (*dir
== '/' || trust
) {
2822 if (dirlen
+ 1 + arg
->namelen
+ 1 > arg
->buflen
)
2825 pathname
= arg
->buffer
;
2826 strncpy(pathname
, dir
, dirlen
);
2827 pathname
[dirlen
] = '/';
2828 strcpy(pathname
+ dirlen
+ 1, arg
->name
);
2830 dbg(" Trying \"%s\"", pathname
);
2831 if (access(pathname
, F_OK
) == 0) { /* We found it */
2832 pathname
= xmalloc(dirlen
+ 1 + arg
->namelen
+ 1);
2833 strcpy(pathname
, arg
->buffer
);
2841 search_library_path(const char *name
, const char *path
)
2844 struct try_library_args arg
;
2850 arg
.namelen
= strlen(name
);
2851 arg
.buffer
= xmalloc(PATH_MAX
);
2852 arg
.buflen
= PATH_MAX
;
2854 p
= path_enumerate(path
, try_library_path
, &arg
);
2863 * Finds the library with the given name using the directory descriptors
2864 * listed in the LD_LIBRARY_PATH_FDS environment variable.
2866 * Returns a freshly-opened close-on-exec file descriptor for the library,
2867 * or -1 if the library cannot be found.
2870 search_library_pathfds(const char *name
, const char *path
, int *fdp
)
2872 char *envcopy
, *fdstr
, *found
, *last_token
;
2876 dbg("%s('%s', '%s', fdp)", __func__
, name
, path
);
2878 /* Don't load from user-specified libdirs into setuid binaries. */
2882 /* We can't do anything if LD_LIBRARY_PATH_FDS isn't set. */
2886 /* LD_LIBRARY_PATH_FDS only works with relative paths. */
2887 if (name
[0] == '/') {
2888 dbg("Absolute path (%s) passed to %s", name
, __func__
);
2893 * Use strtok_r() to walk the FD:FD:FD list. This requires a local
2894 * copy of the path, as strtok_r rewrites separator tokens
2898 envcopy
= xstrdup(path
);
2899 for (fdstr
= strtok_r(envcopy
, ":", &last_token
); fdstr
!= NULL
;
2900 fdstr
= strtok_r(NULL
, ":", &last_token
)) {
2901 dirfd
= parse_libdir(fdstr
);
2904 fd
= openat(dirfd
, name
, O_RDONLY
| O_CLOEXEC
);
2907 len
= strlen(fdstr
) + strlen(name
) + 3;
2908 found
= xmalloc(len
);
2909 if (rtld_snprintf(found
, len
, "#%d/%s", dirfd
, name
) < 0) {
2910 _rtld_error("error generating '%d/%s'",
2914 dbg("open('%s') => %d", found
, fd
);
2925 dlclose(void *handle
)
2928 RtldLockState lockstate
;
2930 wlock_acquire(rtld_bind_lock
, &lockstate
);
2931 root
= dlcheck(handle
);
2933 lock_release(rtld_bind_lock
, &lockstate
);
2936 LD_UTRACE(UTRACE_DLCLOSE_START
, handle
, NULL
, 0, root
->dl_refcount
,
2939 /* Unreference the object and its dependencies. */
2940 root
->dl_refcount
--;
2942 if (root
->refcount
== 1) {
2944 * The object will be no longer referenced, so we must unload it.
2945 * First, call the fini functions.
2947 objlist_call_fini(&list_fini
, root
, &lockstate
);
2951 /* Finish cleaning up the newly-unreferenced objects. */
2952 GDB_STATE(RT_DELETE
,&root
->linkmap
);
2953 unload_object(root
);
2954 GDB_STATE(RT_CONSISTENT
,NULL
);
2958 LD_UTRACE(UTRACE_DLCLOSE_STOP
, handle
, NULL
, 0, 0, NULL
);
2959 lock_release(rtld_bind_lock
, &lockstate
);
2966 char *msg
= error_message
;
2967 error_message
= NULL
;
2972 dlopen(const char *name
, int mode
)
2975 return (rtld_dlopen(name
, -1, mode
));
2979 fdlopen(int fd
, int mode
)
2982 return (rtld_dlopen(NULL
, fd
, mode
));
2986 rtld_dlopen(const char *name
, int fd
, int mode
)
2988 RtldLockState lockstate
;
2991 LD_UTRACE(UTRACE_DLOPEN_START
, NULL
, NULL
, 0, mode
, name
);
2992 ld_tracing
= (mode
& RTLD_TRACE
) == 0 ? NULL
: "1";
2993 if (ld_tracing
!= NULL
) {
2994 rlock_acquire(rtld_bind_lock
, &lockstate
);
2995 if (sigsetjmp(lockstate
.env
, 0) != 0)
2996 lock_upgrade(rtld_bind_lock
, &lockstate
);
2997 environ
= (char **)*get_program_var_addr("environ", &lockstate
);
2998 lock_release(rtld_bind_lock
, &lockstate
);
3000 lo_flags
= RTLD_LO_DLOPEN
;
3001 if (mode
& RTLD_NODELETE
)
3002 lo_flags
|= RTLD_LO_NODELETE
;
3003 if (mode
& RTLD_NOLOAD
)
3004 lo_flags
|= RTLD_LO_NOLOAD
;
3005 if (ld_tracing
!= NULL
)
3006 lo_flags
|= RTLD_LO_TRACE
;
3008 return (dlopen_object(name
, fd
, obj_main
, lo_flags
,
3009 mode
& (RTLD_MODEMASK
| RTLD_GLOBAL
), NULL
));
3013 dlopen_cleanup(Obj_Entry
*obj
)
3018 if (obj
->refcount
== 0)
3023 dlopen_object(const char *name
, int fd
, Obj_Entry
*refobj
, int lo_flags
,
3024 int mode
, RtldLockState
*lockstate
)
3026 Obj_Entry
**old_obj_tail
;
3029 RtldLockState mlockstate
;
3032 objlist_init(&initlist
);
3034 if (lockstate
== NULL
&& !(lo_flags
& RTLD_LO_EARLY
)) {
3035 wlock_acquire(rtld_bind_lock
, &mlockstate
);
3036 lockstate
= &mlockstate
;
3038 GDB_STATE(RT_ADD
,NULL
);
3040 old_obj_tail
= obj_tail
;
3042 if (name
== NULL
&& fd
== -1) {
3046 obj
= load_object(name
, fd
, refobj
, lo_flags
);
3051 if (mode
& RTLD_GLOBAL
&& objlist_find(&list_global
, obj
) == NULL
)
3052 objlist_push_tail(&list_global
, obj
);
3053 if (*old_obj_tail
!= NULL
) { /* We loaded something new. */
3054 assert(*old_obj_tail
== obj
);
3055 result
= load_needed_objects(obj
,
3056 lo_flags
& (RTLD_LO_DLOPEN
| RTLD_LO_EARLY
));
3060 result
= rtld_verify_versions(&obj
->dagmembers
);
3061 if (result
!= -1 && ld_tracing
)
3063 if (result
== -1 || relocate_object_dag(obj
,
3064 (mode
& RTLD_MODEMASK
) == RTLD_NOW
, &obj_rtld
,
3065 (lo_flags
& RTLD_LO_EARLY
) ? SYMLOOK_EARLY
: 0,
3067 dlopen_cleanup(obj
);
3069 } else if (lo_flags
& RTLD_LO_EARLY
) {
3071 * Do not call the init functions for early loaded
3072 * filtees. The image is still not initialized enough
3075 * Our object is found by the global object list and
3076 * will be ordered among all init calls done right
3077 * before transferring control to main.
3080 /* Make list of init functions to call. */
3081 initlist_add_objects(obj
, &obj
->next
, &initlist
);
3084 * Process all no_delete objects here, given them own
3085 * DAGs to prevent their dependencies from being unloaded.
3086 * This has to be done after we have loaded all of the
3087 * dependencies, so that we do not miss any.
3090 process_nodelete(obj
);
3093 * Bump the reference counts for objects on this DAG. If
3094 * this is the first dlopen() call for the object that was
3095 * already loaded as a dependency, initialize the dag
3101 if ((lo_flags
& RTLD_LO_TRACE
) != 0)
3104 if (obj
!= NULL
&& ((lo_flags
& RTLD_LO_NODELETE
) != 0 ||
3105 obj
->z_nodelete
) && !obj
->ref_nodel
) {
3106 dbg("obj %s nodelete", obj
->path
);
3108 obj
->z_nodelete
= obj
->ref_nodel
= true;
3112 LD_UTRACE(UTRACE_DLOPEN_STOP
, obj
, NULL
, 0, obj
? obj
->dl_refcount
: 0,
3114 GDB_STATE(RT_CONSISTENT
,obj
? &obj
->linkmap
: NULL
);
3116 if (!(lo_flags
& RTLD_LO_EARLY
)) {
3117 map_stacks_exec(lockstate
);
3120 if (initlist_objects_ifunc(&initlist
, (mode
& RTLD_MODEMASK
) == RTLD_NOW
,
3121 (lo_flags
& RTLD_LO_EARLY
) ? SYMLOOK_EARLY
: 0,
3123 objlist_clear(&initlist
);
3124 dlopen_cleanup(obj
);
3125 if (lockstate
== &mlockstate
)
3126 lock_release(rtld_bind_lock
, lockstate
);
3130 if (!(lo_flags
& RTLD_LO_EARLY
)) {
3131 /* Call the init functions. */
3132 objlist_call_init(&initlist
, lockstate
);
3134 objlist_clear(&initlist
);
3135 if (lockstate
== &mlockstate
)
3136 lock_release(rtld_bind_lock
, lockstate
);
3139 trace_loaded_objects(obj
);
3140 if (lockstate
== &mlockstate
)
3141 lock_release(rtld_bind_lock
, lockstate
);
3146 do_dlsym(void *handle
, const char *name
, void *retaddr
, const Ver_Entry
*ve
,
3150 const Obj_Entry
*obj
, *defobj
;
3153 RtldLockState lockstate
;
3159 symlook_init(&req
, name
);
3161 req
.flags
= flags
| SYMLOOK_IN_PLT
;
3162 req
.lockstate
= &lockstate
;
3164 rlock_acquire(rtld_bind_lock
, &lockstate
);
3165 if (sigsetjmp(lockstate
.env
, 0) != 0)
3166 lock_upgrade(rtld_bind_lock
, &lockstate
);
3167 if (handle
== NULL
|| handle
== RTLD_NEXT
||
3168 handle
== RTLD_DEFAULT
|| handle
== RTLD_SELF
) {
3170 if ((obj
= obj_from_addr(retaddr
)) == NULL
) {
3171 _rtld_error("Cannot determine caller's shared object");
3172 lock_release(rtld_bind_lock
, &lockstate
);
3175 if (handle
== NULL
) { /* Just the caller's shared object. */
3176 res
= symlook_obj(&req
, obj
);
3179 defobj
= req
.defobj_out
;
3181 } else if (handle
== RTLD_NEXT
|| /* Objects after caller's */
3182 handle
== RTLD_SELF
) { /* ... caller included */
3183 if (handle
== RTLD_NEXT
)
3185 for (; obj
!= NULL
; obj
= obj
->next
) {
3186 res
= symlook_obj(&req
, obj
);
3189 ELF_ST_BIND(req
.sym_out
->st_info
) != STB_WEAK
) {
3191 defobj
= req
.defobj_out
;
3192 if (ELF_ST_BIND(def
->st_info
) != STB_WEAK
)
3198 * Search the dynamic linker itself, and possibly resolve the
3199 * symbol from there. This is how the application links to
3200 * dynamic linker services such as dlopen.
3202 if (def
== NULL
|| ELF_ST_BIND(def
->st_info
) == STB_WEAK
) {
3203 res
= symlook_obj(&req
, &obj_rtld
);
3206 defobj
= req
.defobj_out
;
3210 assert(handle
== RTLD_DEFAULT
);
3211 res
= symlook_default(&req
, obj
);
3213 defobj
= req
.defobj_out
;
3218 if ((obj
= dlcheck(handle
)) == NULL
) {
3219 lock_release(rtld_bind_lock
, &lockstate
);
3223 donelist_init(&donelist
);
3224 if (obj
->mainprog
) {
3225 /* Handle obtained by dlopen(NULL, ...) implies global scope. */
3226 res
= symlook_global(&req
, &donelist
);
3229 defobj
= req
.defobj_out
;
3232 * Search the dynamic linker itself, and possibly resolve the
3233 * symbol from there. This is how the application links to
3234 * dynamic linker services such as dlopen.
3236 if (def
== NULL
|| ELF_ST_BIND(def
->st_info
) == STB_WEAK
) {
3237 res
= symlook_obj(&req
, &obj_rtld
);
3240 defobj
= req
.defobj_out
;
3245 /* Search the whole DAG rooted at the given object. */
3246 res
= symlook_list(&req
, &obj
->dagmembers
, &donelist
);
3249 defobj
= req
.defobj_out
;
3255 lock_release(rtld_bind_lock
, &lockstate
);
3258 * The value required by the caller is derived from the value
3259 * of the symbol. this is simply the relocated value of the
3262 if (ELF_ST_TYPE(def
->st_info
) == STT_FUNC
)
3263 return (make_function_pointer(def
, defobj
));
3264 else if (ELF_ST_TYPE(def
->st_info
) == STT_GNU_IFUNC
)
3265 return (rtld_resolve_ifunc(defobj
, def
));
3266 else if (ELF_ST_TYPE(def
->st_info
) == STT_TLS
) {
3267 ti
.ti_module
= defobj
->tlsindex
;
3268 ti
.ti_offset
= def
->st_value
;
3269 return (__tls_get_addr(&ti
));
3271 return (defobj
->relocbase
+ def
->st_value
);
3274 _rtld_error("Undefined symbol \"%s\"", name
);
3275 lock_release(rtld_bind_lock
, &lockstate
);
3280 dlsym(void *handle
, const char *name
)
3282 return do_dlsym(handle
, name
, __builtin_return_address(0), NULL
,
3287 dlfunc(void *handle
, const char *name
)
3294 rv
.d
= do_dlsym(handle
, name
, __builtin_return_address(0), NULL
,
3300 dlvsym(void *handle
, const char *name
, const char *version
)
3304 ventry
.name
= version
;
3306 ventry
.hash
= elf_hash(version
);
3308 return do_dlsym(handle
, name
, __builtin_return_address(0), &ventry
,
3313 _rtld_addr_phdr(const void *addr
, struct dl_phdr_info
*phdr_info
)
3315 const Obj_Entry
*obj
;
3316 RtldLockState lockstate
;
3318 rlock_acquire(rtld_bind_lock
, &lockstate
);
3319 obj
= obj_from_addr(addr
);
3321 _rtld_error("No shared object contains address");
3322 lock_release(rtld_bind_lock
, &lockstate
);
3325 rtld_fill_dl_phdr_info(obj
, phdr_info
);
3326 lock_release(rtld_bind_lock
, &lockstate
);
3331 dladdr(const void *addr
, Dl_info
*info
)
3333 const Obj_Entry
*obj
;
3336 unsigned long symoffset
;
3337 RtldLockState lockstate
;
3339 rlock_acquire(rtld_bind_lock
, &lockstate
);
3340 obj
= obj_from_addr(addr
);
3342 _rtld_error("No shared object contains address");
3343 lock_release(rtld_bind_lock
, &lockstate
);
3346 info
->dli_fname
= obj
->path
;
3347 info
->dli_fbase
= obj
->mapbase
;
3348 info
->dli_saddr
= NULL
;
3349 info
->dli_sname
= NULL
;
3352 * Walk the symbol list looking for the symbol whose address is
3353 * closest to the address sent in.
3355 for (symoffset
= 0; symoffset
< obj
->dynsymcount
; symoffset
++) {
3356 def
= obj
->symtab
+ symoffset
;
3359 * For skip the symbol if st_shndx is either SHN_UNDEF or
3362 if (def
->st_shndx
== SHN_UNDEF
|| def
->st_shndx
== SHN_COMMON
)
3366 * If the symbol is greater than the specified address, or if it
3367 * is further away from addr than the current nearest symbol,
3370 symbol_addr
= obj
->relocbase
+ def
->st_value
;
3371 if (symbol_addr
> addr
|| symbol_addr
< info
->dli_saddr
)
3374 /* Update our idea of the nearest symbol. */
3375 info
->dli_sname
= obj
->strtab
+ def
->st_name
;
3376 info
->dli_saddr
= symbol_addr
;
3379 if (info
->dli_saddr
== addr
)
3382 lock_release(rtld_bind_lock
, &lockstate
);
3387 dlinfo(void *handle
, int request
, void *p
)
3389 const Obj_Entry
*obj
;
3390 RtldLockState lockstate
;
3393 rlock_acquire(rtld_bind_lock
, &lockstate
);
3395 if (handle
== NULL
|| handle
== RTLD_SELF
) {
3398 retaddr
= __builtin_return_address(0); /* __GNUC__ only */
3399 if ((obj
= obj_from_addr(retaddr
)) == NULL
)
3400 _rtld_error("Cannot determine caller's shared object");
3402 obj
= dlcheck(handle
);
3405 lock_release(rtld_bind_lock
, &lockstate
);
3411 case RTLD_DI_LINKMAP
:
3412 *((struct link_map
const **)p
) = &obj
->linkmap
;
3414 case RTLD_DI_ORIGIN
:
3415 error
= rtld_dirname(obj
->path
, p
);
3418 case RTLD_DI_SERINFOSIZE
:
3419 case RTLD_DI_SERINFO
:
3420 error
= do_search_info(obj
, request
, (struct dl_serinfo
*)p
);
3424 _rtld_error("Invalid request %d passed to dlinfo()", request
);
3428 lock_release(rtld_bind_lock
, &lockstate
);
3434 rtld_fill_dl_phdr_info(const Obj_Entry
*obj
, struct dl_phdr_info
*phdr_info
)
3437 phdr_info
->dlpi_addr
= (Elf_Addr
)obj
->relocbase
;
3438 phdr_info
->dlpi_name
= obj
->path
;
3439 phdr_info
->dlpi_phdr
= obj
->phdr
;
3440 phdr_info
->dlpi_phnum
= obj
->phsize
/ sizeof(obj
->phdr
[0]);
3441 phdr_info
->dlpi_tls_modid
= obj
->tlsindex
;
3442 phdr_info
->dlpi_tls_data
= obj
->tlsinit
;
3443 phdr_info
->dlpi_adds
= obj_loads
;
3444 phdr_info
->dlpi_subs
= obj_loads
- obj_count
;
3448 dl_iterate_phdr(__dl_iterate_hdr_callback callback
, void *param
)
3450 struct dl_phdr_info phdr_info
;
3451 const Obj_Entry
*obj
;
3452 RtldLockState bind_lockstate
, phdr_lockstate
;
3455 wlock_acquire(rtld_phdr_lock
, &phdr_lockstate
);
3456 rlock_acquire(rtld_bind_lock
, &bind_lockstate
);
3460 for (obj
= obj_list
; obj
!= NULL
; obj
= obj
->next
) {
3461 rtld_fill_dl_phdr_info(obj
, &phdr_info
);
3462 if ((error
= callback(&phdr_info
, sizeof phdr_info
, param
)) != 0)
3467 rtld_fill_dl_phdr_info(&obj_rtld
, &phdr_info
);
3468 error
= callback(&phdr_info
, sizeof(phdr_info
), param
);
3471 lock_release(rtld_bind_lock
, &bind_lockstate
);
3472 lock_release(rtld_phdr_lock
, &phdr_lockstate
);
3478 fill_search_info(const char *dir
, size_t dirlen
, void *param
)
3480 struct fill_search_info_args
*arg
;
3484 if (arg
->request
== RTLD_DI_SERINFOSIZE
) {
3485 arg
->serinfo
->dls_cnt
++;
3486 arg
->serinfo
->dls_size
+= sizeof(struct dl_serpath
) + dirlen
+ 1;
3488 struct dl_serpath
*s_entry
;
3490 s_entry
= arg
->serpath
;
3491 s_entry
->dls_name
= arg
->strspace
;
3492 s_entry
->dls_flags
= arg
->flags
;
3494 strncpy(arg
->strspace
, dir
, dirlen
);
3495 arg
->strspace
[dirlen
] = '\0';
3497 arg
->strspace
+= dirlen
+ 1;
3505 do_search_info(const Obj_Entry
*obj
, int request
, struct dl_serinfo
*info
)
3507 struct dl_serinfo _info
;
3508 struct fill_search_info_args args
;
3510 args
.request
= RTLD_DI_SERINFOSIZE
;
3511 args
.serinfo
= &_info
;
3513 _info
.dls_size
= __offsetof(struct dl_serinfo
, dls_serpath
);
3516 path_enumerate(obj
->rpath
, fill_search_info
, &args
);
3517 path_enumerate(ld_library_path
, fill_search_info
, &args
);
3518 path_enumerate(obj
->runpath
, fill_search_info
, &args
);
3519 path_enumerate(gethints(obj
->z_nodeflib
), fill_search_info
, &args
);
3520 if (!obj
->z_nodeflib
)
3521 path_enumerate(STANDARD_LIBRARY_PATH
, fill_search_info
, &args
);
3524 if (request
== RTLD_DI_SERINFOSIZE
) {
3525 info
->dls_size
= _info
.dls_size
;
3526 info
->dls_cnt
= _info
.dls_cnt
;
3530 if (info
->dls_cnt
!= _info
.dls_cnt
|| info
->dls_size
!= _info
.dls_size
) {
3531 _rtld_error("Uninitialized Dl_serinfo struct passed to dlinfo()");
3535 args
.request
= RTLD_DI_SERINFO
;
3536 args
.serinfo
= info
;
3537 args
.serpath
= &info
->dls_serpath
[0];
3538 args
.strspace
= (char *)&info
->dls_serpath
[_info
.dls_cnt
];
3540 args
.flags
= LA_SER_RUNPATH
;
3541 if (path_enumerate(obj
->rpath
, fill_search_info
, &args
) != NULL
)
3544 args
.flags
= LA_SER_LIBPATH
;
3545 if (path_enumerate(ld_library_path
, fill_search_info
, &args
) != NULL
)
3548 args
.flags
= LA_SER_RUNPATH
;
3549 if (path_enumerate(obj
->runpath
, fill_search_info
, &args
) != NULL
)
3552 args
.flags
= LA_SER_CONFIG
;
3553 if (path_enumerate(gethints(obj
->z_nodeflib
), fill_search_info
, &args
)
3557 args
.flags
= LA_SER_DEFAULT
;
3558 if (!obj
->z_nodeflib
&&
3559 path_enumerate(STANDARD_LIBRARY_PATH
, fill_search_info
, &args
) != NULL
)
3565 rtld_dirname(const char *path
, char *bname
)
3569 /* Empty or NULL string gets treated as "." */
3570 if (path
== NULL
|| *path
== '\0') {
3576 /* Strip trailing slashes */
3577 endp
= path
+ strlen(path
) - 1;
3578 while (endp
> path
&& *endp
== '/')
3581 /* Find the start of the dir */
3582 while (endp
> path
&& *endp
!= '/')
3585 /* Either the dir is "/" or there are no slashes */
3587 bname
[0] = *endp
== '/' ? '/' : '.';
3593 } while (endp
> path
&& *endp
== '/');
3596 if (endp
- path
+ 2 > PATH_MAX
)
3598 _rtld_error("Filename is too long: %s", path
);
3602 strncpy(bname
, path
, endp
- path
+ 1);
3603 bname
[endp
- path
+ 1] = '\0';
3608 rtld_dirname_abs(const char *path
, char *base
)
3610 char base_rel
[PATH_MAX
];
3612 if (rtld_dirname(path
, base
) == -1)
3616 if (getcwd(base_rel
, sizeof(base_rel
)) == NULL
||
3617 strlcat(base_rel
, "/", sizeof(base_rel
)) >= sizeof(base_rel
) ||
3618 strlcat(base_rel
, base
, sizeof(base_rel
)) >= sizeof(base_rel
))
3620 strcpy(base
, base_rel
);
3625 linkmap_add(Obj_Entry
*obj
)
3627 struct link_map
*l
= &obj
->linkmap
;
3628 struct link_map
*prev
;
3630 obj
->linkmap
.l_name
= obj
->path
;
3631 obj
->linkmap
.l_addr
= obj
->mapbase
;
3632 obj
->linkmap
.l_ld
= obj
->dynamic
;
3634 if (r_debug
.r_map
== NULL
) {
3640 * Scan to the end of the list, but not past the entry for the
3641 * dynamic linker, which we want to keep at the very end.
3643 for (prev
= r_debug
.r_map
;
3644 prev
->l_next
!= NULL
&& prev
->l_next
!= &obj_rtld
.linkmap
;
3645 prev
= prev
->l_next
)
3648 /* Link in the new entry. */
3650 l
->l_next
= prev
->l_next
;
3651 if (l
->l_next
!= NULL
)
3652 l
->l_next
->l_prev
= l
;
3657 linkmap_delete(Obj_Entry
*obj
)
3659 struct link_map
*l
= &obj
->linkmap
;
3661 if (l
->l_prev
== NULL
) {
3662 if ((r_debug
.r_map
= l
->l_next
) != NULL
)
3663 l
->l_next
->l_prev
= NULL
;
3667 if ((l
->l_prev
->l_next
= l
->l_next
) != NULL
)
3668 l
->l_next
->l_prev
= l
->l_prev
;
3672 * Function for the debugger to set a breakpoint on to gain control.
3674 * The two parameters allow the debugger to easily find and determine
3675 * what the runtime loader is doing and to whom it is doing it.
3677 * When the loadhook trap is hit (r_debug_state, set at program
3678 * initialization), the arguments can be found on the stack:
3680 * +8 struct link_map *m
3681 * +4 struct r_debug *rd
3685 r_debug_state(struct r_debug
* rd
, struct link_map
*m
)
3688 * The following is a hack to force the compiler to emit calls to
3689 * this function, even when optimizing. If the function is empty,
3690 * the compiler is not obliged to emit any code for calls to it,
3691 * even when marked __noinline. However, gdb depends on those
3694 __asm
__volatile("" : : : "memory");
3698 * A function called after init routines have completed. This can be used to
3699 * break before a program's entry routine is called, and can be used when
3700 * main is not available in the symbol table.
3703 _r_debug_postinit(struct link_map
*m
)
3706 /* See r_debug_state(). */
3707 __asm
__volatile("" : : : "memory");
3711 * Get address of the pointer variable in the main program.
3712 * Prefer non-weak symbol over the weak one.
3714 static const void **
3715 get_program_var_addr(const char *name
, RtldLockState
*lockstate
)
3720 symlook_init(&req
, name
);
3721 req
.lockstate
= lockstate
;
3722 donelist_init(&donelist
);
3723 if (symlook_global(&req
, &donelist
) != 0)
3725 if (ELF_ST_TYPE(req
.sym_out
->st_info
) == STT_FUNC
)
3726 return ((const void **)make_function_pointer(req
.sym_out
,
3728 else if (ELF_ST_TYPE(req
.sym_out
->st_info
) == STT_GNU_IFUNC
)
3729 return ((const void **)rtld_resolve_ifunc(req
.defobj_out
, req
.sym_out
));
3731 return ((const void **)(req
.defobj_out
->relocbase
+
3732 req
.sym_out
->st_value
));
3736 * Set a pointer variable in the main program to the given value. This
3737 * is used to set key variables such as "environ" before any of the
3738 * init functions are called.
3741 set_program_var(const char *name
, const void *value
)
3745 if ((addr
= get_program_var_addr(name
, NULL
)) != NULL
) {
3746 dbg("\"%s\": *%p <-- %p", name
, addr
, value
);
3752 * Search the global objects, including dependencies and main object,
3753 * for the given symbol.
3756 symlook_global(SymLook
*req
, DoneList
*donelist
)
3759 const Objlist_Entry
*elm
;
3762 symlook_init_from_req(&req1
, req
);
3764 /* Search all objects loaded at program start up. */
3765 if (req
->defobj_out
== NULL
||
3766 ELF_ST_BIND(req
->sym_out
->st_info
) == STB_WEAK
) {
3767 res
= symlook_list(&req1
, &list_main
, donelist
);
3768 if (res
== 0 && (req
->defobj_out
== NULL
||
3769 ELF_ST_BIND(req1
.sym_out
->st_info
) != STB_WEAK
)) {
3770 req
->sym_out
= req1
.sym_out
;
3771 req
->defobj_out
= req1
.defobj_out
;
3772 assert(req
->defobj_out
!= NULL
);
3776 /* Search all DAGs whose roots are RTLD_GLOBAL objects. */
3777 STAILQ_FOREACH(elm
, &list_global
, link
) {
3778 if (req
->defobj_out
!= NULL
&&
3779 ELF_ST_BIND(req
->sym_out
->st_info
) != STB_WEAK
)
3781 res
= symlook_list(&req1
, &elm
->obj
->dagmembers
, donelist
);
3782 if (res
== 0 && (req
->defobj_out
== NULL
||
3783 ELF_ST_BIND(req1
.sym_out
->st_info
) != STB_WEAK
)) {
3784 req
->sym_out
= req1
.sym_out
;
3785 req
->defobj_out
= req1
.defobj_out
;
3786 assert(req
->defobj_out
!= NULL
);
3790 return (req
->sym_out
!= NULL
? 0 : ESRCH
);
3794 * This is a special version of getenv which is far more efficient
3795 * at finding LD_ environment vars.
3799 _getenv_ld(const char *id
)
3803 int idlen
= strlen(id
);
3805 if (ld_index
== LD_ARY_CACHE
)
3807 if (ld_index
== 0) {
3808 for (i
= j
= 0; (envp
= environ
[i
]) != NULL
&& j
< LD_ARY_CACHE
; ++i
) {
3809 if (envp
[0] == 'L' && envp
[1] == 'D' && envp
[2] == '_')
3816 for (i
= ld_index
- 1; i
>= 0; --i
) {
3817 if (strncmp(ld_ary
[i
], id
, idlen
) == 0 && ld_ary
[i
][idlen
] == '=')
3818 return(ld_ary
[i
] + idlen
+ 1);
3824 * Given a symbol name in a referencing object, find the corresponding
3825 * definition of the symbol. Returns a pointer to the symbol, or NULL if
3826 * no definition was found. Returns a pointer to the Obj_Entry of the
3827 * defining object via the reference parameter DEFOBJ_OUT.
3830 symlook_default(SymLook
*req
, const Obj_Entry
*refobj
)
3833 const Objlist_Entry
*elm
;
3837 donelist_init(&donelist
);
3838 symlook_init_from_req(&req1
, req
);
3840 /* Look first in the referencing object if linked symbolically. */
3841 if (refobj
->symbolic
&& !donelist_check(&donelist
, refobj
)) {
3842 res
= symlook_obj(&req1
, refobj
);
3844 req
->sym_out
= req1
.sym_out
;
3845 req
->defobj_out
= req1
.defobj_out
;
3846 assert(req
->defobj_out
!= NULL
);
3850 symlook_global(req
, &donelist
);
3852 /* Search all dlopened DAGs containing the referencing object. */
3853 STAILQ_FOREACH(elm
, &refobj
->dldags
, link
) {
3854 if (req
->sym_out
!= NULL
&&
3855 ELF_ST_BIND(req
->sym_out
->st_info
) != STB_WEAK
)
3857 res
= symlook_list(&req1
, &elm
->obj
->dagmembers
, &donelist
);
3858 if (res
== 0 && (req
->sym_out
== NULL
||
3859 ELF_ST_BIND(req1
.sym_out
->st_info
) != STB_WEAK
)) {
3860 req
->sym_out
= req1
.sym_out
;
3861 req
->defobj_out
= req1
.defobj_out
;
3862 assert(req
->defobj_out
!= NULL
);
3867 * Search the dynamic linker itself, and possibly resolve the
3868 * symbol from there. This is how the application links to
3869 * dynamic linker services such as dlopen.
3871 if (req
->sym_out
== NULL
||
3872 ELF_ST_BIND(req
->sym_out
->st_info
) == STB_WEAK
) {
3873 res
= symlook_obj(&req1
, &obj_rtld
);
3875 req
->sym_out
= req1
.sym_out
;
3876 req
->defobj_out
= req1
.defobj_out
;
3877 assert(req
->defobj_out
!= NULL
);
3881 return (req
->sym_out
!= NULL
? 0 : ESRCH
);
3885 symlook_list(SymLook
*req
, const Objlist
*objlist
, DoneList
*dlp
)
3888 const Obj_Entry
*defobj
;
3889 const Objlist_Entry
*elm
;
3895 STAILQ_FOREACH(elm
, objlist
, link
) {
3896 if (donelist_check(dlp
, elm
->obj
))
3898 symlook_init_from_req(&req1
, req
);
3899 if ((res
= symlook_obj(&req1
, elm
->obj
)) == 0) {
3900 if (def
== NULL
|| ELF_ST_BIND(req1
.sym_out
->st_info
) != STB_WEAK
) {
3902 defobj
= req1
.defobj_out
;
3903 if (ELF_ST_BIND(def
->st_info
) != STB_WEAK
)
3910 req
->defobj_out
= defobj
;
3917 * Search the chain of DAGS cointed to by the given Needed_Entry
3918 * for a symbol of the given name. Each DAG is scanned completely
3919 * before advancing to the next one. Returns a pointer to the symbol,
3920 * or NULL if no definition was found.
3923 symlook_needed(SymLook
*req
, const Needed_Entry
*needed
, DoneList
*dlp
)
3926 const Needed_Entry
*n
;
3927 const Obj_Entry
*defobj
;
3933 symlook_init_from_req(&req1
, req
);
3934 for (n
= needed
; n
!= NULL
; n
= n
->next
) {
3935 if (n
->obj
== NULL
||
3936 (res
= symlook_list(&req1
, &n
->obj
->dagmembers
, dlp
)) != 0)
3938 if (def
== NULL
|| ELF_ST_BIND(req1
.sym_out
->st_info
) != STB_WEAK
) {
3940 defobj
= req1
.defobj_out
;
3941 if (ELF_ST_BIND(def
->st_info
) != STB_WEAK
)
3947 req
->defobj_out
= defobj
;
3954 * Search the symbol table of a single shared object for a symbol of
3955 * the given name and version, if requested. Returns a pointer to the
3956 * symbol, or NULL if no definition was found. If the object is
3957 * filter, return filtered symbol from filtee.
3959 * The symbol's hash value is passed in for efficiency reasons; that
3960 * eliminates many recomputations of the hash value.
3963 symlook_obj(SymLook
*req
, const Obj_Entry
*obj
)
3967 int flags
, res
, mres
;
3970 * If there is at least one valid hash at this point, we prefer to
3971 * use the faster GNU version if available.
3973 if (obj
->valid_hash_gnu
)
3974 mres
= symlook_obj1_gnu(req
, obj
);
3975 else if (obj
->valid_hash_sysv
)
3976 mres
= symlook_obj1_sysv(req
, obj
);
3981 if (obj
->needed_filtees
!= NULL
) {
3982 flags
= (req
->flags
& SYMLOOK_EARLY
) ? RTLD_LO_EARLY
: 0;
3983 load_filtees(__DECONST(Obj_Entry
*, obj
), flags
, req
->lockstate
);
3984 donelist_init(&donelist
);
3985 symlook_init_from_req(&req1
, req
);
3986 res
= symlook_needed(&req1
, obj
->needed_filtees
, &donelist
);
3988 req
->sym_out
= req1
.sym_out
;
3989 req
->defobj_out
= req1
.defobj_out
;
3993 if (obj
->needed_aux_filtees
!= NULL
) {
3994 flags
= (req
->flags
& SYMLOOK_EARLY
) ? RTLD_LO_EARLY
: 0;
3995 load_filtees(__DECONST(Obj_Entry
*, obj
), flags
, req
->lockstate
);
3996 donelist_init(&donelist
);
3997 symlook_init_from_req(&req1
, req
);
3998 res
= symlook_needed(&req1
, obj
->needed_aux_filtees
, &donelist
);
4000 req
->sym_out
= req1
.sym_out
;
4001 req
->defobj_out
= req1
.defobj_out
;
4009 /* Symbol match routine common to both hash functions */
4011 matched_symbol(SymLook
*req
, const Obj_Entry
*obj
, Sym_Match_Result
*result
,
4012 const unsigned long symnum
)
4015 const Elf_Sym
*symp
;
4018 symp
= obj
->symtab
+ symnum
;
4019 strp
= obj
->strtab
+ symp
->st_name
;
4021 switch (ELF_ST_TYPE(symp
->st_info
)) {
4027 if (symp
->st_value
== 0)
4031 if (symp
->st_shndx
!= SHN_UNDEF
)
4033 else if (((req
->flags
& SYMLOOK_IN_PLT
) == 0) &&
4034 (ELF_ST_TYPE(symp
->st_info
) == STT_FUNC
))
4040 if (strcmp(req
->name
, strp
) != 0)
4043 if (req
->ventry
== NULL
) {
4044 if (obj
->versyms
!= NULL
) {
4045 verndx
= VER_NDX(obj
->versyms
[symnum
]);
4046 if (verndx
> obj
->vernum
) {
4048 "%s: symbol %s references wrong version %d",
4049 obj
->path
, obj
->strtab
+ symnum
, verndx
);
4053 * If we are not called from dlsym (i.e. this
4054 * is a normal relocation from unversioned
4055 * binary), accept the symbol immediately if
4056 * it happens to have first version after this
4057 * shared object became versioned. Otherwise,
4058 * if symbol is versioned and not hidden,
4059 * remember it. If it is the only symbol with
4060 * this name exported by the shared object, it
4061 * will be returned as a match by the calling
4062 * function. If symbol is global (verndx < 2)
4063 * accept it unconditionally.
4065 if ((req
->flags
& SYMLOOK_DLSYM
) == 0 &&
4066 verndx
== VER_NDX_GIVEN
) {
4067 result
->sym_out
= symp
;
4070 else if (verndx
>= VER_NDX_GIVEN
) {
4071 if ((obj
->versyms
[symnum
] & VER_NDX_HIDDEN
)
4073 if (result
->vsymp
== NULL
)
4074 result
->vsymp
= symp
;
4080 result
->sym_out
= symp
;
4083 if (obj
->versyms
== NULL
) {
4084 if (object_match_name(obj
, req
->ventry
->name
)) {
4085 _rtld_error("%s: object %s should provide version %s "
4086 "for symbol %s", obj_rtld
.path
, obj
->path
,
4087 req
->ventry
->name
, obj
->strtab
+ symnum
);
4091 verndx
= VER_NDX(obj
->versyms
[symnum
]);
4092 if (verndx
> obj
->vernum
) {
4093 _rtld_error("%s: symbol %s references wrong version %d",
4094 obj
->path
, obj
->strtab
+ symnum
, verndx
);
4097 if (obj
->vertab
[verndx
].hash
!= req
->ventry
->hash
||
4098 strcmp(obj
->vertab
[verndx
].name
, req
->ventry
->name
)) {
4100 * Version does not match. Look if this is a
4101 * global symbol and if it is not hidden. If
4102 * global symbol (verndx < 2) is available,
4103 * use it. Do not return symbol if we are
4104 * called by dlvsym, because dlvsym looks for
4105 * a specific version and default one is not
4106 * what dlvsym wants.
4108 if ((req
->flags
& SYMLOOK_DLSYM
) ||
4109 (verndx
>= VER_NDX_GIVEN
) ||
4110 (obj
->versyms
[symnum
] & VER_NDX_HIDDEN
))
4114 result
->sym_out
= symp
;
4119 * Search for symbol using SysV hash function.
4120 * obj->buckets is known not to be NULL at this point; the test for this was
4121 * performed with the obj->valid_hash_sysv assignment.
4124 symlook_obj1_sysv(SymLook
*req
, const Obj_Entry
*obj
)
4126 unsigned long symnum
;
4127 Sym_Match_Result matchres
;
4129 matchres
.sym_out
= NULL
;
4130 matchres
.vsymp
= NULL
;
4131 matchres
.vcount
= 0;
4133 for (symnum
= obj
->buckets
[req
->hash
% obj
->nbuckets
];
4134 symnum
!= STN_UNDEF
; symnum
= obj
->chains
[symnum
]) {
4135 if (symnum
>= obj
->nchains
)
4136 return (ESRCH
); /* Bad object */
4138 if (matched_symbol(req
, obj
, &matchres
, symnum
)) {
4139 req
->sym_out
= matchres
.sym_out
;
4140 req
->defobj_out
= obj
;
4144 if (matchres
.vcount
== 1) {
4145 req
->sym_out
= matchres
.vsymp
;
4146 req
->defobj_out
= obj
;
4152 /* Search for symbol using GNU hash function */
4154 symlook_obj1_gnu(SymLook
*req
, const Obj_Entry
*obj
)
4156 Elf_Addr bloom_word
;
4157 const Elf32_Word
*hashval
;
4159 Sym_Match_Result matchres
;
4160 unsigned int h1
, h2
;
4161 unsigned long symnum
;
4163 matchres
.sym_out
= NULL
;
4164 matchres
.vsymp
= NULL
;
4165 matchres
.vcount
= 0;
4167 /* Pick right bitmask word from Bloom filter array */
4168 bloom_word
= obj
->bloom_gnu
[(req
->hash_gnu
/ __ELF_WORD_SIZE
) &
4169 obj
->maskwords_bm_gnu
];
4171 /* Calculate modulus word size of gnu hash and its derivative */
4172 h1
= req
->hash_gnu
& (__ELF_WORD_SIZE
- 1);
4173 h2
= ((req
->hash_gnu
>> obj
->shift2_gnu
) & (__ELF_WORD_SIZE
- 1));
4175 /* Filter out the "definitely not in set" queries */
4176 if (((bloom_word
>> h1
) & (bloom_word
>> h2
) & 1) == 0)
4179 /* Locate hash chain and corresponding value element*/
4180 bucket
= obj
->buckets_gnu
[req
->hash_gnu
% obj
->nbuckets_gnu
];
4183 hashval
= &obj
->chain_zero_gnu
[bucket
];
4185 if (((*hashval
^ req
->hash_gnu
) >> 1) == 0) {
4186 symnum
= hashval
- obj
->chain_zero_gnu
;
4187 if (matched_symbol(req
, obj
, &matchres
, symnum
)) {
4188 req
->sym_out
= matchres
.sym_out
;
4189 req
->defobj_out
= obj
;
4193 } while ((*hashval
++ & 1) == 0);
4194 if (matchres
.vcount
== 1) {
4195 req
->sym_out
= matchres
.vsymp
;
4196 req
->defobj_out
= obj
;
4203 trace_loaded_objects(Obj_Entry
*obj
)
4205 const char *fmt1
, *fmt2
, *fmt
, *main_local
, *list_containers
;
4208 if ((main_local
= _getenv_ld("LD_TRACE_LOADED_OBJECTS_PROGNAME")) == NULL
)
4211 if ((fmt1
= _getenv_ld("LD_TRACE_LOADED_OBJECTS_FMT1")) == NULL
)
4212 fmt1
= "\t%o => %p (%x)\n";
4214 if ((fmt2
= _getenv_ld("LD_TRACE_LOADED_OBJECTS_FMT2")) == NULL
)
4215 fmt2
= "\t%o (%x)\n";
4217 list_containers
= _getenv_ld("LD_TRACE_LOADED_OBJECTS_ALL");
4219 for (; obj
; obj
= obj
->next
) {
4220 Needed_Entry
*needed
;
4224 if (list_containers
&& obj
->needed
!= NULL
)
4225 rtld_printf("%s:\n", obj
->path
);
4226 for (needed
= obj
->needed
; needed
; needed
= needed
->next
) {
4227 if (needed
->obj
!= NULL
) {
4228 if (needed
->obj
->traced
&& !list_containers
)
4230 needed
->obj
->traced
= true;
4231 path
= needed
->obj
->path
;
4235 name
= (char *)obj
->strtab
+ needed
->name
;
4236 is_lib
= strncmp(name
, "lib", 3) == 0; /* XXX - bogus */
4238 fmt
= is_lib
? fmt1
: fmt2
;
4239 while ((c
= *fmt
++) != '\0') {
4265 rtld_putstr(main_local
);
4268 rtld_putstr(obj_main
->path
);
4277 rtld_printf("%p", needed
->obj
? needed
->obj
->mapbase
:
4290 * Unload a dlopened object and its dependencies from memory and from
4291 * our data structures. It is assumed that the DAG rooted in the
4292 * object has already been unreferenced, and that the object has a
4293 * reference count of 0.
4296 unload_object(Obj_Entry
*root
)
4301 assert(root
->refcount
== 0);
4304 * Pass over the DAG removing unreferenced objects from
4305 * appropriate lists.
4307 unlink_object(root
);
4309 /* Unmap all objects that are no longer referenced. */
4310 linkp
= &obj_list
->next
;
4311 while ((obj
= *linkp
) != NULL
) {
4312 if (obj
->refcount
== 0) {
4313 LD_UTRACE(UTRACE_UNLOAD_OBJECT
, obj
, obj
->mapbase
, obj
->mapsize
, 0,
4315 dbg("unloading \"%s\"", obj
->path
);
4316 unload_filtees(root
);
4317 munmap(obj
->mapbase
, obj
->mapsize
);
4318 linkmap_delete(obj
);
4329 unlink_object(Obj_Entry
*root
)
4333 if (root
->refcount
== 0) {
4334 /* Remove the object from the RTLD_GLOBAL list. */
4335 objlist_remove(&list_global
, root
);
4337 /* Remove the object from all objects' DAG lists. */
4338 STAILQ_FOREACH(elm
, &root
->dagmembers
, link
) {
4339 objlist_remove(&elm
->obj
->dldags
, root
);
4340 if (elm
->obj
!= root
)
4341 unlink_object(elm
->obj
);
4347 ref_dag(Obj_Entry
*root
)
4351 assert(root
->dag_inited
);
4352 STAILQ_FOREACH(elm
, &root
->dagmembers
, link
)
4353 elm
->obj
->refcount
++;
4357 unref_dag(Obj_Entry
*root
)
4361 assert(root
->dag_inited
);
4362 STAILQ_FOREACH(elm
, &root
->dagmembers
, link
)
4363 elm
->obj
->refcount
--;
4367 * Common code for MD __tls_get_addr().
4370 tls_get_addr_common(Elf_Addr
** dtvp
, int index
, size_t offset
)
4372 Elf_Addr
* dtv
= *dtvp
;
4373 RtldLockState lockstate
;
4375 /* Check dtv generation in case new modules have arrived */
4376 if (dtv
[0] != tls_dtv_generation
) {
4380 wlock_acquire(rtld_bind_lock
, &lockstate
);
4381 newdtv
= xcalloc(tls_max_index
+ 2, sizeof(Elf_Addr
));
4383 if (to_copy
> tls_max_index
)
4384 to_copy
= tls_max_index
;
4385 memcpy(&newdtv
[2], &dtv
[2], to_copy
* sizeof(Elf_Addr
));
4386 newdtv
[0] = tls_dtv_generation
;
4387 newdtv
[1] = tls_max_index
;
4389 lock_release(rtld_bind_lock
, &lockstate
);
4390 dtv
= *dtvp
= newdtv
;
4393 /* Dynamically allocate module TLS if necessary */
4394 if (!dtv
[index
+ 1]) {
4395 /* Signal safe, wlock will block out signals. */
4396 wlock_acquire(rtld_bind_lock
, &lockstate
);
4397 if (!dtv
[index
+ 1])
4398 dtv
[index
+ 1] = (Elf_Addr
)allocate_module_tls(index
);
4399 lock_release(rtld_bind_lock
, &lockstate
);
4401 return ((void *)(dtv
[index
+ 1] + offset
));
4404 #if defined(RTLD_STATIC_TLS_VARIANT_II)
4407 * Allocate the static TLS area. Return a pointer to the TCB. The
4408 * static area is based on negative offsets relative to the tcb.
4410 * The TCB contains an errno pointer for the system call layer, but because
4411 * we are the RTLD we really have no idea how the caller was compiled so
4412 * the information has to be passed in. errno can either be:
4414 * type 0 errno is a simple non-TLS global pointer.
4415 * (special case for e.g. libc_rtld)
4416 * type 1 errno accessed by GOT entry (dynamically linked programs)
4417 * type 2 errno accessed by %gs:OFFSET (statically linked programs)
4420 allocate_tls(Obj_Entry
*objs
)
4425 struct tls_tcb
*tcb
;
4430 * Allocate the new TCB. static TLS storage is placed just before the
4431 * TCB to support the %gs:OFFSET (negative offset) model.
4433 data_size
= (tls_static_space
+ RTLD_STATIC_TLS_ALIGN_MASK
) &
4434 ~RTLD_STATIC_TLS_ALIGN_MASK
;
4435 tcb
= malloc(data_size
+ sizeof(*tcb
));
4436 tcb
= (void *)((char *)tcb
+ data_size
); /* actual tcb location */
4438 dtv_size
= (tls_max_index
+ 2) * sizeof(Elf_Addr
);
4439 dtv
= malloc(dtv_size
);
4440 bzero(dtv
, dtv_size
);
4442 #ifdef RTLD_TCB_HAS_SELF_POINTER
4443 tcb
->tcb_self
= tcb
;
4446 tcb
->tcb_pthread
= NULL
;
4448 dtv
[0] = tls_dtv_generation
;
4449 dtv
[1] = tls_max_index
;
4451 for (obj
= objs
; obj
; obj
= obj
->next
) {
4452 if (obj
->tlsoffset
) {
4453 addr
= (Elf_Addr
)tcb
- obj
->tlsoffset
;
4454 memset((void *)(addr
+ obj
->tlsinitsize
),
4455 0, obj
->tlssize
- obj
->tlsinitsize
);
4457 memcpy((void*) addr
, obj
->tlsinit
, obj
->tlsinitsize
);
4458 dtv
[obj
->tlsindex
+ 1] = addr
;
4465 free_tls(struct tls_tcb
*tcb
)
4469 Elf_Addr tls_start
, tls_end
;
4472 data_size
= (tls_static_space
+ RTLD_STATIC_TLS_ALIGN_MASK
) &
4473 ~RTLD_STATIC_TLS_ALIGN_MASK
;
4477 tls_end
= (Elf_Addr
)tcb
;
4478 tls_start
= (Elf_Addr
)tcb
- data_size
;
4479 for (i
= 0; i
< dtv_size
; i
++) {
4480 if (dtv
[i
+2] != 0 && (dtv
[i
+2] < tls_start
|| dtv
[i
+2] > tls_end
)) {
4481 free((void *)dtv
[i
+2]);
4486 free((void*) tls_start
);
4490 #error "Unsupported TLS layout"
4494 * Allocate TLS block for module with given index.
4497 allocate_module_tls(int index
)
4502 for (obj
= obj_list
; obj
; obj
= obj
->next
) {
4503 if (obj
->tlsindex
== index
)
4507 _rtld_error("Can't find module with TLS index %d", index
);
4511 p
= malloc(obj
->tlssize
);
4513 _rtld_error("Cannot allocate TLS block for index %d", index
);
4516 memcpy(p
, obj
->tlsinit
, obj
->tlsinitsize
);
4517 memset(p
+ obj
->tlsinitsize
, 0, obj
->tlssize
- obj
->tlsinitsize
);
4523 allocate_tls_offset(Obj_Entry
*obj
)
4530 if (obj
->tlssize
== 0) {
4531 obj
->tls_done
= true;
4535 if (obj
->tlsindex
== 1)
4536 off
= calculate_first_tls_offset(obj
->tlssize
, obj
->tlsalign
);
4538 off
= calculate_tls_offset(tls_last_offset
, tls_last_size
,
4539 obj
->tlssize
, obj
->tlsalign
);
4542 * If we have already fixed the size of the static TLS block, we
4543 * must stay within that size. When allocating the static TLS, we
4544 * leave a small amount of space spare to be used for dynamically
4545 * loading modules which use static TLS.
4547 if (tls_static_space
) {
4548 if (calculate_tls_end(off
, obj
->tlssize
) > tls_static_space
)
4552 tls_last_offset
= obj
->tlsoffset
= off
;
4553 tls_last_size
= obj
->tlssize
;
4554 obj
->tls_done
= true;
4560 free_tls_offset(Obj_Entry
*obj
)
4562 #ifdef RTLD_STATIC_TLS_VARIANT_II
4564 * If we were the last thing to allocate out of the static TLS
4565 * block, we give our space back to the 'allocator'. This is a
4566 * simplistic workaround to allow libGL.so.1 to be loaded and
4567 * unloaded multiple times. We only handle the Variant II
4568 * mechanism for now - this really needs a proper allocator.
4570 if (calculate_tls_end(obj
->tlsoffset
, obj
->tlssize
)
4571 == calculate_tls_end(tls_last_offset
, tls_last_size
)) {
4572 tls_last_offset
-= obj
->tlssize
;
4579 _rtld_allocate_tls(void)
4581 struct tls_tcb
*new_tcb
;
4582 RtldLockState lockstate
;
4584 wlock_acquire(rtld_bind_lock
, &lockstate
);
4585 new_tcb
= allocate_tls(obj_list
);
4586 lock_release(rtld_bind_lock
, &lockstate
);
4591 _rtld_free_tls(struct tls_tcb
*tcb
)
4593 RtldLockState lockstate
;
4595 wlock_acquire(rtld_bind_lock
, &lockstate
);
4597 lock_release(rtld_bind_lock
, &lockstate
);
4601 object_add_name(Obj_Entry
*obj
, const char *name
)
4607 entry
= malloc(sizeof(Name_Entry
) + len
);
4609 if (entry
!= NULL
) {
4610 strcpy(entry
->name
, name
);
4611 STAILQ_INSERT_TAIL(&obj
->names
, entry
, link
);
4616 object_match_name(const Obj_Entry
*obj
, const char *name
)
4620 STAILQ_FOREACH(entry
, &obj
->names
, link
) {
4621 if (strcmp(name
, entry
->name
) == 0)
4628 locate_dependency(const Obj_Entry
*obj
, const char *name
)
4630 const Objlist_Entry
*entry
;
4631 const Needed_Entry
*needed
;
4633 STAILQ_FOREACH(entry
, &list_main
, link
) {
4634 if (object_match_name(entry
->obj
, name
))
4638 for (needed
= obj
->needed
; needed
!= NULL
; needed
= needed
->next
) {
4639 if (strcmp(obj
->strtab
+ needed
->name
, name
) == 0 ||
4640 (needed
->obj
!= NULL
&& object_match_name(needed
->obj
, name
))) {
4642 * If there is DT_NEEDED for the name we are looking for,
4643 * we are all set. Note that object might not be found if
4644 * dependency was not loaded yet, so the function can
4645 * return NULL here. This is expected and handled
4646 * properly by the caller.
4648 return (needed
->obj
);
4651 _rtld_error("%s: Unexpected inconsistency: dependency %s not found",
4657 check_object_provided_version(Obj_Entry
*refobj
, const Obj_Entry
*depobj
,
4658 const Elf_Vernaux
*vna
)
4660 const Elf_Verdef
*vd
;
4661 const char *vername
;
4663 vername
= refobj
->strtab
+ vna
->vna_name
;
4664 vd
= depobj
->verdef
;
4666 _rtld_error("%s: version %s required by %s not defined",
4667 depobj
->path
, vername
, refobj
->path
);
4671 if (vd
->vd_version
!= VER_DEF_CURRENT
) {
4672 _rtld_error("%s: Unsupported version %d of Elf_Verdef entry",
4673 depobj
->path
, vd
->vd_version
);
4676 if (vna
->vna_hash
== vd
->vd_hash
) {
4677 const Elf_Verdaux
*aux
= (const Elf_Verdaux
*)
4678 ((char *)vd
+ vd
->vd_aux
);
4679 if (strcmp(vername
, depobj
->strtab
+ aux
->vda_name
) == 0)
4682 if (vd
->vd_next
== 0)
4684 vd
= (const Elf_Verdef
*) ((char *)vd
+ vd
->vd_next
);
4686 if (vna
->vna_flags
& VER_FLG_WEAK
)
4688 _rtld_error("%s: version %s required by %s not found",
4689 depobj
->path
, vername
, refobj
->path
);
4694 rtld_verify_object_versions(Obj_Entry
*obj
)
4696 const Elf_Verneed
*vn
;
4697 const Elf_Verdef
*vd
;
4698 const Elf_Verdaux
*vda
;
4699 const Elf_Vernaux
*vna
;
4700 const Obj_Entry
*depobj
;
4701 int maxvernum
, vernum
;
4703 if (obj
->ver_checked
)
4705 obj
->ver_checked
= true;
4709 * Walk over defined and required version records and figure out
4710 * max index used by any of them. Do very basic sanity checking
4714 while (vn
!= NULL
) {
4715 if (vn
->vn_version
!= VER_NEED_CURRENT
) {
4716 _rtld_error("%s: Unsupported version %d of Elf_Verneed entry",
4717 obj
->path
, vn
->vn_version
);
4720 vna
= (const Elf_Vernaux
*) ((char *)vn
+ vn
->vn_aux
);
4722 vernum
= VER_NEED_IDX(vna
->vna_other
);
4723 if (vernum
> maxvernum
)
4725 if (vna
->vna_next
== 0)
4727 vna
= (const Elf_Vernaux
*) ((char *)vna
+ vna
->vna_next
);
4729 if (vn
->vn_next
== 0)
4731 vn
= (const Elf_Verneed
*) ((char *)vn
+ vn
->vn_next
);
4735 while (vd
!= NULL
) {
4736 if (vd
->vd_version
!= VER_DEF_CURRENT
) {
4737 _rtld_error("%s: Unsupported version %d of Elf_Verdef entry",
4738 obj
->path
, vd
->vd_version
);
4741 vernum
= VER_DEF_IDX(vd
->vd_ndx
);
4742 if (vernum
> maxvernum
)
4744 if (vd
->vd_next
== 0)
4746 vd
= (const Elf_Verdef
*) ((char *)vd
+ vd
->vd_next
);
4753 * Store version information in array indexable by version index.
4754 * Verify that object version requirements are satisfied along the
4757 obj
->vernum
= maxvernum
+ 1;
4758 obj
->vertab
= xcalloc(obj
->vernum
, sizeof(Ver_Entry
));
4761 while (vd
!= NULL
) {
4762 if ((vd
->vd_flags
& VER_FLG_BASE
) == 0) {
4763 vernum
= VER_DEF_IDX(vd
->vd_ndx
);
4764 assert(vernum
<= maxvernum
);
4765 vda
= (const Elf_Verdaux
*)((char *)vd
+ vd
->vd_aux
);
4766 obj
->vertab
[vernum
].hash
= vd
->vd_hash
;
4767 obj
->vertab
[vernum
].name
= obj
->strtab
+ vda
->vda_name
;
4768 obj
->vertab
[vernum
].file
= NULL
;
4769 obj
->vertab
[vernum
].flags
= 0;
4771 if (vd
->vd_next
== 0)
4773 vd
= (const Elf_Verdef
*) ((char *)vd
+ vd
->vd_next
);
4777 while (vn
!= NULL
) {
4778 depobj
= locate_dependency(obj
, obj
->strtab
+ vn
->vn_file
);
4781 vna
= (const Elf_Vernaux
*) ((char *)vn
+ vn
->vn_aux
);
4783 if (check_object_provided_version(obj
, depobj
, vna
))
4785 vernum
= VER_NEED_IDX(vna
->vna_other
);
4786 assert(vernum
<= maxvernum
);
4787 obj
->vertab
[vernum
].hash
= vna
->vna_hash
;
4788 obj
->vertab
[vernum
].name
= obj
->strtab
+ vna
->vna_name
;
4789 obj
->vertab
[vernum
].file
= obj
->strtab
+ vn
->vn_file
;
4790 obj
->vertab
[vernum
].flags
= (vna
->vna_other
& VER_NEED_HIDDEN
) ?
4791 VER_INFO_HIDDEN
: 0;
4792 if (vna
->vna_next
== 0)
4794 vna
= (const Elf_Vernaux
*) ((char *)vna
+ vna
->vna_next
);
4796 if (vn
->vn_next
== 0)
4798 vn
= (const Elf_Verneed
*) ((char *)vn
+ vn
->vn_next
);
4804 rtld_verify_versions(const Objlist
*objlist
)
4806 Objlist_Entry
*entry
;
4810 STAILQ_FOREACH(entry
, objlist
, link
) {
4812 * Skip dummy objects or objects that have their version requirements
4815 if (entry
->obj
->strtab
== NULL
|| entry
->obj
->vertab
!= NULL
)
4817 if (rtld_verify_object_versions(entry
->obj
) == -1) {
4819 if (ld_tracing
== NULL
)
4823 if (rc
== 0 || ld_tracing
!= NULL
)
4824 rc
= rtld_verify_object_versions(&obj_rtld
);
4829 fetch_ventry(const Obj_Entry
*obj
, unsigned long symnum
)
4834 vernum
= VER_NDX(obj
->versyms
[symnum
]);
4835 if (vernum
>= obj
->vernum
) {
4836 _rtld_error("%s: symbol %s has wrong verneed value %d",
4837 obj
->path
, obj
->strtab
+ symnum
, vernum
);
4838 } else if (obj
->vertab
[vernum
].hash
!= 0) {
4839 return &obj
->vertab
[vernum
];
4846 _rtld_get_stack_prot(void)
4849 return (stack_prot
);
4853 map_stacks_exec(RtldLockState
*lockstate
)
4857 * Stack protection must be implemented in the kernel before the dynamic
4858 * linker can handle PT_GNU_STACK sections.
4859 * The following is the FreeBSD implementation of map_stacks_exec()
4860 * void (*thr_map_stacks_exec)(void);
4862 * if ((max_stack_flags & PF_X) == 0 || (stack_prot & PROT_EXEC) != 0)
4864 * thr_map_stacks_exec = (void (*)(void))(uintptr_t)
4865 * get_program_var_addr("__pthread_map_stacks_exec", lockstate);
4866 * if (thr_map_stacks_exec != NULL) {
4867 * stack_prot |= PROT_EXEC;
4868 * thr_map_stacks_exec();
4874 symlook_init(SymLook
*dst
, const char *name
)
4877 bzero(dst
, sizeof(*dst
));
4879 dst
->hash
= elf_hash(name
);
4880 dst
->hash_gnu
= gnu_hash(name
);
4884 symlook_init_from_req(SymLook
*dst
, const SymLook
*src
)
4887 dst
->name
= src
->name
;
4888 dst
->hash
= src
->hash
;
4889 dst
->hash_gnu
= src
->hash_gnu
;
4890 dst
->ventry
= src
->ventry
;
4891 dst
->flags
= src
->flags
;
4892 dst
->defobj_out
= NULL
;
4893 dst
->sym_out
= NULL
;
4894 dst
->lockstate
= src
->lockstate
;
4899 * Parse a file descriptor number without pulling in more of libc (e.g. atoi).
4902 parse_libdir(const char *str
)
4904 static const int RADIX
= 10; /* XXXJA: possibly support hex? */
4911 for (c
= *str
; c
!= '\0'; c
= *++str
) {
4912 if (c
< '0' || c
> '9')
4919 /* Make sure we actually parsed something. */
4921 _rtld_error("failed to parse directory FD from '%s'", str
);
4927 #ifdef ENABLE_OSRELDATE
4929 * Overrides for libc_pic-provided functions.
4933 __getosreldate(void)
4943 oid
[1] = KERN_OSRELDATE
;
4945 len
= sizeof(osrel
);
4946 error
= sysctl(oid
, 2, &osrel
, &len
, NULL
, 0);
4947 if (error
== 0 && osrel
> 0 && len
== sizeof(osrel
))
4954 * No unresolved symbols for rtld.
4957 __pthread_cxa_finalize(struct dl_phdr_info
*a
)
4962 rtld_strerror(int errnum
)
4965 if (errnum
< 0 || errnum
>= sys_nerr
)
4966 return ("Unknown error");
4967 return (sys_errlist
[errnum
]);