/*
* 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 rtld
* @brief
* @{
*/
/**
* @file
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <libadt/list.h>
#include <loader/pcb.h>
#include <rtld.h>
#include <dynamic.h>
#include <elf_load.h>
#include <rtld_arch.h>
#include <module.h>
/** (Eagerly) process all relocation tables in a module.
*
* Currently works as if LD_BIND_NOW was specified.
*/
void module_process_relocs(module_t *m)
{
DPRINTF("module_process_relocs('%s')\n", m->dyn.soname);
/* Do not relocate twice. */
if (m->relocated) return;
if (m->dyn.plt_rel == DT_REL) {
if (m->dyn.rel != NULL)
rel_table_process(m, m->dyn.rel, m->dyn.rel_sz);
/* FIXME: this seems wrong */
if (m->dyn.jmp_rel != NULL)
rel_table_process(m, m->dyn.jmp_rel, m->dyn.plt_rel_sz);
} else { /* (m->dyn.plt_rel == DT_RELA) */
DPRINTF("table type DT_RELA\n");
if (m->dyn.rela != NULL) {
DPRINTF("non-empty\n");
rela_table_process(m, m->dyn.rela, m->dyn.rela_sz);
}
}
m->relocated = true;
}
/** Find module structure by soname/pathname.
*
* Used primarily to see if a module has already been loaded.
* Modules are compared according to their soname, i.e. possible
* path components are ignored.
*/
module_t *module_find(char *name)
{
link_t *head = &runtime_env->modules_head;
link_t *cur;
module_t *m;
char *p, *soname;
/*
* If name contains slashes, treat it as a pathname and
* construct soname by chopping off the path. Otherwise
* treat it as soname.
*/
soname = p ? (p + 1) : name;
/* Traverse list of all modules. Not extremely fast, but simple */
for (cur = head->next; cur != head; cur = cur->next) {
m = list_get_instance(cur, module_t, modules_link);
if (strcmp(m
->dyn.
soname, soname
) == 0) { return m; /* Found */
}
}
return NULL; /* Not found */
}
#define NAME_BUF_SIZE 64
/** Load a module.
*
* Currently this trivially tries to load '/<name>'.
*/
module_t *module_load(char *name)
{
elf_info_t info;
char name_buf[NAME_BUF_SIZE];
module_t *m;
int rc;
if (!m) {
}
if (strlen(name
) > NAME_BUF_SIZE
- 2) { printf("soname too long. increase NAME_BUF_SIZE\n"); }
/* Prepend soname with '/lib/' */
name_buf[0] = '/';
/* FIXME: need to real allocation of address space */
m->bias = runtime_env->next_bias;
runtime_env->next_bias += 0x100000;
DPRINTF("filename:'%s'\n", name_buf);
rc = elf_load_file(name_buf, m->bias, ELDF_RW, &info);
if (rc != EE_OK) {
printf("Failed to load '%s'\n", name_buf
); }
if (info.dynamic == NULL) {
printf("Error: '%s' is not a dynamically-linked object.\n", name_buf);
}
/* Pending relocation. */
m->relocated = false;
DPRINTF("parse dynamic section\n");
/* Parse ELF .dynamic section. Store info to m->dyn. */
dynamic_parse(info.dynamic, m->bias, &m->dyn);
/* Insert into the list of loaded modules */
list_append(&m->modules_link, &runtime_env->modules_head);
return m;
}
/** Load all modules on which m (transitively) depends.
*/
void module_load_deps(module_t *m)
{
elf_dyn_t *dp;
char *dep_name;
module_t *dm;
size_t n, i;
/* Count direct dependencies */
dp = m->dyn.dynamic;
n = 0;
while (dp->d_tag != DT_NULL) {
if (dp->d_tag == DT_NEEDED) ++n;
++dp;
}
/* Create an array of pointers to direct dependencies */
m->n_deps = n;
if (n == 0) {
/* There are no dependencies, so we are done. */
m->deps = NULL;
return;
}
m
->deps
= malloc(n
* sizeof(module_t
*)); if (!m->deps) {
}
i = 0; /* Current dependency index */
dp = m->dyn.dynamic;
while (dp->d_tag != DT_NULL) {
if (dp->d_tag == DT_NEEDED) {
dep_name = m->dyn.str_tab + dp->d_un.d_val;
DPRINTF("%s needs %s\n", m->dyn.soname, dep_name);
dm = module_find(dep_name);
if (!dm) {
dm = module_load(dep_name);
module_load_deps(dm);
}
/* Save into deps table */
m->deps[i++] = dm;
}
++dp;
}
}
/** Process relocations in modules.
*
* Processes relocations in @a start and all its dependencies.
* Modules that have already been relocated are unaffected.
*
* @param start The module where to start from.
*/
void modules_process_relocs(module_t *start)
{
link_t *head = &runtime_env->modules_head;
link_t *cur;
module_t *m;
for (cur = head->next; cur != head; cur = cur->next) {
m = list_get_instance(cur, module_t, modules_link);
/* Skip rtld, since it has already been processed */
if (m != &runtime_env->rtld) {
module_process_relocs(m);
}
}
}
/** Clear BFS tags of all modules.
*/
void modules_untag(void)
{
link_t *head = &runtime_env->modules_head;
link_t *cur;
module_t *m;
for (cur = head->next; cur != head; cur = cur->next) {
m = list_get_instance(cur, module_t, modules_link);
m->bfs_tag = false;
}
}
/** @}
*/