18 #include "pthread_impl.h"
22 static char errbuf
[128];
26 #if ULONG_MAX == 0xffffffff
27 typedef Elf32_Ehdr Ehdr
;
28 typedef Elf32_Phdr Phdr
;
29 typedef Elf32_Sym Sym
;
30 #define R_TYPE(x) ((x)&255)
31 #define R_SYM(x) ((x)>>8)
33 typedef Elf64_Ehdr Ehdr
;
34 typedef Elf64_Phdr Phdr
;
35 typedef Elf64_Sym Sym
;
36 #define R_TYPE(x) ((x)&0xffffffff)
37 #define R_SYM(x) ((x)>>32)
40 #define MAXP2(a,b) (-(-(a)&-(b)))
41 #define ALIGN(x,y) ((x)+(y)-1 & -(y))
55 struct dso
*next
, *prev
;
73 struct dso
**deps
, *needed_by
;
74 char *rpath_orig
, *rpath
;
76 size_t tls_len
, tls_size
, tls_align
, tls_id
, tls_offset
;
78 unsigned char *new_tls
;
79 int new_dtv_idx
, new_tls_idx
;
80 struct dso
*fini_next
;
92 void __init_ssp(size_t *);
93 void *__install_initial_tls(void *);
94 void __init_libc(char **, char *);
96 const char *__libc_get_version(void);
98 static struct dso
*head
, *tail
, *ldso
, *fini_head
;
99 static char *env_path
, *sys_path
;
100 static unsigned long long gencnt
;
104 static int ldso_fail
;
106 static jmp_buf *rtld_fail
;
107 static pthread_rwlock_t lock
;
108 static struct debug debug
;
109 static size_t tls_cnt
, tls_offset
, tls_align
= 4*sizeof(size_t);
110 static pthread_mutex_t init_fini_lock
= { ._m_type
= PTHREAD_MUTEX_RECURSIVE
};
112 struct debug
*_dl_debug_addr
= &debug
;
117 static void decode_vec(size_t *v
, size_t *a
, size_t cnt
)
119 memset(a
, 0, cnt
*sizeof(size_t));
120 for (; v
[0]; v
+=2) if (v
[0]<cnt
) {
126 static int search_vec(size_t *v
, size_t *r
, size_t key
)
128 for (; v
[0]!=key
; v
+=2)
134 static uint32_t sysv_hash(const char *s0
)
136 const unsigned char *s
= (void *)s0
;
142 return h
& 0xfffffff;
145 static uint32_t gnu_hash(const char *s0
)
147 const unsigned char *s
= (void *)s0
;
148 uint_fast32_t h
= 5381;
154 static Sym
*sysv_lookup(const char *s
, uint32_t h
, struct dso
*dso
)
157 Sym
*syms
= dso
->syms
;
158 uint32_t *hashtab
= dso
->hashtab
;
159 char *strings
= dso
->strings
;
160 for (i
=hashtab
[2+h
%hashtab
[0]]; i
; i
=hashtab
[2+hashtab
[0]+i
]) {
161 if ((!dso
->versym
|| dso
->versym
[i
] >= 0)
162 && (!strcmp(s
, strings
+syms
[i
].st_name
)))
168 static Sym
*gnu_lookup(const char *s
, uint32_t h1
, struct dso
*dso
)
170 Sym
*syms
= dso
->syms
;
171 char *strings
= dso
->strings
;
172 uint32_t *hashtab
= dso
->ghashtab
;
173 uint32_t nbuckets
= hashtab
[0];
174 uint32_t *buckets
= hashtab
+ 4 + hashtab
[2]*(sizeof(size_t)/4);
177 uint32_t i
= buckets
[h1
% nbuckets
];
181 hashval
= buckets
+ nbuckets
+ (i
- hashtab
[1]);
183 for (h1
|= 1; ; i
++) {
185 if ((!dso
->versym
|| dso
->versym
[i
] >= 0)
186 && (h1
== (h2
|1)) && !strcmp(s
, strings
+ syms
[i
].st_name
))
194 #define OK_TYPES (1<<STT_NOTYPE | 1<<STT_OBJECT | 1<<STT_FUNC | 1<<STT_COMMON | 1<<STT_TLS)
195 #define OK_BINDS (1<<STB_GLOBAL | 1<<STB_WEAK | 1<<STB_GNU_UNIQUE)
197 static struct symdef
find_sym(struct dso
*dso
, const char *s
, int need_def
)
199 uint32_t h
= 0, gh
= 0;
200 struct symdef def
= {0};
203 if (gh
== 0x1f4039c9 && !strcmp(s
, "__stack_chk_fail")) ssp_used
= 1;
206 if (h
== 0x595a4cc && !strcmp(s
, "__stack_chk_fail")) ssp_used
= 1;
208 for (; dso
; dso
=dso
->next
) {
210 if (!dso
->global
) continue;
212 if (!gh
) gh
= gnu_hash(s
);
213 sym
= gnu_lookup(s
, gh
, dso
);
215 if (!h
) h
= sysv_hash(s
);
216 sym
= sysv_lookup(s
, h
, dso
);
220 if (need_def
|| (sym
->st_info
&0xf) == STT_TLS
)
223 if ((sym
->st_info
&0xf) != STT_TLS
)
225 if (!(1<<(sym
->st_info
&0xf) & OK_TYPES
)) continue;
226 if (!(1<<(sym
->st_info
>>4) & OK_BINDS
)) continue;
228 if (def
.sym
&& sym
->st_info
>>4 == STB_WEAK
) continue;
231 if (sym
->st_info
>>4 == STB_GLOBAL
) break;
236 static void do_relocs(struct dso
*dso
, size_t *rel
, size_t rel_size
, size_t stride
)
238 unsigned char *base
= dso
->base
;
239 Sym
*syms
= dso
->syms
;
240 char *strings
= dso
->strings
;
248 for (; rel_size
; rel
+=stride
, rel_size
-=stride
*sizeof(size_t)) {
249 type
= R_TYPE(rel
[1]);
250 sym_index
= R_SYM(rel
[1]);
252 sym
= syms
+ sym_index
;
253 name
= strings
+ sym
->st_name
;
254 ctx
= IS_COPY(type
) ? head
->next
: head
;
255 def
= find_sym(ctx
, name
, IS_PLT(type
));
256 if (!def
.sym
&& (sym
->st_shndx
!= SHN_UNDEF
257 || sym
->st_info
>>4 != STB_WEAK
)) {
258 snprintf(errbuf
, sizeof errbuf
,
259 "Error relocating %s: %s: symbol not found",
261 if (runtime
) longjmp(*rtld_fail
, 1);
262 dprintf(2, "%s\n", errbuf
);
271 do_single_reloc(dso
, base
, (void *)(base
+ rel
[0]), type
,
272 stride
>2 ? rel
[2] : 0, sym
, sym
?sym
->st_size
:0, def
,
273 def
.sym
?(size_t)(def
.dso
->base
+def
.sym
->st_value
):0);
277 /* A huge hack: to make up for the wastefulness of shared libraries
278 * needing at least a page of dirty memory even if they have no global
279 * data, we reclaim the gaps at the beginning and end of writable maps
280 * and "donate" them to the heap by setting up minimal malloc
281 * structures and then freeing them. */
283 static void reclaim(unsigned char *base
, size_t start
, size_t end
)
286 start
= start
+ 6*sizeof(size_t)-1 & -4*sizeof(size_t);
287 end
= (end
& -4*sizeof(size_t)) - 2*sizeof(size_t);
288 if (start
>end
|| end
-start
< 4*sizeof(size_t)) return;
289 a
= (size_t *)(base
+ start
);
290 z
= (size_t *)(base
+ end
);
292 a
[-1] = z
[0] = end
-start
+ 2*sizeof(size_t) | 1;
297 static void reclaim_gaps(unsigned char *base
, Phdr
*ph
, size_t phent
, size_t phcnt
)
299 for (; phcnt
--; ph
=(void *)((char *)ph
+phent
)) {
300 if (ph
->p_type
!=PT_LOAD
) continue;
301 if ((ph
->p_flags
&(PF_R
|PF_W
))!=(PF_R
|PF_W
)) continue;
302 reclaim(base
, ph
->p_vaddr
& -PAGE_SIZE
, ph
->p_vaddr
);
303 reclaim(base
, ph
->p_vaddr
+ph
->p_memsz
,
304 ph
->p_vaddr
+ph
->p_memsz
+PAGE_SIZE
-1 & -PAGE_SIZE
);
308 static void *map_library(int fd
, struct dso
*dso
)
310 Ehdr buf
[(896+sizeof(Ehdr
))/sizeof(Ehdr
)];
311 void *allocated_buf
=0;
313 size_t addr_min
=SIZE_MAX
, addr_max
=0, map_len
;
314 size_t this_min
, this_max
;
319 unsigned char *map
=MAP_FAILED
, *base
;
324 ssize_t l
= read(fd
, buf
, sizeof buf
);
327 if (l
<sizeof *eh
|| (eh
->e_type
!= ET_DYN
&& eh
->e_type
!= ET_EXEC
))
329 phsize
= eh
->e_phentsize
* eh
->e_phnum
;
330 if (phsize
> sizeof buf
- sizeof *eh
) {
331 allocated_buf
= malloc(phsize
);
332 if (!allocated_buf
) return 0;
333 l
= pread(fd
, allocated_buf
, phsize
, eh
->e_phoff
);
334 if (l
< 0) goto error
;
335 if (l
!= phsize
) goto noexec
;
336 ph
= ph0
= allocated_buf
;
337 } else if (eh
->e_phoff
+ phsize
> l
) {
338 l
= pread(fd
, buf
+1, phsize
, eh
->e_phoff
);
339 if (l
< 0) goto error
;
340 if (l
!= phsize
) goto noexec
;
341 ph
= ph0
= (void *)(buf
+ 1);
343 ph
= ph0
= (void *)((char *)buf
+ eh
->e_phoff
);
345 for (i
=eh
->e_phnum
; i
; i
--, ph
=(void *)((char *)ph
+eh
->e_phentsize
)) {
346 if (ph
->p_type
== PT_DYNAMIC
)
348 if (ph
->p_type
== PT_TLS
) {
349 tls_image
= ph
->p_vaddr
;
350 dso
->tls_align
= ph
->p_align
;
351 dso
->tls_len
= ph
->p_filesz
;
352 dso
->tls_size
= ph
->p_memsz
;
354 if (ph
->p_type
!= PT_LOAD
) continue;
355 if (ph
->p_vaddr
< addr_min
) {
356 addr_min
= ph
->p_vaddr
;
357 off_start
= ph
->p_offset
;
358 prot
= (((ph
->p_flags
&PF_R
) ? PROT_READ
: 0) |
359 ((ph
->p_flags
&PF_W
) ? PROT_WRITE
: 0) |
360 ((ph
->p_flags
&PF_X
) ? PROT_EXEC
: 0));
362 if (ph
->p_vaddr
+ph
->p_memsz
> addr_max
) {
363 addr_max
= ph
->p_vaddr
+ph
->p_memsz
;
366 if (!dyn
) goto noexec
;
367 addr_max
+= PAGE_SIZE
-1;
368 addr_max
&= -PAGE_SIZE
;
369 addr_min
&= -PAGE_SIZE
;
370 off_start
&= -PAGE_SIZE
;
371 map_len
= addr_max
- addr_min
+ off_start
;
372 /* The first time, we map too much, possibly even more than
373 * the length of the file. This is okay because we will not
374 * use the invalid part; we just need to reserve the right
375 * amount of virtual address space to map over later. */
376 map
= mmap((void *)addr_min
, map_len
, prot
, MAP_PRIVATE
, fd
, off_start
);
377 if (map
==MAP_FAILED
) goto error
;
378 /* If the loaded file is not relocatable and the requested address is
379 * not available, then the load operation must fail. */
380 if (eh
->e_type
!= ET_DYN
&& addr_min
&& map
!=(void *)addr_min
) {
384 base
= map
- addr_min
;
387 for (ph
=ph0
, i
=eh
->e_phnum
; i
; i
--, ph
=(void *)((char *)ph
+eh
->e_phentsize
)) {
388 if (ph
->p_type
!= PT_LOAD
) continue;
389 /* Check if the programs headers are in this load segment, and
390 * if so, record the address for use by dl_iterate_phdr. */
391 if (!dso
->phdr
&& eh
->e_phoff
>= ph
->p_offset
392 && eh
->e_phoff
+phsize
<= ph
->p_offset
+ph
->p_filesz
) {
393 dso
->phdr
= (void *)(base
+ ph
->p_vaddr
394 + (eh
->e_phoff
-ph
->p_offset
));
395 dso
->phnum
= eh
->e_phnum
;
397 /* Reuse the existing mapping for the lowest-address LOAD */
398 if ((ph
->p_vaddr
& -PAGE_SIZE
) == addr_min
) continue;
399 this_min
= ph
->p_vaddr
& -PAGE_SIZE
;
400 this_max
= ph
->p_vaddr
+ph
->p_memsz
+PAGE_SIZE
-1 & -PAGE_SIZE
;
401 off_start
= ph
->p_offset
& -PAGE_SIZE
;
402 prot
= (((ph
->p_flags
&PF_R
) ? PROT_READ
: 0) |
403 ((ph
->p_flags
&PF_W
) ? PROT_WRITE
: 0) |
404 ((ph
->p_flags
&PF_X
) ? PROT_EXEC
: 0));
405 if (mmap(base
+this_min
, this_max
-this_min
, prot
, MAP_PRIVATE
|MAP_FIXED
, fd
, off_start
) == MAP_FAILED
)
407 if (ph
->p_memsz
> ph
->p_filesz
) {
408 size_t brk
= (size_t)base
+ph
->p_vaddr
+ph
->p_filesz
;
409 size_t pgbrk
= brk
+PAGE_SIZE
-1 & -PAGE_SIZE
;
410 memset((void *)brk
, 0, pgbrk
-brk
& PAGE_SIZE
-1);
411 if (pgbrk
-(size_t)base
< this_max
&& mmap((void *)pgbrk
, (size_t)base
+this_max
-pgbrk
, prot
, MAP_PRIVATE
|MAP_FIXED
|MAP_ANONYMOUS
, -1, 0) == MAP_FAILED
)
415 for (i
=0; ((size_t *)(base
+dyn
))[i
]; i
+=2)
416 if (((size_t *)(base
+dyn
))[i
]==DT_TEXTREL
) {
417 if (mprotect(map
, map_len
, PROT_READ
|PROT_WRITE
|PROT_EXEC
) < 0)
421 if (!runtime
) reclaim_gaps(base
, ph0
, eh
->e_phentsize
, eh
->e_phnum
);
423 dso
->map_len
= map_len
;
425 dso
->dynv
= (void *)(base
+dyn
);
426 if (dso
->tls_size
) dso
->tls_image
= (void *)(base
+tls_image
);
432 if (map
!=MAP_FAILED
) munmap(map
, map_len
);
437 static int path_open(const char *name
, const char *s
, char *buf
, size_t buf_size
)
442 s
+= strspn(s
, ":\n");
443 l
= strcspn(s
, ":\n");
444 if (l
-1 >= INT_MAX
) return -1;
445 if (snprintf(buf
, buf_size
, "%.*s/%s", (int)l
, s
, name
) >= buf_size
)
447 if ((fd
= open(buf
, O_RDONLY
|O_CLOEXEC
))>=0) return fd
;
452 static int fixup_rpath(struct dso
*p
, char *buf
, size_t buf_size
)
455 const char *s
, *t
, *origin
;
457 if (p
->rpath
) return 0;
458 if (!p
->rpath_orig
) return -1;
459 if (!strchr(p
->rpath_orig
, '$')) {
460 p
->rpath
= p
->rpath_orig
;
465 while ((t
=strchr(s
, '$'))) {
466 if (strncmp(t
, "$ORIGIN", 7) && strncmp(t
, "${ORIGIN}", 9))
471 if (n
> SSIZE_MAX
/PATH_MAX
) return -1;
473 if (p
->kernel_mapped
) {
474 /* $ORIGIN searches cannot be performed for the main program
475 * when it is suid/sgid/AT_SECURE. This is because the
476 * pathname is under the control of the caller of execve.
477 * For libraries, however, $ORIGIN can be processed safely
478 * since the library's pathname came from a trusted source
479 * (either system paths or a call to dlopen). */
482 l
= readlink("/proc/self/exe", buf
, buf_size
);
490 t
= strrchr(origin
, '/');
491 l
= t
? t
-origin
: 0;
492 p
->rpath
= malloc(strlen(p
->rpath_orig
) + n
*l
+ 1);
493 if (!p
->rpath
) return -1;
497 while ((t
=strchr(s
, '$'))) {
500 memcpy(d
, origin
, l
);
502 /* It was determined previously that the '$' is followed
503 * either by "ORIGIN" or "{ORIGIN}". */
504 s
= t
+ 7 + 2*(t
[1]=='{');
510 static void decode_dyn(struct dso
*p
)
512 size_t dyn
[DYN_CNT
] = {0};
513 decode_vec(p
->dynv
, dyn
, DYN_CNT
);
514 p
->syms
= (void *)(p
->base
+ dyn
[DT_SYMTAB
]);
515 p
->strings
= (void *)(p
->base
+ dyn
[DT_STRTAB
]);
516 if (dyn
[0]&(1<<DT_HASH
))
517 p
->hashtab
= (void *)(p
->base
+ dyn
[DT_HASH
]);
518 if (dyn
[0]&(1<<DT_RPATH
))
519 p
->rpath_orig
= (void *)(p
->strings
+ dyn
[DT_RPATH
]);
520 if (search_vec(p
->dynv
, dyn
, DT_GNU_HASH
))
521 p
->ghashtab
= (void *)(p
->base
+ *dyn
);
522 if (search_vec(p
->dynv
, dyn
, DT_VERSYM
))
523 p
->versym
= (void *)(p
->base
+ *dyn
);
526 static struct dso
*load_library(const char *name
, struct dso
*needed_by
)
528 char buf
[2*NAME_MAX
+2];
529 const char *pathname
;
531 struct dso
*p
, temp_dso
= {0};
538 /* Catch and block attempts to reload the implementation itself */
539 if (name
[0]=='l' && name
[1]=='i' && name
[2]=='b') {
540 static const char *rp
, reserved
[] =
541 "c\0pthread\0rt\0m\0dl\0util\0xnet\0";
542 char *z
= strchr(name
, '.');
545 for (rp
=reserved
; *rp
&& strncmp(name
+3, rp
, l
-3); rp
+=strlen(rp
)+1);
548 /* Track which names have been resolved
549 * and only report each one once. */
550 static unsigned reported
;
551 unsigned mask
= 1U<<(rp
-reserved
);
552 if (!(reported
& mask
)) {
554 dprintf(1, "\t%s => %s (%p)\n",
563 if (!strcmp(name
, ldso
->name
)) is_self
= 1;
568 tail
= ldso
->next
? ldso
->next
: ldso
;
572 if (strchr(name
, '/')) {
574 fd
= open(name
, O_RDONLY
|O_CLOEXEC
);
576 /* Search for the name to see if it's already loaded */
577 for (p
=head
->next
; p
; p
=p
->next
) {
578 if (p
->shortname
&& !strcmp(p
->shortname
, name
)) {
583 if (strlen(name
) > NAME_MAX
) return 0;
585 if (env_path
) fd
= path_open(name
, env_path
, buf
, sizeof buf
);
586 for (p
=needed_by
; fd
< 0 && p
; p
=p
->needed_by
)
587 if (!fixup_rpath(p
, buf
, sizeof buf
))
588 fd
= path_open(name
, p
->rpath
, buf
, sizeof buf
);
593 if (ldso
->name
[0]=='/') {
595 for (s
=t
=z
=ldso
->name
; *s
; s
++)
596 if (*s
=='/') z
=t
, t
=s
;
597 prefix_len
= z
-ldso
->name
;
598 if (prefix_len
< PATH_MAX
)
605 char etc_ldso_path
[prefix_len
+ 1
606 + sizeof "/etc/ld-musl-" LDSO_ARCH
".path"];
607 snprintf(etc_ldso_path
, sizeof etc_ldso_path
,
608 "%.*s/etc/ld-musl-" LDSO_ARCH
".path",
609 (int)prefix_len
, prefix
);
610 FILE *f
= fopen(etc_ldso_path
, "rbe");
612 if (getdelim(&sys_path
, (size_t[1]){0}, 0, f
) <= 0) {
617 } else if (errno
!= ENOENT
) {
621 if (!sys_path
) sys_path
= "/lib:/usr/local/lib:/usr/lib";
622 fd
= path_open(name
, sys_path
, buf
, sizeof buf
);
626 if (fd
< 0) return 0;
627 if (fstat(fd
, &st
) < 0) {
631 for (p
=head
->next
; p
; p
=p
->next
) {
632 if (p
->dev
== st
.st_dev
&& p
->ino
== st
.st_ino
) {
633 /* If this library was previously loaded with a
634 * pathname but a search found the same inode,
635 * setup its shortname so it can be found by name. */
636 if (!p
->shortname
&& pathname
!= name
)
637 p
->shortname
= strrchr(p
->name
, '/')+1;
643 map
= noload
? 0 : map_library(fd
, &temp_dso
);
647 /* Allocate storage for the new DSO. When there is TLS, this
648 * storage must include a reservation for all pre-existing
649 * threads to obtain copies of both the new TLS, and an
650 * extended DTV capable of storing an additional slot for
651 * the newly-loaded DSO. */
652 alloc_size
= sizeof *p
+ strlen(pathname
) + 1;
653 if (runtime
&& temp_dso
.tls_image
) {
654 size_t per_th
= temp_dso
.tls_size
+ temp_dso
.tls_align
655 + sizeof(void *) * (tls_cnt
+3);
656 n_th
= libc
.threads_minus_1
+ 1;
657 if (n_th
> SSIZE_MAX
/ per_th
) alloc_size
= SIZE_MAX
;
658 else alloc_size
+= n_th
* per_th
;
660 p
= calloc(1, alloc_size
);
662 munmap(map
, temp_dso
.map_len
);
665 memcpy(p
, &temp_dso
, sizeof temp_dso
);
670 p
->needed_by
= needed_by
;
672 strcpy(p
->name
, pathname
);
673 /* Add a shortname only if name arg was not an explicit pathname. */
674 if (pathname
!= name
) p
->shortname
= strrchr(p
->name
, '/')+1;
676 if (runtime
&& !__pthread_self_init()) {
677 munmap(map
, p
->map_len
);
681 p
->tls_id
= ++tls_cnt
;
682 tls_align
= MAXP2(tls_align
, p
->tls_align
);
684 p
->tls_offset
= tls_offset
+ ( (tls_align
-1) &
685 -(tls_offset
+ (uintptr_t)p
->tls_image
) );
686 tls_offset
+= p
->tls_size
;
688 tls_offset
+= p
->tls_size
+ p
->tls_align
- 1;
689 tls_offset
-= (tls_offset
+ (uintptr_t)p
->tls_image
)
691 p
->tls_offset
= tls_offset
;
693 p
->new_dtv
= (void *)(-sizeof(size_t) &
694 (uintptr_t)(p
->name
+strlen(p
->name
)+sizeof(size_t)));
695 p
->new_tls
= (void *)(p
->new_dtv
+ n_th
*(tls_cnt
+1));
702 if (ldd_mode
) dprintf(1, "\t%s => %s (%p)\n", name
, pathname
, p
->base
);
707 static void load_deps(struct dso
*p
)
710 struct dso
***deps
= &p
->deps
, **tmp
, *dep
;
711 for (; p
; p
=p
->next
) {
712 for (i
=0; p
->dynv
[i
]; i
+=2) {
713 if (p
->dynv
[i
] != DT_NEEDED
) continue;
714 dep
= load_library(p
->strings
+ p
->dynv
[i
+1], p
);
716 snprintf(errbuf
, sizeof errbuf
,
717 "Error loading shared library %s: %m (needed by %s)",
718 p
->strings
+ p
->dynv
[i
+1], p
->name
);
719 if (runtime
) longjmp(*rtld_fail
, 1);
720 dprintf(2, "%s\n", errbuf
);
725 tmp
= realloc(*deps
, sizeof(*tmp
)*(ndeps
+2));
726 if (!tmp
) longjmp(*rtld_fail
, 1);
735 static void load_preload(char *s
)
740 for ( ; *s
&& isspace(*s
); s
++);
741 for (z
=s
; *z
&& !isspace(*z
); z
++);
749 static void make_global(struct dso
*p
)
751 for (; p
; p
=p
->next
) p
->global
= 1;
754 static void reloc_all(struct dso
*p
)
756 size_t dyn
[DYN_CNT
] = {0};
757 for (; p
; p
=p
->next
) {
758 if (p
->relocated
) continue;
759 decode_vec(p
->dynv
, dyn
, DYN_CNT
);
760 #ifdef NEED_ARCH_RELOCS
761 do_arch_relocs(p
, head
);
763 do_relocs(p
, (void *)(p
->base
+dyn
[DT_JMPREL
]), dyn
[DT_PLTRELSZ
],
764 2+(dyn
[DT_PLTREL
]==DT_RELA
));
765 do_relocs(p
, (void *)(p
->base
+dyn
[DT_REL
]), dyn
[DT_RELSZ
], 2);
766 do_relocs(p
, (void *)(p
->base
+dyn
[DT_RELA
]), dyn
[DT_RELASZ
], 3);
771 static size_t find_dyn(Phdr
*ph
, size_t cnt
, size_t stride
)
773 for (; cnt
--; ph
= (void *)((char *)ph
+ stride
))
774 if (ph
->p_type
== PT_DYNAMIC
)
779 static void find_map_range(Phdr
*ph
, size_t cnt
, size_t stride
, struct dso
*p
)
781 size_t min_addr
= -1, max_addr
= 0;
782 for (; cnt
--; ph
= (void *)((char *)ph
+ stride
)) {
783 if (ph
->p_type
!= PT_LOAD
) continue;
784 if (ph
->p_vaddr
< min_addr
)
785 min_addr
= ph
->p_vaddr
;
786 if (ph
->p_vaddr
+ph
->p_memsz
> max_addr
)
787 max_addr
= ph
->p_vaddr
+ph
->p_memsz
;
789 min_addr
&= -PAGE_SIZE
;
790 max_addr
= (max_addr
+ PAGE_SIZE
-1) & -PAGE_SIZE
;
791 p
->map
= p
->base
+ min_addr
;
792 p
->map_len
= max_addr
- min_addr
;
795 static void do_fini()
798 size_t dyn
[DYN_CNT
] = {0};
799 for (p
=fini_head
; p
; p
=p
->fini_next
) {
800 if (!p
->constructed
) continue;
801 decode_vec(p
->dynv
, dyn
, DYN_CNT
);
802 if (dyn
[0] & (1<<DT_FINI_ARRAY
)) {
803 size_t n
= dyn
[DT_FINI_ARRAYSZ
]/sizeof(size_t);
804 size_t *fn
= (size_t *)(p
->base
+ dyn
[DT_FINI_ARRAY
])+n
;
805 while (n
--) ((void (*)(void))*--fn
)();
807 #ifndef NO_LEGACY_INITFINI
808 if ((dyn
[0] & (1<<DT_FINI
)) && dyn
[DT_FINI
])
809 ((void (*)(void))(p
->base
+ dyn
[DT_FINI
]))();
814 static void do_init_fini(struct dso
*p
)
816 size_t dyn
[DYN_CNT
] = {0};
817 int need_locking
= libc
.threads_minus_1
;
818 /* Allow recursive calls that arise when a library calls
819 * dlopen from one of its constructors, but block any
820 * other threads until all ctors have finished. */
821 if (need_locking
) pthread_mutex_lock(&init_fini_lock
);
822 for (; p
; p
=p
->prev
) {
823 if (p
->constructed
) continue;
825 decode_vec(p
->dynv
, dyn
, DYN_CNT
);
826 if (dyn
[0] & ((1<<DT_FINI
) | (1<<DT_FINI_ARRAY
))) {
827 p
->fini_next
= fini_head
;
830 #ifndef NO_LEGACY_INITFINI
831 if ((dyn
[0] & (1<<DT_INIT
)) && dyn
[DT_INIT
])
832 ((void (*)(void))(p
->base
+ dyn
[DT_INIT
]))();
834 if (dyn
[0] & (1<<DT_INIT_ARRAY
)) {
835 size_t n
= dyn
[DT_INIT_ARRAYSZ
]/sizeof(size_t);
836 size_t *fn
= (void *)(p
->base
+ dyn
[DT_INIT_ARRAY
]);
837 while (n
--) ((void (*)(void))*fn
++)();
839 if (!need_locking
&& libc
.threads_minus_1
) {
841 pthread_mutex_lock(&init_fini_lock
);
844 if (need_locking
) pthread_mutex_unlock(&init_fini_lock
);
847 void _dl_debug_state(void)
853 pthread_t self
= __pthread_self();
855 for (p
=head
; p
; p
=p
->next
) {
856 if (!p
->tls_id
|| !self
->dtv
[p
->tls_id
]) continue;
857 memcpy(self
->dtv
[p
->tls_id
], p
->tls_image
, p
->tls_len
);
858 memset((char *)self
->dtv
[p
->tls_id
]+p
->tls_len
, 0,
859 p
->tls_size
- p
->tls_len
);
860 if (p
->tls_id
== (size_t)self
->dtv
[0]) break;
864 void *__copy_tls(unsigned char *mem
)
869 if (!tls_cnt
) return mem
;
871 void **dtv
= (void *)mem
;
872 dtv
[0] = (void *)tls_cnt
;
875 mem
+= sizeof(void *) * (tls_cnt
+1);
876 mem
+= -((uintptr_t)mem
+ sizeof(struct pthread
)) & (tls_align
-1);
878 mem
+= sizeof(struct pthread
);
880 for (p
=head
; p
; p
=p
->next
) {
881 if (!p
->tls_id
) continue;
882 dtv
[p
->tls_id
] = mem
+ p
->tls_offset
;
883 memcpy(dtv
[p
->tls_id
], p
->tls_image
, p
->tls_len
);
886 mem
+= libc
.tls_size
- sizeof(struct pthread
);
887 mem
-= (uintptr_t)mem
& (tls_align
-1);
890 for (p
=head
; p
; p
=p
->next
) {
891 if (!p
->tls_id
) continue;
892 dtv
[p
->tls_id
] = mem
- p
->tls_offset
;
893 memcpy(dtv
[p
->tls_id
], p
->tls_image
, p
->tls_len
);
900 void *__tls_get_addr(size_t *v
)
902 pthread_t self
= __pthread_self();
903 if (v
[0]<=(size_t)self
->dtv
[0] && self
->dtv
[v
[0]])
904 return (char *)self
->dtv
[v
[0]]+v
[1];
906 /* Block signals to make accessing new TLS async-signal-safe */
908 pthread_sigmask(SIG_BLOCK
, SIGALL_SET
, &set
);
909 if (v
[0]<=(size_t)self
->dtv
[0] && self
->dtv
[v
[0]]) {
910 pthread_sigmask(SIG_SETMASK
, &set
, 0);
911 return (char *)self
->dtv
[v
[0]]+v
[1];
914 /* This is safe without any locks held because, if the caller
915 * is able to request the Nth entry of the DTV, the DSO list
916 * must be valid at least that far out and it was synchronized
917 * at program startup or by an already-completed call to dlopen. */
919 for (p
=head
; p
->tls_id
!= v
[0]; p
=p
->next
);
921 /* Get new DTV space from new DSO if needed */
922 if (v
[0] > (size_t)self
->dtv
[0]) {
923 void **newdtv
= p
->new_dtv
+
924 (v
[0]+1)*sizeof(void *)*a_fetch_add(&p
->new_dtv_idx
,1);
925 memcpy(newdtv
, self
->dtv
,
926 ((size_t)self
->dtv
[0]+1) * sizeof(void *));
927 newdtv
[0] = (void *)v
[0];
931 /* Get new TLS memory from new DSO */
932 unsigned char *mem
= p
->new_tls
+
933 (p
->tls_size
+ p
->tls_align
) * a_fetch_add(&p
->new_tls_idx
,1);
934 mem
+= ((uintptr_t)p
->tls_image
- (uintptr_t)mem
) & (p
->tls_align
-1);
935 self
->dtv
[v
[0]] = mem
;
936 memcpy(mem
, p
->tls_image
, p
->tls_len
);
937 pthread_sigmask(SIG_SETMASK
, &set
, 0);
941 static void update_tls_size()
943 libc
.tls_size
= ALIGN(
944 (1+tls_cnt
) * sizeof(void *) +
946 sizeof(struct pthread
) +
951 void *__dynlink(int argc
, char **argv
)
953 size_t aux
[AUX_CNT
] = {0};
957 static struct dso builtin_dsos
[3];
958 struct dso
*const app
= builtin_dsos
+0;
959 struct dso
*const lib
= builtin_dsos
+1;
960 struct dso
*const vdso
= builtin_dsos
+2;
964 char **envp
= argv
+argc
+1;
966 /* Find aux vector just past environ[] */
967 for (i
=argc
+1; argv
[i
]; i
++)
968 if (!memcmp(argv
[i
], "LD_LIBRARY_PATH=", 16))
969 env_path
= argv
[i
]+16;
970 else if (!memcmp(argv
[i
], "LD_PRELOAD=", 11))
971 env_preload
= argv
[i
]+11;
972 auxv
= (void *)(argv
+i
+1);
974 decode_vec(auxv
, aux
, AUX_CNT
);
976 /* Only trust user/env if kernel says we're not suid/sgid */
977 if ((aux
[0]&0x7800)!=0x7800 || aux
[AT_UID
]!=aux
[AT_EUID
]
978 || aux
[AT_GID
]!=aux
[AT_EGID
] || aux
[AT_SECURE
]) {
983 libc
.page_size
= aux
[AT_PAGESZ
];
985 /* If the dynamic linker was invoked as a program itself, AT_BASE
986 * will not be set. In that case, we assume the base address is
987 * the start of the page containing the PHDRs; I don't know any
988 * better approach... */
990 aux
[AT_BASE
] = aux
[AT_PHDR
] & -PAGE_SIZE
;
991 aux
[AT_PHDR
] = aux
[AT_PHENT
] = aux
[AT_PHNUM
] = 0;
994 /* The dynamic linker load address is passed by the kernel
995 * in the AUX vector, so this is easy. */
996 lib
->base
= (void *)aux
[AT_BASE
];
997 lib
->name
= lib
->shortname
= "libc.so";
999 lib
->kernel_mapped
= 1;
1000 ehdr
= (void *)lib
->base
;
1001 lib
->phnum
= ehdr
->e_phnum
;
1002 lib
->phdr
= (void *)(aux
[AT_BASE
]+ehdr
->e_phoff
);
1003 find_map_range(lib
->phdr
, ehdr
->e_phnum
, ehdr
->e_phentsize
, lib
);
1004 lib
->dynv
= (void *)(lib
->base
+ find_dyn(lib
->phdr
,
1005 ehdr
->e_phnum
, ehdr
->e_phentsize
));
1009 size_t interp_off
= 0;
1010 size_t tls_image
= 0;
1011 /* Find load address of the main program, via AT_PHDR vs PT_PHDR. */
1012 app
->phdr
= phdr
= (void *)aux
[AT_PHDR
];
1013 app
->phnum
= aux
[AT_PHNUM
];
1014 for (i
=aux
[AT_PHNUM
]; i
; i
--, phdr
=(void *)((char *)phdr
+ aux
[AT_PHENT
])) {
1015 if (phdr
->p_type
== PT_PHDR
)
1016 app
->base
= (void *)(aux
[AT_PHDR
] - phdr
->p_vaddr
);
1017 else if (phdr
->p_type
== PT_INTERP
)
1018 interp_off
= (size_t)phdr
->p_vaddr
;
1019 else if (phdr
->p_type
== PT_TLS
) {
1020 tls_image
= phdr
->p_vaddr
;
1021 app
->tls_len
= phdr
->p_filesz
;
1022 app
->tls_size
= phdr
->p_memsz
;
1023 app
->tls_align
= phdr
->p_align
;
1026 if (app
->tls_size
) app
->tls_image
= (char *)app
->base
+ tls_image
;
1027 if (interp_off
) lib
->name
= (char *)app
->base
+ interp_off
;
1028 if ((aux
[0] & (1UL<<AT_EXECFN
))
1029 && strncmp((char *)aux
[AT_EXECFN
], "/proc/", 6))
1030 app
->name
= (char *)aux
[AT_EXECFN
];
1032 app
->name
= argv
[0];
1033 app
->kernel_mapped
= 1;
1034 app
->dynv
= (void *)(app
->base
+ find_dyn(
1035 (void *)aux
[AT_PHDR
], aux
[AT_PHNUM
], aux
[AT_PHENT
]));
1036 find_map_range((void *)aux
[AT_PHDR
],
1037 aux
[AT_PHNUM
], aux
[AT_PHENT
], app
);
1040 char *ldname
= argv
[0];
1041 size_t l
= strlen(ldname
);
1042 if (l
>= 3 && !strcmp(ldname
+l
-3, "ldd")) ldd_mode
= 1;
1043 *argv
++ = (void *)-1;
1044 if (argv
[0] && !strcmp(argv
[0], "--")) *argv
++ = (void *)-1;
1046 dprintf(2, "musl libc\n"
1048 "Dynamic Program Loader\n"
1049 "Usage: %s [--] pathname%s\n",
1050 __libc_get_version(), ldname
,
1051 ldd_mode
? "" : " [args]");
1054 fd
= open(argv
[0], O_RDONLY
);
1056 dprintf(2, "%s: cannot load %s: %s\n", ldname
, argv
[0], strerror(errno
));
1060 ehdr
= (void *)map_library(fd
, app
);
1062 dprintf(2, "%s: %s: Not a valid dynamic program\n", ldname
, argv
[0]);
1068 app
->name
= argv
[0];
1069 aux
[AT_ENTRY
] = (size_t)app
->base
+ ehdr
->e_entry
;
1070 /* Find the name that would have been used for the dynamic
1071 * linker had ldd not taken its place. */
1073 for (i
=0; i
<app
->phnum
; i
++) {
1074 if (app
->phdr
[i
].p_type
== PT_INTERP
)
1075 lib
->name
= (void *)(app
->base
1076 + app
->phdr
[i
].p_vaddr
);
1078 dprintf(1, "\t%s (%p)\n", lib
->name
, lib
->base
);
1081 if (app
->tls_size
) {
1082 app
->tls_id
= tls_cnt
= 1;
1084 app
->tls_offset
= 0;
1085 tls_offset
= app
->tls_size
1086 + ( -((uintptr_t)app
->tls_image
+ app
->tls_size
)
1087 & (app
->tls_align
-1) );
1089 tls_offset
= app
->tls_offset
= app
->tls_size
1090 + ( -((uintptr_t)app
->tls_image
+ app
->tls_size
)
1091 & (app
->tls_align
-1) );
1093 tls_align
= MAXP2(tls_align
, app
->tls_align
);
1098 /* Attach to vdso, if provided by the kernel */
1099 if (search_vec(auxv
, &vdso_base
, AT_SYSINFO_EHDR
)) {
1100 ehdr
= (void *)vdso_base
;
1101 vdso
->phdr
= phdr
= (void *)(vdso_base
+ ehdr
->e_phoff
);
1102 vdso
->phnum
= ehdr
->e_phnum
;
1103 for (i
=ehdr
->e_phnum
; i
; i
--, phdr
=(void *)((char *)phdr
+ ehdr
->e_phentsize
)) {
1104 if (phdr
->p_type
== PT_DYNAMIC
)
1105 vdso
->dynv
= (void *)(vdso_base
+ phdr
->p_offset
);
1106 if (phdr
->p_type
== PT_LOAD
)
1107 vdso
->base
= (void *)(vdso_base
- phdr
->p_vaddr
+ phdr
->p_offset
);
1110 vdso
->shortname
= "linux-gate.so.1";
1117 /* Initial dso chain consists only of the app. We temporarily
1118 * append the dynamic linker/libc so we can relocate it, then
1119 * restore the initial chain in preparation for loading third
1120 * party libraries (preload/needed). */
1127 /* PAST THIS POINT, ALL LIBC INTERFACES ARE FULLY USABLE. */
1129 /* Donate unused parts of app and library mapping to malloc */
1130 reclaim_gaps(app
->base
, (void *)aux
[AT_PHDR
], aux
[AT_PHENT
], aux
[AT_PHNUM
]);
1131 ehdr
= (void *)lib
->base
;
1132 reclaim_gaps(lib
->base
, (void *)(lib
->base
+ehdr
->e_phoff
),
1133 ehdr
->e_phentsize
, ehdr
->e_phnum
);
1135 /* Load preload/needed libraries, add their symbols to the global
1136 * namespace, and perform all remaining relocations. The main
1137 * program must be relocated LAST since it may contain copy
1138 * relocations which depend on libraries' relocations. */
1139 if (env_preload
) load_preload(env_preload
);
1143 reloc_all(app
->next
);
1148 void *mem
= mmap(0, libc
.tls_size
, PROT_READ
|PROT_WRITE
,
1149 MAP_ANONYMOUS
|MAP_PRIVATE
, -1, 0);
1150 if (mem
==MAP_FAILED
||
1151 !__install_initial_tls(__copy_tls(mem
))) {
1152 dprintf(2, "%s: Error getting %zu bytes thread-local storage: %m\n",
1153 argv
[0], libc
.tls_size
);
1158 if (ldso_fail
) _exit(127);
1159 if (ldd_mode
) _exit(0);
1161 /* Switch to runtime mode: any further failures in the dynamic
1162 * linker are a reportable failure rather than a fatal startup
1163 * error. If the dynamic loader (dlopen) will not be used, free
1164 * all memory used by the dynamic linker. */
1167 #ifndef DYNAMIC_IS_RO
1168 for (i
=0; app
->dynv
[i
]; i
+=2)
1169 if (app
->dynv
[i
]==DT_DEBUG
)
1170 app
->dynv
[i
+1] = (size_t)&debug
;
1173 debug
.bp
= _dl_debug_state
;
1175 debug
.base
= lib
->base
;
1179 if (ssp_used
) __init_ssp((void *)aux
[AT_RANDOM
]);
1180 __init_libc(envp
, argv
[0]);
1185 return (void *)aux
[AT_ENTRY
];
1188 void *dlopen(const char *file
, int mode
)
1190 struct dso
*volatile p
, *orig_tail
, *next
;
1191 size_t orig_tls_cnt
, orig_tls_offset
, orig_tls_align
;
1196 if (!file
) return head
;
1198 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE
, &cs
);
1199 pthread_rwlock_wrlock(&lock
);
1203 orig_tls_cnt
= tls_cnt
;
1204 orig_tls_offset
= tls_offset
;
1205 orig_tls_align
= tls_align
;
1207 noload
= mode
& RTLD_NOLOAD
;
1210 if (setjmp(*rtld_fail
)) {
1211 /* Clean up anything new that was (partially) loaded */
1212 if (p
&& p
->deps
) for (i
=0; p
->deps
[i
]; i
++)
1213 if (p
->deps
[i
]->global
< 0)
1214 p
->deps
[i
]->global
= 0;
1215 for (p
=orig_tail
->next
; p
; p
=next
) {
1217 munmap(p
->map
, p
->map_len
);
1221 tls_cnt
= orig_tls_cnt
;
1222 tls_offset
= orig_tls_offset
;
1223 tls_align
= orig_tls_align
;
1229 } else p
= load_library(file
, head
);
1232 snprintf(errbuf
, sizeof errbuf
, noload
?
1233 "Library %s is not already loaded" :
1234 "Error loading shared library %s: %m",
1240 /* First load handling */
1243 if (p
->deps
) for (i
=0; p
->deps
[i
]; i
++)
1244 if (!p
->deps
[i
]->global
)
1245 p
->deps
[i
]->global
= -1;
1246 if (!p
->global
) p
->global
= -1;
1248 if (p
->deps
) for (i
=0; p
->deps
[i
]; i
++)
1249 if (p
->deps
[i
]->global
< 0)
1250 p
->deps
[i
]->global
= 0;
1251 if (p
->global
< 0) p
->global
= 0;
1254 if (mode
& RTLD_GLOBAL
) {
1255 if (p
->deps
) for (i
=0; p
->deps
[i
]; i
++)
1256 p
->deps
[i
]->global
= 1;
1262 if (ssp_used
) __init_ssp(libc
.auxv
);
1269 pthread_rwlock_unlock(&lock
);
1270 if (p
) do_init_fini(orig_tail
);
1271 pthread_setcancelstate(cs
, 0);
1275 static int invalid_dso_handle(void *h
)
1278 for (p
=head
; p
; p
=p
->next
) if (h
==p
) return 0;
1279 snprintf(errbuf
, sizeof errbuf
, "Invalid library handle %p", (void *)h
);
1284 static void *do_dlsym(struct dso
*p
, const char *s
, void *ra
)
1287 uint32_t h
= 0, gh
= 0;
1289 if (p
== head
|| p
== RTLD_DEFAULT
|| p
== RTLD_NEXT
) {
1290 if (p
== RTLD_DEFAULT
) {
1292 } else if (p
== RTLD_NEXT
) {
1293 for (p
=head
; p
&& (unsigned char *)ra
-p
->map
>p
->map_len
; p
=p
->next
);
1297 struct symdef def
= find_sym(p
, s
, 0);
1298 if (!def
.sym
) goto failed
;
1299 if ((def
.sym
->st_info
&0xf) == STT_TLS
)
1300 return __tls_get_addr((size_t []){def
.dso
->tls_id
, def
.sym
->st_value
});
1301 return def
.dso
->base
+ def
.sym
->st_value
;
1303 if (p
!= RTLD_DEFAULT
&& p
!= RTLD_NEXT
&& invalid_dso_handle(p
))
1307 sym
= gnu_lookup(s
, gh
, p
);
1310 sym
= sysv_lookup(s
, h
, p
);
1312 if (sym
&& (sym
->st_info
&0xf) == STT_TLS
)
1313 return __tls_get_addr((size_t []){p
->tls_id
, sym
->st_value
});
1314 if (sym
&& sym
->st_value
&& (1<<(sym
->st_info
&0xf) & OK_TYPES
))
1315 return p
->base
+ sym
->st_value
;
1316 if (p
->deps
) for (i
=0; p
->deps
[i
]; i
++) {
1317 if (p
->deps
[i
]->ghashtab
) {
1318 if (!gh
) gh
= gnu_hash(s
);
1319 sym
= gnu_lookup(s
, gh
, p
->deps
[i
]);
1321 if (!h
) h
= sysv_hash(s
);
1322 sym
= sysv_lookup(s
, h
, p
->deps
[i
]);
1324 if (sym
&& (sym
->st_info
&0xf) == STT_TLS
)
1325 return __tls_get_addr((size_t []){p
->deps
[i
]->tls_id
, sym
->st_value
});
1326 if (sym
&& sym
->st_value
&& (1<<(sym
->st_info
&0xf) & OK_TYPES
))
1327 return p
->deps
[i
]->base
+ sym
->st_value
;
1331 snprintf(errbuf
, sizeof errbuf
, "Symbol not found: %s", s
);
1335 int __dladdr(const void *addr
, Dl_info
*info
)
1345 pthread_rwlock_rdlock(&lock
);
1346 for (p
=head
; p
&& (unsigned char *)addr
-p
->map
>p
->map_len
; p
=p
->next
);
1347 pthread_rwlock_unlock(&lock
);
1352 strings
= p
->strings
;
1354 nsym
= p
->hashtab
[1];
1358 buckets
= p
->ghashtab
+ 4 + (p
->ghashtab
[2]*sizeof(size_t)/4);
1359 sym
+= p
->ghashtab
[1];
1360 for (i
= nsym
= 0; i
< p
->ghashtab
[0]; i
++) {
1361 if (buckets
[i
] > nsym
)
1365 nsym
-= p
->ghashtab
[1];
1366 hashval
= buckets
+ p
->ghashtab
[0] + nsym
;
1368 while (!(*hashval
++ & 1));
1372 for (; nsym
; nsym
--, sym
++) {
1374 && (1<<(sym
->st_info
&0xf) & OK_TYPES
)
1375 && (1<<(sym
->st_info
>>4) & OK_BINDS
)) {
1376 void *symaddr
= p
->base
+ sym
->st_value
;
1377 if (symaddr
> addr
|| symaddr
< best
)
1380 bestname
= strings
+ sym
->st_name
;
1381 if (addr
== symaddr
)
1386 if (!best
) return 0;
1388 info
->dli_fname
= p
->name
;
1389 info
->dli_fbase
= p
->base
;
1390 info
->dli_sname
= bestname
;
1391 info
->dli_saddr
= best
;
1396 void *__dlsym(void *restrict p
, const char *restrict s
, void *restrict ra
)
1399 pthread_rwlock_rdlock(&lock
);
1400 res
= do_dlsym(p
, s
, ra
);
1401 pthread_rwlock_unlock(&lock
);
1405 int dl_iterate_phdr(int(*callback
)(struct dl_phdr_info
*info
, size_t size
, void *data
), void *data
)
1407 struct dso
*current
;
1408 struct dl_phdr_info info
;
1410 for(current
= head
; current
;) {
1411 info
.dlpi_addr
= (uintptr_t)current
->base
;
1412 info
.dlpi_name
= current
->name
;
1413 info
.dlpi_phdr
= current
->phdr
;
1414 info
.dlpi_phnum
= current
->phnum
;
1415 info
.dlpi_adds
= gencnt
;
1417 info
.dlpi_tls_modid
= current
->tls_id
;
1418 info
.dlpi_tls_data
= current
->tls_image
;
1420 ret
= (callback
)(&info
, sizeof (info
), data
);
1422 if (ret
!= 0) break;
1424 pthread_rwlock_rdlock(&lock
);
1425 current
= current
->next
;
1426 pthread_rwlock_unlock(&lock
);
1431 static int invalid_dso_handle(void *h
)
1433 snprintf(errbuf
, sizeof errbuf
, "Invalid library handle %p", (void *)h
);
1437 void *dlopen(const char *file
, int mode
)
1441 void *__dlsym(void *restrict p
, const char *restrict s
, void *restrict ra
)
1445 int __dladdr (const void *addr
, Dl_info
*info
)
1451 int __dlinfo(void *dso
, int req
, void *res
)
1453 if (invalid_dso_handle(dso
)) return -1;
1454 if (req
!= RTLD_DI_LINKMAP
) {
1455 snprintf(errbuf
, sizeof errbuf
, "Unsupported request %d", req
);
1459 *(struct link_map
**)res
= dso
;
1465 if (!errflag
) return 0;
1470 int dlclose(void *p
)
1472 return invalid_dso_handle(p
);