7 * ELF run-time linker, ported from FreeBSD by KJK::Hyperion as part of the ELF
8 * support initiative. Original copyright, licensing and disclaimers follow
12 * Copyright 1996, 1997, 1998, 1999, 2000 John D. Polstra.
13 * Copyright 2003 Alexander Kabaev <kan@FreeBSD.ORG>.
14 * All rights reserved.
16 * Redistribution and use in source and binary forms, with or without
17 * modification, are permitted provided that the following conditions
19 * 1. Redistributions of source code must retain the above copyright
20 * notice, this list of conditions and the following disclaimer.
21 * 2. Redistributions in binary form must reproduce the above copyright
22 * notice, this list of conditions and the following disclaimer in the
23 * documentation and/or other materials provided with the distribution.
25 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
26 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
27 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
28 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
29 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
30 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
34 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 * $FreeBSD: src/libexec/rtld-elf/rtld.c,v 1.101 2004/11/02 09:42:21 ssouhlal Exp $
40 * Dynamic linker for ELF.
42 * John Polstra <jdp@polstra.com>.
48 #error "GCC is needed to compile this file"
51 #include <sys/param.h>
71 #define PATH_RTLD "/libexec/ld-elf.so.1"
73 #define PATH_RTLD "/libexec/ld-elf32.so.1"
77 typedef void (*func_ptr_type
)();
78 typedef void * (*path_enum_proc
) (const char *path
, size_t len
, void *arg
);
81 * This structure provides a reentrant way to keep a list of objects and
82 * check which ones have already been processed in some way.
84 typedef struct Struct_DoneList
{
85 const Obj_Entry
**objs
; /* Array of object pointers */
86 unsigned int num_alloc
; /* Allocated size of the array */
87 unsigned int num_used
; /* Number of array slots used */
91 * Function declarations.
93 static const char *basename(const char *);
94 static void die(void);
95 static void digest_dynamic(Obj_Entry
*, int);
96 static Obj_Entry
*digest_phdr(const Elf_Phdr
*, int, caddr_t
, const char *);
97 static Obj_Entry
*dlcheck(void *);
98 static int do_search_info(const Obj_Entry
*obj
, int, struct dl_serinfo
*);
99 static bool donelist_check(DoneList
*, const Obj_Entry
*);
100 static void errmsg_restore(char *);
101 static char *errmsg_save(void);
102 static void *fill_search_info(const char *, size_t, void *);
103 static char *find_library(const char *, const Obj_Entry
*);
104 static const char *gethints(void);
105 static void init_dag(Obj_Entry
*);
106 static void init_dag1(Obj_Entry
*root
, Obj_Entry
*obj
, DoneList
*);
107 static void init_rtld(caddr_t
);
108 static void initlist_add_neededs(Needed_Entry
*needed
, Objlist
*list
);
109 static void initlist_add_objects(Obj_Entry
*obj
, Obj_Entry
**tail
,
111 static bool is_exported(const Elf_Sym
*);
112 static void linkmap_add(Obj_Entry
*);
113 static void linkmap_delete(Obj_Entry
*);
114 static int load_needed_objects(Obj_Entry
*);
115 static int load_preload_objects(void);
116 static Obj_Entry
*load_object(char *);
117 static Obj_Entry
*obj_from_addr(const void *);
118 static void objlist_call_fini(Objlist
*);
119 static void objlist_call_init(Objlist
*);
120 static void objlist_clear(Objlist
*);
121 static Objlist_Entry
*objlist_find(Objlist
*, const Obj_Entry
*);
122 static void objlist_init(Objlist
*);
123 static void objlist_push_head(Objlist
*, Obj_Entry
*);
124 static void objlist_push_tail(Objlist
*, Obj_Entry
*);
125 static void objlist_remove(Objlist
*, Obj_Entry
*);
126 static void objlist_remove_unref(Objlist
*);
127 static void *path_enumerate(const char *, path_enum_proc
, void *);
128 static int relocate_objects(Obj_Entry
*, bool, Obj_Entry
*);
129 static int rtld_dirname(const char *, char *);
130 static void rtld_exit(void);
131 static char *search_library_path(const char *, const char *);
132 static const void **get_program_var_addr(const char *name
);
133 static void set_program_var(const char *, const void *);
134 static const Elf_Sym
*symlook_default(const char *, unsigned long hash
,
135 const Obj_Entry
*refobj
, const Obj_Entry
**defobj_out
, bool in_plt
);
136 static const Elf_Sym
*symlook_list(const char *, unsigned long,
137 Objlist
*, const Obj_Entry
**, bool in_plt
, DoneList
*);
138 static void trace_loaded_objects(Obj_Entry
*obj
);
139 static void unlink_object(Obj_Entry
*);
140 static void unload_object(Obj_Entry
*);
141 static void unref_dag(Obj_Entry
*);
142 static void ref_dag(Obj_Entry
*);
144 void r_debug_state(struct r_debug
*, struct link_map
*);
149 static char *error_message
; /* Message for dlerror(), or NULL */
150 struct r_debug r_debug
; /* for GDB; */
151 static bool libmap_disable
; /* Disable libmap */
152 static bool trust
; /* False for setuid and setgid programs */
153 static char *ld_bind_now
; /* Environment variable for immediate binding */
154 static char *ld_debug
; /* Environment variable for debugging */
155 static char *ld_library_path
; /* Environment variable for search path */
156 static char *ld_preload
; /* Environment variable for libraries to
158 static char *ld_tracing
; /* Called from ldd to print libs */
159 static Obj_Entry
*obj_list
; /* Head of linked list of shared objects */
160 static Obj_Entry
**obj_tail
; /* Link field of last object in list */
161 static Obj_Entry
*obj_main
; /* The main program shared object */
162 static Obj_Entry obj_rtld
; /* The dynamic linker shared object */
163 static unsigned int obj_count
; /* Number of objects in obj_list */
165 static Objlist list_global
= /* Objects dlopened with RTLD_GLOBAL */
166 STAILQ_HEAD_INITIALIZER(list_global
);
167 static Objlist list_main
= /* Objects loaded at program startup */
168 STAILQ_HEAD_INITIALIZER(list_main
);
169 static Objlist list_fini
= /* Objects needing fini() calls */
170 STAILQ_HEAD_INITIALIZER(list_fini
);
172 static Elf_Sym sym_zero
; /* For resolving undefined weak refs. */
174 #define GDB_STATE(s,m) r_debug.r_state = s; r_debug_state(&r_debug,m);
176 extern Elf_Dyn _DYNAMIC
;
177 #pragma weak _DYNAMIC
178 #ifndef RTLD_IS_DYNAMIC
179 #define RTLD_IS_DYNAMIC() (&_DYNAMIC != NULL)
183 * These are the functions the dynamic linker exports to application
184 * programs. They are the only symbols the dynamic linker is willing
185 * to export from itself.
187 static func_ptr_type exports
[] = {
188 (func_ptr_type
) &_rtld_error
,
189 (func_ptr_type
) &dlclose
,
190 (func_ptr_type
) &dlerror
,
191 (func_ptr_type
) &dlopen
,
192 (func_ptr_type
) &dlsym
,
193 (func_ptr_type
) &dladdr
,
194 (func_ptr_type
) &dllockinit
,
195 (func_ptr_type
) &dlinfo
,
196 (func_ptr_type
) &_rtld_thread_init
,
198 (func_ptr_type
) &___tls_get_addr
,
200 (func_ptr_type
) &__tls_get_addr
,
201 (func_ptr_type
) &_rtld_allocate_tls
,
202 (func_ptr_type
) &_rtld_free_tls
,
207 * Global declarations normally provided by crt1. The dynamic linker is
208 * not built with crt1, so we have to provide them ourselves.
214 * Globals to control TLS allocation.
216 size_t tls_last_offset
; /* Static TLS offset of last module */
217 size_t tls_last_size
; /* Static TLS size of last module */
218 size_t tls_static_space
; /* Static TLS space allocated */
219 int tls_dtv_generation
= 1; /* Used to detect when dtv size changes */
220 int tls_max_index
= 1; /* Largest module index allocated */
223 * Fill in a DoneList with an allocation large enough to hold all of
224 * the currently-loaded objects. Keep this as a macro since it calls
225 * alloca and we want that to occur within the scope of the caller.
227 #define donelist_init(dlp) \
228 ((dlp)->objs = alloca(obj_count * sizeof (dlp)->objs[0]), \
229 assert((dlp)->objs != NULL), \
230 (dlp)->num_alloc = obj_count, \
234 * Main entry point for dynamic linking. The first argument is the
235 * stack pointer. The stack is expected to be laid out as described
236 * in the SVR4 ABI specification, Intel 386 Processor Supplement.
237 * Specifically, the stack pointer points to a word containing
238 * ARGC. Following that in the stack is a null-terminated sequence
239 * of pointers to argument strings. Then comes a null-terminated
240 * sequence of pointers to environment strings. Finally, there is a
241 * sequence of "auxiliary vector" entries.
243 * The second argument points to a place to store the dynamic linker's
244 * exit procedure pointer and the third to a place to store the main
247 * The return value is the main program's entry point.
250 _rtld(Elf_Addr
*sp
, func_ptr_type
*exit_proc
, Obj_Entry
**objp
)
252 Elf_Auxinfo
*aux_info
[AT_COUNT
];
260 Objlist_Entry
*entry
;
262 Obj_Entry
**preload_tail
;
267 * On entry, the dynamic linker itself has not been relocated yet.
268 * Be very careful not to reference any global data until after
269 * init_rtld has returned. It is OK to reference file-scope statics
270 * and string constants, and to call static and global functions.
273 /* Find the auxiliary vector on the stack. */
276 sp
+= argc
+ 1; /* Skip over arguments and NULL terminator */
278 while (*sp
++ != 0) /* Skip over environment, and NULL terminator */
280 aux
= (Elf_Auxinfo
*) sp
;
282 /* Digest the auxiliary vector. */
283 for (i
= 0; i
< AT_COUNT
; i
++)
285 for (auxp
= aux
; auxp
->a_type
!= AT_NULL
; auxp
++) {
286 if (auxp
->a_type
< AT_COUNT
)
287 aux_info
[auxp
->a_type
] = auxp
;
290 /* Initialize and relocate ourselves. */
291 assert(aux_info
[AT_BASE
] != NULL
);
292 init_rtld((caddr_t
) aux_info
[AT_BASE
]->a_un
.a_ptr
);
294 __progname
= obj_rtld
.path
;
295 argv0
= argv
[0] != NULL
? argv
[0] : "(null)";
298 trust
= !issetugid();
300 ld_bind_now
= getenv(LD_
"BIND_NOW");
302 ld_debug
= getenv(LD_
"DEBUG");
303 libmap_disable
= getenv(LD_
"LIBMAP_DISABLE") != NULL
;
304 ld_library_path
= getenv(LD_
"LIBRARY_PATH");
305 ld_preload
= getenv(LD_
"PRELOAD");
307 ld_tracing
= getenv(LD_
"TRACE_LOADED_OBJECTS");
309 if (ld_debug
!= NULL
&& *ld_debug
!= '\0')
311 dbg("%s is initialized, base address = %p", __progname
,
312 (caddr_t
) aux_info
[AT_BASE
]->a_un
.a_ptr
);
313 dbg("RTLD dynamic = %p", obj_rtld
.dynamic
);
314 dbg("RTLD pltgot = %p", obj_rtld
.pltgot
);
317 * Load the main program, or process its program header if it is
320 if (aux_info
[AT_EXECFD
] != NULL
) { /* Load the main program. */
321 int fd
= aux_info
[AT_EXECFD
]->a_un
.a_val
;
322 dbg("loading main program");
323 obj_main
= map_object(fd
, argv0
, NULL
);
325 if (obj_main
== NULL
)
327 } else { /* Main program already loaded. */
328 const Elf_Phdr
*phdr
;
332 dbg("processing main program's program header");
333 assert(aux_info
[AT_PHDR
] != NULL
);
334 phdr
= (const Elf_Phdr
*) aux_info
[AT_PHDR
]->a_un
.a_ptr
;
335 assert(aux_info
[AT_PHNUM
] != NULL
);
336 phnum
= aux_info
[AT_PHNUM
]->a_un
.a_val
;
337 assert(aux_info
[AT_PHENT
] != NULL
);
338 assert(aux_info
[AT_PHENT
]->a_un
.a_val
== sizeof(Elf_Phdr
));
339 assert(aux_info
[AT_ENTRY
] != NULL
);
340 entry
= (caddr_t
) aux_info
[AT_ENTRY
]->a_un
.a_ptr
;
341 if ((obj_main
= digest_phdr(phdr
, phnum
, entry
, argv0
)) == NULL
)
345 obj_main
->path
= xstrdup(argv0
);
346 obj_main
->mainprog
= true;
349 * Get the actual dynamic linker pathname from the executable if
350 * possible. (It should always be possible.) That ensures that
351 * gdb will find the right dynamic linker even if a non-standard
354 if (obj_main
->interp
!= NULL
&&
355 strcmp(obj_main
->interp
, obj_rtld
.path
) != 0) {
357 obj_rtld
.path
= xstrdup(obj_main
->interp
);
358 __progname
= obj_rtld
.path
;
361 digest_dynamic(obj_main
, 0);
363 linkmap_add(obj_main
);
364 linkmap_add(&obj_rtld
);
366 /* Link the main program into the list of objects. */
367 *obj_tail
= obj_main
;
368 obj_tail
= &obj_main
->next
;
370 /* Make sure we don't call the main program's init and fini functions. */
371 obj_main
->init
= obj_main
->fini
= (Elf_Addr
)NULL
;
373 /* Initialize a fake symbol for resolving undefined weak references. */
374 sym_zero
.st_info
= ELF_ST_INFO(STB_GLOBAL
, STT_NOTYPE
);
375 sym_zero
.st_shndx
= SHN_UNDEF
;
378 libmap_disable
= (bool)lm_init();
380 dbg("loading LD_PRELOAD libraries");
381 if (load_preload_objects() == -1)
383 preload_tail
= obj_tail
;
385 dbg("loading needed objects");
386 if (load_needed_objects(obj_main
) == -1)
389 /* Make a list of all objects loaded at startup. */
390 for (obj
= obj_list
; obj
!= NULL
; obj
= obj
->next
) {
391 objlist_push_tail(&list_main
, obj
);
395 if (ld_tracing
) { /* We're done */
396 trace_loaded_objects(obj_main
);
400 if (getenv(LD_
"DUMP_REL_PRE") != NULL
) {
401 dump_relocations(obj_main
);
405 /* setup TLS for main thread */
406 dbg("initializing initial thread local storage");
407 STAILQ_FOREACH(entry
, &list_main
, link
) {
409 * Allocate all the initial objects out of the static TLS
410 * block even if they didn't ask for it.
412 allocate_tls_offset(entry
->obj
);
414 allocate_initial_tls(obj_list
);
416 if (relocate_objects(obj_main
,
417 ld_bind_now
!= NULL
&& *ld_bind_now
!= '\0', &obj_rtld
) == -1)
420 dbg("doing copy relocations");
421 if (do_copy_relocations(obj_main
) == -1)
424 if (getenv(LD_
"DUMP_REL_POST") != NULL
) {
425 dump_relocations(obj_main
);
429 dbg("initializing key program variables");
430 set_program_var("__progname", argv
[0] != NULL
? basename(argv
[0]) : "");
431 set_program_var("environ", env
);
433 dbg("initializing thread locks");
436 /* Make a list of init functions to call. */
437 objlist_init(&initlist
);
438 initlist_add_objects(obj_list
, preload_tail
, &initlist
);
440 r_debug_state(NULL
, &obj_main
->linkmap
); /* say hello to gdb! */
442 objlist_call_init(&initlist
);
443 lockstate
= wlock_acquire(rtld_bind_lock
);
444 objlist_clear(&initlist
);
445 wlock_release(rtld_bind_lock
, lockstate
);
447 dbg("transferring control to program entry point = %p", obj_main
->entry
);
449 /* Return the exit procedure and the program entry point. */
450 *exit_proc
= rtld_exit
;
452 return (func_ptr_type
) obj_main
->entry
;
458 _rtld_bind(Obj_Entry
*obj
, Elf_Word reloff
)
462 const Obj_Entry
*defobj
;
467 lockstate
= rlock_acquire(rtld_bind_lock
);
469 rel
= (const Elf_Rel
*) ((caddr_t
) obj
->pltrel
+ reloff
);
471 rel
= (const Elf_Rel
*) ((caddr_t
) obj
->pltrela
+ reloff
);
473 where
= (Elf_Addr
*) (obj
->relocbase
+ rel
->r_offset
);
474 def
= find_symdef(ELF_R_SYM(rel
->r_info
), obj
, &defobj
, true, NULL
);
478 target
= (Elf_Addr
)(defobj
->relocbase
+ def
->st_value
);
480 dbg("\"%s\" in \"%s\" ==> %p in \"%s\"",
481 defobj
->strtab
+ def
->st_name
, basename(obj
->path
),
482 (void *)target
, basename(defobj
->path
));
485 * Write the new contents for the jmpslot. Note that depending on
486 * architecture, the value which we need to return back to the
487 * lazy binding trampoline may or may not be the target
488 * address. The value returned from reloc_jmpslot() is the value
489 * that the trampoline needs.
491 target
= reloc_jmpslot(where
, target
, defobj
, obj
, rel
);
492 rlock_release(rtld_bind_lock
, lockstate
);
499 * Error reporting function. Use it like printf. If formats the message
500 * into a buffer, and sets things up so that the next call to dlerror()
501 * will return the message.
504 _rtld_error(const char *fmt
, ...)
506 static char buf
[512];
510 vsnprintf(buf
, sizeof buf
, fmt
, ap
);
516 * Return a dynamically-allocated copy of the current error message, if any.
521 return error_message
== NULL
? NULL
: xstrdup(error_message
);
525 * Restore the current error message from a copy which was previously saved
526 * by errmsg_save(). The copy is freed.
529 errmsg_restore(char *saved_msg
)
531 if (saved_msg
== NULL
)
532 error_message
= NULL
;
534 _rtld_error("%s", saved_msg
);
540 basename(const char *name
)
542 const char *p
= strrchr(name
, '/');
543 return p
!= NULL
? p
+ 1 : name
;
549 const char *msg
= dlerror();
559 * Process a shared object's DYNAMIC section, and save the important
560 * information in its Obj_Entry structure.
563 digest_dynamic(Obj_Entry
*obj
, int early
)
566 Needed_Entry
**needed_tail
= &obj
->needed
;
567 const Elf_Dyn
*dyn_rpath
= NULL
;
568 int plttype
= DT_REL
;
570 obj
->bind_now
= false;
571 for (dynp
= obj
->dynamic
; dynp
->d_tag
!= DT_NULL
; dynp
++) {
572 switch (dynp
->d_tag
) {
575 obj
->rel
= (const Elf_Rel
*) (obj
->relocbase
+ dynp
->d_un
.d_ptr
);
579 obj
->relsize
= dynp
->d_un
.d_val
;
583 assert(dynp
->d_un
.d_val
== sizeof(Elf_Rel
));
587 obj
->pltrel
= (const Elf_Rel
*)
588 (obj
->relocbase
+ dynp
->d_un
.d_ptr
);
592 obj
->pltrelsize
= dynp
->d_un
.d_val
;
596 obj
->rela
= (const Elf_Rela
*) (obj
->relocbase
+ dynp
->d_un
.d_ptr
);
600 obj
->relasize
= dynp
->d_un
.d_val
;
604 assert(dynp
->d_un
.d_val
== sizeof(Elf_Rela
));
608 plttype
= dynp
->d_un
.d_val
;
609 assert(dynp
->d_un
.d_val
== DT_REL
|| plttype
== DT_RELA
);
613 obj
->symtab
= (const Elf_Sym
*)
614 (obj
->relocbase
+ dynp
->d_un
.d_ptr
);
618 assert(dynp
->d_un
.d_val
== sizeof(Elf_Sym
));
622 obj
->strtab
= (const char *) (obj
->relocbase
+ dynp
->d_un
.d_ptr
);
626 obj
->strsize
= dynp
->d_un
.d_val
;
631 const Elf_Hashelt
*hashtab
= (const Elf_Hashelt
*)
632 (obj
->relocbase
+ dynp
->d_un
.d_ptr
);
633 obj
->nbuckets
= hashtab
[0];
634 obj
->nchains
= hashtab
[1];
635 obj
->buckets
= hashtab
+ 2;
636 obj
->chains
= obj
->buckets
+ obj
->nbuckets
;
642 Needed_Entry
*nep
= NEW(Needed_Entry
);
643 nep
->name
= dynp
->d_un
.d_val
;
648 needed_tail
= &nep
->next
;
653 obj
->pltgot
= (Elf_Addr
*) (obj
->relocbase
+ dynp
->d_un
.d_ptr
);
661 obj
->symbolic
= true;
665 case DT_RUNPATH
: /* XXX: process separately */
667 * We have to wait until later to process this, because we
668 * might not have gotten the address of the string table yet.
674 /* Not used by the dynamic linker. */
678 obj
->init
= (Elf_Addr
) (obj
->relocbase
+ dynp
->d_un
.d_ptr
);
682 obj
->fini
= (Elf_Addr
) (obj
->relocbase
+ dynp
->d_un
.d_ptr
);
686 /* XXX - not implemented yet */
688 dbg("Filling in DT_DEBUG entry");
689 ((Elf_Dyn
*)dynp
)->d_un
.d_ptr
= (Elf_Addr
) &r_debug
;
693 if (dynp
->d_un
.d_val
& DF_ORIGIN
) {
694 obj
->origin_path
= xmalloc(PATH_MAX
);
695 if (rtld_dirname(obj
->path
, obj
->origin_path
) == -1)
698 if (dynp
->d_un
.d_val
& DF_SYMBOLIC
)
699 obj
->symbolic
= true;
700 if (dynp
->d_un
.d_val
& DF_TEXTREL
)
702 if (dynp
->d_un
.d_val
& DF_BIND_NOW
)
703 obj
->bind_now
= true;
704 if (dynp
->d_un
.d_val
& DF_STATIC_TLS
)
710 dbg("Ignoring d_tag %ld = %#lx", (long)dynp
->d_tag
,
719 if (plttype
== DT_RELA
) {
720 obj
->pltrela
= (const Elf_Rela
*) obj
->pltrel
;
722 obj
->pltrelasize
= obj
->pltrelsize
;
726 if (dyn_rpath
!= NULL
)
727 obj
->rpath
= obj
->strtab
+ dyn_rpath
->d_un
.d_val
;
731 * Process a shared object's program header. This is used only for the
732 * main program, when the kernel has already loaded the main program
733 * into memory before calling the dynamic linker. It creates and
734 * returns an Obj_Entry structure.
737 digest_phdr(const Elf_Phdr
*phdr
, int phnum
, caddr_t entry
, const char *path
)
740 const Elf_Phdr
*phlimit
= phdr
+ phnum
;
745 for (ph
= phdr
; ph
< phlimit
; ph
++) {
746 switch (ph
->p_type
) {
749 if ((const Elf_Phdr
*)ph
->p_vaddr
!= phdr
) {
750 _rtld_error("%s: invalid PT_PHDR", path
);
753 obj
->phdr
= (const Elf_Phdr
*) ph
->p_vaddr
;
754 obj
->phsize
= ph
->p_memsz
;
758 obj
->interp
= (const char *) ph
->p_vaddr
;
762 if (nsegs
== 0) { /* First load segment */
763 obj
->vaddrbase
= trunc_page(ph
->p_vaddr
);
764 obj
->mapbase
= (caddr_t
) obj
->vaddrbase
;
765 obj
->relocbase
= obj
->mapbase
- obj
->vaddrbase
;
766 obj
->textsize
= round_page(ph
->p_vaddr
+ ph
->p_memsz
) -
768 } else { /* Last load segment */
769 obj
->mapsize
= round_page(ph
->p_vaddr
+ ph
->p_memsz
) -
776 obj
->dynamic
= (const Elf_Dyn
*) ph
->p_vaddr
;
781 obj
->tlssize
= ph
->p_memsz
;
782 obj
->tlsalign
= ph
->p_align
;
783 obj
->tlsinitsize
= ph
->p_filesz
;
784 obj
->tlsinit
= (void*) ph
->p_vaddr
;
789 _rtld_error("%s: too few PT_LOAD segments", path
);
800 dlcheck(void *handle
)
804 for (obj
= obj_list
; obj
!= NULL
; obj
= obj
->next
)
805 if (obj
== (Obj_Entry
*) handle
)
808 if (obj
== NULL
|| obj
->refcount
== 0 || obj
->dl_refcount
== 0) {
809 _rtld_error("Invalid shared object handle %p", handle
);
816 * If the given object is already in the donelist, return true. Otherwise
817 * add the object to the list and return false.
820 donelist_check(DoneList
*dlp
, const Obj_Entry
*obj
)
824 for (i
= 0; i
< dlp
->num_used
; i
++)
825 if (dlp
->objs
[i
] == obj
)
828 * Our donelist allocation should always be sufficient. But if
829 * our threads locking isn't working properly, more shared objects
830 * could have been loaded since we allocated the list. That should
831 * never happen, but we'll handle it properly just in case it does.
833 if (dlp
->num_used
< dlp
->num_alloc
)
834 dlp
->objs
[dlp
->num_used
++] = obj
;
841 * Hash function for symbol table lookup. Don't even think about changing
842 * this. It is specified by the System V ABI.
845 elf_hash(const char *name
)
847 const unsigned char *p
= (const unsigned char *) name
;
853 if ((g
= h
& 0xf0000000) != 0)
863 * Find the library with the given name, and return its full pathname.
864 * The returned string is dynamically allocated. Generates an error
865 * message and returns NULL if the library cannot be found.
867 * If the second argument is non-NULL, then it refers to an already-
868 * loaded shared object, whose library search path will be searched.
870 * The search order is:
872 * rpath in the referencing file
877 find_library(const char *xname
, const Obj_Entry
*refobj
)
882 if (strchr(xname
, '/') != NULL
) { /* Hard coded pathname */
883 if (xname
[0] != '/' && !trust
) {
884 _rtld_error("Absolute pathname required for shared object \"%s\"",
888 return xstrdup(xname
);
891 if (libmap_disable
|| (refobj
== NULL
) ||
892 (name
= lm_find(refobj
->path
, xname
)) == NULL
)
893 name
= (char *)xname
;
895 dbg(" Searching for \"%s\"", name
);
897 if ((pathname
= search_library_path(name
, ld_library_path
)) != NULL
||
899 (pathname
= search_library_path(name
, refobj
->rpath
)) != NULL
) ||
900 (pathname
= search_library_path(name
, gethints())) != NULL
||
901 (pathname
= search_library_path(name
, STANDARD_LIBRARY_PATH
)) != NULL
)
904 if(refobj
!= NULL
&& refobj
->path
!= NULL
) {
905 _rtld_error("Shared object \"%s\" not found, required by \"%s\"",
906 name
, basename(refobj
->path
));
908 _rtld_error("Shared object \"%s\" not found", name
);
916 * Given a symbol number in a referencing object, find the corresponding
917 * definition of the symbol. Returns a pointer to the symbol, or NULL if
918 * no definition was found. Returns a pointer to the Obj_Entry of the
919 * defining object via the reference parameter DEFOBJ_OUT.
922 find_symdef(unsigned long symnum
, const Obj_Entry
*refobj
,
923 const Obj_Entry
**defobj_out
, bool in_plt
, SymCache
*cache
)
927 const Obj_Entry
*defobj
;
932 * If we have already found this symbol, get the information from
935 if (symnum
>= refobj
->nchains
)
936 return NULL
; /* Bad object */
937 if (cache
!= NULL
&& cache
[symnum
].sym
!= NULL
) {
938 *defobj_out
= cache
[symnum
].obj
;
939 return cache
[symnum
].sym
;
942 ref
= refobj
->symtab
+ symnum
;
943 name
= refobj
->strtab
+ ref
->st_name
;
947 * We don't have to do a full scale lookup if the symbol is local.
948 * We know it will bind to the instance in this load module; to
949 * which we already have a pointer (ie ref). By not doing a lookup,
950 * we not only improve performance, but it also avoids unresolvable
951 * symbols when local symbols are not in the hash table. This has
952 * been seen with the ia64 toolchain.
954 if (ELF_ST_BIND(ref
->st_info
) != STB_LOCAL
) {
955 if (ELF_ST_TYPE(ref
->st_info
) == STT_SECTION
) {
956 _rtld_error("%s: Bogus symbol table entry %lu", refobj
->path
,
959 hash
= elf_hash(name
);
960 def
= symlook_default(name
, hash
, refobj
, &defobj
, in_plt
);
967 * If we found no definition and the reference is weak, treat the
968 * symbol as having the value zero.
970 if (def
== NULL
&& ELF_ST_BIND(ref
->st_info
) == STB_WEAK
) {
976 *defobj_out
= defobj
;
977 /* Record the information in the cache to avoid subsequent lookups. */
979 cache
[symnum
].sym
= def
;
980 cache
[symnum
].obj
= defobj
;
983 if (refobj
!= &obj_rtld
)
984 _rtld_error("%s: Undefined symbol \"%s\"", refobj
->path
, name
);
992 * Return the search path from the ldconfig hints file, reading it if
993 * necessary. Returns NULL if there are problems with the hints file,
994 * or if the search path there is empty.
1001 if (hints
== NULL
) {
1003 struct elfhints_hdr hdr
;
1006 /* Keep from trying again in case the hints file is bad. */
1009 if ((fd
= open(_PATH_ELF_HINTS
, O_RDONLY
)) == -1)
1011 if (read(fd
, &hdr
, sizeof hdr
) != sizeof hdr
||
1012 hdr
.magic
!= ELFHINTS_MAGIC
||
1017 p
= xmalloc(hdr
.dirlistlen
+ 1);
1018 if (lseek(fd
, hdr
.strtab
+ hdr
.dirlist
, SEEK_SET
) == -1 ||
1019 read(fd
, p
, hdr
.dirlistlen
+ 1) != (ssize_t
)hdr
.dirlistlen
+ 1) {
1027 return hints
[0] != '\0' ? hints
: NULL
;
1031 init_dag(Obj_Entry
*root
)
1035 donelist_init(&donelist
);
1036 init_dag1(root
, root
, &donelist
);
1040 init_dag1(Obj_Entry
*root
, Obj_Entry
*obj
, DoneList
*dlp
)
1042 const Needed_Entry
*needed
;
1044 if (donelist_check(dlp
, obj
))
1048 objlist_push_tail(&obj
->dldags
, root
);
1049 objlist_push_tail(&root
->dagmembers
, obj
);
1050 for (needed
= obj
->needed
; needed
!= NULL
; needed
= needed
->next
)
1051 if (needed
->obj
!= NULL
)
1052 init_dag1(root
, needed
->obj
, dlp
);
1056 * Initialize the dynamic linker. The argument is the address at which
1057 * the dynamic linker has been mapped into memory. The primary task of
1058 * this function is to relocate the dynamic linker.
1061 init_rtld(caddr_t mapbase
)
1063 Obj_Entry objtmp
; /* Temporary rtld object */
1066 * Conjure up an Obj_Entry structure for the dynamic linker.
1068 * The "path" member can't be initialized yet because string constatns
1069 * cannot yet be acessed. Below we will set it correctly.
1071 memset(&objtmp
, 0, sizeof(objtmp
));
1074 objtmp
.mapbase
= mapbase
;
1076 objtmp
.relocbase
= mapbase
;
1078 if (RTLD_IS_DYNAMIC()) {
1079 objtmp
.dynamic
= rtld_dynamic(&objtmp
);
1080 digest_dynamic(&objtmp
, 1);
1081 assert(objtmp
.needed
== NULL
);
1082 assert(!objtmp
.textrel
);
1085 * Temporarily put the dynamic linker entry into the object list, so
1086 * that symbols can be found.
1089 relocate_objects(&objtmp
, true, &objtmp
);
1092 /* Initialize the object list. */
1093 obj_tail
= &obj_list
;
1095 /* Now that non-local variables can be accesses, copy out obj_rtld. */
1096 memcpy(&obj_rtld
, &objtmp
, sizeof(obj_rtld
));
1098 /* Replace the path with a dynamically allocated copy. */
1099 obj_rtld
.path
= xstrdup(PATH_RTLD
);
1101 r_debug
.r_brk
= r_debug_state
;
1102 r_debug
.r_state
= RT_CONSISTENT
;
1106 * Add the init functions from a needed object list (and its recursive
1107 * needed objects) to "list". This is not used directly; it is a helper
1108 * function for initlist_add_objects(). The write lock must be held
1109 * when this function is called.
1112 initlist_add_neededs(Needed_Entry
*needed
, Objlist
*list
)
1114 /* Recursively process the successor needed objects. */
1115 if (needed
->next
!= NULL
)
1116 initlist_add_neededs(needed
->next
, list
);
1118 /* Process the current needed object. */
1119 if (needed
->obj
!= NULL
)
1120 initlist_add_objects(needed
->obj
, &needed
->obj
->next
, list
);
1124 * Scan all of the DAGs rooted in the range of objects from "obj" to
1125 * "tail" and add their init functions to "list". This recurses over
1126 * the DAGs and ensure the proper init ordering such that each object's
1127 * needed libraries are initialized before the object itself. At the
1128 * same time, this function adds the objects to the global finalization
1129 * list "list_fini" in the opposite order. The write lock must be
1130 * held when this function is called.
1133 initlist_add_objects(Obj_Entry
*obj
, Obj_Entry
**tail
, Objlist
*list
)
1137 obj
->init_done
= true;
1139 /* Recursively process the successor objects. */
1140 if (&obj
->next
!= tail
)
1141 initlist_add_objects(obj
->next
, tail
, list
);
1143 /* Recursively process the needed objects. */
1144 if (obj
->needed
!= NULL
)
1145 initlist_add_neededs(obj
->needed
, list
);
1147 /* Add the object to the init list. */
1148 if (obj
->init
!= (Elf_Addr
)NULL
)
1149 objlist_push_tail(list
, obj
);
1151 /* Add the object to the global fini list in the reverse order. */
1152 if (obj
->fini
!= (Elf_Addr
)NULL
)
1153 objlist_push_head(&list_fini
, obj
);
1157 #define FPTR_TARGET(f) ((Elf_Addr) (f))
1161 is_exported(const Elf_Sym
*def
)
1164 const func_ptr_type
*p
;
1166 value
= (Elf_Addr
)(obj_rtld
.relocbase
+ def
->st_value
);
1167 for (p
= exports
; *p
!= NULL
; p
++)
1168 if (FPTR_TARGET(*p
) == value
)
1174 * Given a shared object, traverse its list of needed objects, and load
1175 * each of them. Returns 0 on success. Generates an error message and
1176 * returns -1 on failure.
1179 load_needed_objects(Obj_Entry
*first
)
1183 for (obj
= first
; obj
!= NULL
; obj
= obj
->next
) {
1184 Needed_Entry
*needed
;
1186 for (needed
= obj
->needed
; needed
!= NULL
; needed
= needed
->next
) {
1187 const char *name
= obj
->strtab
+ needed
->name
;
1188 char *path
= find_library(name
, obj
);
1191 if (path
== NULL
&& !ld_tracing
)
1195 needed
->obj
= load_object(path
);
1196 if (needed
->obj
== NULL
&& !ld_tracing
)
1197 return -1; /* XXX - cleanup */
1206 load_preload_objects(void)
1208 char *p
= ld_preload
;
1209 static const char delim
[] = " \t:;";
1214 p
+= strspn(p
, delim
);
1215 while (*p
!= '\0') {
1216 size_t len
= strcspn(p
, delim
);
1222 if ((path
= find_library(p
, NULL
)) == NULL
)
1224 if (load_object(path
) == NULL
)
1225 return -1; /* XXX - cleanup */
1228 p
+= strspn(p
, delim
);
1234 * Load a shared object into memory, if it is not already loaded. The
1235 * argument must be a string allocated on the heap. This function assumes
1236 * responsibility for freeing it when necessary.
1238 * Returns a pointer to the Obj_Entry for the object. Returns NULL
1242 load_object(char *path
)
1248 for (obj
= obj_list
->next
; obj
!= NULL
; obj
= obj
->next
)
1249 if (strcmp(obj
->path
, path
) == 0)
1253 * If we didn't find a match by pathname, open the file and check
1254 * again by device and inode. This avoids false mismatches caused
1255 * by multiple links or ".." in pathnames.
1257 * To avoid a race, we open the file and use fstat() rather than
1261 if ((fd
= open(path
, O_RDONLY
)) == -1) {
1262 _rtld_error("Cannot open \"%s\"", path
);
1265 if (fstat(fd
, &sb
) == -1) {
1266 _rtld_error("Cannot fstat \"%s\"", path
);
1270 for (obj
= obj_list
->next
; obj
!= NULL
; obj
= obj
->next
) {
1271 if (obj
->ino
== sb
.st_ino
&& obj
->dev
== sb
.st_dev
) {
1278 if (obj
== NULL
) { /* First use of this object, so we must map it in */
1279 dbg("loading \"%s\"", path
);
1280 obj
= map_object(fd
, path
, &sb
);
1288 digest_dynamic(obj
, 0);
1291 obj_tail
= &obj
->next
;
1293 linkmap_add(obj
); /* for GDB & dlinfo() */
1295 dbg(" %p .. %p: %s", obj
->mapbase
,
1296 obj
->mapbase
+ obj
->mapsize
- 1, obj
->path
);
1298 dbg(" WARNING: %s has impure text", obj
->path
);
1306 obj_from_addr(const void *addr
)
1310 for (obj
= obj_list
; obj
!= NULL
; obj
= obj
->next
) {
1311 if (addr
< (void *) obj
->mapbase
)
1313 if (addr
< (void *) (obj
->mapbase
+ obj
->mapsize
))
1320 * Call the finalization functions for each of the objects in "list"
1321 * which are unreferenced. All of the objects are expected to have
1322 * non-NULL fini functions.
1325 objlist_call_fini(Objlist
*list
)
1331 * Preserve the current error message since a fini function might
1332 * call into the dynamic linker and overwrite it.
1334 saved_msg
= errmsg_save();
1335 STAILQ_FOREACH(elm
, list
, link
) {
1336 if (elm
->obj
->refcount
== 0) {
1337 dbg("calling fini function for %s at %p", elm
->obj
->path
,
1338 (void *)elm
->obj
->fini
);
1339 call_initfini_pointer(elm
->obj
, elm
->obj
->fini
);
1342 errmsg_restore(saved_msg
);
1346 * Call the initialization functions for each of the objects in
1347 * "list". All of the objects are expected to have non-NULL init
1351 objlist_call_init(Objlist
*list
)
1357 * Preserve the current error message since an init function might
1358 * call into the dynamic linker and overwrite it.
1360 saved_msg
= errmsg_save();
1361 STAILQ_FOREACH(elm
, list
, link
) {
1362 dbg("calling init function for %s at %p", elm
->obj
->path
,
1363 (void *)elm
->obj
->init
);
1364 call_initfini_pointer(elm
->obj
, elm
->obj
->init
);
1366 errmsg_restore(saved_msg
);
1370 objlist_clear(Objlist
*list
)
1374 while (!STAILQ_EMPTY(list
)) {
1375 elm
= STAILQ_FIRST(list
);
1376 STAILQ_REMOVE_HEAD(list
, link
);
1381 static Objlist_Entry
*
1382 objlist_find(Objlist
*list
, const Obj_Entry
*obj
)
1386 STAILQ_FOREACH(elm
, list
, link
)
1387 if (elm
->obj
== obj
)
1393 objlist_init(Objlist
*list
)
1399 objlist_push_head(Objlist
*list
, Obj_Entry
*obj
)
1403 elm
= NEW(Objlist_Entry
);
1405 STAILQ_INSERT_HEAD(list
, elm
, link
);
1409 objlist_push_tail(Objlist
*list
, Obj_Entry
*obj
)
1413 elm
= NEW(Objlist_Entry
);
1415 STAILQ_INSERT_TAIL(list
, elm
, link
);
1419 objlist_remove(Objlist
*list
, Obj_Entry
*obj
)
1423 if ((elm
= objlist_find(list
, obj
)) != NULL
) {
1424 STAILQ_REMOVE(list
, elm
, Struct_Objlist_Entry
, link
);
1430 * Remove all of the unreferenced objects from "list".
1433 objlist_remove_unref(Objlist
*list
)
1438 STAILQ_INIT(&newlist
);
1439 while (!STAILQ_EMPTY(list
)) {
1440 elm
= STAILQ_FIRST(list
);
1441 STAILQ_REMOVE_HEAD(list
, link
);
1442 if (elm
->obj
->refcount
== 0)
1445 STAILQ_INSERT_TAIL(&newlist
, elm
, link
);
1453 * Relocate newly-loaded shared objects. The argument is a pointer to
1454 * the Obj_Entry for the first such object. All objects from the first
1455 * to the end of the list of objects are relocated. Returns 0 on success,
1459 relocate_objects(Obj_Entry
*first
, bool bind_now
, Obj_Entry
*rtldobj
)
1463 for (obj
= first
; obj
!= NULL
; obj
= obj
->next
) {
1465 dbg("relocating \"%s\"", obj
->path
);
1466 if (obj
->nbuckets
== 0 || obj
->nchains
== 0 || obj
->buckets
== NULL
||
1467 obj
->symtab
== NULL
|| obj
->strtab
== NULL
) {
1468 _rtld_error("%s: Shared object has no run-time symbol table",
1474 /* There are relocations to the write-protected text segment. */
1475 if (mprotect(obj
->mapbase
, obj
->textsize
,
1476 PROT_READ
|PROT_WRITE
|PROT_EXEC
) == -1) {
1477 _rtld_error("%s: Cannot write-enable text segment: %s",
1478 obj
->path
, strerror(errno
));
1483 /* Process the non-PLT relocations. */
1484 if (reloc_non_plt(obj
, rtldobj
))
1487 if (obj
->textrel
) { /* Re-protected the text segment. */
1488 if (mprotect(obj
->mapbase
, obj
->textsize
,
1489 PROT_READ
|PROT_EXEC
) == -1) {
1490 _rtld_error("%s: Cannot write-protect text segment: %s",
1491 obj
->path
, strerror(errno
));
1496 /* Process the PLT relocations. */
1497 if (reloc_plt(obj
) == -1)
1499 /* Relocate the jump slots if we are doing immediate binding. */
1500 if (obj
->bind_now
|| bind_now
)
1501 if (reloc_jmpslots(obj
) == -1)
1506 * Set up the magic number and version in the Obj_Entry. These
1507 * were checked in the crt1.o from the original ElfKit, so we
1508 * set them for backward compatibility.
1510 obj
->magic
= RTLD_MAGIC
;
1511 obj
->version
= RTLD_VERSION
;
1513 /* Set the special PLT or GOT entries. */
1523 * Cleanup procedure. It will be called (by the atexit mechanism) just
1524 * before the process exits.
1532 /* Clear all the reference counts so the fini functions will be called. */
1533 for (obj
= obj_list
; obj
!= NULL
; obj
= obj
->next
)
1535 objlist_call_fini(&list_fini
);
1536 /* No need to remove the items from the list, since we are exiting. */
1537 if (!libmap_disable
)
1542 path_enumerate(const char *path
, path_enum_proc callback
, void *arg
)
1550 path
+= strspn(path
, ":;");
1551 while (*path
!= '\0') {
1555 len
= strcspn(path
, ":;");
1557 trans
= lm_findn(NULL
, path
, len
);
1559 res
= callback(trans
, strlen(trans
), arg
);
1562 res
= callback(path
, len
, arg
);
1568 path
+= strspn(path
, ":;");
1574 struct try_library_args
{
1582 try_library_path(const char *dir
, size_t dirlen
, void *param
)
1584 struct try_library_args
*arg
;
1587 if (*dir
== '/' || trust
) {
1590 if (dirlen
+ 1 + arg
->namelen
+ 1 > arg
->buflen
)
1593 pathname
= arg
->buffer
;
1594 strncpy(pathname
, dir
, dirlen
);
1595 pathname
[dirlen
] = '/';
1596 strcpy(pathname
+ dirlen
+ 1, arg
->name
);
1598 dbg(" Trying \"%s\"", pathname
);
1599 if (access(pathname
, F_OK
) == 0) { /* We found it */
1600 pathname
= xmalloc(dirlen
+ 1 + arg
->namelen
+ 1);
1601 strcpy(pathname
, arg
->buffer
);
1609 search_library_path(const char *name
, const char *path
)
1612 struct try_library_args arg
;
1618 arg
.namelen
= strlen(name
);
1619 arg
.buffer
= xmalloc(PATH_MAX
);
1620 arg
.buflen
= PATH_MAX
;
1622 p
= path_enumerate(path
, try_library_path
, &arg
);
1630 dlclose(void *handle
)
1635 lockstate
= wlock_acquire(rtld_bind_lock
);
1636 root
= dlcheck(handle
);
1638 wlock_release(rtld_bind_lock
, lockstate
);
1642 /* Unreference the object and its dependencies. */
1643 root
->dl_refcount
--;
1647 if (root
->refcount
== 0) {
1649 * The object is no longer referenced, so we must unload it.
1650 * First, call the fini functions with no locks held.
1652 wlock_release(rtld_bind_lock
, lockstate
);
1653 objlist_call_fini(&list_fini
);
1654 lockstate
= wlock_acquire(rtld_bind_lock
);
1655 objlist_remove_unref(&list_fini
);
1657 /* Finish cleaning up the newly-unreferenced objects. */
1658 GDB_STATE(RT_DELETE
,&root
->linkmap
);
1659 unload_object(root
);
1660 GDB_STATE(RT_CONSISTENT
,NULL
);
1662 wlock_release(rtld_bind_lock
, lockstate
);
1669 char *msg
= error_message
;
1670 error_message
= NULL
;
1675 * This function is deprecated and has no effect.
1678 dllockinit(void *context
,
1679 void *(*lock_create
)(void *context
),
1680 void (*rlock_acquire
)(void *lock
),
1681 void (*wlock_acquire
)(void *lock
),
1682 void (*lock_release
)(void *lock
),
1683 void (*lock_destroy
)(void *lock
),
1684 void (*context_destroy
)(void *context
))
1686 static void *cur_context
;
1687 static void (*cur_context_destroy
)(void *);
1689 /* Just destroy the context from the previous call, if necessary. */
1690 if (cur_context_destroy
!= NULL
)
1691 cur_context_destroy(cur_context
);
1692 cur_context
= context
;
1693 cur_context_destroy
= context_destroy
;
1697 dlopen(const char *name
, int mode
)
1699 Obj_Entry
**old_obj_tail
;
1702 int result
, lockstate
;
1704 ld_tracing
= (mode
& RTLD_TRACE
) == 0 ? NULL
: "1";
1705 if (ld_tracing
!= NULL
)
1706 environ
= (char **)*get_program_var_addr("environ");
1708 objlist_init(&initlist
);
1710 lockstate
= wlock_acquire(rtld_bind_lock
);
1711 GDB_STATE(RT_ADD
,NULL
);
1713 old_obj_tail
= obj_tail
;
1719 char *path
= find_library(name
, obj_main
);
1721 obj
= load_object(path
);
1726 if (mode
& RTLD_GLOBAL
&& objlist_find(&list_global
, obj
) == NULL
)
1727 objlist_push_tail(&list_global
, obj
);
1728 mode
&= RTLD_MODEMASK
;
1729 if (*old_obj_tail
!= NULL
) { /* We loaded something new. */
1730 assert(*old_obj_tail
== obj
);
1732 result
= load_needed_objects(obj
);
1733 if (result
!= -1 && ld_tracing
)
1737 (init_dag(obj
), relocate_objects(obj
, mode
== RTLD_NOW
,
1738 &obj_rtld
)) == -1) {
1741 if (obj
->refcount
== 0)
1745 /* Make list of init functions to call. */
1746 initlist_add_objects(obj
, &obj
->next
, &initlist
);
1750 /* Bump the reference counts for objects on this DAG. */
1758 GDB_STATE(RT_CONSISTENT
,obj
? &obj
->linkmap
: NULL
);
1760 /* Call the init functions with no locks held. */
1761 wlock_release(rtld_bind_lock
, lockstate
);
1762 objlist_call_init(&initlist
);
1763 lockstate
= wlock_acquire(rtld_bind_lock
);
1764 objlist_clear(&initlist
);
1765 wlock_release(rtld_bind_lock
, lockstate
);
1768 trace_loaded_objects(obj
);
1769 wlock_release(rtld_bind_lock
, lockstate
);
1774 dlsym(void *handle
, const char *name
)
1776 const Obj_Entry
*obj
;
1779 const Obj_Entry
*defobj
;
1782 hash
= elf_hash(name
);
1786 lockstate
= rlock_acquire(rtld_bind_lock
);
1787 if (handle
== NULL
|| handle
== RTLD_NEXT
||
1788 handle
== RTLD_DEFAULT
|| handle
== RTLD_SELF
) {
1791 retaddr
= __builtin_return_address(0); /* __GNUC__ only */
1792 if ((obj
= obj_from_addr(retaddr
)) == NULL
) {
1793 _rtld_error("Cannot determine caller's shared object");
1794 rlock_release(rtld_bind_lock
, lockstate
);
1797 if (handle
== NULL
) { /* Just the caller's shared object. */
1798 def
= symlook_obj(name
, hash
, obj
, true);
1800 } else if (handle
== RTLD_NEXT
|| /* Objects after caller's */
1801 handle
== RTLD_SELF
) { /* ... caller included */
1802 if (handle
== RTLD_NEXT
)
1804 for (; obj
!= NULL
; obj
= obj
->next
) {
1805 if ((def
= symlook_obj(name
, hash
, obj
, true)) != NULL
) {
1811 assert(handle
== RTLD_DEFAULT
);
1812 def
= symlook_default(name
, hash
, obj
, &defobj
, true);
1815 if ((obj
= dlcheck(handle
)) == NULL
) {
1816 rlock_release(rtld_bind_lock
, lockstate
);
1820 if (obj
->mainprog
) {
1823 /* Search main program and all libraries loaded by it. */
1824 donelist_init(&donelist
);
1825 def
= symlook_list(name
, hash
, &list_main
, &defobj
, true,
1829 * XXX - This isn't correct. The search should include the whole
1830 * DAG rooted at the given object.
1832 def
= symlook_obj(name
, hash
, obj
, true);
1838 rlock_release(rtld_bind_lock
, lockstate
);
1841 * The value required by the caller is derived from the value
1842 * of the symbol. For the ia64 architecture, we need to
1843 * construct a function descriptor which the caller can use to
1844 * call the function with the right 'gp' value. For other
1845 * architectures and for non-functions, the value is simply
1846 * the relocated value of the symbol.
1848 if (ELF_ST_TYPE(def
->st_info
) == STT_FUNC
)
1849 return make_function_pointer(def
, defobj
);
1851 return defobj
->relocbase
+ def
->st_value
;
1854 _rtld_error("Undefined symbol \"%s\"", name
);
1855 rlock_release(rtld_bind_lock
, lockstate
);
1860 dladdr(const void *addr
, Dl_info
*info
)
1862 const Obj_Entry
*obj
;
1865 unsigned long symoffset
;
1868 lockstate
= rlock_acquire(rtld_bind_lock
);
1869 obj
= obj_from_addr(addr
);
1871 _rtld_error("No shared object contains address");
1872 rlock_release(rtld_bind_lock
, lockstate
);
1875 info
->dli_fname
= obj
->path
;
1876 info
->dli_fbase
= obj
->mapbase
;
1877 info
->dli_saddr
= (void *)0;
1878 info
->dli_sname
= NULL
;
1881 * Walk the symbol list looking for the symbol whose address is
1882 * closest to the address sent in.
1884 for (symoffset
= 0; symoffset
< obj
->nchains
; symoffset
++) {
1885 def
= obj
->symtab
+ symoffset
;
1888 * For skip the symbol if st_shndx is either SHN_UNDEF or
1891 if (def
->st_shndx
== SHN_UNDEF
|| def
->st_shndx
== SHN_COMMON
)
1895 * If the symbol is greater than the specified address, or if it
1896 * is further away from addr than the current nearest symbol,
1899 symbol_addr
= obj
->relocbase
+ def
->st_value
;
1900 if (symbol_addr
> addr
|| symbol_addr
< info
->dli_saddr
)
1903 /* Update our idea of the nearest symbol. */
1904 info
->dli_sname
= obj
->strtab
+ def
->st_name
;
1905 info
->dli_saddr
= symbol_addr
;
1908 if (info
->dli_saddr
== addr
)
1911 rlock_release(rtld_bind_lock
, lockstate
);
1916 dlinfo(void *handle
, int request
, void *p
)
1918 const Obj_Entry
*obj
;
1919 int error
, lockstate
;
1921 lockstate
= rlock_acquire(rtld_bind_lock
);
1923 if (handle
== NULL
|| handle
== RTLD_SELF
) {
1926 retaddr
= __builtin_return_address(0); /* __GNUC__ only */
1927 if ((obj
= obj_from_addr(retaddr
)) == NULL
)
1928 _rtld_error("Cannot determine caller's shared object");
1930 obj
= dlcheck(handle
);
1933 rlock_release(rtld_bind_lock
, lockstate
);
1939 case RTLD_DI_LINKMAP
:
1940 *((struct link_map
const **)p
) = &obj
->linkmap
;
1942 case RTLD_DI_ORIGIN
:
1943 error
= rtld_dirname(obj
->path
, p
);
1946 case RTLD_DI_SERINFOSIZE
:
1947 case RTLD_DI_SERINFO
:
1948 error
= do_search_info(obj
, request
, (struct dl_serinfo
*)p
);
1952 _rtld_error("Invalid request %d passed to dlinfo()", request
);
1956 rlock_release(rtld_bind_lock
, lockstate
);
1961 struct fill_search_info_args
{
1964 Dl_serinfo
*serinfo
;
1965 Dl_serpath
*serpath
;
1970 fill_search_info(const char *dir
, size_t dirlen
, void *param
)
1972 struct fill_search_info_args
*arg
;
1976 if (arg
->request
== RTLD_DI_SERINFOSIZE
) {
1977 arg
->serinfo
->dls_cnt
++;
1978 arg
->serinfo
->dls_size
+= dirlen
+ 1;
1980 struct dl_serpath
*s_entry
;
1982 s_entry
= arg
->serpath
;
1983 s_entry
->dls_name
= arg
->strspace
;
1984 s_entry
->dls_flags
= arg
->flags
;
1986 strncpy(arg
->strspace
, dir
, dirlen
);
1987 arg
->strspace
[dirlen
] = '\0';
1989 arg
->strspace
+= dirlen
+ 1;
1997 do_search_info(const Obj_Entry
*obj
, int request
, struct dl_serinfo
*info
)
1999 struct dl_serinfo _info
;
2000 struct fill_search_info_args args
;
2002 args
.request
= RTLD_DI_SERINFOSIZE
;
2003 args
.serinfo
= &_info
;
2005 _info
.dls_size
= __offsetof(struct dl_serinfo
, dls_serpath
);
2008 path_enumerate(ld_library_path
, fill_search_info
, &args
);
2009 path_enumerate(obj
->rpath
, fill_search_info
, &args
);
2010 path_enumerate(gethints(), fill_search_info
, &args
);
2011 path_enumerate(STANDARD_LIBRARY_PATH
, fill_search_info
, &args
);
2014 if (request
== RTLD_DI_SERINFOSIZE
) {
2015 info
->dls_size
= _info
.dls_size
;
2016 info
->dls_cnt
= _info
.dls_cnt
;
2020 if (info
->dls_cnt
!= _info
.dls_cnt
|| info
->dls_size
!= _info
.dls_size
) {
2021 _rtld_error("Uninitialized Dl_serinfo struct passed to dlinfo()");
2025 args
.request
= RTLD_DI_SERINFO
;
2026 args
.serinfo
= info
;
2027 args
.serpath
= &info
->dls_serpath
[0];
2028 args
.strspace
= (char *)&info
->dls_serpath
[_info
.dls_cnt
];
2030 args
.flags
= LA_SER_LIBPATH
;
2031 if (path_enumerate(ld_library_path
, fill_search_info
, &args
) != NULL
)
2034 args
.flags
= LA_SER_RUNPATH
;
2035 if (path_enumerate(obj
->rpath
, fill_search_info
, &args
) != NULL
)
2038 args
.flags
= LA_SER_CONFIG
;
2039 if (path_enumerate(gethints(), fill_search_info
, &args
) != NULL
)
2042 args
.flags
= LA_SER_DEFAULT
;
2043 if (path_enumerate(STANDARD_LIBRARY_PATH
, fill_search_info
, &args
) != NULL
)
2049 rtld_dirname(const char *path
, char *bname
)
2053 /* Empty or NULL string gets treated as "." */
2054 if (path
== NULL
|| *path
== '\0') {
2060 /* Strip trailing slashes */
2061 endp
= path
+ strlen(path
) - 1;
2062 while (endp
> path
&& *endp
== '/')
2065 /* Find the start of the dir */
2066 while (endp
> path
&& *endp
!= '/')
2069 /* Either the dir is "/" or there are no slashes */
2071 bname
[0] = *endp
== '/' ? '/' : '.';
2077 } while (endp
> path
&& *endp
== '/');
2080 if (endp
- path
+ 2 > PATH_MAX
)
2082 _rtld_error("Filename is too long: %s", path
);
2086 strncpy(bname
, path
, endp
- path
+ 1);
2087 bname
[endp
- path
+ 1] = '\0';
2092 linkmap_add(Obj_Entry
*obj
)
2094 struct link_map
*l
= &obj
->linkmap
;
2095 struct link_map
*prev
;
2097 obj
->linkmap
.l_name
= obj
->path
;
2098 obj
->linkmap
.l_addr
= obj
->mapbase
;
2099 obj
->linkmap
.l_ld
= obj
->dynamic
;
2101 /* GDB needs load offset on MIPS to use the symbols */
2102 obj
->linkmap
.l_offs
= obj
->relocbase
;
2105 if (r_debug
.r_map
== NULL
) {
2111 * Scan to the end of the list, but not past the entry for the
2112 * dynamic linker, which we want to keep at the very end.
2114 for (prev
= r_debug
.r_map
;
2115 prev
->l_next
!= NULL
&& prev
->l_next
!= &obj_rtld
.linkmap
;
2116 prev
= prev
->l_next
)
2119 /* Link in the new entry. */
2121 l
->l_next
= prev
->l_next
;
2122 if (l
->l_next
!= NULL
)
2123 l
->l_next
->l_prev
= l
;
2128 linkmap_delete(Obj_Entry
*obj
)
2130 struct link_map
*l
= &obj
->linkmap
;
2132 if (l
->l_prev
== NULL
) {
2133 if ((r_debug
.r_map
= l
->l_next
) != NULL
)
2134 l
->l_next
->l_prev
= NULL
;
2138 if ((l
->l_prev
->l_next
= l
->l_next
) != NULL
)
2139 l
->l_next
->l_prev
= l
->l_prev
;
2143 * Function for the debugger to set a breakpoint on to gain control.
2145 * The two parameters allow the debugger to easily find and determine
2146 * what the runtime loader is doing and to whom it is doing it.
2148 * When the loadhook trap is hit (r_debug_state, set at program
2149 * initialization), the arguments can be found on the stack:
2151 * +8 struct link_map *m
2152 * +4 struct r_debug *rd
2156 r_debug_state(struct r_debug
* rd
, struct link_map
*m
)
2161 * Get address of the pointer variable in the main program.
2163 static const void **
2164 get_program_var_addr(const char *name
)
2166 const Obj_Entry
*obj
;
2169 hash
= elf_hash(name
);
2170 for (obj
= obj_main
; obj
!= NULL
; obj
= obj
->next
) {
2173 if ((def
= symlook_obj(name
, hash
, obj
, false)) != NULL
) {
2176 addr
= (const void **)(obj
->relocbase
+ def
->st_value
);
2184 * Set a pointer variable in the main program to the given value. This
2185 * is used to set key variables such as "environ" before any of the
2186 * init functions are called.
2189 set_program_var(const char *name
, const void *value
)
2193 if ((addr
= get_program_var_addr(name
)) != NULL
) {
2194 dbg("\"%s\": *%p <-- %p", name
, addr
, value
);
2200 * Given a symbol name in a referencing object, find the corresponding
2201 * definition of the symbol. Returns a pointer to the symbol, or NULL if
2202 * no definition was found. Returns a pointer to the Obj_Entry of the
2203 * defining object via the reference parameter DEFOBJ_OUT.
2205 static const Elf_Sym
*
2206 symlook_default(const char *name
, unsigned long hash
,
2207 const Obj_Entry
*refobj
, const Obj_Entry
**defobj_out
, bool in_plt
)
2211 const Elf_Sym
*symp
;
2212 const Obj_Entry
*obj
;
2213 const Obj_Entry
*defobj
;
2214 const Objlist_Entry
*elm
;
2217 donelist_init(&donelist
);
2219 /* Look first in the referencing object if linked symbolically. */
2220 if (refobj
->symbolic
&& !donelist_check(&donelist
, refobj
)) {
2221 symp
= symlook_obj(name
, hash
, refobj
, in_plt
);
2228 /* Search all objects loaded at program start up. */
2229 if (def
== NULL
|| ELF_ST_BIND(def
->st_info
) == STB_WEAK
) {
2230 symp
= symlook_list(name
, hash
, &list_main
, &obj
, in_plt
, &donelist
);
2232 (def
== NULL
|| ELF_ST_BIND(symp
->st_info
) != STB_WEAK
)) {
2238 /* Search all DAGs whose roots are RTLD_GLOBAL objects. */
2239 STAILQ_FOREACH(elm
, &list_global
, link
) {
2240 if (def
!= NULL
&& ELF_ST_BIND(def
->st_info
) != STB_WEAK
)
2242 symp
= symlook_list(name
, hash
, &elm
->obj
->dagmembers
, &obj
, in_plt
,
2245 (def
== NULL
|| ELF_ST_BIND(symp
->st_info
) != STB_WEAK
)) {
2251 /* Search all dlopened DAGs containing the referencing object. */
2252 STAILQ_FOREACH(elm
, &refobj
->dldags
, link
) {
2253 if (def
!= NULL
&& ELF_ST_BIND(def
->st_info
) != STB_WEAK
)
2255 symp
= symlook_list(name
, hash
, &elm
->obj
->dagmembers
, &obj
, in_plt
,
2258 (def
== NULL
|| ELF_ST_BIND(symp
->st_info
) != STB_WEAK
)) {
2265 * Search the dynamic linker itself, and possibly resolve the
2266 * symbol from there. This is how the application links to
2267 * dynamic linker services such as dlopen. Only the values listed
2268 * in the "exports" array can be resolved from the dynamic linker.
2270 if (def
== NULL
|| ELF_ST_BIND(def
->st_info
) == STB_WEAK
) {
2271 symp
= symlook_obj(name
, hash
, &obj_rtld
, in_plt
);
2272 if (symp
!= NULL
&& is_exported(symp
)) {
2279 *defobj_out
= defobj
;
2283 static const Elf_Sym
*
2284 symlook_list(const char *name
, unsigned long hash
, Objlist
*objlist
,
2285 const Obj_Entry
**defobj_out
, bool in_plt
, DoneList
*dlp
)
2287 const Elf_Sym
*symp
;
2289 const Obj_Entry
*defobj
;
2290 const Objlist_Entry
*elm
;
2294 STAILQ_FOREACH(elm
, objlist
, link
) {
2295 if (donelist_check(dlp
, elm
->obj
))
2297 if ((symp
= symlook_obj(name
, hash
, elm
->obj
, in_plt
)) != NULL
) {
2298 if (def
== NULL
|| ELF_ST_BIND(symp
->st_info
) != STB_WEAK
) {
2301 if (ELF_ST_BIND(def
->st_info
) != STB_WEAK
)
2307 *defobj_out
= defobj
;
2314 * Search the symbol table of a single shared object for a symbol of
2315 * the given name. Returns a pointer to the symbol, or NULL if no
2316 * definition was found.
2318 * The symbol's hash value is passed in for efficiency reasons; that
2319 * eliminates many recomputations of the hash value.
2322 symlook_obj(const char *name
, unsigned long hash
, const Obj_Entry
*obj
,
2325 if (obj
->buckets
!= NULL
) {
2326 unsigned long symnum
= obj
->buckets
[hash
% obj
->nbuckets
];
2328 while (symnum
!= STN_UNDEF
) {
2329 const Elf_Sym
*symp
;
2332 if (symnum
>= obj
->nchains
)
2333 return NULL
; /* Bad object */
2334 symp
= obj
->symtab
+ symnum
;
2335 strp
= obj
->strtab
+ symp
->st_name
;
2337 if (name
[0] == strp
[0] && strcmp(name
, strp
) == 0)
2338 return symp
->st_shndx
!= SHN_UNDEF
||
2339 (!in_plt
&& symp
->st_value
!= 0 &&
2340 ELF_ST_TYPE(symp
->st_info
) == STT_FUNC
) ? symp
: NULL
;
2342 symnum
= obj
->chains
[symnum
];
2351 trace_loaded_objects(Obj_Entry
*obj
)
2353 char *fmt1
, *fmt2
, *fmt
, *main_local
, *list_containers
;
2356 if ((main_local
= getenv(LD_
"TRACE_LOADED_OBJECTS_PROGNAME")) == NULL
)
2359 if ((fmt1
= getenv(LD_
"TRACE_LOADED_OBJECTS_FMT1")) == NULL
)
2360 fmt1
= "\t%o => %p (%x)\n";
2362 if ((fmt2
= getenv(LD_
"TRACE_LOADED_OBJECTS_FMT2")) == NULL
)
2363 fmt2
= "\t%o (%x)\n";
2365 list_containers
= getenv(LD_
"TRACE_LOADED_OBJECTS_ALL");
2367 for (; obj
; obj
= obj
->next
) {
2368 Needed_Entry
*needed
;
2372 if (list_containers
&& obj
->needed
!= NULL
)
2373 printf("%s:\n", obj
->path
);
2374 for (needed
= obj
->needed
; needed
; needed
= needed
->next
) {
2375 if (needed
->obj
!= NULL
) {
2376 if (needed
->obj
->traced
&& !list_containers
)
2378 needed
->obj
->traced
= true;
2379 path
= needed
->obj
->path
;
2383 name
= (char *)obj
->strtab
+ needed
->name
;
2384 is_lib
= strncmp(name
, "lib", 3) == 0; /* XXX - bogus */
2386 fmt
= is_lib
? fmt1
: fmt2
;
2387 while ((c
= *fmt
++) != '\0') {
2413 printf("%s", main_local
);
2416 printf("%s", obj_main
->path
);
2423 printf("%d", sodp
->sod_major
);
2426 printf("%d", sodp
->sod_minor
);
2433 printf("%p", needed
->obj
? needed
->obj
->mapbase
: 0);
2445 * Unload a dlopened object and its dependencies from memory and from
2446 * our data structures. It is assumed that the DAG rooted in the
2447 * object has already been unreferenced, and that the object has a
2448 * reference count of 0.
2451 unload_object(Obj_Entry
*root
)
2456 assert(root
->refcount
== 0);
2459 * Pass over the DAG removing unreferenced objects from
2460 * appropriate lists.
2462 unlink_object(root
);
2464 /* Unmap all objects that are no longer referenced. */
2465 linkp
= &obj_list
->next
;
2466 while ((obj
= *linkp
) != NULL
) {
2467 if (obj
->refcount
== 0) {
2468 dbg("unloading \"%s\"", obj
->path
);
2469 munmap(obj
->mapbase
, obj
->mapsize
);
2470 linkmap_delete(obj
);
2481 unlink_object(Obj_Entry
*root
)
2485 if (root
->refcount
== 0) {
2486 /* Remove the object from the RTLD_GLOBAL list. */
2487 objlist_remove(&list_global
, root
);
2489 /* Remove the object from all objects' DAG lists. */
2490 STAILQ_FOREACH(elm
, &root
->dagmembers
, link
) {
2491 objlist_remove(&elm
->obj
->dldags
, root
);
2492 if (elm
->obj
!= root
)
2493 unlink_object(elm
->obj
);
2499 ref_dag(Obj_Entry
*root
)
2503 STAILQ_FOREACH(elm
, &root
->dagmembers
, link
)
2504 elm
->obj
->refcount
++;
2508 unref_dag(Obj_Entry
*root
)
2512 STAILQ_FOREACH(elm
, &root
->dagmembers
, link
)
2513 elm
->obj
->refcount
--;
2517 * Common code for MD __tls_get_addr().
2520 tls_get_addr_common(Elf_Addr
** dtvp
, int index
, size_t offset
)
2522 Elf_Addr
* dtv
= *dtvp
;
2524 /* Check dtv generation in case new modules have arrived */
2525 if (dtv
[0] != tls_dtv_generation
) {
2529 newdtv
= calloc(1, (tls_max_index
+ 2) * sizeof(Elf_Addr
));
2531 if (to_copy
> tls_max_index
)
2532 to_copy
= tls_max_index
;
2533 memcpy(&newdtv
[2], &dtv
[2], to_copy
* sizeof(Elf_Addr
));
2534 newdtv
[0] = tls_dtv_generation
;
2535 newdtv
[1] = tls_max_index
;
2540 /* Dynamically allocate module TLS if necessary */
2541 if (!dtv
[index
+ 1])
2542 dtv
[index
+ 1] = (Elf_Addr
)allocate_module_tls(index
);
2544 return (void*) (dtv
[index
+ 1] + offset
);
2547 /* XXX not sure what variants to use for arm. */
2549 #if defined(__ia64__) || defined(__alpha__) || defined(__powerpc__)
2552 * Allocate Static TLS using the Variant I method.
2555 allocate_tls(Obj_Entry
*objs
, void *oldtls
, size_t tcbsize
, size_t tcbalign
)
2560 Elf_Addr
*dtv
, *olddtv
;
2564 size
= tls_static_space
;
2567 dtv
= malloc((tls_max_index
+ 2) * sizeof(Elf_Addr
));
2569 *(Elf_Addr
**) tls
= dtv
;
2571 dtv
[0] = tls_dtv_generation
;
2572 dtv
[1] = tls_max_index
;
2576 * Copy the static TLS block over whole.
2578 memcpy(tls
+ tcbsize
, oldtls
+ tcbsize
, tls_static_space
- tcbsize
);
2581 * If any dynamic TLS blocks have been created tls_get_addr(),
2584 olddtv
= *(Elf_Addr
**) oldtls
;
2585 for (i
= 0; i
< olddtv
[1]; i
++) {
2586 if (olddtv
[i
+2] < (Elf_Addr
)oldtls
||
2587 olddtv
[i
+2] > (Elf_Addr
)oldtls
+ tls_static_space
) {
2588 dtv
[i
+2] = olddtv
[i
+2];
2594 * We assume that all tls blocks are allocated with the same
2595 * size and alignment.
2597 free_tls(oldtls
, tcbsize
, tcbalign
);
2599 for (obj
= objs
; obj
; obj
= obj
->next
) {
2600 if (obj
->tlsoffset
) {
2601 addr
= (Elf_Addr
)tls
+ obj
->tlsoffset
;
2602 memset((void*) (addr
+ obj
->tlsinitsize
),
2603 0, obj
->tlssize
- obj
->tlsinitsize
);
2605 memcpy((void*) addr
, obj
->tlsinit
,
2607 dtv
[obj
->tlsindex
+ 1] = addr
;
2608 } else if (obj
->tlsindex
) {
2609 dtv
[obj
->tlsindex
+ 1] = 0;
2618 free_tls(void *tls
, size_t tcbsize
, size_t tcbalign
)
2623 Elf_Addr tlsstart
, tlsend
;
2626 * Figure out the size of the initial TLS block so that we can
2627 * find stuff which __tls_get_addr() allocated dynamically.
2629 size
= tls_static_space
;
2631 dtv
= ((Elf_Addr
**)tls
)[0];
2633 tlsstart
= (Elf_Addr
) tls
;
2634 tlsend
= tlsstart
+ size
;
2635 for (i
= 0; i
< dtvsize
; i
++) {
2636 if (dtv
[i
+2] < tlsstart
|| dtv
[i
+2] > tlsend
) {
2637 free((void*) dtv
[i
+2]);
2641 free((void*) tlsstart
);
2646 #if defined(__i386__) || defined(__amd64__) || defined(__sparc64__) || \
2650 * Allocate Static TLS using the Variant II method.
2653 allocate_tls(Obj_Entry
*objs
, void *oldtls
, size_t tcbsize
, size_t tcbalign
)
2658 Elf_Addr
*dtv
, *olddtv
;
2659 Elf_Addr segbase
, oldsegbase
, addr
;
2662 size
= round(tls_static_space
, tcbalign
);
2664 assert(tcbsize
>= 2*sizeof(Elf_Addr
));
2665 tls
= malloc(size
+ tcbsize
);
2666 dtv
= malloc((tls_max_index
+ 2) * sizeof(Elf_Addr
));
2668 segbase
= (Elf_Addr
)(tls
+ size
);
2669 ((Elf_Addr
*)segbase
)[0] = segbase
;
2670 ((Elf_Addr
*)segbase
)[1] = (Elf_Addr
) dtv
;
2672 dtv
[0] = tls_dtv_generation
;
2673 dtv
[1] = tls_max_index
;
2677 * Copy the static TLS block over whole.
2679 oldsegbase
= (Elf_Addr
) oldtls
;
2680 memcpy((void *)(segbase
- tls_static_space
),
2681 (const void *)(oldsegbase
- tls_static_space
),
2685 * If any dynamic TLS blocks have been created tls_get_addr(),
2688 olddtv
= ((Elf_Addr
**)oldsegbase
)[1];
2689 for (i
= 0; i
< olddtv
[1]; i
++) {
2690 if (olddtv
[i
+2] < oldsegbase
- size
|| olddtv
[i
+2] > oldsegbase
) {
2691 dtv
[i
+2] = olddtv
[i
+2];
2697 * We assume that this block was the one we created with
2698 * allocate_initial_tls().
2700 free_tls(oldtls
, 2*sizeof(Elf_Addr
), sizeof(Elf_Addr
));
2702 for (obj
= objs
; obj
; obj
= obj
->next
) {
2703 if (obj
->tlsoffset
) {
2704 addr
= segbase
- obj
->tlsoffset
;
2705 memset((void*) (addr
+ obj
->tlsinitsize
),
2706 0, obj
->tlssize
- obj
->tlsinitsize
);
2708 memcpy((void*) addr
, obj
->tlsinit
, obj
->tlsinitsize
);
2709 dtv
[obj
->tlsindex
+ 1] = addr
;
2710 } else if (obj
->tlsindex
) {
2711 dtv
[obj
->tlsindex
+ 1] = 0;
2716 return (void*) segbase
;
2720 free_tls(void *tls
, size_t tcbsize
, size_t tcbalign
)
2725 Elf_Addr tlsstart
, tlsend
;
2728 * Figure out the size of the initial TLS block so that we can
2729 * find stuff which ___tls_get_addr() allocated dynamically.
2731 size
= round(tls_static_space
, tcbalign
);
2733 dtv
= ((Elf_Addr
**)tls
)[1];
2735 tlsend
= (Elf_Addr
) tls
;
2736 tlsstart
= tlsend
- size
;
2737 for (i
= 0; i
< dtvsize
; i
++) {
2738 if (dtv
[i
+2] < tlsstart
|| dtv
[i
+2] > tlsend
) {
2739 free((void*) dtv
[i
+2]);
2743 free((void*) tlsstart
);
2749 * Allocate TLS block for module with given index.
2752 allocate_module_tls(int index
)
2757 for (obj
= obj_list
; obj
; obj
= obj
->next
) {
2758 if (obj
->tlsindex
== index
)
2762 _rtld_error("Can't find module with TLS index %d", index
);
2766 p
= malloc(obj
->tlssize
);
2767 memcpy(p
, obj
->tlsinit
, obj
->tlsinitsize
);
2768 memset(p
+ obj
->tlsinitsize
, 0, obj
->tlssize
- obj
->tlsinitsize
);
2774 allocate_tls_offset(Obj_Entry
*obj
)
2781 if (obj
->tlssize
== 0) {
2782 obj
->tls_done
= true;
2786 if (obj
->tlsindex
== 1)
2787 off
= calculate_first_tls_offset(obj
->tlssize
, obj
->tlsalign
);
2789 off
= calculate_tls_offset(tls_last_offset
, tls_last_size
,
2790 obj
->tlssize
, obj
->tlsalign
);
2793 * If we have already fixed the size of the static TLS block, we
2794 * must stay within that size. When allocating the static TLS, we
2795 * leave a small amount of space spare to be used for dynamically
2796 * loading modules which use static TLS.
2798 if (tls_static_space
) {
2799 if (calculate_tls_end(off
, obj
->tlssize
) > tls_static_space
)
2803 tls_last_offset
= obj
->tlsoffset
= off
;
2804 tls_last_size
= obj
->tlssize
;
2805 obj
->tls_done
= true;
2811 _rtld_allocate_tls(void *oldtls
, size_t tcbsize
, size_t tcbalign
)
2813 return allocate_tls(obj_list
, oldtls
, tcbsize
, tcbalign
);
2817 _rtld_free_tls(void *tcb
, size_t tcbsize
, size_t tcbalign
)
2819 free_tls(tcb
, tcbsize
, tcbalign
);