/*
* Copyright (c) 2024 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 <align.h>
#include <adt/list.h>
#include <elf/elf_load.h>
#include <errno.h>
#include <loader/pcb.h>
#include <stdalign.h>
#include <stdio.h>
#include <stdlib.h>
#include <str.h>
#include <macros.h>
#include <rtld/rtld.h>
#include <rtld/rtld_debug.h>
#include <rtld/dynamic.h>
#include <rtld/rtld_arch.h>
#include <rtld/module.h>
#include <libarch/rtld/module.h>
#include "../private/libc.h"
/** Create module for static executable.
*
* @param rtld Run-time dynamic linker
* @param rmodule Place to store pointer to new module or @c NULL
* @return EOK on success, ENOMEM if out of memory
*/
errno_t module_create_static_exec(rtld_t *rtld, module_t **rmodule)
{
module_t *module;
module = calloc(1, sizeof(module_t));
if (module == NULL) {
DPRINTF("malloc failed\n");
return ENOMEM;
}
module->id = rtld_get_next_id(rtld);
module->dyn.soname = "[program]";
module->rtld = rtld;
module->exec = true;
module->local = true;
const elf_segment_header_t *tls =
elf_get_phdr(__progsymbols.elfstart, PT_TLS);
if (tls) {
uintptr_t bias = elf_get_bias(__progsymbols.elfstart);
module->tdata = (void *) (tls->p_vaddr + bias);
module->tdata_size = tls->p_filesz;
module->tbss_size = tls->p_memsz - tls->p_filesz;
module->tls_align = tls->p_align;
} else {
module->tdata = NULL;
module->tdata_size = 0;
module->tbss_size = 0;
module->tls_align = 1;
}
list_append(&module->modules_link, &rtld->modules);
if (rmodule != NULL)
*rmodule = module;
return EOK;
}
/** (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;
module_process_pre_arch(m);
/* jmp_rel table */
if (m->dyn.jmp_rel != NULL) {
DPRINTF("jmp_rel table\n");
if (m->dyn.plt_rel == DT_REL) {
DPRINTF("jmp_rel table type DT_REL\n");
rel_table_process(m, m->dyn.jmp_rel, m->dyn.plt_rel_sz);
} else {
assert(m->dyn.plt_rel == DT_RELA);
DPRINTF("jmp_rel table type DT_RELA\n");
rela_table_process(m, m->dyn.jmp_rel, m->dyn.plt_rel_sz);
}
}
/* rel table */
if (m->dyn.rel != NULL) {
DPRINTF("rel table\n");
rel_table_process(m, m->dyn.rel, m->dyn.rel_sz);
}
/* rela table */
if (m->dyn.rela != NULL) {
DPRINTF("rela table\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(rtld_t *rtld, const char *name)
{
const char *p, *soname;
DPRINTF("module_find('%s')\n", name);
/*
* If name contains slashes, treat it as a pathname and
* construct soname by chopping off the path. Otherwise
* treat it as soname.
*/
p = str_rchr(name, '/');
soname = p ? (p + 1) : name;
/* Traverse list of all modules. Not extremely fast, but simple */
list_foreach(rtld->modules, modules_link, module_t, m) {
DPRINTF("m = %p\n", m);
if (str_cmp(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(rtld_t *rtld, const char *name, mlflags_t flags)
{
elf_finfo_t info;
char name_buf[NAME_BUF_SIZE];
module_t *m;
errno_t rc;
m = calloc(1, sizeof(module_t));
if (m == NULL) {
DPRINTF("malloc failed\n");
goto error;
}
m->rtld = rtld;
m->id = rtld_get_next_id(rtld);
if ((flags & mlf_local) != 0)
m->local = true;
if (str_size(name) > NAME_BUF_SIZE - 2) {
DPRINTF("soname too long. increase NAME_BUF_SIZE\n");
goto error;
}
/* Prepend soname with '/lib/' */
str_cpy(name_buf, NAME_BUF_SIZE, "/lib/");
str_cpy(name_buf + 5, NAME_BUF_SIZE - 5, name);
DPRINTF("filename:'%s'\n", name_buf);
rc = elf_load_file_name(name_buf, RTLD_MODULE_LDF, &info);
if (rc != EOK) {
DPRINTF("Failed to load '%s'\n", name_buf);
goto error;
}
m->bias = elf_get_bias(info.base);
DPRINTF("loaded '%s' at 0x%zx\n", name_buf, m->bias);
if (info.dynamic == NULL) {
DPRINTF("Error: '%s' is not a dynamically-linked object.\n",
name_buf);
goto error;
}
/* 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, &rtld->modules);
/* Copy TLS info */
m->tdata = info.tls.tdata;
m->tdata_size = info.tls.tdata_size;
m->tbss_size = info.tls.tbss_size;
m->tls_align = info.tls.tls_align;
DPRINTF("tdata at %p size %zu, tbss size %zu\n",
m->tdata, m->tdata_size, m->tbss_size);
return m;
error:
if (m)
free(m);
return NULL;
}
/** Load all modules on which m (transitively) depends.
*/
errno_t module_load_deps(module_t *m, mlflags_t flags)
{
elf_dyn_t *dp;
char *dep_name;
module_t *dm;
size_t n, i;
DPRINTF("module_load_deps('%s')\n", m->dyn.soname);
/* 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 EOK;
}
m->deps = malloc(n * sizeof(module_t *));
if (!m->deps) {
DPRINTF("malloc failed\n");
return ENOMEM;
}
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(m->rtld, dep_name);
if (!dm) {
dm = module_load(m->rtld, dep_name, flags);
if (!dm) {
return EINVAL;
}
errno_t rc = module_load_deps(dm, flags);
if (rc != EOK) {
return rc;
}
}
/* Save into deps table */
m->deps[i++] = dm;
}
++dp;
}
return EOK;
}
/** Find module structure by ID. */
module_t *module_by_id(rtld_t *rtld, unsigned long id)
{
list_foreach(rtld->modules, modules_link, module_t, m) {
if (m->id == id)
return m;
}
return NULL;
}
/** 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(rtld_t *rtld, module_t *start)
{
list_foreach(rtld->modules, modules_link, module_t, m) {
/*
* Skip rtld module, since it has already been processed.
* Skip start / main program -- leave it for later
*/
if (m != &rtld->rtld && m != start) {
module_process_relocs(m);
}
}
/*
* Now that shared libraries have been processed and their variables
* are thus initialized, we can process the main program,
* which may contain COPY relocations that copy value from shared
* library variables to instances of those variables defined
* in the main program.
*/
module_process_relocs(start);
}
void modules_process_tls(rtld_t *rtld)
{
#ifdef CONFIG_TLS_VARIANT_1
rtld->tls_size = sizeof(tcb_t);
rtld->tls_align = alignof(tcb_t);
list_foreach(rtld->modules, modules_link, module_t, m) {
list_append(&m->imodules_link, &rtld->imodules);
rtld->tls_align = max(rtld->tls_align, m->tls_align);
rtld->tls_size = ALIGN_UP(rtld->tls_size, m->tls_align);
m->tpoff = rtld->tls_size;
rtld->tls_size += m->tdata_size + m->tbss_size;
}
#else
rtld->tls_size = 0;
rtld->tls_align = alignof(tcb_t);
list_foreach(rtld->modules, modules_link, module_t, m) {
list_append(&m->imodules_link, &rtld->imodules);
rtld->tls_align = max(rtld->tls_align, m->tls_align);
/*
* We are allocating spans "backwards", here,
* as described in U. Drepper's paper.
*/
rtld->tls_size += m->tdata_size + m->tbss_size;
rtld->tls_size = ALIGN_UP(rtld->tls_size, m->tls_align);
m->tpoff = -(ptrdiff_t) rtld->tls_size;
}
/*
* We are in negative offsets. In order for the alignments to
* be correct, "zero" offset (i.e. the total size) must be aligned
* to the strictest alignment present.
* Note that the padding is actually in front of the TLS data,
* not after it.
*/
rtld->tls_size = ALIGN_UP(rtld->tls_size, rtld->tls_align);
/* Space for the TCB. */
rtld->tls_size += sizeof(tcb_t);
#endif
}
/** Clear BFS tags of all modules.
*/
void modules_untag(rtld_t *rtld)
{
list_foreach(rtld->modules, modules_link, module_t, m) {
m->bfs_tag = false;
}
}
/** @}
*/