/*
* Copyright (c) 2008 Jiri Svoboda
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* - The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/** @addtogroup rtld
* @brief
* @{
*/
/**
* @file
*/
#include <stdio.h>
#include <stdlib.h>
#include <str.h>
#include <elf/elf.h>
#include <rtld/module.h>
#include <rtld/rtld.h>
#include <rtld/rtld_debug.h>
#include <rtld/symbol.h>
/*
* Hash tables are 32-bit (elf_word) even for 64-bit ELF files.
*/
static elf_word elf_hash(const unsigned char *name)
{
elf_word h = 0, g;
while (*name) {
h = (h << 4) + *name++;
g = h & 0xf0000000;
if (g != 0)
h ^= g >> 24;
h &= ~g;
}
return h;
}
static elf_symbol_t *def_find_in_module(const char *name, module_t *m)
{
elf_symbol_t *sym_table;
elf_symbol_t *s, *sym;
elf_word nbucket;
/* elf_word nchain; */
elf_word i;
char *s_name;
elf_word bucket;
DPRINTF("def_find_in_module('%s', %s)\n", name, m->dyn.soname);
sym_table = m->dyn.sym_tab;
nbucket = m->dyn.hash[0];
/* nchain = m->dyn.hash[1]; XXX Use to check HT range */
bucket = elf_hash((unsigned char *)name) % nbucket;
i = m->dyn.hash[2 + bucket];
sym = NULL;
while (i != STN_UNDEF) {
s = &sym_table[i];
s_name = m->dyn.str_tab + s->st_name;
if (str_cmp(name, s_name) == 0) {
sym = s;
break;
}
i = m->dyn.hash[2 + nbucket + i];
}
if (!sym)
return NULL; /* Not found */
if (sym->st_shndx == SHN_UNDEF) {
/* Not a definition */
return NULL;
}
return sym; /* Found */
}
/** Find the definition of a symbol in a module and its deps.
*
* Search the module dependency graph is breadth-first, beginning
* from the module @a start. Thus, @start and all its dependencies
* get searched.
*
* @param name Name of the symbol to search for.
* @param start Module in which to start the search..
* @param mod (output) Will be filled with a pointer to the module
* that contains the symbol.
*/
elf_symbol_t *symbol_bfs_find(const char *name, module_t *start,
module_t **mod)
{
module_t *m, *dm;
elf_symbol_t *sym, *s;
list_t queue;
size_t i;
/*
* Do a BFS using the queue_link and bfs_tag fields.
* Vertices (modules) are tagged the moment they are inserted
* into the queue. This prevents from visiting the same vertex
* more times in case of circular dependencies.
*/
/* Mark all vertices (modules) as unvisited */
modules_untag(start->rtld);
/*
* Insert root (the program) into the queue and tag it.
*
* We disable the dangling-pointer warning because the compiler incorrectly
* assumes that we leak local address (queue) to a parent scope (to start
* argument). However, we always empty the list so the pointer cannot
* actually escape. Probably the compiler can never statically analyze that
* correctly.
*/
list_initialize(&queue);
start->bfs_tag = true;
#pragma GCC diagnostic push
#if defined(__GNUC__) && (__GNUC__ >= 12)
#pragma GCC diagnostic ignored "-Wdangling-pointer"
#endif
list_append(&start->queue_link, &queue);
#pragma GCC diagnostic pop
/* If the symbol is found, it will be stored in 'sym' */
sym = NULL;
/* While queue is not empty */
while (!list_empty(&queue)) {
/* Pop first element from the queue */
m = list_get_instance(list_first(&queue), module_t, queue_link);
list_remove(&m->queue_link);
/* If ssf_noroot is specified, do not look in start module */
s = def_find_in_module(name, m);
if (s != NULL) {
/* Symbol found */
sym = s;
*mod = m;
break;
}
/*
* Insert m's untagged dependencies into the queue
* and tag them.
*/
for (i = 0; i < m->n_deps; ++i) {
dm = m->deps[i];
if (dm->bfs_tag == false) {
dm->bfs_tag = true;
list_append(&dm->queue_link, &queue);
}
}
}
/* Empty the queue so that we leave it in a clean state */
while (!list_empty(&queue))
list_remove(list_first(&queue));
if (!sym) {
return NULL; /* Not found */
}
return sym; /* Symbol found */
}
/** Find the definition of a symbol.
*
* By definition in System V ABI, if module origin has the flag DT_SYMBOLIC,
* origin is searched first. Otherwise, search global modules in the default
* order.
*
* @param name Name of the symbol to search for.
* @param origin Module in which the dependency originates.
* @param flags @c ssf_none or @c ssf_noexec to not look for the symbol
* in the executable program.
* @param mod (output) Will be filled with a pointer to the module
* that contains the symbol.
*/
elf_symbol_t *symbol_def_find(const char *name, module_t *origin,
symbol_search_flags_t flags, module_t **mod)
{
elf_symbol_t *s;
DPRINTF("symbol_def_find('%s', origin='%s'\n",
name, origin->dyn.soname);
if (origin->dyn.symbolic && (!origin->exec || (flags & ssf_noexec) == 0)) {
DPRINTF("symbolic->find '%s' in module '%s'\n", name, origin->dyn.soname);
/*
* Origin module has a DT_SYMBOLIC flag.
* Try this module first
*/
s = def_find_in_module(name, origin);
if (s != NULL) {
/* Found */
*mod = origin;
return s;
}
}
/* Not DT_SYMBOLIC or no match. Now try other locations. */
list_foreach(origin->rtld->modules, modules_link, module_t, m) {
DPRINTF("module '%s' local?\n", m->dyn.soname);
if (!m->local && (!m->exec || (flags & ssf_noexec) == 0)) {
DPRINTF("!local->find '%s' in module '%s'\n", name, m->dyn.soname);
s = def_find_in_module(name, m);
if (s != NULL) {
/* Found */
*mod = m;
return s;
}
}
}
/* Finally, try origin. */
DPRINTF("try finding '%s' in origin '%s'\n", name,
origin->dyn.soname);
if (!origin->exec || (flags & ssf_noexec) == 0) {
s = def_find_in_module(name, origin);
if (s != NULL) {
/* Found */
*mod = origin;
return s;
}
}
DPRINTF("'%s' not found\n", name);
return NULL;
}
/** Get symbol address.
*
* @param sym Symbol
* @param m Module contaning the symbol
* @param tcb TCB of the thread whose thread-local variable instance should
* be returned. If @a tcb is @c NULL then @c NULL is returned for
* thread-local variables.
*
* @return Symbol address
*/
void *symbol_get_addr(elf_symbol_t *sym, module_t *m, tcb_t *tcb)
{
if (elf_st_type(sym->st_info) == STT_TLS) {
if (tcb == NULL)
return NULL;
return rtld_tls_get_addr(m->rtld, tcb, m->id, sym->st_value);
} else if (sym->st_shndx == SHN_ABS) {
/* Do not add bias to absolute symbols */
return (void *) sym->st_value;
} else {
return (void *) (sym->st_value + m->bias);
}
}
/** @}
*/