SetJmp.cpp

Go to the documentation of this file.

 
#include "SetJmp.h"
#include "CothreadPrivate.h"
 
#include <atomic>
#include <csetjmp>
#include <cstddef>
#include <cstdlib>
#include <cstring>
#include <mutex>
#include <stdexcept>
#include <system_error>
 
#include <signal.h>
 
using namespace libcommunism;
using namespace libcommunism::internal;
 
static_assert(sizeof(sigjmp_buf) < (SetJmp::kMainStackSize * sizeof(uintptr_t)),
        "main stack size is too small for sigjmp_buf!");
 
thread_local std::array<uintptr_t, SetJmp::kMainStackSize> SetJmp::gMainStack;
 
SetJmp::EntryContext *SetJmp::gCurrentlyPreparing{nullptr};
std::mutex SetJmp::gSignalLock;
 
SetJmp::SetJmp(const Entry &entry, const size_t stackSize) : CothreadImpl(entry, stackSize) {
    void *buf{nullptr};
 
    // round down stack size to ensure it's aligned before allocating it
    auto allocSize = stackSize & ~(SetJmp::kStackAlignment - 1);
    allocSize = allocSize ? allocSize : SetJmp::kDefaultStackSize;
 
    // then add space for ucontext
    allocSize += sizeof(sigjmp_buf);
    if(allocSize % SetJmp::kStackAlignment) {
        allocSize += SetJmp::kStackAlignment - (allocSize % SetJmp::kStackAlignment);
    }
 
    // and allocate it
#ifdef _WIN32
    buf = _aligned_malloc(allocSize, SetJmp::kStackAlignment);
#else
    int err{0};
    err = posix_memalign(&buf, SetJmp::kStackAlignment, allocSize);
    if(err) {
        throw std::runtime_error("posix_memalign() failed");
    }
#endif
    if(!buf) {
        throw std::runtime_error("failed to allocate stack");
    }
 
    // create it as if we had provided the memory in the first place
    this->stack = {reinterpret_cast<uintptr_t *>(buf), allocSize / sizeof(uintptr_t)};
    this->ownsStack = true;
 
    Prepare(this, entry);
}
 
SetJmp::SetJmp(const Entry &entry, std::span<uintptr_t> stack) : CothreadImpl(entry, stack) {
    Prepare(this, entry);
}
 
SetJmp::~SetJmp() {
    if(this->ownsStack) {
#ifdef _WIN32
        _aligned_free(this->stack.data());
#else
        free(this->stack.data());
#endif
    }
}
 
void SetJmp::switchTo(CothreadImpl *_from) {
    auto from = static_cast<SetJmp *>(_from);
 
    if(!sigsetjmp(*SetJmp::JmpBufFor(from), 0)) {
        std::atomic_thread_fence(std::memory_order_release);
        siglongjmp(*SetJmp::JmpBufFor(this), 1);
    }
}
 
 
 
CothreadImpl *libcommunism::AllocKernelThreadWrapper() {
    return new SetJmp(SetJmp::gMainStack);
}
 
void SetJmp::InvokeCothreadDidReturnHandler(Cothread *from) {
    gReturnHandler(from);
    std::terminate();
}
 
void SetJmp::Prepare(SetJmp *thread, const Cothread::Entry &entry) {
    int err{0};
    struct sigaction handler, oldHandler;
    stack_t stack{}, oldStack{};
 
    auto jbuf = JmpBufFor(thread);
    memset(jbuf, 0, sizeof(*jbuf));
 
    // prepare the signal handling stack
    auto offset = sizeof(sigjmp_buf);
    if(offset % kStackAlignment) {
        offset += kStackAlignment - (offset % kStackAlignment);
    }
 
    stack.ss_sp = reinterpret_cast<std::byte *>(thread->stack.data()) + offset;
    stack.ss_size = (thread->stack.size() * sizeof(uintptr_t)) - offset;
 
    auto info = new EntryContext( thread, entry);
    if(!info) throw std::runtime_error("Failed to allocate context");
 
    // listen man you're just gonna have to trust me on this one
    try {
        std::lock_guard<std::mutex> lock(gSignalLock);
 
        err = sigaltstack(&stack, &oldStack);
        if(err) {
            throw std::system_error(errno, std::generic_category(), "sigaltstack");
        }
 
        gCurrentlyPreparing = info;
        std::atomic_thread_fence(std::memory_order_release);
 
        handler.sa_handler = SignalHandlerSetupThunk;
        handler.sa_flags = SA_ONSTACK;
        sigemptyset(&handler.sa_mask);
 
        err = sigaction(SIGUSR1, &handler, &oldHandler);
        if(err) {
            throw std::system_error(errno, std::generic_category(), "sigaction");
        }
        err = raise(SIGUSR1);
        if(err) {
            throw std::system_error(errno, std::generic_category(), "raise");
        }
        sigaltstack(&oldStack, nullptr);
        sigaction(SIGUSR1, &oldHandler, nullptr);
    } catch(const std::exception &) {
        delete info;
        throw;
    }
}
 
void SetJmp::SignalHandlerSetupThunk(int signal) {
    (void) signal;
 
    auto ctx = gCurrentlyPreparing;
    if(sigsetjmp(*JmpBufFor(ctx->impl), 0)) {
        ctx->entry();
        InvokeCothreadDidReturnHandler(Cothread::Current());
    }
}