tool_root_lock.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#include <entropic/mcp/tool_root_lock.h>
#include <entropic/types/logging.h>
 
static auto logger = entropic::log::get("mcp.tool_root_lock");
 
namespace entropic {
 
void ToolRootLock::lock() {
    const auto me = std::this_thread::get_id();
    if (owner_.load(std::memory_order_acquire) == me) {
        ++depth_;
        return;
    }
    mutex_.lock();
    owner_.store(me, std::memory_order_release);
    depth_ = 1;
}
 
void ToolRootLock::unlock() {
    if (--depth_ == 0) {
        owner_.store(std::thread::id{}, std::memory_order_release);
        mutex_.unlock();
    }
}
 
bool ToolRootLock::lock_shared(const std::string& what) {
    if (owned_by_this_thread()) {
        return false;
    }
    if (!mutex_.try_lock_shared()) {
        logger->info("[{}] waiting: a sandboxed delegation has this server "
                     "set re-rooted; dispatching once it restores", what);
        mutex_.lock_shared();
        logger->info("[{}] working directory restored — dispatching", what);
    }
    return true;
}
 
void ToolRootLock::unlock_shared() {
    mutex_.unlock_shared();
}
 
bool ToolRootLock::owned_by_this_thread() const {
    return owner_.load(std::memory_order_acquire)
        == std::this_thread::get_id();
}
 
ToolRootShared::ToolRootShared(ToolRootLock& lock, const std::string& what)
    : lock_(lock), held_(lock.lock_shared(what)) {}
 
ToolRootShared::~ToolRootShared() {
    if (held_) {
        lock_.unlock_shared();
    }
}
 
} // namespace entropic