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);
318 * Make a writeable mapping of a segment, regardless of whether PF_W is
322 map_writeable (int infile, ElfW(Phdr) *ppnt, int piclib, int flags,
323 unsigned long libaddr)
325 int prot_flags = ppnt->p_flags | PF_W;
326 char *status, *retval;
329 unsigned long map_size;
331 char *piclib2map = NULL;
334 /* We might be able to avoid this call if memsz doesn't
335 require an additional page, but this would require mmap
336 to always return page-aligned addresses and a whole
337 number of pages allocated. Unfortunately on uClinux
338 may return misaligned addresses and may allocate
339 partial pages, so we may end up doing unnecessary mmap
342 This is what we could do if we knew mmap would always
343 return aligned pages:
345 ((ppnt->p_vaddr + ppnt->p_filesz + ADDR_ALIGN) &
346 PAGE_ALIGN) < ppnt->p_vaddr + ppnt->p_memsz)
348 Instead, we have to do this: */
349 ppnt->p_filesz < ppnt->p_memsz)
351 piclib2map = (char *)
352 _dl_mmap(0, (ppnt->p_vaddr & ADDR_ALIGN) + ppnt->p_memsz,
353 LXFLAGS(prot_flags), flags | MAP_ANONYMOUS, -1, 0);
354 if (_dl_mmap_check_error(piclib2map))
358 tryaddr = piclib == 2 ? piclib2map
359 : ((char*) (piclib ? libaddr : 0) +
360 (ppnt->p_vaddr & PAGE_ALIGN));
362 size = (ppnt->p_vaddr & ADDR_ALIGN) + ppnt->p_filesz;
364 /* For !MMU, mmap to fixed address will fail.
365 So instead of desperately call mmap and fail,
366 we set status to MAP_FAILED to save a call
368 #ifndef __ARCH_USE_MMU__
371 status = (char *) _dl_mmap
372 (tryaddr, size, LXFLAGS(prot_flags),
373 flags | (piclib2map ? MAP_FIXED : 0),
374 infile, ppnt->p_offset & OFFS_ALIGN);
375 #ifndef __ARCH_USE_MMU__
380 if (_dl_mmap_check_error(status) && piclib2map
381 && (_DL_PREAD (infile, tryaddr, size,
382 ppnt->p_offset & OFFS_ALIGN) == size))
385 if (_dl_mmap_check_error(status) || (tryaddr && tryaddr != status))
393 /* Now we want to allocate and zero-out any data from the end
394 of the region we mapped in from the file (filesz) to the
395 end of the loadable segment (memsz). We may need
396 additional pages for memsz, that we map in below, and we
397 can count on the kernel to zero them out, but we have to
398 zero out stuff in the last page that we mapped in from the
399 file. However, we can't assume to have actually obtained
400 full pages from the kernel, since we didn't ask for them,
401 and uClibc may not give us full pages for small
402 allocations. So only zero out up to memsz or the end of
403 the page, whichever comes first. */
405 /* CPNT is the beginning of the memsz portion not backed by
407 cpnt = (char *) (status + size);
409 /* MAP_SIZE is the address of the
410 beginning of the next page. */
411 map_size = (ppnt->p_vaddr + ppnt->p_filesz
412 + ADDR_ALIGN) & PAGE_ALIGN;
421 if (map_size < ppnt->p_vaddr + ppnt->p_memsz && !piclib2map) {
422 tryaddr = map_size + (char*)(piclib ? libaddr : 0);
423 status = (char *) _dl_mmap(tryaddr,
424 ppnt->p_vaddr + ppnt->p_memsz - map_size,
426 flags | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
427 if (_dl_mmap_check_error(status) || tryaddr != status)
434 * Read one ELF library into memory, mmap it into the correct locations and
435 * add the symbol info to the symbol chain. Perform any relocations that
439 struct elf_resolve *_dl_load_elf_shared_library(int secure,
440 struct dyn_elf **rpnt, char *libname)
443 unsigned long dynamic_addr = 0;
445 struct elf_resolve *tpnt;
447 #if defined(USE_TLS) && USE_TLS
448 ElfW(Phdr) *tlsppnt = NULL;
450 char *status, *header;
451 unsigned long dynamic_info[DYNAMIC_SIZE];
453 unsigned long libaddr;
454 unsigned long minvma = 0xffffffff, maxvma = 0;
455 unsigned int rtld_flags;
456 int i, flags, piclib, infile;
457 ElfW(Addr) relro_addr = 0;
458 size_t relro_size = 0;
461 DL_LOADADDR_TYPE lib_loadaddr;
462 DL_INIT_LOADADDR_EXTRA_DECLS
465 infile = _dl_open(libname, O_RDONLY, 0);
467 _dl_internal_error_number = LD_ERROR_NOFILE;
471 if (_dl_fstat(infile, &st) < 0) {
472 _dl_internal_error_number = LD_ERROR_NOFILE;
476 /* If we are in secure mode (i.e. a setu/gid binary using LD_PRELOAD),
477 we don't load the library if it isn't setuid. */
479 if (!(st.st_mode & S_ISUID)) {
485 /* Check if file is already loaded */
486 for (tpnt = _dl_loaded_modules; tpnt; tpnt = tpnt->next) {
487 if (tpnt->st_dev == st.st_dev && tpnt->st_ino == st.st_ino) {
494 header = _dl_mmap((void *) 0, _dl_pagesize, PROT_READ | PROT_WRITE,
495 MAP_PRIVATE | MAP_ANONYMOUS | MAP_UNINITIALIZE, -1, 0);
496 if (_dl_mmap_check_error(header)) {
497 _dl_dprintf(2, "%s:%i: can't map '%s'\n", _dl_progname, __LINE__, libname);
498 _dl_internal_error_number = LD_ERROR_MMAP_FAILED;
503 _dl_read(infile, header, _dl_pagesize);
504 epnt = (ElfW(Ehdr) *) (intptr_t) header;
505 p32 = (uint32_t*)&epnt->e_ident;
506 if (*p32 != ELFMAG_U32) {
507 _dl_dprintf(2, "%s: '%s' is not an ELF file\n", _dl_progname,
509 _dl_internal_error_number = LD_ERROR_NOTELF;
511 _dl_munmap(header, _dl_pagesize);
515 if ((epnt->e_type != ET_DYN) || (epnt->e_machine != MAGIC1
517 && epnt->e_machine != MAGIC2
521 _dl_internal_error_number =
522 (epnt->e_type != ET_DYN ? LD_ERROR_NOTDYN : LD_ERROR_NOTMAGIC);
523 _dl_dprintf(2, "%s: '%s' is not an ELF executable for " ELF_TARGET
524 "\n", _dl_progname, libname);
526 _dl_munmap(header, _dl_pagesize);
530 ppnt = (ElfW(Phdr) *)(intptr_t) & header[epnt->e_phoff];
533 for (i = 0; i < epnt->e_phnum; i++) {
535 if (ppnt->p_type == PT_DYNAMIC) {
537 _dl_dprintf(2, "%s: '%s' has more than one dynamic section\n",
538 _dl_progname, libname);
539 dynamic_addr = ppnt->p_vaddr;
542 if (ppnt->p_type == PT_LOAD) {
543 /* See if this is a PIC library. */
544 if (i == 0 && ppnt->p_vaddr > 0x1000000) {
546 minvma = ppnt->p_vaddr;
548 if (piclib && ppnt->p_vaddr < minvma) {
549 minvma = ppnt->p_vaddr;
551 if (((unsigned long) ppnt->p_vaddr + ppnt->p_memsz) > maxvma) {
552 maxvma = ppnt->p_vaddr + ppnt->p_memsz;
555 if (ppnt->p_type == PT_TLS) {
556 #if defined(USE_TLS) && USE_TLS
557 if (ppnt->p_memsz == 0)
558 /* Nothing to do for an empty segment. */
561 /* Save for after 'tpnt' is actually allocated. */
565 * Yup, the user was an idiot and tried to sneak in a library with
566 * TLS in it and we don't support it. Let's fall on our own sword
567 * and scream at the luser while we die.
569 _dl_dprintf(2, "%s: '%s' library contains unsupported TLS\n",
570 _dl_progname, libname);
571 _dl_internal_error_number = LD_ERROR_TLS_FAILED;
573 _dl_munmap(header, _dl_pagesize);
580 DL_CHECK_LIB_TYPE (epnt, piclib, _dl_progname, libname);
582 maxvma = (maxvma + ADDR_ALIGN) & PAGE_ALIGN;
583 minvma = minvma & ~ADDR_ALIGN;
585 flags = MAP_PRIVATE /*| MAP_DENYWRITE */ ;
589 if (piclib == 0 || piclib == 1) {
590 status = (char *) _dl_mmap((char *) (piclib ? 0 : minvma),
591 maxvma - minvma, PROT_NONE, flags | MAP_ANONYMOUS, -1, 0);
592 if (_dl_mmap_check_error(status)) {
594 _dl_dprintf(2, "%s:%i: can't map '%s'\n", _dl_progname, __LINE__, libname);
595 _dl_internal_error_number = LD_ERROR_MMAP_FAILED;
597 _dl_munmap(header, _dl_pagesize);
600 libaddr = (unsigned long) status;
604 /* Get the memory to store the library */
605 ppnt = (ElfW(Phdr) *)(intptr_t) & header[epnt->e_phoff];
607 DL_INIT_LOADADDR(lib_loadaddr, libaddr, ppnt, epnt->e_phnum);
609 for (i = 0; i < epnt->e_phnum; i++) {
610 if (DL_IS_SPECIAL_SEGMENT (epnt, ppnt)) {
613 addr = DL_MAP_SEGMENT (epnt, ppnt, infile, flags);
616 DL_LOADADDR_UNMAP (lib_loadaddr, maxvma - minvma);
620 DL_INIT_LOADADDR_HDR (lib_loadaddr, addr, ppnt);
624 if (ppnt->p_type == PT_GNU_RELRO) {
625 relro_addr = ppnt->p_vaddr;
626 relro_size = ppnt->p_memsz;
628 if (ppnt->p_type == PT_LOAD) {
632 /* See if this is a PIC library. */
633 if (i == 0 && ppnt->p_vaddr > 0x1000000) {
635 /* flags |= MAP_FIXED; */
638 if (ppnt->p_flags & PF_W) {
639 status = map_writeable (infile, ppnt, piclib, flags, libaddr);
643 tryaddr = (piclib == 2 ? 0
644 : (char *) (ppnt->p_vaddr & PAGE_ALIGN)
645 + (piclib ? libaddr : 0));
646 size = (ppnt->p_vaddr & ADDR_ALIGN) + ppnt->p_filesz;
647 status = (char *) _dl_mmap
648 (tryaddr, size, LXFLAGS(ppnt->p_flags),
649 flags | (piclib == 2 ? MAP_EXECUTABLE
650 | MAP_DENYWRITE : 0),
651 infile, ppnt->p_offset & OFFS_ALIGN);
652 if (_dl_mmap_check_error(status)
653 || (tryaddr && tryaddr != status))
656 DL_INIT_LOADADDR_HDR(lib_loadaddr,
657 status + (ppnt->p_vaddr & ADDR_ALIGN),
660 /* if (libaddr == 0 && piclib) {
661 libaddr = (unsigned long) status;
668 /* For a non-PIC library, the addresses are all absolute */
670 dynamic_addr = (unsigned long) DL_RELOC_ADDR(lib_loadaddr, dynamic_addr);
674 * OK, the ELF library is now loaded into VM in the correct locations
675 * The next step is to go through and do the dynamic linking (if needed).
678 /* Start by scanning the dynamic section to get all of the pointers */
681 _dl_internal_error_number = LD_ERROR_NODYNAMIC;
682 _dl_dprintf(2, "%s: '%s' is missing a dynamic section\n",
683 _dl_progname, libname);
684 _dl_munmap(header, _dl_pagesize);
689 dpnt = (ElfW(Dyn) *) dynamic_addr;
690 _dl_memset(dynamic_info, 0, sizeof(dynamic_info));
691 rtld_flags = _dl_parse_dynamic_info(dpnt, dynamic_info, NULL, lib_loadaddr);
692 /* If the TEXTREL is set, this means that we need to make the pages
693 writable before we perform relocations. Do this now. They get set
696 if (dynamic_info[DT_TEXTREL]) {
697 #ifndef __FORCE_SHAREABLE_TEXT_SEGMENTS__
698 ppnt = (ElfW(Phdr) *)(intptr_t) & header[epnt->e_phoff];
699 for (i = 0; i < epnt->e_phnum; i++, ppnt++) {
700 if (ppnt->p_type == PT_LOAD && !(ppnt->p_flags & PF_W)) {
701 #ifdef __ARCH_USE_MMU__
702 _dl_mprotect((void *) ((piclib ? libaddr : 0) +
703 (ppnt->p_vaddr & PAGE_ALIGN)),
704 (ppnt->p_vaddr & ADDR_ALIGN) + (unsigned long) ppnt->p_filesz,
705 PROT_READ | PROT_WRITE | PROT_EXEC);
708 new_addr = map_writeable (infile, ppnt, piclib, flags, libaddr);
710 _dl_dprintf(_dl_debug_file, "Can't modify %s's text section.",
714 DL_UPDATE_LOADADDR_HDR(lib_loadaddr,
715 new_addr + (ppnt->p_vaddr & ADDR_ALIGN),
717 /* This has invalidated all pointers into the previously readonly segment.
718 Update any them to point into the remapped segment. */
719 _dl_parse_dynamic_info(dpnt, dynamic_info, NULL, lib_loadaddr);
724 _dl_dprintf(_dl_debug_file, "Can't modify %s's text section."
725 " Use GCC option -fPIC for shared objects, please.\n",
733 tpnt = _dl_add_elf_hash_table(libname, lib_loadaddr, dynamic_info,
735 tpnt->relro_addr = relro_addr;
736 tpnt->relro_size = relro_size;
737 tpnt->st_dev = st.st_dev;
738 tpnt->st_ino = st.st_ino;
739 tpnt->ppnt = (ElfW(Phdr) *) DL_RELOC_ADDR(tpnt->loadaddr, epnt->e_phoff);
740 tpnt->n_phent = epnt->e_phnum;
741 tpnt->rtld_flags |= rtld_flags;
743 #if defined(USE_TLS) && USE_TLS
745 _dl_debug_early("Found TLS header for %s\n", libname);
746 # if NO_TLS_OFFSET != 0
747 tpnt->l_tls_offset = NO_TLS_OFFSET;
749 tpnt->l_tls_blocksize = tlsppnt->p_memsz;
750 tpnt->l_tls_align = tlsppnt->p_align;
751 if (tlsppnt->p_align == 0)
752 tpnt->l_tls_firstbyte_offset = 0;
754 tpnt->l_tls_firstbyte_offset = tlsppnt->p_vaddr &
755 (tlsppnt->p_align - 1);
756 tpnt->l_tls_initimage_size = tlsppnt->p_filesz;
757 tpnt->l_tls_initimage = (void *) tlsppnt->p_vaddr;
759 /* Assign the next available module ID. */
760 tpnt->l_tls_modid = _dl_next_tls_modid ();
762 /* We know the load address, so add it to the offset. */
763 if (tpnt->l_tls_initimage != NULL)
765 # ifdef __SUPPORT_LD_DEBUG_EARLY__
766 unsigned int tmp = (unsigned int) tpnt->l_tls_initimage;
767 tpnt->l_tls_initimage = (char *) tlsppnt->p_vaddr + tpnt->loadaddr;
768 _dl_debug_early("Relocated TLS initial image from %x to %x (size = %x)\n", tmp, tpnt->l_tls_initimage, tpnt->l_tls_initimage_size);
771 tpnt->l_tls_initimage = (char *) tlsppnt->p_vaddr + tpnt->loadaddr;
778 * Add this object into the symbol chain
781 (*rpnt)->next = _dl_malloc(sizeof(struct dyn_elf));
782 _dl_memset((*rpnt)->next, 0, sizeof(struct dyn_elf));
783 (*rpnt)->next->prev = (*rpnt);
784 *rpnt = (*rpnt)->next;
787 /* When statically linked, the first time we dlopen a DSO
788 * the *rpnt is NULL, so we need to allocate memory for it,
789 * and initialize the _dl_symbol_table.
792 *rpnt = _dl_symbol_tables = _dl_malloc(sizeof(struct dyn_elf));
793 _dl_memset(*rpnt, 0, sizeof(struct dyn_elf));
797 tpnt->symbol_scope = _dl_symbol_tables;
799 tpnt->libtype = elf_lib;
802 * OK, the next thing we need to do is to insert the dynamic linker into
803 * the proper entry in the GOT so that the PLT symbols can be properly
807 lpnt = (unsigned long *) dynamic_info[DT_PLTGOT];
810 lpnt = (unsigned long *) (dynamic_info[DT_PLTGOT]);
811 INIT_GOT(lpnt, tpnt);
815 /* Handle DSBT initialization */
817 struct elf_resolve *t, *ref;
818 int idx = tpnt->loadaddr.map->dsbt_index;
819 unsigned *dsbt = tpnt->loadaddr.map->dsbt_table;
822 if (!dynamic_info[DT_TEXTREL]) {
823 /* This DSO has not been assigned an index. */
824 _dl_dprintf(2, "%s: '%s' is missing a dsbt index assignment!\n",
825 _dl_progname, libname);
828 /* Find a dsbt table from another module. */
830 for (t = _dl_loaded_modules; t; t = t->next) {
831 if (ref == NULL && t != tpnt) {
836 idx = tpnt->loadaddr.map->dsbt_size;
838 if (!ref || ref->loadaddr.map->dsbt_table[idx] == NULL)
841 _dl_dprintf(2, "%s: '%s' caused DSBT table overflow!\n",
842 _dl_progname, libname);
845 _dl_if_debug_dprint("\n\tfile='%s'; assigned index %d\n",
847 tpnt->loadaddr.map->dsbt_index = idx;
852 * Setup dsbt slot for this module in dsbt of all modules.
855 for (t = _dl_loaded_modules; t; t = t->next) {
856 /* find a dsbt table from another module */
857 if (ref == NULL && t != tpnt) {
860 /* make sure index is not already used */
861 if (t->loadaddr.map->dsbt_table[idx]) {
862 struct elf_resolve *dup;
865 for (dup = _dl_loaded_modules; dup; dup = dup->next)
866 if (dup != tpnt && dup->loadaddr.map->dsbt_index == idx)
869 dup_name = dup->libname;
871 dup_name = "runtime linker";
873 dup_name = "unknown library";
874 _dl_dprintf(2, "%s: '%s' dsbt index %d already used by %s!\n",
875 _dl_progname, libname, idx, dup_name);
879 t->loadaddr.map->dsbt_table[idx] = (unsigned)dsbt;
882 _dl_memcpy(dsbt, ref->loadaddr.map->dsbt_table,
883 tpnt->loadaddr.map->dsbt_size * sizeof(unsigned *));
886 _dl_if_debug_dprint("\n\tfile='%s'; generating link map\n", libname);
887 _dl_if_debug_dprint("\t\tdynamic: %x base: %x\n", dynamic_addr, DL_LOADADDR_BASE(lib_loadaddr));
888 _dl_if_debug_dprint("\t\t entry: %x phdr: %x phnum: %x\n\n",
889 DL_RELOC_ADDR(lib_loadaddr, epnt->e_entry), tpnt->ppnt, tpnt->n_phent);
891 _dl_munmap(header, _dl_pagesize);
896 /* now_flag must be RTLD_NOW or zero */
897 int _dl_fixup(struct dyn_elf *rpnt, int now_flag)
900 struct elf_resolve *tpnt;
901 ElfW(Word) reloc_size, relative_count;
902 ElfW(Addr) reloc_addr;
905 goof = _dl_fixup(rpnt->next, now_flag);
910 if (!(tpnt->init_flag & RELOCS_DONE))
911 _dl_if_debug_dprint("relocation processing: %s\n", tpnt->libname);
913 if (unlikely(tpnt->dynamic_info[UNSUPPORTED_RELOC_TYPE])) {
914 _dl_if_debug_dprint("%s: can't handle %s relocation records\n",
915 _dl_progname, UNSUPPORTED_RELOC_STR);
920 reloc_size = tpnt->dynamic_info[DT_RELOC_TABLE_SIZE];
921 /* On some machines, notably SPARC & PPC, DT_REL* includes DT_JMPREL in its
922 range. Note that according to the ELF spec, this is completely legal! */
923 #ifdef ELF_MACHINE_PLTREL_OVERLAP
924 reloc_size -= tpnt->dynamic_info [DT_PLTRELSZ];
926 if (tpnt->dynamic_info[DT_RELOC_TABLE_ADDR] &&
927 !(tpnt->init_flag & RELOCS_DONE)) {
928 reloc_addr = tpnt->dynamic_info[DT_RELOC_TABLE_ADDR];
929 relative_count = tpnt->dynamic_info[DT_RELCONT_IDX];
930 if (relative_count) { /* Optimize the XX_RELATIVE relocations if possible */
931 reloc_size -= relative_count * sizeof(ELF_RELOC);
932 elf_machine_relative(tpnt->loadaddr, reloc_addr, relative_count);
933 reloc_addr += relative_count * sizeof(ELF_RELOC);
935 goof += _dl_parse_relocation_information(rpnt,
938 tpnt->init_flag |= RELOCS_DONE;
940 if (tpnt->dynamic_info[DT_BIND_NOW])
942 if (tpnt->dynamic_info[DT_JMPREL] &&
943 (!(tpnt->init_flag & JMP_RELOCS_DONE) ||
944 (now_flag && !(tpnt->rtld_flags & now_flag)))) {
945 tpnt->rtld_flags |= now_flag;
946 if (!(tpnt->rtld_flags & RTLD_NOW)) {
947 _dl_parse_lazy_relocation_information(rpnt,
948 tpnt->dynamic_info[DT_JMPREL],
949 tpnt->dynamic_info [DT_PLTRELSZ]);
951 goof += _dl_parse_relocation_information(rpnt,
952 tpnt->dynamic_info[DT_JMPREL],
953 tpnt->dynamic_info[DT_PLTRELSZ]);
955 tpnt->init_flag |= JMP_RELOCS_DONE;
959 /* _dl_add_to_slotinfo is called by init_tls() for initial DSO
960 or by dlopen() for dynamically loaded DSO. */
961 #if defined(USE_TLS) && USE_TLS
962 /* Add object to slot information data if necessasy. */
963 if (tpnt->l_tls_blocksize != 0 && tls_init_tp_called)
964 _dl_add_to_slotinfo ((struct link_map *) tpnt);
970 /* Minimal printf which handles only %s, %d, and %x */
971 void _dl_dprintf(int fd, const char *fmt, ...)
979 char *start, *ptr, *string;
985 buf = _dl_mmap((void *) 0, _dl_pagesize, PROT_READ | PROT_WRITE,
986 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
987 if (_dl_mmap_check_error(buf)) {
988 _dl_write(fd, "mmap of a spare page failed!\n", 29);
994 if (_dl_strlen(fmt) >= (_dl_pagesize - 1)) {
995 _dl_write(fd, "overflow\n", 11);
999 _dl_strcpy(buf, fmt);
1000 va_start(args, fmt);
1003 while (*ptr != '%' && *ptr) {
1009 _dl_write(fd, start, _dl_strlen(start));
1013 string = va_arg(args, char *);
1016 _dl_write(fd, "(null)", 6);
1018 _dl_write(fd, string, _dl_strlen(string));
1026 num = va_arg(args, long int);
1028 num = va_arg(args, int);
1030 string = _dl_simple_ltoa(tmp, num);
1031 _dl_write(fd, string, _dl_strlen(string));
1039 num = va_arg(args, long int);
1041 num = va_arg(args, int);
1043 string = _dl_simple_ltoahex(tmp, num);
1044 _dl_write(fd, string, _dl_strlen(string));
1048 _dl_write(fd, "(null)", 6);
1054 _dl_write(fd, start, _dl_strlen(start));
1058 _dl_munmap(buf, _dl_pagesize);
1062 char *_dl_strdup(const char *string)
1067 len = _dl_strlen(string);
1068 retval = _dl_malloc(len + 1);
1069 _dl_strcpy(retval, string);
1073 unsigned int _dl_parse_dynamic_info(ElfW(Dyn) *dpnt, unsigned long dynamic_info[],
1074 void *debug_addr, DL_LOADADDR_TYPE load_off)
1076 return __dl_parse_dynamic_info(dpnt, dynamic_info, debug_addr, load_off);