context.h

Go to the documentation of this file.

#ifndef ZTH_CONTEXT_CONTEXT_H
#define ZTH_CONTEXT_CONTEXT_H
/*
 * SPDX-FileCopyrightText: 2019-2026 Jochem Rutgers
 *
 * SPDX-License-Identifier: MPL-2.0
 */
 
#ifdef __cplusplus
 
#  include "libzth/macros.h"
 
#  include "libzth/allocator.h"
#  include "libzth/context.h"
#  include "libzth/util.h"
#  include "libzth/worker.h"
 
#  include <setjmp.h>
#  include <unistd.h>
 
#  ifndef ZTH_OS_WINDOWS
#    include <signal.h>
#  endif
 
#  ifdef ZTH_HAVE_MMAN
#    include <sys/mman.h>
#    ifndef MAP_STACK
#      define MAP_STACK 0
#    endif
#  endif
 
#  ifdef ZTH_HAVE_VALGRIND
#    include <valgrind/memcheck.h>
#  endif
 
#  ifdef ZTH_ENABLE_ASAN
#    include <sanitizer/common_interface_defs.h>
#  endif
 
namespace zth {
namespace impl {
 
template <typename Impl>
class ContextBase {
        ZTH_CLASS_NOCOPY(ContextBase)
protected:
        constexpr explicit ContextBase(ContextAttr const& attr) noexcept
                : m_attr(attr)
#  ifdef ZTH_ENABLE_ASAN
                , m_alive(true)
#  endif
        {}
 
        ~ContextBase()
        {
                // Make sure destroy() was called before.
                zth_assert(m_stack.p == nullptr);
        }
 
        Impl& impl() noexcept
        {
                return static_cast<Impl&>(*this);
        }
 
        Impl const& impl() const noexcept
        {
                return static_cast<Impl const&>(*this);
        }
 
public:
        static int init() noexcept
        {
                return 0;
        }
 
        static void deinit() noexcept {}
 
        ContextAttr& attr() noexcept
        {
                return m_attr;
        }
 
        ContextAttr const& attr() const noexcept
        {
                return m_attr;
        }
 
        int create() noexcept
        {
                int res = 0;
 
                m_stack = Stack(attr().stackSize);
                m_stackUsable = Stack();
 
                if(attr().stackSize == 0)
                        // No stack requested.
                        return 0;
 
                // Allocate stack.
                if((res = impl().initStack(m_stack, m_stackUsable)))
                        return res;
 
                // Apply guards.
                impl().valgrindRegister();
 
                if(unlikely((res = impl().stackGuardInit()))) {
                        // Uh, oh...
                        impl().deallocStack(m_stack);
                        return res;
                }
 
                return 0;
        }
 
        void destroy() noexcept
        {
                impl().stackGuardDeinit();
                impl().valgrindDeregister();
                impl().deinitStack(m_stack);
                m_stackUsable = m_stack = Stack();
        }
 
        int initStack(Stack& stack, Stack& usable) noexcept
        {
                stack.size = impl().calcStackSize(stack.size);
 
                size_t const page = impl().pageSize();
                zth_assert(__builtin_popcount((unsigned int)page) == 1);
 
                // Round up to full pages.
                stack.size = (stack.size + page - 1U) & ~(page - 1U);
 
                // Add another page size to allow arbitrary allocation location.
                stack.size += page;
 
                if(unlikely(!(stack.p = static_cast<char*>(impl().allocStack(stack.size)))))
                        return errno;
 
                // Compute usable offsets.
                usable = stack;
                impl().stackAlign(usable);
 
                stack_watermark_init(usable.p, usable.size);
                return 0;
        }
 
        void deinitStack(Stack& stack) noexcept
        {
                impl().deallocStack(stack);
        }
 
        static size_t pageSize() noexcept
        {
                static size_t pz =
#  ifdef ZTH_HAVE_MMAN
                        (size_t)sysconf(_SC_PAGESIZE);
#  else
                        sizeof(void*);
#  endif
                return pz;
        }
 
        Stack const& stack() const noexcept
        {
                return m_stack;
        }
 
        Stack const& stackUsable() const noexcept
        {
                return m_stackUsable;
        }
 
        size_t calcStackSize(size_t size) noexcept
        {
#  ifndef ZTH_OS_WINDOWS
                size += MINSIGSTKSZ;
#  endif
 
#  ifdef ZTH_HAVE_MMAN
                if(Config::EnableStackGuard)
                        // Both ends of the stack are guarded using mprotect().
                        size += impl().pageSize() * 2;
#  endif
 
                return size;
        }
 
        void* allocStack(size_t size) noexcept
        {
                void* p = nullptr;
 
#  ifdef ZTH_HAVE_MMAN
                // NOLINTNEXTLINE(hicpp-signed-bitwise,cppcoreguidelines-pro-type-cstyle-cast)
                p =
                        mmap(nullptr, size, PROT_READ | PROT_WRITE,
                             MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0);
 
                if(unlikely(p == MAP_FAILED))
                        return nullptr;
#  else
                if(unlikely((p = static_cast<void*>(allocate_noexcept<char>(size))) == nullptr)) {
                        errno = ENOMEM;
                        return nullptr;
                }
#  endif
 
                return p;
        }
 
        void deallocStack(Stack& stack) noexcept
        {
                if(!stack.p)
                        return;
 
#  ifdef ZTH_HAVE_MMAN
                munmap(stack.p, stack.size);
#  else
                deallocate(static_cast<char*>(stack.p), stack.size);
#  endif
 
                stack.p = nullptr;
        }
 
        void stackAlign(Stack& stack) noexcept
        {
                if(!stack.p || !stack.size)
                        // Nothing to align.
                        return;
 
                size_t const ps = impl().pageSize();
 
                // Align to page size.
                uintptr_t stack_old = (uintptr_t)stack.p;
                // calcStackSize() should have taken care of this.
                zth_assert(stack.size > ps);
 
                // The stack should not wrap.
                zth_assert(stack_old + stack.size > stack_old);
 
                uintptr_t stack_new = ((uintptr_t)(stack_old + ps - 1U) & ~(ps - 1U));
                stack.size = (stack.size - (stack_new - stack_old)) & ~(ps - 1U);
 
#  ifdef ZTH_HAVE_MMAN
                if(Config::EnableStackGuard) {
                        // Do not use the pages at both sides.
                        zth_assert(stack.size > ps * 2U);
                        stack_new += ps;
                        stack.size -= ps * 2U;
                }
#  endif
 
                zth_assert(stack.size > 0);
                stack.p = reinterpret_cast<char*>(stack_new); // NOLINT
        }
 
        void valgrindRegister() noexcept
        {
#  ifdef ZTH_USE_VALGRIND
                if(!m_stackUsable.p)
                        return;
 
                m_valgrind_stack_id = VALGRIND_STACK_REGISTER(
                        m_stackUsable.p, m_stackUsable.p + m_stackUsable.size - 1U);
 
                if(RUNNING_ON_VALGRIND)
                        zth_dbg(context, "[%s] Stack of context %p has Valgrind id %u",
                                currentWorker().id_str(), this, m_valgrind_stack_id);
#  endif
        }
 
        void valgrindDeregister() noexcept
        {
#  ifdef ZTH_USE_VALGRIND
                VALGRIND_STACK_DEREGISTER(m_valgrind_stack_id);
                m_valgrind_stack_id = 0;
#  endif
        }
 
        int stackGuardInit() noexcept
        {
#  ifdef ZTH_HAVE_MMAN
                if(Config::EnableStackGuard) {
                        if(!m_stackUsable.p)
                                return 0;
 
                        size_t const ps = impl().pageSize();
                        // Guard both ends of the stack.
                        if(unlikely(mprotect(m_stackUsable.p - ps, ps, PROT_NONE)))
                                return errno;
                        if(unlikely(mprotect(m_stackUsable.p + m_stackUsable.size, ps, PROT_NONE)))
                                return errno;
                }
#  endif
                return 0;
        }
 
        void stackGuardDeinit() noexcept
        {
                // Automatically released when mprotected area is munmapped.
        }
 
        __attribute__((noinline)) static bool stackGrowsDown(void const* reference)
        {
                int i = 42;
                return reinterpret_cast<uintptr_t>(&i) < reinterpret_cast<uintptr_t>(reference);
        }
 
        void stackGuard() noexcept
        {
                impl().stackGuard(stackUsable());
        }
 
        void stackGuard(Stack const& UNUSED_PAR(stack)) noexcept {}
 
        // cppcheck-suppress constParameterPointer
        void* stackGuard(void* UNUSED_PAR(p)) noexcept
        {
                return nullptr;
        }
 
        void context_switch(Context& to) noexcept;
 
        static void** sp(Stack const& stack) noexcept;
 
        static void stack_push(void**& sp, void* p) noexcept;
 
        static void set_sp(jmp_buf& env, void** sp) noexcept;
 
        static void set_pc(jmp_buf& env, void* sp) noexcept;
 
        static void context_trampoline_from_jmp_buf() noexcept;
 
        void context_push_regs() noexcept {}
 
        void context_pop_regs() noexcept {}
 
        // cppcheck-suppress constParameterReference
        void context_prepare_jmp(Impl& UNUSED_PAR(to), jmp_buf& UNUSED_PAR(env)) noexcept {}
 
        void die() noexcept
        {
#  ifdef ZTH_ENABLE_ASAN
                m_alive = false;
#  endif
        }
 
        bool alive() const noexcept
        {
#  ifdef ZTH_ENABLE_ASAN
                return m_alive;
#  else
                return true;
#  endif
        }
 
        void* stack_switch(
                void* UNUSED_PAR(stack), size_t UNUSED_PAR(size), void* (*f)(void*) noexcept,
                void* arg) noexcept
        {
                // cppcheck-suppress CastIntegerToAddressAtReturn
                return f(arg);
        }
 
private:
        ContextAttr m_attr;
        Stack m_stack;
        Stack m_stackUsable;
#  ifdef ZTH_USE_VALGRIND
        unsigned int m_valgrind_stack_id;
#  endif
#  ifdef ZTH_ENABLE_ASAN
        bool m_alive;
#  endif
};
 
template <typename Impl>
static Impl* current_context() noexcept;
 
} // namespace impl
} // namespace zth
 
#  if defined(ZTH_ARCH_ARM)
#    include "libzth/context/arch_arm.h"
#  else
#    include "libzth/context/arch_generic.h"
#  endif
 
extern "C" void context_entry(zth::Context* context) noexcept __attribute__((noreturn, used));
 
#  if defined(ZTH_CONTEXT_SIGALTSTACK)
#    include "libzth/context/sigaltstack.h"
#  elif defined(ZTH_CONTEXT_SJLJ)
#    include "libzth/context/sjlj.h"
#  elif defined(ZTH_CONTEXT_UCONTEXT)
#    include "libzth/context/ucontext.h"
#  elif defined(ZTH_CONTEXT_WINFIBER)
#    include "libzth/context/winfiber.h"
#  else
#    error Unknown context switching approach.
#  endif
 
#endif // __cplusplus
#endif // ZTH_CONTEXT_CONTEXT_H