Index: uspace/lib/c/generic/adt/prodcons.c =================================================================== --- uspace/lib/c/generic/adt/prodcons.c (revision 04c418dcaeffd13ea8028c1076db5abe46f4c748) +++ uspace/lib/c/generic/adt/prodcons.c (revision 04c418dcaeffd13ea8028c1076db5abe46f4c748) @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2011 Martin Decky + * 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 libc + * @{ + */ +/** @file + */ + +#include +#include +#include + +void prodcons_initialize(prodcons_t *pc) +{ + list_initialize(&pc->list); + fibril_mutex_initialize(&pc->mtx); + fibril_condvar_initialize(&pc->cv); +} + +void prodcons_produce(prodcons_t *pc, link_t *item) +{ + fibril_mutex_lock(&pc->mtx); + + list_append(item, &pc->list); + fibril_condvar_signal(&pc->cv); + + fibril_mutex_unlock(&pc->mtx); +} + +link_t *prodcons_consume(prodcons_t *pc) +{ + fibril_mutex_lock(&pc->mtx); + + while (list_empty(&pc->list)) + fibril_condvar_wait(&pc->cv, &pc->mtx); + + link_t *head = pc->list.next; + list_remove(head); + + fibril_mutex_unlock(&pc->mtx); + + return head; +} + +/** @} + */ Index: uspace/lib/c/generic/as.c =================================================================== --- uspace/lib/c/generic/as.c (revision 72cd53d4a534c31423276f4e863f774083b559ee) +++ uspace/lib/c/generic/as.c (revision 04c418dcaeffd13ea8028c1076db5abe46f4c748) @@ -52,5 +52,5 @@ * */ -void *as_area_create(void *address, size_t size, int flags) +void *as_area_create(void *address, size_t size, unsigned int flags) { return (void *) __SYSCALL3(SYS_AS_AREA_CREATE, (sysarg_t) address, @@ -68,5 +68,5 @@ * */ -int as_area_resize(void *address, size_t size, int flags) +int as_area_resize(void *address, size_t size, unsigned int flags) { return __SYSCALL3(SYS_AS_AREA_RESIZE, (sysarg_t) address, @@ -96,5 +96,5 @@ * */ -int as_area_change_flags(void *address, int flags) +int as_area_change_flags(void *address, unsigned int flags) { return __SYSCALL2(SYS_AS_AREA_CHANGE_FLAGS, (sysarg_t) address, Index: uspace/lib/c/generic/assert.c =================================================================== --- uspace/lib/c/generic/assert.c (revision 04c418dcaeffd13ea8028c1076db5abe46f4c748) +++ uspace/lib/c/generic/assert.c (revision 04c418dcaeffd13ea8028c1076db5abe46f4c748) @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2011 Martin Decky + * 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 libc + * @{ + */ + +#include +#include +#include +#include + +void assert_abort(const char *cond, const char *file, unsigned int line) +{ + printf("Assertion failed (%s) in file \"%s\", line %u.\n", + cond, file, line); + stacktrace_print(); + abort(); +} + +/** @} + */ Index: uspace/lib/c/generic/async.c =================================================================== --- uspace/lib/c/generic/async.c (revision 72cd53d4a534c31423276f4e863f774083b559ee) +++ uspace/lib/c/generic/async.c (revision 04c418dcaeffd13ea8028c1076db5abe46f4c748) @@ -102,4 +102,6 @@ #include #include +#include +#include #include "private/async.h" Index: uspace/lib/c/generic/async_sess.c =================================================================== --- uspace/lib/c/generic/async_sess.c (revision 72cd53d4a534c31423276f4e863f774083b559ee) +++ uspace/lib/c/generic/async_sess.c (revision 04c418dcaeffd13ea8028c1076db5abe46f4c748) @@ -105,4 +105,5 @@ #include #include +#include #include "private/async_sess.h" Index: uspace/lib/c/generic/dlfcn.c =================================================================== --- uspace/lib/c/generic/dlfcn.c (revision 04c418dcaeffd13ea8028c1076db5abe46f4c748) +++ uspace/lib/c/generic/dlfcn.c (revision 04c418dcaeffd13ea8028c1076db5abe46f4c748) @@ -0,0 +1,90 @@ +/* + * 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 +#include +#include + +#include +#include + +void *dlopen(const char *path, int flag) +{ + module_t *m; + + if (runtime_env == NULL) { + printf("Dynamic linker not set up -- initializing.\n"); + rtld_init_static(); + } + + printf("dlopen(\"%s\", %d)\n", path, flag); + + printf("module_find('%s')\n", path); + m = module_find(path); + if (m == NULL) { + printf("NULL. module_load('%s')\n", path); + m = module_load(path); + printf("module_load_deps(m)\n"); + module_load_deps(m); + /* Now relocate. */ + printf("module_process_relocs(m)\n"); + module_process_relocs(m); + } else { + printf("not NULL\n"); + } + + return (void *) m; +} + +/* + * @note Symbols with NULL values are not accounted for. + */ +void *dlsym(void *mod, const char *sym_name) +{ + elf_symbol_t *sd; + module_t *sm; + + printf("dlsym(0x%lx, \"%s\")\n", (long)mod, sym_name); + sd = symbol_bfs_find(sym_name, (module_t *) mod, &sm); + if (sd != NULL) { + return symbol_get_addr(sd, sm); + } + + return NULL; +} + +/** @} + */ Index: uspace/lib/c/generic/errno.c =================================================================== --- uspace/lib/c/generic/errno.c (revision 72cd53d4a534c31423276f4e863f774083b559ee) +++ uspace/lib/c/generic/errno.c (revision 04c418dcaeffd13ea8028c1076db5abe46f4c748) @@ -36,5 +36,10 @@ #include -int _errno; +static fibril_local int fibril_errno; + +int *__errno(void) +{ + return &fibril_errno; +} /** @} Index: uspace/lib/c/generic/event.c =================================================================== --- uspace/lib/c/generic/event.c (revision 72cd53d4a534c31423276f4e863f774083b559ee) +++ uspace/lib/c/generic/event.c (revision 04c418dcaeffd13ea8028c1076db5abe46f4c748) @@ -41,14 +41,28 @@ #include -/** Subscribe for event notifications. +/** Subscribe event notifications. * - * @param evno Event number. - * @param method Use this method for notifying me. + * @param evno Event type to subscribe. + * @param imethod Use this interface and method for notifying me. * * @return Value returned by the kernel. + * */ -int event_subscribe(event_type_t e, sysarg_t method) +int event_subscribe(event_type_t evno, sysarg_t imethod) { - return __SYSCALL2(SYS_EVENT_SUBSCRIBE, (sysarg_t) e, (sysarg_t) method); + return __SYSCALL2(SYS_EVENT_SUBSCRIBE, (sysarg_t) evno, + (sysarg_t) imethod); +} + +/** Unmask event notifications. + * + * @param evno Event type to unmask. + * + * @return Value returned by the kernel. + * + */ +int event_unmask(event_type_t evno) +{ + return __SYSCALL1(SYS_EVENT_UNMASK, (sysarg_t) evno); } Index: uspace/lib/c/generic/fibril_synch.c =================================================================== --- uspace/lib/c/generic/fibril_synch.c (revision 72cd53d4a534c31423276f4e863f774083b559ee) +++ uspace/lib/c/generic/fibril_synch.c (revision 04c418dcaeffd13ea8028c1076db5abe46f4c748) @@ -43,4 +43,5 @@ #include #include +#include #include "private/async.h" Index: uspace/lib/c/generic/io/io.c =================================================================== --- uspace/lib/c/generic/io/io.c (revision 72cd53d4a534c31423276f4e863f774083b559ee) +++ uspace/lib/c/generic/io/io.c (revision 04c418dcaeffd13ea8028c1076db5abe46f4c748) @@ -173,4 +173,5 @@ } *flags = (O_APPEND | O_CREAT) | (plus ? O_RDWR : O_WRONLY); + break; default: errno = EINVAL; Index: uspace/lib/c/generic/libc.c =================================================================== --- uspace/lib/c/generic/libc.c (revision 72cd53d4a534c31423276f4e863f774083b559ee) +++ uspace/lib/c/generic/libc.c (revision 04c418dcaeffd13ea8028c1076db5abe46f4c748) @@ -53,4 +53,8 @@ #include "private/io.h" +#ifdef CONFIG_RTLD +#include +#endif + static bool env_setup = false; @@ -77,4 +81,9 @@ char **argv; +#ifdef __IN_SHARED_LIBC__ + if (__pcb != NULL && __pcb->rtld_runtime != NULL) { + runtime_env = (runtime_env_t *) __pcb->rtld_runtime; + } +#endif /* * Get command line arguments and initialize Index: uspace/lib/c/generic/malloc.c =================================================================== --- uspace/lib/c/generic/malloc.c (revision 72cd53d4a534c31423276f4e863f774083b559ee) +++ uspace/lib/c/generic/malloc.c (revision 04c418dcaeffd13ea8028c1076db5abe46f4c748) @@ -44,4 +44,5 @@ #include #include +#include #include #include "private/malloc.h" Index: uspace/lib/c/generic/rtld/dynamic.c =================================================================== --- uspace/lib/c/generic/rtld/dynamic.c (revision 04c418dcaeffd13ea8028c1076db5abe46f4c748) +++ uspace/lib/c/generic/rtld/dynamic.c (revision 04c418dcaeffd13ea8028c1076db5abe46f4c748) @@ -0,0 +1,142 @@ +/* + * 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 + +#include +#include +#include +#include + +void dynamic_parse(elf_dyn_t *dyn_ptr, size_t bias, dyn_info_t *info) +{ + elf_dyn_t *dp = dyn_ptr; + + void *d_ptr; + elf_word d_val; + + elf_word soname_idx; + elf_word rpath_idx; + + DPRINTF("memset\n"); + memset(info, 0, sizeof(dyn_info_t)); + + soname_idx = 0; + rpath_idx = 0; + + DPRINTF("pass 1\n"); + while (dp->d_tag != DT_NULL) { + d_ptr = (void *)((uint8_t *)dp->d_un.d_ptr + bias); + d_val = dp->d_un.d_val; + DPRINTF("tag=%u ptr=0x%x val=%u\n", (unsigned)dp->d_tag, + (unsigned)d_ptr, (unsigned)d_val); + + switch (dp->d_tag) { + + case DT_PLTRELSZ: info->plt_rel_sz = d_val; break; + case DT_PLTGOT: info->plt_got = d_ptr; break; + case DT_HASH: info->hash = d_ptr; break; + case DT_STRTAB: info->str_tab = d_ptr; break; + case DT_SYMTAB: info->sym_tab = d_ptr; break; + case DT_RELA: info->rela = d_ptr; break; + case DT_RELASZ: info->rela_sz = d_val; break; + case DT_RELAENT: info->rela_ent = d_val; break; + case DT_STRSZ: info->str_sz = d_val; break; + case DT_SYMENT: info->sym_ent = d_val; break; + case DT_INIT: info->init = d_ptr; break; + case DT_FINI: info->fini = d_ptr; break; + case DT_SONAME: soname_idx = d_val; break; + case DT_RPATH: rpath_idx = d_val; break; + case DT_SYMBOLIC: info->symbolic = true; break; + case DT_REL: info->rel = d_ptr; break; + case DT_RELSZ: info->rel_sz = d_val; break; + case DT_RELENT: info->rel_ent = d_val; break; + case DT_PLTREL: info->plt_rel = d_val; break; + case DT_TEXTREL: info->text_rel = true; break; + case DT_JMPREL: info->jmp_rel = d_ptr; break; + case DT_BIND_NOW: info->bind_now = true; break; + + default: + if (dp->d_tag >= DT_LOPROC && dp->d_tag <= DT_HIPROC) + dyn_parse_arch(dp, bias, info); + break; + } + + ++dp; + } + + info->soname = info->str_tab + soname_idx; + info->rpath = info->str_tab + rpath_idx; + + /* This will be useful for parsing dependencies later */ + info->dynamic = dyn_ptr; + + DPRINTF("str_tab=0x%x, soname_idx=0x%x, soname=0x%x\n", + (uintptr_t)info->soname, soname_idx, (uintptr_t)info->soname); + DPRINTF("soname='%s'\n", info->soname); + DPRINTF("rpath='%s'\n", info->rpath); + DPRINTF("hash=0x%x\n", (uintptr_t)info->hash); + DPRINTF("dt_rela=0x%x\n", (uintptr_t)info->rela); + DPRINTF("dt_rela_sz=0x%x\n", (uintptr_t)info->rela_sz); + DPRINTF("dt_rel=0x%x\n", (uintptr_t)info->rel); + DPRINTF("dt_rel_sz=0x%x\n", (uintptr_t)info->rel_sz); + + /* + * Now that we have a pointer to the string table, + * we can parse DT_NEEDED fields (which contain offsets into it). + */ + + DPRINTF("pass 2\n"); + dp = dyn_ptr; + while (dp->d_tag != DT_NULL) { + d_val = dp->d_un.d_val; + + switch (dp->d_tag) { + case DT_NEEDED: + /* Assume just for now there's only one dependency */ + info->needed = info->str_tab + d_val; + DPRINTF("needed:'%s'\n", info->needed); + break; + + default: break; + } + + ++dp; + } +} + +/** @} + */ Index: uspace/lib/c/generic/rtld/elf_load.c =================================================================== --- uspace/lib/c/generic/rtld/elf_load.c (revision 04c418dcaeffd13ea8028c1076db5abe46f4c748) +++ uspace/lib/c/generic/rtld/elf_load.c (revision 04c418dcaeffd13ea8028c1076db5abe46f4c748) @@ -0,0 +1,1 @@ +../../../../srv/loader/elf_load.c Index: uspace/lib/c/generic/rtld/module.c =================================================================== --- uspace/lib/c/generic/rtld/module.c (revision 04c418dcaeffd13ea8028c1076db5abe46f4c748) +++ uspace/lib/c/generic/rtld/module.c (revision 04c418dcaeffd13ea8028c1076db5abe46f4c748) @@ -0,0 +1,282 @@ +/* + * 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 +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +/** (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); + + if (m->dyn.plt_rel == DT_REL) { + DPRINTF("table type DT_REL\n"); + if (m->dyn.rel != NULL) { + DPRINTF("non-empty\n"); + rel_table_process(m, m->dyn.rel, m->dyn.rel_sz); + } + /* FIXME: this seems wrong */ + if (m->dyn.jmp_rel != NULL) { + DPRINTF("table type jmp-rel\n"); + DPRINTF("non-empty\n"); + 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(const char *name) +{ + link_t *head = &runtime_env->modules_head; + + link_t *cur; + module_t *m; + 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 */ + DPRINTF("head = %p\n", head); + for (cur = head->next; cur != head; cur = cur->next) { + DPRINTF("cur = %p\n", cur); + m = list_get_instance(cur, module_t, modules_link); + 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 '/'. + */ +module_t *module_load(const char *name) +{ + elf_info_t info; + char name_buf[NAME_BUF_SIZE]; + module_t *m; + int rc; + + m = malloc(sizeof(module_t)); + if (!m) { + printf("malloc failed\n"); + exit(1); + } + + if (str_size(name) > NAME_BUF_SIZE - 2) { + printf("soname too long. increase NAME_BUF_SIZE\n"); + exit(1); + } + + /* Prepend soname with '/lib/' */ + str_cpy(name_buf, NAME_BUF_SIZE, "/lib/"); + str_cpy(name_buf + 5, NAME_BUF_SIZE - 5, name); + + /* 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); + DPRINTF("load '%s' at 0x%x\n", name_buf, m->bias); + + rc = elf_load_file(name_buf, m->bias, ELDF_RW, &info); + if (rc != EE_OK) { + printf("Failed to load '%s'\n", name_buf); + exit(1); + } + + if (info.dynamic == NULL) { + printf("Error: '%s' is not a dynamically-linked object.\n", + name_buf); + exit(1); + } + + /* 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; + + 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; + } + + m->deps = malloc(n * sizeof(module_t *)); + if (!m->deps) { + printf("malloc failed\n"); + exit(1); + } + + 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; + } +} + +/** @} + */ Index: uspace/lib/c/generic/rtld/rtld.c =================================================================== --- uspace/lib/c/generic/rtld/rtld.c (revision 04c418dcaeffd13ea8028c1076db5abe46f4c748) +++ uspace/lib/c/generic/rtld/rtld.c (revision 04c418dcaeffd13ea8028c1076db5abe46f4c748) @@ -0,0 +1,52 @@ +/* + * 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 + +runtime_env_t *runtime_env; +static runtime_env_t rt_env_static; + +/** Initialize the loder for use in a statically-linked binary. */ +void rtld_init_static(void) +{ + runtime_env = &rt_env_static; + list_initialize(&runtime_env->modules_head); + runtime_env->next_bias = 0x2000000; + runtime_env->program = NULL; +} + +/** @} + */ Index: uspace/lib/c/generic/rtld/symbol.c =================================================================== --- uspace/lib/c/generic/rtld/symbol.c (revision 04c418dcaeffd13ea8028c1076db5abe46f4c748) +++ uspace/lib/c/generic/rtld/symbol.c (revision 04c418dcaeffd13ea8028c1076db5abe46f4c748) @@ -0,0 +1,232 @@ +/* + * 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 +#include + +#include +#include +#include +#include + +/* + * 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; + link_t queue_head; + 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(); + + /* Insert root (the program) into the queue and tag it */ + list_initialize(&queue_head); + start->bfs_tag = true; + list_append(&start->queue_link, &queue_head); + + /* If the symbol is found, it will be stored in 'sym' */ + sym = NULL; + + /* While queue is not empty */ + while (!list_empty(&queue_head)) { + /* Pop first element from the queue */ + m = list_get_instance(queue_head.next, module_t, queue_link); + list_remove(&m->queue_link); + + 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_head); + } + } + } + + /* Empty the queue so that we leave it in a clean state */ + while (!list_empty(&queue_head)) + list_remove(queue_head.next); + + 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, or if the symbol hasn't been found, + * the module dependency graph is searched breadth-first, beginning + * from the executable program. + * + * @param name Name of the symbol to search for. + * @param origin Module in which the dependency originates. + * @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, module_t **mod) +{ + elf_symbol_t *s; + + if (origin->dyn.symbolic) { + /* + * 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. */ + + if (runtime_env->program) { + /* Program is dynamic -- start with program as root. */ + return symbol_bfs_find(name, runtime_env->program, mod); + } else { + /* Program is static -- start with @a origin as root. */ + return symbol_bfs_find(name, origin, mod); + } +} + +void *symbol_get_addr(elf_symbol_t *sym, module_t *m) +{ + 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); + } +} + +/** @} + */ Index: uspace/lib/c/generic/stacktrace.c =================================================================== --- uspace/lib/c/generic/stacktrace.c (revision 72cd53d4a534c31423276f4e863f774083b559ee) +++ uspace/lib/c/generic/stacktrace.c (revision 04c418dcaeffd13ea8028c1076db5abe46f4c748) @@ -61,9 +61,11 @@ stacktrace_prepare(); stacktrace_print_fp_pc(stacktrace_fp_get(), stacktrace_pc_get()); + /* * Prevent the tail call optimization of the previous call by * making it a non-tail call. */ - (void) stacktrace_fp_get(); + + printf("-- end of stack trace --\n"); } Index: uspace/lib/c/generic/str.c =================================================================== --- uspace/lib/c/generic/str.c (revision 72cd53d4a534c31423276f4e863f774083b559ee) +++ uspace/lib/c/generic/str.c (revision 04c418dcaeffd13ea8028c1076db5abe46f4c748) @@ -1215,21 +1215,21 @@ void order_suffix(const uint64_t val, uint64_t *rv, char *suffix) { - if (val > 10000000000000000000ULL) { - *rv = val / 1000000000000000000ULL; + if (val > UINT64_C(10000000000000000000)) { + *rv = val / UINT64_C(1000000000000000000); *suffix = 'Z'; - } else if (val > 1000000000000000000ULL) { - *rv = val / 1000000000000000ULL; + } else if (val > UINT64_C(1000000000000000000)) { + *rv = val / UINT64_C(1000000000000000); *suffix = 'E'; - } else if (val > 1000000000000000ULL) { - *rv = val / 1000000000000ULL; + } else if (val > UINT64_C(1000000000000000)) { + *rv = val / UINT64_C(1000000000000); *suffix = 'T'; - } else if (val > 1000000000000ULL) { - *rv = val / 1000000000ULL; + } else if (val > UINT64_C(1000000000000)) { + *rv = val / UINT64_C(1000000000); *suffix = 'G'; - } else if (val > 1000000000ULL) { - *rv = val / 1000000ULL; + } else if (val > UINT64_C(1000000000)) { + *rv = val / UINT64_C(1000000); *suffix = 'M'; - } else if (val > 1000000ULL) { - *rv = val / 1000ULL; + } else if (val > UINT64_C(1000000)) { + *rv = val / UINT64_C(1000); *suffix = 'k'; } else { @@ -1239,4 +1239,31 @@ } +void bin_order_suffix(const uint64_t val, uint64_t *rv, const char **suffix, + bool fixed) +{ + if (val > UINT64_C(1152921504606846976)) { + *rv = val / UINT64_C(1125899906842624); + *suffix = "EiB"; + } else if (val > UINT64_C(1125899906842624)) { + *rv = val / UINT64_C(1099511627776); + *suffix = "TiB"; + } else if (val > UINT64_C(1099511627776)) { + *rv = val / UINT64_C(1073741824); + *suffix = "GiB"; + } else if (val > UINT64_C(1073741824)) { + *rv = val / UINT64_C(1048576); + *suffix = "MiB"; + } else if (val > UINT64_C(1048576)) { + *rv = val / UINT64_C(1024); + *suffix = "KiB"; + } else { + *rv = val; + if (fixed) + *suffix = "B "; + else + *suffix = "B"; + } +} + /** @} */