reload_library.hpp

Go to the documentation of this file.

#pragma once

 
#include <string>
#include <utility>
 
#if defined(_WIN32)
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#ifndef NOMINMAX
#define NOMINMAX
#endif
#include <windows.h>
#else
#include <dlfcn.h>
#endif
 
namespace pulp::format::reload {
 
#if !defined(_WIN32)
inline void promote_host_symbols_once() {
    static const bool promoted = [] {
        ::Dl_info info{};
        if (::dladdr(reinterpret_cast<const void*>(&promote_host_symbols_once), &info) &&
            info.dli_fname) {
            // RTLD_NOLOAD: do not map a new copy — just look up the already-loaded
            // host image and (via RTLD_GLOBAL) promote its symbols' scope. glibc
            // rejects a mode without RTLD_LAZY or RTLD_NOW ("invalid mode"), so
            // on Linux the promotion silently did nothing and thin logic failed
            // to bind in a plug-in loaded RTLD_LOCAL.
#if defined(__linux__)
            constexpr int kPromoteMode = RTLD_LAZY | RTLD_GLOBAL | RTLD_NOLOAD;
#else
            constexpr int kPromoteMode = RTLD_GLOBAL | RTLD_NOLOAD;
#endif
            if (void* self = ::dlopen(info.dli_fname, kPromoteMode)) {
                // Intentionally leak this handle: we only wanted the scope change;
                // the image is the running host and is never unloaded regardless.
                (void)self;
            }
        }
        return true;
    }();
    (void)promoted;
}
#else
inline void promote_host_symbols_once() {}
#endif

enum class LeakPolicy {
    Retain,         
    CloseOnDestroy  
};
 
class ReloadLibrary {
public:
    ReloadLibrary() = default;

    explicit ReloadLibrary(const std::string& path,
                           LeakPolicy policy = LeakPolicy::Retain)
        : path_(path), policy_(policy) {
        open(path);
    }
 
    // Move-only: a handle has unique ownership of the (un)load decision.
    ReloadLibrary(ReloadLibrary&& other) noexcept { move_from(other); }
    ReloadLibrary& operator=(ReloadLibrary&& other) noexcept {
        if (this != &other) {
            destroy();
            move_from(other);
        }
        return *this;
    }
    ReloadLibrary(const ReloadLibrary&) = delete;
    ReloadLibrary& operator=(const ReloadLibrary&) = delete;
 
    ~ReloadLibrary() { destroy(); }
 
    bool valid() const noexcept { return handle_ != nullptr; }
    explicit operator bool() const noexcept { return valid(); }
 
    const std::string& error() const noexcept { return error_; }
    const std::string& path() const noexcept { return path_; }
    void* native_handle() const noexcept { return handle_; }
 
    LeakPolicy leak_policy() const noexcept { return policy_; }
    void set_leak_policy(LeakPolicy policy) noexcept { policy_ = policy; }

    void* raw_symbol(const char* name) const noexcept {
        if (!handle_ || !name) return nullptr;
#if defined(_WIN32)
        return reinterpret_cast<void*>(
            ::GetProcAddress(reinterpret_cast<HMODULE>(handle_), name));
#else
        return ::dlsym(handle_, name);
#endif
    }

    template <typename T>
    T symbol(const char* name) const noexcept {
        return reinterpret_cast<T>(raw_symbol(name));
    }

    bool close() noexcept {
        if (!handle_) return false;
        const bool ok = native_close(handle_);
        handle_ = nullptr;
        return ok;
    }
 
private:
    void open(const std::string& path) {
#if defined(_WIN32)
        DWORD old_mode = 0;
        const BOOL changed = ::SetThreadErrorMode(
            SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX, &old_mode);
        handle_ = reinterpret_cast<void*>(::LoadLibraryA(path.c_str()));
        if (changed) ::SetThreadErrorMode(old_mode, nullptr);
        if (!handle_) error_ = "LoadLibraryA failed for '" + path + "'";
#else
        // Ensure the host bundle's pulp::* SDK symbols are globally visible
        // BEFORE loading (possibly thin) logic that resolves them at dlopen via
        // flat-namespace lookup — the in-DAW RTLD_LOCAL fix. Once per
        // process; a no-op after the first load and for the static-link model.
        promote_host_symbols_once();
        handle_ = ::dlopen(path.c_str(), RTLD_NOW | RTLD_LOCAL);
        if (!handle_) {
            const char* e = ::dlerror();
            error_ = e ? e : ("dlopen failed for '" + path + "'");
        }
#endif
    }
 
    static bool native_close(void* handle) noexcept {
#if defined(_WIN32)
        return ::FreeLibrary(reinterpret_cast<HMODULE>(handle)) != 0;
#else
        return ::dlclose(handle) == 0;
#endif
    }
 
    void destroy() noexcept {
        if (handle_ && policy_ == LeakPolicy::CloseOnDestroy) {
            native_close(handle_);
        }
        // LeakPolicy::Retain: intentionally leak the image for the process
        // lifetime (see file header). Drop our reference without unloading.
        handle_ = nullptr;
    }
 
    void move_from(ReloadLibrary& other) noexcept {
        handle_ = other.handle_;
        path_ = std::move(other.path_);
        error_ = std::move(other.error_);
        policy_ = other.policy_;
        other.handle_ = nullptr;  // moved-from never unloads
    }
 
    void* handle_ = nullptr;
    std::string path_;
    std::string error_;
    LeakPolicy policy_ = LeakPolicy::Retain;
};
 
} // namespace pulp::format::reload