koffi 2.2.3-beta.1 → 2.2.3-beta.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "koffi",
-    "version": "2.2.3-beta.1",
+    "version": "2.2.3-beta.3",
     "stable": "2.2.2",
     "description": "Fast and simple C FFI (foreign function interface) for Node.js",
     "keywords": [

package/src/koffi/src/abi_x64_win.cc

@@ -17,14 +17,7 @@
 #include "ffi.hh"
 #include "call.hh"
 #include "util.hh"
-
-#ifndef NOMINMAX
-    #define NOMINMAX
-#endif
-#ifndef WIN32_LEAN_AND_MEAN
-    #define WIN32_LEAN_AND_MEAN
-#endif
-#include <windows.h>
+#include "win32.hh"
 
 #include <napi.h>
 
@@ -224,15 +217,21 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
 
 void CallData::Execute(const FunctionInfo *func)
 {
-    NT_TIB *tib = (NT_TIB *)__readgsqword(0x30);
-
-    // Adjust TIB stack limits so SEH works correctly
-    RG_DEFER_C(base = tib->StackBase, limit = tib->StackLimit) {
-        tib->StackBase = base;
-        tib->StackLimit = limit;
+    TEB *teb = GetTEB();
+
+    // Restore previous stack limits at the end
+    RG_DEFER_C(base = teb->StackBase,
+               limit = teb->StackLimit,
+               dealloc = teb->DeallocationStack) {
+        teb->StackBase = base;
+        teb->StackLimit = limit;
+        teb->DeallocationStack = dealloc;
     };
-    tib->StackBase = mem->stack0.end();
-    tib->StackLimit = mem->stack0.ptr;
+
+    // Adjust stack limits so SEH works correctly
+    teb->StackBase = mem->stack0.end();
+    teb->StackLimit = mem->stack0.ptr;
+    teb->DeallocationStack = mem->stack0.ptr;
 
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
@@ -335,15 +334,21 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
     if (RG_UNLIKELY(env.IsExceptionPending()))
         return;
 
-    NT_TIB *tib = (NT_TIB *)__readgsqword(0x30);
+    TEB *teb = GetTEB();
 
-    // Restore real thread stack limits
-    RG_DEFER_C(base = tib->StackBase, limit = tib->StackLimit) {
-        tib->StackBase = base;
-        tib->StackLimit = limit;
+    // Restore previous stack limits at the end
+    RG_DEFER_C(base = teb->StackBase,
+               limit = teb->StackLimit,
+               dealloc = teb->DeallocationStack) {
+        teb->StackBase = base;
+        teb->StackLimit = limit;
+        teb->DeallocationStack = dealloc;
     };
-    tib->StackBase = instance->main_stack_base;
-    tib->StackLimit = instance->main_stack_limit;
+
+    // Adjust stack limits so SEH works correctly
+    teb->StackBase = instance->main_stack_max;
+    teb->StackLimit = instance->main_stack_min;
+    teb->DeallocationStack = instance->main_stack_min;
 
     const TrampolineInfo &trampoline = shared.trampolines[idx];
 

package/src/koffi/src/abi_x86.cc

@@ -17,15 +17,8 @@
 #include "ffi.hh"
 #include "call.hh"
 #include "util.hh"
-
 #ifdef _WIN32
-    #ifndef NOMINMAX
-        #define NOMINMAX
-    #endif
-    #ifndef WIN32_LEAN_AND_MEAN
-        #define WIN32_LEAN_AND_MEAN
-    #endif
-    #include <windows.h>
+    #include "win32.hh"
 #endif
 
 #include <napi.h>
@@ -308,15 +301,21 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
 void CallData::Execute(const FunctionInfo *func)
 {
 #ifdef _WIN32
-    NT_TIB *tib = (NT_TIB *)__readfsdword(0x18);
-
-    // Adjust TIB stack limits so SEH works correctly
-    RG_DEFER_C(base = tib->StackBase, limit = tib->StackLimit) {
-        tib->StackBase = base;
-        tib->StackLimit = limit;
+    TEB *teb = GetTEB();
+
+    // Restore previous stack limits at the end
+    RG_DEFER_C(base = teb->StackBase,
+               limit = teb->StackLimit,
+               dealloc = teb->DeallocationStack) {
+        teb->StackBase = base;
+        teb->StackLimit = limit;
+        teb->DeallocationStack = dealloc;
     };
-    tib->StackBase = mem->stack0.end();
-    tib->StackLimit = mem->stack0.ptr;
+
+    // Adjust stack limits so SEH works correctly
+    teb->StackBase = mem->stack0.end();
+    teb->StackLimit = mem->stack0.ptr;
+    teb->DeallocationStack = mem->stack0.ptr;
 #endif
 
 #define PERFORM_CALL(Suffix) \
@@ -422,15 +421,21 @@ void CallData::Relay(Size idx, uint8_t *, uint8_t *caller_sp, bool async, BackRe
         return;
 
 #ifdef _WIN32
-    NT_TIB *tib = (NT_TIB *)__readfsdword(0x18);
-
-    // Restore real thread stack limits
-    RG_DEFER_C(base = tib->StackBase, limit = tib->StackLimit) {
-        tib->StackBase = base;
-        tib->StackLimit = limit;
+    TEB *teb = GetTEB();
+
+    // Restore previous stack limits at the end
+    RG_DEFER_C(base = teb->StackBase,
+               limit = teb->StackLimit,
+               dealloc = teb->DeallocationStack) {
+        teb->StackBase = base;
+        teb->StackLimit = limit;
+        teb->DeallocationStack = dealloc;
     };
-    tib->StackBase = instance->main_stack_base;
-    tib->StackLimit = instance->main_stack_limit;
+
+    // Adjust stack limits so SEH works correctly
+    teb->StackBase = instance->main_stack_max;
+    teb->StackLimit = instance->main_stack_min;
+    teb->DeallocationStack = instance->main_stack_min;
 #endif
 
     const TrampolineInfo &trampoline = shared.trampolines[idx];

package/src/koffi/src/ffi.cc

@@ -16,6 +16,9 @@
 #include "call.hh"
 #include "parser.hh"
 #include "util.hh"
+#ifdef _WIN32
+    #include "win32.hh"
+#endif
 
 #ifdef _WIN32
     #ifndef NOMINMAX
@@ -1014,13 +1017,59 @@ static InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, S
         return nullptr;
 
     InstanceMemory *mem = new InstanceMemory();
+    RG_DEFER_N(mem_guard) { delete mem; };
 
-    mem->stack.len = stack_size;
 #if defined(_WIN32)
-    mem->stack.ptr = (uint8_t *)VirtualAlloc(nullptr, mem->stack.len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+    {
+        struct FiberContext {
+            InstanceMemory *mem;
+            void *self;
+            bool was_fiber;
+        };
+
+        FiberContext ctx;
+        bool is_fiber = IsThreadAFiber();
+
+        ctx.mem = mem;
+        ctx.self = is_fiber ? GetCurrentFiber() : ConvertThreadToFiber(nullptr);
+        if (!ctx.self) {
+            LogError("Failed to make initial fiber: %1", GetWin32ErrorString());
+            return nullptr;
+        }
+        RG_DEFER {
+            if (!is_fiber) {
+                ConvertFiberToThread();
+            }
+        };
+
+        // Work around issue with CreateFiber() API and stack size
+        // See here: https://github.com/google/marl/issues/12
+        mem->fiber = CreateFiberEx(stack_size - 1, stack_size,
+                                   FIBER_FLAG_FLOAT_SWITCH, [](void *udata) {
+            FiberContext *ctx = (FiberContext *)udata;
+
+            TEB *teb = GetTEB();
+
+            ctx->mem->stack.ptr = (uint8_t *)teb->DeallocationStack;
+            ctx->mem->stack.len = (uint8_t *)teb->StackBase - ctx->mem->stack.ptr;
+
+            SwitchToFiber(ctx->self);
+        }, &ctx);
+
+        if (!mem->fiber) {
+            LogError("Failed to create Win32 fiber: %1", GetWin32ErrorString());
+            return nullptr;
+        }
+
+        SwitchToFiber(mem->fiber);
+    }
+
+    RG_ASSERT(mem->stack.ptr);
 #elif defined(__APPLE__)
+    mem->stack.len = stack_size;
     mem->stack.ptr = (uint8_t *)mmap(nullptr, mem->stack.len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
 #else
+    mem->stack.len = stack_size;
     mem->stack.ptr = (uint8_t *)mmap(nullptr, mem->stack.len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON | MAP_STACK, -1, 0);
 #endif
     RG_CRITICAL(mem->stack.ptr, "Failed to allocate %1 of memory", mem->stack.len);
@@ -1051,6 +1100,7 @@ static InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, S
         mem->temporary = true;
     }
 
+    mem_guard.Disable();
     return mem;
 }
 
@@ -1691,8 +1741,8 @@ void FunctionInfo::Unref() const
 InstanceMemory::~InstanceMemory()
 {
 #ifdef _WIN32
-    if (stack.ptr) {
-        VirtualFree(stack.ptr, 0, MEM_RELEASE);
+    if (fiber) {
+        DeleteFiber(fiber);
     }
     if (heap.ptr) {
         VirtualFree(heap.ptr, 0, MEM_RELEASE);
@@ -1707,6 +1757,38 @@ InstanceMemory::~InstanceMemory()
 #endif
 }
 
+static InstanceData *CreateInstance(Napi::Env env)
+{
+    InstanceData *instance = new InstanceData();
+    RG_DEFER_N(err_guard) { delete instance; };
+
+    instance->main_thread_id = std::this_thread::get_id();
+
+    if (napi_create_threadsafe_function(env, nullptr, nullptr,
+                                        Napi::String::New(env, "Koffi Async Callback Broker"),
+                                        0, 1, nullptr, nullptr, nullptr,
+                                        CallData::RelayAsync, &instance->broker) != napi_ok) {
+        LogError("Failed to create async callback broker");
+        return nullptr;
+    }
+    napi_unref_threadsafe_function(env, instance->broker);
+
+#if defined(_WIN32) && (defined(__x86_64__) || defined(_M_AMD64))
+    void *teb = (void *)__readgsqword(0x30);
+
+    instance->main_stack_max = *(void **)((uint8_t *)teb + 0x08); // StackBase
+    instance->main_stack_min = *(void **)((uint8_t *)teb + 0x1478); // DeallocationStack
+#elif defined(_WIN32) && (defined(__i386__) || defined(_M_IX86))
+    void *teb = (void *)__readfsdword(0x18);
+
+    instance->main_stack_max = *(void **)((uint8_t *)teb + 0x04); // StackBase
+    instance->main_stack_min = *(void **)((uint8_t *)teb + 0xE0C); // DeallocationStack
+#endif
+
+    err_guard.Disable();
+    return instance;
+}
+
 InstanceData::~InstanceData()
 {
     for (InstanceMemory *mem: memories) {
@@ -1916,38 +1998,6 @@ extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, Bac
     }
 }
 
-static InstanceData *CreateInstance(Napi::Env env)
-{
-    InstanceData *instance = new InstanceData();
-    RG_DEFER_N(err_guard) { delete instance; };
-
-    instance->main_thread_id = std::this_thread::get_id();
-
-    if (napi_create_threadsafe_function(env, nullptr, nullptr,
-                                        Napi::String::New(env, "Koffi Async Callback Broker"),
-                                        0, 1, nullptr, nullptr, nullptr,
-                                        CallData::RelayAsync, &instance->broker) != napi_ok) {
-        LogError("Failed to create async callback broker");
-        return nullptr;
-    }
-    napi_unref_threadsafe_function(env, instance->broker);
-
-#if defined(_WIN32) && (defined(__x86_64__) || defined(_M_AMD64))
-    NT_TIB *tib = (NT_TIB *)__readgsqword(0x30);
-
-    instance->main_stack_base = tib->StackBase;
-    instance->main_stack_limit = tib->StackLimit;
-#elif defined(_WIN32) && (defined(__i386__) || defined(_M_IX86))
-    NT_TIB *tib = (NT_TIB *)__readfsdword(0x18);
-
-    instance->main_stack_base = tib->StackBase;
-    instance->main_stack_limit = tib->StackLimit;
-#endif
-
-    err_guard.Disable();
-    return instance;
-}
-
 template <typename Func>
 static void SetExports(Napi::Env env, Func func)
 {

package/src/koffi/src/ffi.hh

@@ -232,6 +232,10 @@ struct InstanceMemory {
 
     int16_t depth;
     bool temporary;
+
+#ifdef _WIN32
+    void *fiber;
+#endif
 };
 
 struct InstanceData {
@@ -256,8 +260,8 @@ struct InstanceData {
     napi_threadsafe_function broker = nullptr;
 
 #ifdef _WIN32
-    void *main_stack_base;
-    void *main_stack_limit;
+    void *main_stack_max;
+    void *main_stack_min;
 #endif
 
     HashMap<void *, int16_t> trampolines_map;

package/src/koffi/src/win32.hh

@@ -0,0 +1,59 @@
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see https://www.gnu.org/licenses/.
+
+#pragma once
+
+#include "src/core/libcc/libcc.hh"
+
+#include <intrin.h>
+
+namespace RG {
+
+#if _WIN64
+
+struct TEB {
+    char _pad1[8];
+    void *StackBase;
+    void *StackLimit;
+    char _pad2[5216];
+    void *DeallocationStack;
+};
+RG_STATIC_ASSERT(RG_OFFSET_OF(TEB, DeallocationStack) == 0x1478);
+
+#else
+
+struct TEB {
+    char _pad1[4];
+    void *StackBase;
+    void *StackLimit;
+    char _pad2[3584];
+    void *DeallocationStack;
+};
+RG_STATIC_ASSERT(RG_OFFSET_OF(TEB, DeallocationStack) == 0xE0C);
+
+#endif
+
+static inline TEB *GetTEB()
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    TEB *teb = (TEB *)__getReg(18);
+#elif defined(__x86_64__) || defined(_M_AMD64)
+    TEB *teb = (TEB *)__readgsqword(0x30);
+#else
+    TEB *teb = (TEB *)__readfsdword(0x18);
+#endif
+
+    return teb;
+}
+
+}