UContext.h

Go to the documentation of this file.

#ifndef ARCH_UCONTEXT_UCONTEXT_H
#define ARCH_UCONTEXT_UCONTEXT_H
 
#include "CothreadPrivate.h"
#include "CothreadImpl.h"
 
#include <array>
#include <cstddef>
#include <memory>
#include <mutex>
#include <unordered_map>
 
#define _XOPEN_SOURCE
#include <ucontext.h>
 
namespace libcommunism::internal {
class UContext final: public CothreadImpl {
    friend CothreadImpl *libcommunism::AllocKernelThreadWrapper();
 
    public:
        UContext(const Entry &entry, const size_t stackSize = 0);
        UContext(const Entry &entry, std::span<uintptr_t> stack);
        UContext(std::span<uintptr_t> stack) : CothreadImpl(stack) {}
        ~UContext();
 
        void switchTo(CothreadImpl *from) override;
 
    private:
        struct Context {
            Cothread::Entry entry;
 
            Context(const Cothread::Entry &_entry) : entry(_entry) {}
        };
 
        static ucontext_t *ContextFor(CothreadImpl *thread) {
            return reinterpret_cast<ucontext_t *>(static_cast<UContext *>(thread)->stack.data());
        }
 
        static void AllocMainCothread();
        static void Prepare(UContext *thread, const Cothread::Entry &entry);
        static void EntryStub(int id);
        static void InvokeCothreadDidReturnHandler(Cothread *from);
 
    public:
        static constexpr const size_t kStackAlignment{64};
 
        static constexpr const size_t kMainStackSize{128};
 
        static constexpr const size_t kDefaultStackSize{sizeof(uintptr_t) * 0x10000};
 
    private:
        static thread_local std::array<uintptr_t, kMainStackSize> gMainStack;
 
        static std::unordered_map<int, std::unique_ptr<Context>> gContextInfo;
 
        static std::mutex gContextInfoLock;
 
        static int gContextNextId;
 
    private:
        bool ownsStack{false};
};
}
 
 
#endif