#include <ldso.h>
#include <stdio.h>
-#include <string.h>
+#include <string.h> /* Needed for 'strstr' prototype' */
+#include <stdbool.h>
#ifdef SHARED
extern char *_dl_debug;
#endif
-
-#else /* SHARED */
+#else /* !SHARED */
#define _dl_malloc malloc
#define _dl_free free
* the symbols that otherwise would have been loaded in from ldso... */
#ifdef __SUPPORT_LD_DEBUG__
-/* Needed for 'strstr' prototype' */
-#include <string.h>
-char *_dl_debug = 0;
-char *_dl_debug_symbols = 0;
-char *_dl_debug_move = 0;
-char *_dl_debug_reloc = 0;
-char *_dl_debug_detail = 0;
-char *_dl_debug_nofixups = 0;
-char *_dl_debug_bindings = 0;
-int _dl_debug_file = 2;
+char *_dl_debug = NULL;
+char *_dl_debug_symbols = NULL;
+char *_dl_debug_move = NULL;
+char *_dl_debug_reloc = NULL;
+char *_dl_debug_detail = NULL;
+char *_dl_debug_nofixups = NULL;
+char *_dl_debug_bindings = NULL;
+int _dl_debug_file = NULL;
#endif
const char *_dl_progname = ""; /* Program name */
void *(*_dl_malloc_function)(size_t);
void (*_dl_free_function) (void *p);
-char *_dl_library_path = 0; /* Where we look for libraries */
-char *_dl_ldsopath = 0; /* Location of the shared lib loader */
+char *_dl_library_path = NULL; /* Where we look for libraries */
+char *_dl_ldsopath = NULL; /* Location of the shared lib loader */
int _dl_errno = 0; /* We can't use the real errno in ldso */
size_t _dl_pagesize = PAGE_SIZE; /* Store the page size for use later */
/* This global variable is also to communicate with debuggers such as gdb. */
static int do_dlclose(void *, int need_fini);
-static const char *dl_error_names[] = {
+static const char *const dl_error_names[] = {
"",
"File not found",
"Unable to open /dev/zero",
void dl_cleanup(void) __attribute__ ((destructor));
void dl_cleanup(void)
{
- struct dyn_elf *d;
- for (d = _dl_handles; d; d = d->next_handle) {
- do_dlclose(d, 1);
+ struct dyn_elf *h, *n;
+
+ for (h = _dl_handles; h; h = n) {
+ n = h->next_handle;
+ do_dlclose(h, 1);
}
}
struct init_fini_list *tmp, *runp, *runp2, *dep_list;
unsigned int nlist, i;
struct elf_resolve **init_fini_list;
- static int _dl_init = 0;
+ static bool _dl_init;
/* A bit of sanity checking... */
if (!(flag & (RTLD_LAZY|RTLD_NOW))) {
from = (ElfW(Addr)) __builtin_return_address(0);
if (!_dl_init) {
- _dl_init++;
+ _dl_init = true;
_dl_malloc_function = malloc;
_dl_free_function = free;
}
_dl_debug_bindings = strstr(_dl_debug, "bind");
}
}
-# endif
+# endif
#endif
_dl_map_cache();
tfrom = tpnt;
}
}
- for(rpnt = _dl_symbol_tables; rpnt && rpnt->next; rpnt=rpnt->next);
+ for (rpnt = _dl_symbol_tables; rpnt && rpnt->next; rpnt = rpnt->next)
+ continue;
relro_ptr = rpnt;
now_flag = (flag & RTLD_NOW) ? RTLD_NOW : 0;
#ifndef SHARED
/* When statically linked, the _dl_library_path is not yet initialized */
_dl_library_path = getenv("LD_LIBRARY_PATH");
-#endif
-
+#endif
+
/* Try to load the specified library */
_dl_if_debug_print("Trying to dlopen '%s', RTLD_GLOBAL:%d RTLD_NOW:%d\n",
(char*)libname, (flag & RTLD_GLOBAL ? 1:0), (now_flag & RTLD_NOW ? 1:0));
if (handle->dyn == tpnt) {
dyn_chain->init_fini.init_fini = handle->init_fini.init_fini;
dyn_chain->init_fini.nlist = handle->init_fini.nlist;
- for(i=0; i < dyn_chain->init_fini.nlist; i++)
+ for (i = 0; i < dyn_chain->init_fini.nlist; i++)
dyn_chain->init_fini.init_fini[i]->rtld_flags |= (flag & RTLD_GLOBAL);
dyn_chain->next = handle->next;
break;
}
}
return dyn_chain;
- } else {
- tpnt->init_flag |= DL_OPENED;
}
+ tpnt->init_flag |= DL_OPENED;
+
_dl_if_debug_print("Looking for needed libraries\n");
nlist = 0;
runp = alloca(sizeof(*runp));
runp->tpnt = tpnt;
runp->next = NULL;
dep_list = runp2 = runp;
- for (; runp; runp = runp->next)
- {
+ for (; runp; runp = runp->next) {
ElfW(Dyn) *dpnt;
char *lpntstr;
i = 0;
for (runp2 = dep_list; runp2; runp2 = runp2->next) {
init_fini_list[i++] = runp2->tpnt;
- for(runp = runp2->tpnt->init_fini; runp; runp = runp->next){
+ for (runp = runp2->tpnt->init_fini; runp; runp = runp->next) {
if (!(runp->tpnt->rtld_flags & RTLD_GLOBAL)) {
tmp = malloc(sizeof(struct init_fini_list));
tmp->tpnt = runp->tpnt;
}
}
#ifdef __SUPPORT_LD_DEBUG__
- if(_dl_debug) {
+ if (_dl_debug) {
fprintf(stderr, "\nINIT/FINI order and dependencies:\n");
- for (i=0;i < nlist;i++) {
+ for (i = 0; i < nlist; i++) {
fprintf(stderr, "lib: %s has deps:\n", init_fini_list[i]->libname);
runp = init_fini_list[i]->init_fini;
for (; runp; runp = runp->next)
- printf(" %s ", runp->tpnt->libname);
- printf("\n");
+ fprintf(stderr, " %s ", runp->tpnt->libname);
+ fprintf(stderr, "\n");
}
}
#endif
}
/* TODO: Should we set the protections of all pages back to R/O now ? */
-
/* Notify the debugger we have added some objects. */
if (_dl_debug_addr) {
dl_brk = (void (*)(void)) _dl_debug_addr->r_brk;
struct dyn_elf *rpnt;
void *ret;
/* Nastiness to support underscore prefixes. */
+#ifdef __UCLIBC_UNDERSCORES__
char tmp_buf[80];
-#ifndef __UCLIBC_NO_UNDERSCORES__
char *name2 = tmp_buf;
size_t nlen = strlen (name) + 1;
if (nlen + 1 > sizeof (tmp_buf))
- name2 = malloc (nlen + 1);
+ name2 = malloc (nlen + 1);
if (name2 == 0) {
- _dl_error_number = LD_ERROR_MMAP_FAILED;
- return 0;
+ _dl_error_number = LD_ERROR_MMAP_FAILED;
+ return 0;
}
name2[0] = '_';
memcpy (name2 + 1, name, nlen);
}
tpnt = NULL;
if (handle == _dl_symbol_tables)
- tpnt = handle->dyn; /* Only search RTLD_GLOBAL objs if global object */
+ tpnt = handle->dyn; /* Only search RTLD_GLOBAL objs if global object */
ret = _dl_find_hash(name2, handle, tpnt, ELF_RTYPE_CLASS_DLSYM);
/*
if (!ret)
_dl_error_number = LD_NO_SYMBOL;
out:
-#ifndef __UCLIBC_NO_UNDERSCORES__
+#ifdef __UCLIBC_UNDERSCORES__
if (name2 != tmp_buf)
free (name2);
#endif
if (--tpnt->usage_count == 0) {
if ((tpnt->dynamic_info[DT_FINI]
|| tpnt->dynamic_info[DT_FINI_ARRAY])
- && need_fini &&
- !(tpnt->init_flag & FINI_FUNCS_CALLED)) {
+ && need_fini
+ && !(tpnt->init_flag & FINI_FUNCS_CALLED)
+ ) {
tpnt->init_flag |= FINI_FUNCS_CALLED;
_dl_run_fini_array(tpnt);
if (end < ppnt->p_vaddr + ppnt->p_memsz)
end = ppnt->p_vaddr + ppnt->p_memsz;
}
- _dl_munmap((void*)tpnt->loadaddr, end);
- /* Free elements in RTLD_LOCAL scope list */
+ DL_LIB_UNMAP (tpnt, end);
+ /* Free elements in RTLD_LOCAL scope list */
for (runp = tpnt->rtld_local; runp; runp = tmp) {
tmp = runp->next;
free(runp);
_dl_loaded_modules = tpnt->next;
if (_dl_loaded_modules)
_dl_loaded_modules->prev = 0;
- } else
- for (run_tpnt = _dl_loaded_modules; run_tpnt; run_tpnt = run_tpnt->next)
+ } else {
+ for (run_tpnt = _dl_loaded_modules; run_tpnt; run_tpnt = run_tpnt->next) {
if (run_tpnt->next == tpnt) {
_dl_if_debug_print("removing loaded_modules: %s\n", tpnt->libname);
run_tpnt->next = run_tpnt->next->next;
run_tpnt->next->prev = run_tpnt;
break;
}
+ }
+ }
/* Next, remove tpnt from the global symbol table list */
if (_dl_symbol_tables) {
_dl_symbol_tables = _dl_symbol_tables->next;
if (_dl_symbol_tables)
_dl_symbol_tables->prev = 0;
- } else
+ } else {
for (rpnt1 = _dl_symbol_tables; rpnt1->next; rpnt1 = rpnt1->next) {
if (rpnt1->next->dyn == tpnt) {
_dl_if_debug_print("removing symbol_tables: %s\n", tpnt->libname);
break;
}
}
+ }
}
free(tpnt->libname);
free(tpnt);
free(handle->init_fini.init_fini);
free(handle);
-
if (_dl_debug_addr) {
dl_brk = (void (*)(void)) _dl_debug_addr->r_brk;
if (dl_brk != NULL) {
* Dump information to stderr about the current loaded modules
*/
#ifdef __USE_GNU
-static char *type[] = { "Lib", "Exe", "Int", "Mod" };
+static const char type[][4] = { "Lib", "Exe", "Int", "Mod" };
int dlinfo(void)
{
_dl_if_debug_print("__address: %p __info: %p\n", __address, __info);
+ __address = DL_LOOKUP_ADDRESS (__address);
+
for (rpnt = _dl_loaded_modules; rpnt; rpnt = rpnt->next) {
struct elf_resolve *tpnt;
char *strtab;
ElfW(Sym) *symtab;
unsigned int hn, si, sn, sf;
- ElfW(Addr) sa;
+ ElfW(Addr) sa = 0;
+
+ /* Set the info for the object the address lies in */
+ __info->dli_fname = pelf->libname;
+ __info->dli_fbase = (void *)pelf->mapaddr;
- sa = 0;
symtab = (ElfW(Sym) *) (pelf->dynamic_info[DT_SYMTAB]);
strtab = (char *) (pelf->dynamic_info[DT_STRTAB]);
sf = sn = 0;
+
+#ifdef __LDSO_GNU_HASH_SUPPORT__
+ if (pelf->l_gnu_bitmask) {
+ for (hn = 0; hn < pelf->nbucket; hn++) {
+ si = pelf->l_gnu_buckets[hn];
+ if (!si)
+ continue;
+
+ const Elf32_Word *hasharr = &pelf->l_gnu_chain_zero[si];
+ do {
+ ElfW(Addr) symbol_addr;
+
+ symbol_addr = (ElfW(Addr)) DL_RELOC_ADDR(pelf->loadaddr, symtab[si].st_value);
+ if (symbol_addr <= (ElfW(Addr))__address && (!sf || sa < symbol_addr)) {
+ sa = symbol_addr;
+ sn = si;
+ sf = 1;
+ }
+ _dl_if_debug_print("Symbol \"%s\" at %p\n", strtab + symtab[si].st_name, symbol_addr);
+ ++si;
+ } while ((*hasharr++ & 1u) == 0);
+ }
+ } else
+#endif
for (hn = 0; hn < pelf->nbucket; hn++) {
for (si = pelf->elf_buckets[hn]; si; si = pelf->chains[si]) {
ElfW(Addr) symbol_addr;
}
if (sf) {
- __info->dli_fname = pelf->libname;
- __info->dli_fbase = (void *) DL_LOADADDR_BASE(pelf->loadaddr);
+ /* A nearest symbol has been found; fill the entries */
__info->dli_sname = strtab + symtab[sn].st_name;
__info->dli_saddr = (void *)sa;
+ } else {
+ /* No symbol found, fill entries with NULL value,
+ only the containing object will be returned. */
+ __info->dli_sname = NULL;
+ __info->dli_saddr = NULL;
}
return 1;
}