koffi 2.15.2 → 2.15.3

package/src/koffi/src/ffi.cc

@@ -39,6 +39,8 @@ SharedData shared;
 
 static thread_local CallData *exec_call;
 
+extern "C" napi_value SwitchAndRelay(CallData *call, Size idx, uint8_t *sp, uint8_t *saved_sp, Span<uint8_t> *new_stack);
+
 static bool ChangeSize(const char *name, Napi::Value value, Size min_size, Size max_size, Size *out_size)
 {
     Napi::Env env = value.Env();
@@ -1690,35 +1692,54 @@ Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info)
     return TranslateAsyncCall(func, func->native, info);
 }
 
-extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
+extern "C" void RelayCallback(Size idx, uint8_t *sp)
 {
-    if (exec_call) [[likely]] {
-        exec_call->RelaySafe(idx, own_sp, caller_sp, false, out_reg);
-    } else {
-        // This happens if the callback pointer is called from a different thread
-        // than the one that runs the FFI call (sync or async).
+    CallData *call = exec_call;
 
-        TrampolineInfo *trampoline = &shared.trampolines[idx];
+    // Try the fast path first: we are on the main thread and we are running a native call through Koffi.
+    // It should be easy, but in this case we are running on the custom Koffi stack, which will trip up
+    // Node and V8. So we need to switch back to the normal/main stack.
+    if (call && std::this_thread::get_id() == call->instance->main_thread_id) {
+        SwitchAndRelay(call, idx, sp, call->old_sp, &call->mem->stack);
+        return;
+    }
 
-        Napi::Env env = trampoline->func.Env();
-        InstanceData *instance = env.GetInstanceData<InstanceData>();
+    // Otherwise, we need to allocate memory to perform the callback.
+    // Since the necessary machinery live in CallData, just use a temporary instance.
+    // In some cases we would reuse the existing call (exec_call may be not null),
+    // but it is rare so let's ignore this for simplicity.
 
-        InstanceMemory *mem = AllocateMemory(instance, instance->config.async_stack_size, instance->config.async_heap_size);
-        if (!mem) [[unlikely]] {
-            ThrowError<Napi::Error>(env, "Too many asynchronous calls are running");
-            return;
-        }
+    TrampolineInfo *trampoline = &shared.trampolines[idx];
+    Napi::Env env = trampoline->func.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    InstanceMemory *mem = AllocateMemory(instance, instance->config.async_stack_size, instance->config.async_heap_size);
+    if (!mem) [[unlikely]] {
+        ThrowError<Napi::Error>(env, "Too many asynchronous calls are running");
+        return;
+    }
 
-        // Avoid triggering the "use callback beyond FFI" check
-        K_DEFER_C(generation = trampoline->generation) { trampoline->generation = generation; };
-        trampoline->generation = -1;
+    // Avoid triggering the "use callback beyond FFI" check
+    K_DEFER_C(generation = trampoline->generation) { trampoline->generation = generation; };
+    trampoline->generation = -1;
 
-        // We set dispose_call to true so that the main thread will dispose of CallData itself
+    if (std::this_thread::get_id() == instance->main_thread_id) {
         CallData call(env, instance, mem);
-        call.RelaySafe(idx, own_sp, caller_sp, true, out_reg);
+
+        Napi::HandleScope scope(env);
+        call.Relay(idx, sp);
+    } else {
+        CallData call(env, instance, mem);
+        call.RelayAsync(idx, sp);
     }
 }
 
+extern "C" void RelayDirect(CallData *call, Size idx, uint8_t *sp)
+{
+    Napi::HandleScope scope(call->env);
+    call->Relay(idx, sp);
+}
+
 static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
@@ -2338,7 +2359,7 @@ bool InitAsyncBroker(Napi::Env env, InstanceData *instance)
         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) {
+                                            PerformAsyncRelay, &instance->broker) != napi_ok) {
             LogError("Failed to create async callback broker");
             return false;
         }

package/src/koffi/src/ffi.hh

@@ -85,7 +85,7 @@ static const char *const PrimitiveKindNames[] = {
 struct TypeInfo;
 struct RecordMember;
 struct FunctionInfo;
-class CallData;
+struct CallData;
 
 typedef void DisposeFunc (Napi::Env env, const TypeInfo *type, const void *ptr);
 

package/src/koffi/src/util.cc

@@ -1683,19 +1683,15 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
 #undef PUSH_INTEGER
 
     // Keep memory around if any was allocated
-    {
-        BlockAllocator *alloc = call.GetAllocator();
-
-        if (alloc->IsUsed()) {
-            BlockAllocator *copy = instance->encode_map.FindValue(origin, nullptr);
+    if (call.alloc.IsUsed()) {
+        BlockAllocator *copy = instance->encode_map.FindValue(origin, nullptr);
 
-            if (!copy) {
-                copy = instance->encode_allocators.AppendDefault();
-                instance->encode_map.Set(origin, copy);
-            }
-
-            std::swap(*alloc, *copy);
+        if (!copy) {
+            copy = instance->encode_allocators.AppendDefault();
+            instance->encode_map.Set(origin, copy);
         }
+
+        std::swap(call.alloc, *copy);
     }
 
     return true;

package/src/koffi/src/win32.cc

@@ -180,6 +180,19 @@ int GetDllMachine(const wchar_t *filename)
     return GetFileMachine(h, true);
 }
 
+extern "C" int __cdecl SehHandler(void *ptr, void *, void *ctx, void *)
+{
+    EXCEPTION_RECORD *rec = (EXCEPTION_RECORD *)ptr;
+
+    if (!(rec->ExceptionFlags & (EXCEPTION_UNWINDING | EXCEPTION_EXIT_UNWIND))) {
+        EXCEPTION_POINTERS ep = { rec, (CONTEXT *)ctx };
+        UnhandledExceptionFilter(&ep);
+        ExitProcess(rec->ExceptionCode);
+    }
+
+    return ExceptionContinueSearch;
+}
+
 }
 
 #endif

package/src/koffi/src/win32.hh

@@ -109,4 +109,6 @@ void *LoadWindowsLibrary(Napi::Env env, Span<const char> path); // Returns HANDL
 int GetSelfMachine();
 int GetDllMachine(const wchar_t *filename);
 
+extern "C" int __cdecl SehHandler(void *ptr, void *, void *ctx, void *);
+
 }