LibC+LibELF: Implement more fully-features dlfcn functionality

This implements more of the dlfcn functionality. Most notably: * It's now possible to dlopen() libraries which were already loaded at program startup time. This does not cause those libraries to be loaded twice. * Errors are reported via dlerror() rather than by crashing the program. * Calls to the dl*() functions are thread-safe.
2025-07-25 03:57:43 +00:00 · 2021-04-24 20:39:58 +02:00 · 2021-04-24 20:39:58 +02:00 · f40ee1b03f
commit f40ee1b03f
parent 549d9bd3ea
12 changed files with 371 additions and 200 deletions
--- a/Userland/Libraries/LibELF/DynamicLinker.cpp
+++ b/Userland/Libraries/LibELF/DynamicLinker.cpp
@ -12,38 +12,44 @@
 #include <AK/LexicalPath.h>
 #include <AK/NonnullRefPtrVector.h>
 #include <AK/ScopeGuard.h>
+#include <LibC/bits/pthread_integration.h>
 #include <LibC/link.h>
 #include <LibC/mman.h>
 #include <LibC/unistd.h>
+#include <LibDl/dlfcn.h>
+#include <LibDl/dlfcn_integration.h>
 #include <LibELF/AuxiliaryVector.h>
 #include <LibELF/DynamicLinker.h>
 #include <LibELF/DynamicLoader.h>
 #include <LibELF/DynamicObject.h>
 #include <LibELF/Hashes.h>
-#include <dlfcn.h>
 #include <fcntl.h>
 #include <sys/types.h>
 #include <syscall.h>

 namespace ELF {

-namespace {
-HashMap<String, NonnullRefPtr<ELF::DynamicLoader>> g_loaders;
-Vector<NonnullRefPtr<ELF::DynamicObject>> g_global_objects;
+static HashMap<String, NonnullRefPtr<ELF::DynamicLoader>> s_loaders;
+static String s_main_program_name;
+static HashMap<String, NonnullRefPtr<ELF::DynamicObject>> s_global_objects;

 using EntryPointFunction = int (*)(int, char**, char**);
 using LibCExitFunction = void (*)(int);
 using DlIteratePhdrCallbackFunction = int (*)(struct dl_phdr_info*, size_t, void*);
 using DlIteratePhdrFunction = int (*)(DlIteratePhdrCallbackFunction, void*);

-size_t g_current_tls_offset = 0;
-size_t g_total_tls_size = 0;
-char** g_envp = nullptr;
-LibCExitFunction g_libc_exit = nullptr;
+static size_t s_current_tls_offset = 0;
+static size_t s_total_tls_size = 0;
+static char** s_envp = nullptr;
+static LibCExitFunction s_libc_exit = nullptr;
+static __pthread_mutex_t s_loader_lock = __PTHREAD_MUTEX_INITIALIZER;

-bool g_allowed_to_check_environment_variables { false };
-bool g_do_breakpoint_trap_before_entry { false };
-}
+static bool s_allowed_to_check_environment_variables { false };
+static bool s_do_breakpoint_trap_before_entry { false };
+
+static Result<void, DlErrorMessage> __dlclose(void* handle);
+static Result<void*, DlErrorMessage> __dlopen(const char* filename, int flags);
+static Result<void*, DlErrorMessage> __dlsym(void* handle, const char* symbol_name);

 Optional<DynamicObject::SymbolLookupResult> DynamicLinker::lookup_global_symbol(const StringView& name)
 {
@ -51,8 +57,8 @@ Optional<DynamicObject::SymbolLookupResult> DynamicLinker::lookup_global_symbol(

    auto symbol = DynamicObject::HashSymbol { name };

-    for (auto& lib : g_global_objects) {
-        auto res = lib->lookup_symbol(symbol);
+    for (auto& lib : s_global_objects) {
+        auto res = lib.value->lookup_symbol(symbol);
        if (!res.has_value())
            continue;
        if (res.value().bind == STB_GLOBAL)
@ -64,22 +70,39 @@ Optional<DynamicObject::SymbolLookupResult> DynamicLinker::lookup_global_symbol(
    return weak_result;
 }

-static void map_library(const String& name, int fd)
+static String get_library_name(String path)
 {
-    auto loader = ELF::DynamicLoader::try_create(fd, name);
-    if (!loader) {
-        dbgln("Failed to create ELF::DynamicLoader for fd={}, name={}", fd, name);
-        VERIFY_NOT_REACHED();
-    }
-    loader->set_tls_offset(g_current_tls_offset);
-
-    g_loaders.set(name, *loader);
-
-    g_current_tls_offset += loader->tls_size();
+    return LexicalPath(move(path)).basename();
 }

-static void map_library(const String& name)
+static Result<NonnullRefPtr<DynamicLoader>, DlErrorMessage> map_library(const String& filename, int fd, bool is_program)
 {
+    auto result = ELF::DynamicLoader::try_create(fd, filename);
+    if (result.is_error()) {
+        return result;
+    }
+
+    auto& loader = result.value();
+
+    s_loaders.set(get_library_name(filename), *loader);
+
+    if (is_program) {
+        loader->set_tls_offset(s_current_tls_offset);
+        s_current_tls_offset += loader->tls_size();
+    }
+
+    return loader;
+}
+
+static Result<NonnullRefPtr<DynamicLoader>, DlErrorMessage> map_library(const String& name, bool is_program)
+{
+    if (name.contains("/")) {
+        int fd = open(name.characters(), O_RDONLY);
+        if (fd < 0)
+            return DlErrorMessage { String::formatted("Could not open shared library: {}", name) };
+        return map_library(name, fd, is_program);
+    }
+
    // TODO: Do we want to also look for libs in other paths too?
    const char* search_paths[] = { "/usr/lib/{}", "/usr/local/lib/{}" };
    for (auto& search_path : search_paths) {
@ -87,22 +110,15 @@ static void map_library(const String& name)
        int fd = open(path.characters(), O_RDONLY);
        if (fd < 0)
            continue;
-        map_library(name, fd);
-        return;
+        return map_library(name, fd, is_program);
    }

-    fprintf(stderr, "Could not find required shared library: %s\n", name.characters());
-    VERIFY_NOT_REACHED();
-}
-
-static String get_library_name(String path)
-{
-    return LexicalPath(move(path)).basename();
+    return DlErrorMessage { String::formatted("Could not find required shared library: {}", name) };
 }

 static Vector<String> get_dependencies(const String& name)
 {
-    auto lib = g_loaders.get(name).value();
+    auto lib = s_loaders.get(name).value();
    Vector<String> dependencies;

    lib->for_each_needed_library([&dependencies, &name](auto needed_name) {
@ -114,7 +130,7 @@ static Vector<String> get_dependencies(const String& name)
    return dependencies;
 }

-static void map_dependencies(const String& name)
+static Result<void, DlErrorMessage> map_dependencies(const String& name)
 {
    dbgln_if(DYNAMIC_LOAD_DEBUG, "mapping dependencies for: {}", name);

@ -122,18 +138,25 @@ static void map_dependencies(const String& name)
        dbgln_if(DYNAMIC_LOAD_DEBUG, "needed library: {}", needed_name.characters());
        String library_name = get_library_name(needed_name);

-        if (!g_loaders.contains(library_name)) {
-            map_library(library_name);
-            map_dependencies(library_name);
+        if (!s_loaders.contains(library_name) && !s_global_objects.contains(library_name)) {
+            auto result1 = map_library(needed_name, false);
+            if (result1.is_error()) {
+                return result1.error();
+            }
+            auto result2 = map_dependencies(library_name);
+            if (result2.is_error()) {
+                return result2.error();
+            }
        }
    }
    dbgln_if(DYNAMIC_LOAD_DEBUG, "mapped dependencies for {}", name);
+    return {};
 }

 static void allocate_tls()
 {
    size_t total_tls_size = 0;
-    for (const auto& data : g_loaders) {
+    for (const auto& data : s_loaders) {
        dbgln_if(DYNAMIC_LOAD_DEBUG, "{}: TLS Size: {}", data.key, data.value->tls_size());
        total_tls_size += data.value->tls_size();
    }
@ -141,12 +164,16 @@ static void allocate_tls()
        [[maybe_unused]] void* tls_address = ::allocate_tls(total_tls_size);
        dbgln_if(DYNAMIC_LOAD_DEBUG, "from userspace, tls_address: {:p}", tls_address);
    }
-    g_total_tls_size = total_tls_size;
+    s_total_tls_size = total_tls_size;
 }

 static int __dl_iterate_phdr(DlIteratePhdrCallbackFunction callback, void* data)
 {
-    for (auto& object : g_global_objects) {
+    __pthread_mutex_lock(&s_loader_lock);
+    ScopeGuard unlock_guard = [] { __pthread_mutex_unlock(&s_loader_lock); };
+
+    for (auto& it : s_global_objects) {
+        auto& object = it.value;
        auto info = dl_phdr_info {
            .dlpi_addr = (ElfW(Addr))object->base_address().as_ptr(),
            .dlpi_name = object->filename().characters(),
@ -171,7 +198,7 @@ static void initialize_libc(DynamicObject& libc)
    // because it uses getenv() internally, so `environ` has to be initialized before we call `__libc_init`.
    auto res = libc.lookup_symbol("environ"sv);
    VERIFY(res.has_value());
-    *((char***)res.value().address.as_ptr()) = g_envp;
+    *((char***)res.value().address.as_ptr()) = s_envp;

    res = libc.lookup_symbol("__environ_is_malloced"sv);
    VERIFY(res.has_value());
@ -179,12 +206,24 @@ static void initialize_libc(DynamicObject& libc)

    res = libc.lookup_symbol("exit"sv);
    VERIFY(res.has_value());
-    g_libc_exit = (LibCExitFunction)res.value().address.as_ptr();
+    s_libc_exit = (LibCExitFunction)res.value().address.as_ptr();

    res = libc.lookup_symbol("__dl_iterate_phdr"sv);
    VERIFY(res.has_value());
    *((DlIteratePhdrFunction*)res.value().address.as_ptr()) = __dl_iterate_phdr;

+    res = libc.lookup_symbol("__dlclose"sv);
+    VERIFY(res.has_value());
+    *((DlCloseFunction*)res.value().address.as_ptr()) = __dlclose;
+
+    res = libc.lookup_symbol("__dlopen"sv);
+    VERIFY(res.has_value());
+    *((DlOpenFunction*)res.value().address.as_ptr()) = __dlopen;
+
+    res = libc.lookup_symbol("__dlsym"sv);
+    VERIFY(res.has_value());
+    *((DlSymFunction*)res.value().address.as_ptr()) = __dlsym;
+
    res = libc.lookup_symbol("__libc_init"sv);
    VERIFY(res.has_value());
    typedef void libc_init_func();
@ -192,52 +231,56 @@ static void initialize_libc(DynamicObject& libc)
 }

 template<typename Callback>
-static void for_each_dependency_of(const String& name, HashTable<String>& seen_names, Callback callback)
+static void for_each_unfinished_dependency_of(const String& name, HashTable<String>& seen_names, Callback callback)
 {
+    if (!s_loaders.contains(name))
+        return;
+
    if (seen_names.contains(name))
        return;
    seen_names.set(name);

    for (const auto& needed_name : get_dependencies(name))
-        for_each_dependency_of(get_library_name(needed_name), seen_names, callback);
+        for_each_unfinished_dependency_of(get_library_name(needed_name), seen_names, callback);

-    callback(*g_loaders.get(name).value());
+    callback(*s_loaders.get(name).value());
 }

-static NonnullRefPtrVector<DynamicLoader> collect_loaders_for_executable(const String& name)
+static NonnullRefPtrVector<DynamicLoader> collect_loaders_for_library(const String& name)
 {
    HashTable<String> seen_names;
    NonnullRefPtrVector<DynamicLoader> loaders;
-    for_each_dependency_of(name, seen_names, [&](auto& loader) {
+    for_each_unfinished_dependency_of(name, seen_names, [&](auto& loader) {
        loaders.append(loader);
    });
    return loaders;
 }

-static NonnullRefPtr<DynamicLoader> load_main_executable(const String& name)
+static Result<NonnullRefPtr<DynamicLoader>, DlErrorMessage> load_main_library(const String& name, int flags)
 {
-    // NOTE: We always map the main executable first, since it may require
-    //       placement at a specific address.
-    auto& main_executable_loader = *g_loaders.get(name).value();
-    auto main_executable_object = main_executable_loader.map();
-    g_global_objects.append(*main_executable_object);
+    auto main_library_loader = *s_loaders.get(name);
+    auto main_library_object = main_library_loader->map();
+    s_global_objects.set(name, *main_library_object);

-    auto loaders = collect_loaders_for_executable(name);
+    auto loaders = collect_loaders_for_library(name);

    for (auto& loader : loaders) {
        auto dynamic_object = loader.map();
        if (dynamic_object)
-            g_global_objects.append(*dynamic_object);
+            s_global_objects.set(dynamic_object->filename(), *dynamic_object);
    }

    for (auto& loader : loaders) {
-        bool success = loader.link(RTLD_GLOBAL | RTLD_LAZY, g_total_tls_size);
-        VERIFY(success);
+        bool success = loader.link(flags, s_total_tls_size);
+        if (!success) {
+            return DlErrorMessage { String::formatted("Failed to link library {}", loader.filename()) };
+        }
    }

    for (auto& loader : loaders) {
-        auto object = loader.load_stage_3(RTLD_GLOBAL | RTLD_LAZY, g_total_tls_size);
-        VERIFY(object);
+        auto result = loader.load_stage_3(flags, s_total_tls_size);
+        VERIFY(!result.is_error());
+        auto& object = result.value();

        if (loader.filename() == "libsystem.so") {
            if (syscall(SC_msyscall, object->base_address().as_ptr())) {
@ -254,45 +297,150 @@ static NonnullRefPtr<DynamicLoader> load_main_executable(const String& name)
        loader.load_stage_4();
    }

-    return main_executable_loader;
+    return main_library_loader;
+}
+
+static Result<void, DlErrorMessage> __dlclose(void* handle)
+{
+    dbgln_if(DYNAMIC_LOAD_DEBUG, "__dlclose: {}", handle);
+
+    __pthread_mutex_lock(&s_loader_lock);
+    ScopeGuard unlock_guard = [] { __pthread_mutex_unlock(&s_loader_lock); };
+
+    // FIXME: this will not currently destroy the dynamic object
+    // because we're intentionally holding a strong reference to it
+    // via s_global_objects until there's proper unload support.
+    auto object = static_cast<ELF::DynamicObject*>(handle);
+    object->unref();
+    return {};
+}
+
+static Result<void*, DlErrorMessage> __dlopen(const char* filename, int flags)
+{
+    // FIXME: RTLD_NOW and RTLD_LOCAL are not supported
+    flags &= ~RTLD_NOW;
+    flags |= RTLD_LAZY;
+    flags &= ~RTLD_LOCAL;
+    flags |= RTLD_GLOBAL;
+
+    dbgln_if(DYNAMIC_LOAD_DEBUG, "__dlopen invoked, filename={}, flags={}", filename, flags);
+
+    auto library_name = get_library_name(filename ? filename : s_main_program_name);
+
+    if (__pthread_mutex_trylock(&s_loader_lock) != 0)
+        return DlErrorMessage { "Nested calls to dlopen() are not permitted." };
+    ScopeGuard unlock_guard = [] { __pthread_mutex_unlock(&s_loader_lock); };
+
+    auto existing_elf_object = s_global_objects.get(library_name);
+    if (existing_elf_object.has_value()) {
+        // It's up to the caller to release the ref with dlclose().
+        return &existing_elf_object->leak_ref();
+    }
+
+    VERIFY(!library_name.is_empty());
+
+    auto result1 = map_library(filename, false);
+    if (result1.is_error()) {
+        return result1.error();
+    }
+
+    auto result2 = map_dependencies(library_name);
+    if (result2.is_error()) {
+        return result2.error();
+    }
+
+    auto result = load_main_library(library_name, flags);
+    if (result.is_error())
+        return result.error();
+
+    auto object = s_global_objects.get(library_name);
+    if (!object.has_value())
+        return DlErrorMessage { "Could not load ELF object." };
+
+    // It's up to the caller to release the ref with dlclose().
+    return &object->leak_ref();
+}
+
+static Result<void*, DlErrorMessage> __dlsym(void* handle, const char* symbol_name)
+{
+    dbgln_if(DYNAMIC_LOAD_DEBUG, "__dlsym: {}, {}", handle, symbol_name);
+
+    __pthread_mutex_lock(&s_loader_lock);
+    ScopeGuard unlock_guard = [] { __pthread_mutex_unlock(&s_loader_lock); };
+
+    auto object = static_cast<DynamicObject*>(handle);
+    if (!handle) {
+        auto library_name = get_library_name(s_main_program_name);
+        auto global_object = s_global_objects.get(library_name);
+        object = *global_object;
+    }
+    auto symbol = object->lookup_symbol(symbol_name);
+    if (!symbol.has_value()) {
+        return DlErrorMessage { String::formatted("Symbol {} not found", symbol_name) };
+    }
+    return symbol.value().address.as_ptr();
 }

 static void read_environment_variables()
 {
-    for (char** env = g_envp; *env; ++env) {
+    for (char** env = s_envp; *env; ++env) {
        if (StringView { *env } == "_LOADER_BREAKPOINT=1") {
-            g_do_breakpoint_trap_before_entry = true;
+            s_do_breakpoint_trap_before_entry = true;
        }
    }
 }

 void ELF::DynamicLinker::linker_main(String&& main_program_name, int main_program_fd, bool is_secure, int argc, char** argv, char** envp)
 {
-    g_envp = envp;
+    s_envp = envp;

-    g_allowed_to_check_environment_variables = !is_secure;
-    if (g_allowed_to_check_environment_variables)
+    s_allowed_to_check_environment_variables = !is_secure;
+    if (s_allowed_to_check_environment_variables)
        read_environment_variables();

-    map_library(main_program_name, main_program_fd);
-    map_dependencies(main_program_name);
+    s_main_program_name = main_program_name;
+
+    auto library_name = get_library_name(main_program_name);
+
+    // NOTE: We always map the main library first, since it may require
+    //       placement at a specific address.
+    auto result1 = map_library(main_program_name, main_program_fd, true);
+    if (result1.is_error()) {
+        warnln("{}", result1.error().text);
+        fflush(stderr);
+        _exit(1);
+    }
+    result1.release_value();
+
+    auto result2 = map_dependencies(library_name);
+    if (result2.is_error()) {
+        warnln("{}", result2.error().text);
+        fflush(stderr);
+        _exit(1);
+    }

    dbgln_if(DYNAMIC_LOAD_DEBUG, "loaded all dependencies");
-    for ([[maybe_unused]] auto& lib : g_loaders) {
+    for ([[maybe_unused]] auto& lib : s_loaders) {
        dbgln_if(DYNAMIC_LOAD_DEBUG, "{} - tls size: {}, tls offset: {}", lib.key, lib.value->tls_size(), lib.value->tls_offset());
    }

    allocate_tls();

    auto entry_point_function = [&main_program_name] {
-        auto main_executable_loader = load_main_executable(main_program_name);
+        auto library_name = get_library_name(main_program_name);
+        auto result = load_main_library(library_name, RTLD_GLOBAL | RTLD_LAZY);
+        if (result.is_error()) {
+            warnln("{}", result.error().text);
+            _exit(1);
+        }
+        auto& main_executable_loader = result.value();
        auto entry_point = main_executable_loader->image().entry();
        if (main_executable_loader->is_dynamic())
            entry_point = entry_point.offset(main_executable_loader->base_address().get());
        return (EntryPointFunction)(entry_point.as_ptr());
    }();

-    g_loaders.clear();
+    s_loaders.clear();

    int rc = syscall(SC_msyscall, nullptr);
    if (rc < 0) {
@ -300,13 +448,13 @@ void ELF::DynamicLinker::linker_main(String&& main_program_name, int main_progra
    }

    dbgln_if(DYNAMIC_LOAD_DEBUG, "Jumping to entry point: {:p}", entry_point_function);
-    if (g_do_breakpoint_trap_before_entry) {
+    if (s_do_breakpoint_trap_before_entry) {
        asm("int3");
    }
    rc = entry_point_function(argc, argv, envp);
    dbgln_if(DYNAMIC_LOAD_DEBUG, "rc: {}", rc);
-    if (g_libc_exit != nullptr) {
-        g_libc_exit(rc);
+    if (s_libc_exit != nullptr) {
+        s_libc_exit(rc);
    } else {
        _exit(rc);
    }