1 /* vi: set sw=4 ts=4: */
3 * This file contains the helper routines to load an ELF shared
4 * library into memory and add the symbol table info to the chain.
6 * Copyright (C) 2000-2006 by Erik Andersen <andersen@codepoet.org>
7 * Copyright (c) 1994-2000 Eric Youngdale, Peter MacDonald,
8 * David Engel, Hongjiu Lu and Mitch D'Souza
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. The name of the above contributors may not be
16 * used to endorse or promote products derived from this software
17 * without specific prior written permission.
19 * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 #ifdef __LDSO_CACHE_SUPPORT__
37 static caddr_t _dl_cache_addr = NULL;
38 static size_t _dl_cache_size = 0;
40 int _dl_map_cache(void)
48 if (_dl_cache_addr == MAP_FAILED)
50 else if (_dl_cache_addr != NULL)
53 if (_dl_stat(LDSO_CACHE, &st)
54 || (fd = _dl_open(LDSO_CACHE, O_RDONLY|O_CLOEXEC, 0)) < 0) {
55 _dl_cache_addr = MAP_FAILED; /* so we won't try again */
59 _dl_cache_size = st.st_size;
60 _dl_cache_addr = _dl_mmap(0, _dl_cache_size, PROT_READ, LDSO_CACHE_MMAP_FLAGS, fd, 0);
62 if (_dl_mmap_check_error(_dl_cache_addr)) {
63 _dl_dprintf(2, "%s:%i: can't map '%s'\n",
64 _dl_progname, __LINE__, LDSO_CACHE);
68 header = (header_t *) _dl_cache_addr;
70 if (_dl_cache_size < sizeof(header_t) ||
71 _dl_memcmp(header->magic, LDSO_CACHE_MAGIC, LDSO_CACHE_MAGIC_LEN)
72 || _dl_memcmp(header->version, LDSO_CACHE_VER, LDSO_CACHE_VER_LEN)
74 (sizeof(header_t) + header->nlibs * sizeof(libentry_t))
75 || _dl_cache_addr[_dl_cache_size - 1] != '\0')
77 _dl_dprintf(2, "%s: cache '%s' is corrupt\n", _dl_progname,
82 strtabsize = _dl_cache_size - sizeof(header_t) -
83 header->nlibs * sizeof(libentry_t);
84 libent = (libentry_t *) & header[1];
86 for (i = 0; i < header->nlibs; i++) {
87 if (libent[i].sooffset >= strtabsize ||
88 libent[i].liboffset >= strtabsize)
90 _dl_dprintf(2, "%s: cache '%s' is corrupt\n", _dl_progname, LDSO_CACHE);
98 _dl_munmap(_dl_cache_addr, _dl_cache_size);
99 _dl_cache_addr = MAP_FAILED;
103 int _dl_unmap_cache(void)
105 if (_dl_cache_addr == NULL || _dl_cache_addr == MAP_FAILED)
109 _dl_munmap(_dl_cache_addr, _dl_cache_size);
110 _dl_cache_addr = NULL;
119 _dl_protect_relro (struct elf_resolve *l)
121 ElfW(Addr) base = (ElfW(Addr)) DL_RELOC_ADDR(l->loadaddr, l->relro_addr);
122 ElfW(Addr) start = (base & PAGE_ALIGN);
123 ElfW(Addr) end = ((base + l->relro_size) & PAGE_ALIGN);
124 _dl_if_debug_dprint("RELRO protecting %s: start:%x, end:%x\n", l->libname, start, end);
126 _dl_mprotect ((void *) start, end - start, PROT_READ) < 0) {
127 _dl_dprintf(2, "%s: cannot apply additional memory protection after relocation", l->libname);
132 /* This function's behavior must exactly match that
133 * in uClibc/ldso/util/ldd.c */
134 static struct elf_resolve *
135 search_for_named_library(const char *name, int secure, const char *path_list,
136 struct dyn_elf **rpnt)
138 char *path, *path_n, *mylibname;
139 struct elf_resolve *tpnt;
145 /* We need a writable copy of this string, but we don't
146 * need this allocated permanently since we don't want
147 * to leak memory, so use alloca to put path on the stack */
148 done = _dl_strlen(path_list);
149 path = alloca(done + 1);
151 /* another bit of local storage */
152 mylibname = alloca(2050);
154 _dl_memcpy(path, path_list, done+1);
156 /* Unlike ldd.c, don't bother to eliminate double //s */
158 /* Replace colons with zeros in path_list */
159 /* : at the beginning or end of path maps to CWD */
160 /* :: anywhere maps CWD */
172 _dl_strcpy(mylibname, path_n);
174 _dl_strcpy(mylibname, "."); /* Assume current dir if empty path */
175 _dl_strcat(mylibname, "/");
176 _dl_strcat(mylibname, name);
177 if ((tpnt = _dl_load_elf_shared_library(secure, rpnt, mylibname)) != NULL)
186 /* Used to return error codes back to dlopen et. al. */
187 unsigned long _dl_error_number;
188 unsigned long _dl_internal_error_number;
190 struct elf_resolve *_dl_load_shared_library(int secure, struct dyn_elf **rpnt,
191 struct elf_resolve *tpnt, char *full_libname, int __attribute__((unused)) trace_loaded_objects)
194 struct elf_resolve *tpnt1;
197 _dl_internal_error_number = 0;
198 libname = full_libname;
200 /* quick hack to ensure mylibname buffer doesn't overflow. don't
201 allow full_libname or any directory to be longer than 1024. */
202 if (_dl_strlen(full_libname) > 1024)
205 /* Skip over any initial initial './' and '/' stuff to
206 * get the short form libname with no path garbage */
207 pnt = _dl_strrchr(libname, '/');
212 _dl_if_debug_dprint("\tfind library='%s'; searching\n", libname);
213 /* If the filename has any '/', try it straight and leave it at that.
214 For IBCS2 compatibility under linux, we substitute the string
215 /usr/i486-sysv4/lib for /usr/lib in library names. */
217 if (libname != full_libname) {
218 _dl_if_debug_dprint("\ttrying file='%s'\n", full_libname);
219 tpnt1 = _dl_load_elf_shared_library(secure, rpnt, full_libname);
226 * The ABI specifies that RPATH is searched before LD_LIBRARY_PATH or
227 * the default path of /usr/lib. Check in rpath directories.
229 #ifdef __LDSO_RUNPATH__
230 pnt = (tpnt ? (char *) tpnt->dynamic_info[DT_RPATH] : NULL);
232 pnt += (unsigned long) tpnt->dynamic_info[DT_STRTAB];
233 _dl_if_debug_dprint("\tsearching RPATH='%s'\n", pnt);
234 if ((tpnt1 = search_for_named_library(libname, secure, pnt, rpnt)) != NULL)
239 /* Check in LD_{ELF_}LIBRARY_PATH, if specified and allowed */
240 if (_dl_library_path) {
241 _dl_if_debug_dprint("\tsearching LD_LIBRARY_PATH='%s'\n", _dl_library_path);
242 if ((tpnt1 = search_for_named_library(libname, secure, _dl_library_path, rpnt)) != NULL)
249 * The ABI specifies that RUNPATH is searched after LD_LIBRARY_PATH.
251 #ifdef __LDSO_RUNPATH__
252 pnt = (tpnt ? (char *)tpnt->dynamic_info[DT_RUNPATH] : NULL);
254 pnt += (unsigned long) tpnt->dynamic_info[DT_STRTAB];
255 _dl_if_debug_dprint("\tsearching RUNPATH='%s'\n", pnt);
256 if ((tpnt1 = search_for_named_library(libname, secure, pnt, rpnt)) != NULL)
262 * Where should the cache be searched? There is no such concept in the
263 * ABI, so we have some flexibility here. For now, search it before
264 * the hard coded paths that follow (i.e before /lib and /usr/lib).
266 #ifdef __LDSO_CACHE_SUPPORT__
267 if (_dl_cache_addr != NULL && _dl_cache_addr != MAP_FAILED) {
269 header_t *header = (header_t *) _dl_cache_addr;
270 libentry_t *libent = (libentry_t *) & header[1];
271 char *strs = (char *) &libent[header->nlibs];
273 _dl_if_debug_dprint("\tsearching cache='%s'\n", LDSO_CACHE);
274 for (i = 0; i < header->nlibs; i++) {
275 if ((libent[i].flags == LIB_ELF
276 || libent[i].flags == LIB_ELF_LIBC0
277 || libent[i].flags == LIB_ELF_LIBC5)
278 && _dl_strcmp(libname, strs + libent[i].sooffset) == 0
279 && (tpnt1 = _dl_load_elf_shared_library(secure, rpnt, strs + libent[i].liboffset))
287 /* Look for libraries wherever the shared library loader
289 _dl_if_debug_dprint("\tsearching ldso dir='%s'\n", _dl_ldsopath);
290 tpnt1 = search_for_named_library(libname, secure, _dl_ldsopath, rpnt);
294 /* Lastly, search the standard list of paths for the library.
295 This list must exactly match the list in uClibc/ldso/util/ldd.c */
296 _dl_if_debug_dprint("\tsearching full lib path list\n");
297 tpnt1 = search_for_named_library(libname, secure,
298 UCLIBC_RUNTIME_PREFIX "lib:"
299 UCLIBC_RUNTIME_PREFIX "usr/lib"
300 #ifndef __LDSO_CACHE_SUPPORT__
301 ":" UCLIBC_RUNTIME_PREFIX "usr/X11R6/lib"
308 /* Well, we shot our wad on that one. All we can do now is punt */
309 if (_dl_internal_error_number)
310 _dl_error_number = _dl_internal_error_number;
312 _dl_error_number = LD_ERROR_NOFILE;
313 _dl_if_debug_dprint("Bummer: could not find '%s'!\n", libname);
319 * Read one ELF library into memory, mmap it into the correct locations and
320 * add the symbol info to the symbol chain. Perform any relocations that
324 struct elf_resolve *_dl_load_elf_shared_library(int secure,
325 struct dyn_elf **rpnt, char *libname)
328 unsigned long dynamic_addr = 0;
330 struct elf_resolve *tpnt;
333 ElfW(Phdr) *tlsppnt = NULL;
335 char *status, *header;
336 unsigned long dynamic_info[DYNAMIC_SIZE];
338 unsigned long libaddr;
339 unsigned long minvma = 0xffffffff, maxvma = 0;
340 int i, flags, piclib, infile;
341 ElfW(Addr) relro_addr = 0;
342 size_t relro_size = 0;
345 DL_LOADADDR_TYPE lib_loadaddr;
346 DL_INIT_LOADADDR_EXTRA_DECLS
349 infile = _dl_open(libname, O_RDONLY, 0);
351 _dl_internal_error_number = LD_ERROR_NOFILE;
355 if (_dl_fstat(infile, &st) < 0) {
356 _dl_internal_error_number = LD_ERROR_NOFILE;
360 /* If we are in secure mode (i.e. a setu/gid binary using LD_PRELOAD),
361 we don't load the library if it isn't setuid. */
363 if (!(st.st_mode & S_ISUID)) {
369 /* Check if file is already loaded */
370 for (tpnt = _dl_loaded_modules; tpnt; tpnt = tpnt->next) {
371 if (tpnt->st_dev == st.st_dev && tpnt->st_ino == st.st_ino) {
378 header = _dl_mmap((void *) 0, _dl_pagesize, PROT_READ | PROT_WRITE,
379 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
380 if (_dl_mmap_check_error(header)) {
381 _dl_dprintf(2, "%s:%i: can't map '%s'\n", _dl_progname, __LINE__, libname);
382 _dl_internal_error_number = LD_ERROR_MMAP_FAILED;
387 _dl_read(infile, header, _dl_pagesize);
388 epnt = (ElfW(Ehdr) *) (intptr_t) header;
389 p32 = (uint32_t*)&epnt->e_ident;
390 if (*p32 != ELFMAG_U32) {
391 _dl_dprintf(2, "%s: '%s' is not an ELF file\n", _dl_progname,
393 _dl_internal_error_number = LD_ERROR_NOTELF;
395 _dl_munmap(header, _dl_pagesize);
399 if ((epnt->e_type != ET_DYN) || (epnt->e_machine != MAGIC1
401 && epnt->e_machine != MAGIC2
405 _dl_internal_error_number =
406 (epnt->e_type != ET_DYN ? LD_ERROR_NOTDYN : LD_ERROR_NOTMAGIC);
407 _dl_dprintf(2, "%s: '%s' is not an ELF executable for " ELF_TARGET
408 "\n", _dl_progname, libname);
410 _dl_munmap(header, _dl_pagesize);
414 ppnt = (ElfW(Phdr) *)(intptr_t) & header[epnt->e_phoff];
417 for (i = 0; i < epnt->e_phnum; i++) {
419 if (ppnt->p_type == PT_DYNAMIC) {
421 _dl_dprintf(2, "%s: '%s' has more than one dynamic section\n",
422 _dl_progname, libname);
423 dynamic_addr = ppnt->p_vaddr;
426 if (ppnt->p_type == PT_LOAD) {
427 /* See if this is a PIC library. */
428 if (i == 0 && ppnt->p_vaddr > 0x1000000) {
430 minvma = ppnt->p_vaddr;
432 if (piclib && ppnt->p_vaddr < minvma) {
433 minvma = ppnt->p_vaddr;
435 if (((unsigned long) ppnt->p_vaddr + ppnt->p_memsz) > maxvma) {
436 maxvma = ppnt->p_vaddr + ppnt->p_memsz;
439 if (ppnt->p_type == PT_TLS) {
441 if (ppnt->p_memsz == 0)
442 /* Nothing to do for an empty segment. */
445 /* Save for after 'tpnt' is actually allocated. */
449 * Yup, the user was an idiot and tried to sneak in a library with
450 * TLS in it and we don't support it. Let's fall on our own sword
451 * and scream at the luser while we die.
453 _dl_dprintf(2, "%s: '%s' library contains unsupported TLS\n",
454 _dl_progname, libname);
455 _dl_internal_error_number = LD_ERROR_TLS_FAILED;
457 _dl_munmap(header, _dl_pagesize);
464 DL_CHECK_LIB_TYPE (epnt, piclib, _dl_progname, libname);
466 maxvma = (maxvma + ADDR_ALIGN) & PAGE_ALIGN;
467 minvma = minvma & ~0xffffU;
469 flags = MAP_PRIVATE /*| MAP_DENYWRITE */ ;
473 if (piclib == 0 || piclib == 1) {
474 status = (char *) _dl_mmap((char *) (piclib ? 0 : minvma),
475 maxvma - minvma, PROT_NONE, flags | MAP_ANONYMOUS, -1, 0);
476 if (_dl_mmap_check_error(status)) {
477 _dl_dprintf(2, "%s:%i: can't map '%s'\n", _dl_progname, __LINE__, libname);
478 _dl_internal_error_number = LD_ERROR_MMAP_FAILED;
480 _dl_munmap(header, _dl_pagesize);
483 libaddr = (unsigned long) status;
487 /* Get the memory to store the library */
488 ppnt = (ElfW(Phdr) *)(intptr_t) & header[epnt->e_phoff];
490 DL_INIT_LOADADDR(lib_loadaddr, libaddr, ppnt, epnt->e_phnum);
492 for (i = 0; i < epnt->e_phnum; i++) {
493 if (DL_IS_SPECIAL_SEGMENT (epnt, ppnt)) {
496 addr = DL_MAP_SEGMENT (epnt, ppnt, infile, flags);
500 DL_INIT_LOADADDR_HDR (lib_loadaddr, addr, ppnt);
504 if (ppnt->p_type == PT_GNU_RELRO) {
505 relro_addr = ppnt->p_vaddr;
506 relro_size = ppnt->p_memsz;
508 if (ppnt->p_type == PT_LOAD) {
512 /* See if this is a PIC library. */
513 if (i == 0 && ppnt->p_vaddr > 0x1000000) {
515 /* flags |= MAP_FIXED; */
518 if (ppnt->p_flags & PF_W) {
519 unsigned long map_size;
521 char *piclib2map = 0;
524 /* We might be able to avoid this
525 call if memsz doesn't require
526 an additional page, but this
527 would require mmap to always
528 return page-aligned addresses
529 and a whole number of pages
530 allocated. Unfortunately on
531 uClinux may return misaligned
532 addresses and may allocate
533 partial pages, so we may end up
534 doing unnecessary mmap calls.
536 This is what we could do if we
537 knew mmap would always return
540 ((ppnt->p_vaddr + ppnt->p_filesz
543 < ppnt->p_vaddr + ppnt->p_memsz)
545 Instead, we have to do this: */
546 ppnt->p_filesz < ppnt->p_memsz)
548 piclib2map = (char *)
549 _dl_mmap(0, (ppnt->p_vaddr & ADDR_ALIGN)
551 LXFLAGS(ppnt->p_flags),
552 flags | MAP_ANONYMOUS, -1, 0);
553 if (_dl_mmap_check_error(piclib2map))
556 (lib_loadaddr, piclib2map
557 + (ppnt->p_vaddr & ADDR_ALIGN), ppnt);
560 tryaddr = piclib == 2 ? piclib2map
561 : ((char*) (piclib ? libaddr : 0) +
562 (ppnt->p_vaddr & PAGE_ALIGN));
564 size = (ppnt->p_vaddr & ADDR_ALIGN)
567 /* For !MMU, mmap to fixed address will fail.
568 So instead of desperately call mmap and fail,
569 we set status to MAP_FAILED to save a call
571 #ifndef __ARCH_USE_MMU__
574 status = (char *) _dl_mmap
575 (tryaddr, size, LXFLAGS(ppnt->p_flags),
576 flags | (piclib2map ? MAP_FIXED : 0),
577 infile, ppnt->p_offset & OFFS_ALIGN);
578 #ifndef __ARCH_USE_MMU__
583 if (_dl_mmap_check_error(status) && piclib2map
584 && (_DL_PREAD (infile, tryaddr, size,
585 ppnt->p_offset & OFFS_ALIGN)
589 if (_dl_mmap_check_error(status)
590 || (tryaddr && tryaddr != status)) {
592 _dl_dprintf(2, "%s:%i: can't map '%s'\n",
593 _dl_progname, __LINE__, libname);
594 _dl_internal_error_number = LD_ERROR_MMAP_FAILED;
595 DL_LOADADDR_UNMAP (lib_loadaddr, maxvma - minvma);
597 _dl_munmap(header, _dl_pagesize);
603 (lib_loadaddr, status
604 + (ppnt->p_vaddr & ADDR_ALIGN), ppnt);
606 /* Now we want to allocate and
607 zero-out any data from the end of
608 the region we mapped in from the
609 file (filesz) to the end of the
610 loadable segment (memsz). We may
611 need additional pages for memsz,
612 that we map in below, and we can
613 count on the kernel to zero them
614 out, but we have to zero out stuff
615 in the last page that we mapped in
616 from the file. However, we can't
617 assume to have actually obtained
618 full pages from the kernel, since
619 we didn't ask for them, and uClibc
620 may not give us full pages for
621 small allocations. So only zero
622 out up to memsz or the end of the
623 page, whichever comes first. */
625 /* CPNT is the beginning of the memsz
626 portion not backed by filesz. */
627 cpnt = (char *) (status + size);
629 /* MAP_SIZE is the address of the
630 beginning of the next page. */
631 map_size = (ppnt->p_vaddr + ppnt->p_filesz
632 + ADDR_ALIGN) & PAGE_ALIGN;
635 # define MIN(a,b) ((a) < (b) ? (a) : (b))
644 if (map_size < ppnt->p_vaddr + ppnt->p_memsz
646 tryaddr = map_size + (char*)(piclib ? libaddr : 0);
647 status = (char *) _dl_mmap(tryaddr,
648 ppnt->p_vaddr + ppnt->p_memsz - map_size,
649 LXFLAGS(ppnt->p_flags), flags | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
650 if (_dl_mmap_check_error(status)
651 || tryaddr != status)
655 tryaddr = (piclib == 2 ? 0
656 : (char *) (ppnt->p_vaddr & PAGE_ALIGN)
657 + (piclib ? libaddr : 0));
658 size = (ppnt->p_vaddr & ADDR_ALIGN) + ppnt->p_filesz;
659 status = (char *) _dl_mmap
660 (tryaddr, size, LXFLAGS(ppnt->p_flags),
661 flags | (piclib == 2 ? MAP_EXECUTABLE
662 | MAP_DENYWRITE : 0),
663 infile, ppnt->p_offset & OFFS_ALIGN);
664 if (_dl_mmap_check_error(status)
665 || (tryaddr && tryaddr != status))
668 (lib_loadaddr, status
669 + (ppnt->p_vaddr & ADDR_ALIGN), ppnt);
672 /* if (libaddr == 0 && piclib) {
673 libaddr = (unsigned long) status;
681 /* For a non-PIC library, the addresses are all absolute */
683 dynamic_addr = (unsigned long) DL_RELOC_ADDR(lib_loadaddr, dynamic_addr);
687 * OK, the ELF library is now loaded into VM in the correct locations
688 * The next step is to go through and do the dynamic linking (if needed).
691 /* Start by scanning the dynamic section to get all of the pointers */
694 _dl_internal_error_number = LD_ERROR_NODYNAMIC;
695 _dl_dprintf(2, "%s: '%s' is missing a dynamic section\n",
696 _dl_progname, libname);
697 _dl_munmap(header, _dl_pagesize);
701 dpnt = (ElfW(Dyn) *) dynamic_addr;
702 _dl_memset(dynamic_info, 0, sizeof(dynamic_info));
703 _dl_parse_dynamic_info(dpnt, dynamic_info, NULL, lib_loadaddr);
704 /* If the TEXTREL is set, this means that we need to make the pages
705 writable before we perform relocations. Do this now. They get set
708 if (dynamic_info[DT_TEXTREL]) {
709 #ifndef __FORCE_SHAREABLE_TEXT_SEGMENTS__
710 ppnt = (ElfW(Phdr) *)(intptr_t) & header[epnt->e_phoff];
711 for (i = 0; i < epnt->e_phnum; i++, ppnt++) {
712 if (ppnt->p_type == PT_LOAD && !(ppnt->p_flags & PF_W)) {
713 _dl_mprotect((void *) ((piclib ? libaddr : 0) +
714 (ppnt->p_vaddr & PAGE_ALIGN)),
715 (ppnt->p_vaddr & ADDR_ALIGN) + (unsigned long) ppnt->p_filesz,
716 PROT_READ | PROT_WRITE | PROT_EXEC);
720 _dl_dprintf(_dl_debug_file, "Can't modify %s's text section."
721 " Use GCC option -fPIC for shared objects, please.\n",
727 tpnt = _dl_add_elf_hash_table(libname, lib_loadaddr, dynamic_info,
729 tpnt->relro_addr = relro_addr;
730 tpnt->relro_size = relro_size;
731 tpnt->st_dev = st.st_dev;
732 tpnt->st_ino = st.st_ino;
733 tpnt->ppnt = (ElfW(Phdr) *) DL_RELOC_ADDR(tpnt->loadaddr, epnt->e_phoff);
734 tpnt->n_phent = epnt->e_phnum;
738 _dl_debug_early("Found TLS header for %s\n", libname);
739 #if NO_TLS_OFFSET != 0
740 tpnt->l_tls_offset = NO_TLS_OFFSET;
742 tpnt->l_tls_blocksize = tlsppnt->p_memsz;
743 tpnt->l_tls_align = tlsppnt->p_align;
744 if (tlsppnt->p_align == 0)
745 tpnt->l_tls_firstbyte_offset = 0;
747 tpnt->l_tls_firstbyte_offset = tlsppnt->p_vaddr &
748 (tlsppnt->p_align - 1);
749 tpnt->l_tls_initimage_size = tlsppnt->p_filesz;
750 tpnt->l_tls_initimage = (void *) tlsppnt->p_vaddr;
752 /* Assign the next available module ID. */
753 tpnt->l_tls_modid = _dl_next_tls_modid ();
755 /* We know the load address, so add it to the offset. */
756 if (tpnt->l_tls_initimage != NULL)
758 unsigned int tmp = (unsigned int) tpnt->l_tls_initimage;
759 tpnt->l_tls_initimage = (char *) tlsppnt->p_vaddr + tpnt->loadaddr;
760 _dl_debug_early("Relocated TLS initial image from %x to %x (size = %x)\n", tmp, tpnt->l_tls_initimage, tpnt->l_tls_initimage_size);
767 * Add this object into the symbol chain
770 (*rpnt)->next = _dl_malloc(sizeof(struct dyn_elf));
771 _dl_memset((*rpnt)->next, 0, sizeof(struct dyn_elf));
772 (*rpnt)->next->prev = (*rpnt);
773 *rpnt = (*rpnt)->next;
776 /* When statically linked, the first time we dlopen a DSO
777 * the *rpnt is NULL, so we need to allocate memory for it,
778 * and initialize the _dl_symbol_table.
781 *rpnt = _dl_symbol_tables = _dl_malloc(sizeof(struct dyn_elf));
782 _dl_memset(*rpnt, 0, sizeof(struct dyn_elf));
786 tpnt->symbol_scope = _dl_symbol_tables;
788 tpnt->libtype = elf_lib;
791 * OK, the next thing we need to do is to insert the dynamic linker into
792 * the proper entry in the GOT so that the PLT symbols can be properly
796 lpnt = (unsigned long *) dynamic_info[DT_PLTGOT];
799 lpnt = (unsigned long *) (dynamic_info[DT_PLTGOT]);
800 INIT_GOT(lpnt, tpnt);
803 _dl_if_debug_dprint("\n\tfile='%s'; generating link map\n", libname);
804 _dl_if_debug_dprint("\t\tdynamic: %x base: %x\n", dynamic_addr, DL_LOADADDR_BASE(lib_loadaddr));
805 _dl_if_debug_dprint("\t\t entry: %x phdr: %x phnum: %x\n\n",
806 DL_RELOC_ADDR(lib_loadaddr, epnt->e_entry), tpnt->ppnt, tpnt->n_phent);
808 _dl_munmap(header, _dl_pagesize);
813 /* now_flag must be RTLD_NOW or zero */
814 int _dl_fixup(struct dyn_elf *rpnt, int now_flag)
817 struct elf_resolve *tpnt;
818 ElfW(Word) reloc_size, relative_count;
819 ElfW(Addr) reloc_addr;
822 goof = _dl_fixup(rpnt->next, now_flag);
827 if (!(tpnt->init_flag & RELOCS_DONE))
828 _dl_if_debug_dprint("relocation processing: %s\n", tpnt->libname);
830 if (unlikely(tpnt->dynamic_info[UNSUPPORTED_RELOC_TYPE])) {
831 _dl_if_debug_dprint("%s: can't handle %s relocation records\n",
832 _dl_progname, UNSUPPORTED_RELOC_STR);
837 reloc_size = tpnt->dynamic_info[DT_RELOC_TABLE_SIZE];
838 /* On some machines, notably SPARC & PPC, DT_REL* includes DT_JMPREL in its
839 range. Note that according to the ELF spec, this is completely legal! */
840 #ifdef ELF_MACHINE_PLTREL_OVERLAP
841 reloc_size -= tpnt->dynamic_info [DT_PLTRELSZ];
843 if (tpnt->dynamic_info[DT_RELOC_TABLE_ADDR] &&
844 !(tpnt->init_flag & RELOCS_DONE)) {
845 reloc_addr = tpnt->dynamic_info[DT_RELOC_TABLE_ADDR];
846 relative_count = tpnt->dynamic_info[DT_RELCONT_IDX];
847 if (relative_count) { /* Optimize the XX_RELATIVE relocations if possible */
848 reloc_size -= relative_count * sizeof(ELF_RELOC);
849 elf_machine_relative(tpnt->loadaddr, reloc_addr, relative_count);
850 reloc_addr += relative_count * sizeof(ELF_RELOC);
852 goof += _dl_parse_relocation_information(rpnt,
855 tpnt->init_flag |= RELOCS_DONE;
857 if (tpnt->dynamic_info[DT_BIND_NOW])
859 if (tpnt->dynamic_info[DT_JMPREL] &&
860 (!(tpnt->init_flag & JMP_RELOCS_DONE) ||
861 (now_flag && !(tpnt->rtld_flags & now_flag)))) {
862 tpnt->rtld_flags |= now_flag;
863 if (!(tpnt->rtld_flags & RTLD_NOW)) {
864 _dl_parse_lazy_relocation_information(rpnt,
865 tpnt->dynamic_info[DT_JMPREL],
866 tpnt->dynamic_info [DT_PLTRELSZ]);
868 goof += _dl_parse_relocation_information(rpnt,
869 tpnt->dynamic_info[DT_JMPREL],
870 tpnt->dynamic_info[DT_PLTRELSZ]);
872 tpnt->init_flag |= JMP_RELOCS_DONE;
876 /* _dl_add_to_slotinfo is called by init_tls() for initial DSO
877 or by dlopen() for dynamically loaded DSO. */
879 /* Add object to slot information data if necessasy. */
880 if (tpnt->l_tls_blocksize != 0 && tls_init_tp_called)
881 _dl_add_to_slotinfo ((struct link_map *) tpnt);
887 /* Minimal printf which handles only %s, %d, and %x */
888 void _dl_dprintf(int fd, const char *fmt, ...)
896 char *start, *ptr, *string;
902 buf = _dl_mmap((void *) 0, _dl_pagesize, PROT_READ | PROT_WRITE,
903 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
904 if (_dl_mmap_check_error(buf)) {
905 _dl_write(fd, "mmap of a spare page failed!\n", 29);
911 if (_dl_strlen(fmt) >= (_dl_pagesize - 1)) {
912 _dl_write(fd, "overflow\n", 11);
916 _dl_strcpy(buf, fmt);
920 while (*ptr != '%' && *ptr) {
926 _dl_write(fd, start, _dl_strlen(start));
930 string = va_arg(args, char *);
933 _dl_write(fd, "(null)", 6);
935 _dl_write(fd, string, _dl_strlen(string));
943 num = va_arg(args, long int);
945 num = va_arg(args, int);
947 string = _dl_simple_ltoa(tmp, num);
948 _dl_write(fd, string, _dl_strlen(string));
956 num = va_arg(args, long int);
958 num = va_arg(args, int);
960 string = _dl_simple_ltoahex(tmp, num);
961 _dl_write(fd, string, _dl_strlen(string));
965 _dl_write(fd, "(null)", 6);
971 _dl_write(fd, start, _dl_strlen(start));
975 _dl_munmap(buf, _dl_pagesize);
979 char *_dl_strdup(const char *string)
984 len = _dl_strlen(string);
985 retval = _dl_malloc(len + 1);
986 _dl_strcpy(retval, string);
990 void _dl_parse_dynamic_info(ElfW(Dyn) *dpnt, unsigned long dynamic_info[],
991 void *debug_addr, DL_LOADADDR_TYPE load_off)
993 __dl_parse_dynamic_info(dpnt, dynamic_info, debug_addr, load_off);