koffi 2.2.0 → 2.2.2-beta.1

package/ChangeLog.md

@@ -2,6 +2,12 @@
 
 ## History
 
+### Koffi 2.2.1
+
+**Main fixes:**
+
+- Fix crash when [calling callback again after FFI call inside previous callback](https://github.com/Koromix/rygel/issues/15)
+
 ### Koffi 2.2.0
 
 **New features:**

package/package.json

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

package/src/koffi/qemu/qemu.js

@@ -63,6 +63,7 @@ async function main() {
         switch (process.argv[2]) {
             case 'pack': { command = pack; } break;
             case 'publish': { command = publish; } break;
+            case 'prepare': { command = prepare; } break;
             case 'test': { command = test; } break;
             case 'start': { command = start; } break;
             case 'stop': { command = stop; } break;
@@ -190,7 +191,7 @@ async function main() {
     console.log();
 
     try {
-        let success = await command();
+        let success = !!(await command());
         process.exit(!success);
     } catch (err) {
         console.error(err);
@@ -205,6 +206,7 @@ Commands:
     test                         Run the machines and perform the tests (default)
     pack                         Create NPM package with prebuilt Koffi binaries
     publish                      Publish NPM package with prebuilt Koffi binaries
+    prepare                      Prepare distribution-ready NPM package directory
 
     start                        Start the machines but don't run anythingh
     stop                         Stop running machines
@@ -290,10 +292,9 @@ async function start(detach = true) {
 
 async function pack() {
     let pack_dir = script_dir + '/../build';
-    let dist_dir = script_dir + '/../build/dist';
+    let dist_dir = await prepare(dist_dir);
 
-    let success = await prepare(dist_dir);
-    if (!success)
+    if (dist_dir == null)
         return false;
 
     let npm = (process.platform == 'win32') ? 'npm.cmd' : 'npm';
@@ -305,10 +306,9 @@ async function pack() {
 }
 
 async function publish() {
-    let dist_dir = script_dir + '/../build/dist';
+    let dist_dir = await prepare();
 
-    let success = await prepare(dist_dir);
-    if (!success)
+    if (dist_dir == null)
         return false;
 
     let npm = (process.platform == 'win32') ? 'npm.cmd' : 'npm';
@@ -319,7 +319,8 @@ async function publish() {
     });
 }
 
-async function prepare(dist_dir) {
+async function prepare() {
+    let dist_dir = script_dir + '/../build/dist';
     let snapshot_dir = snapshot();
 
     let json = fs.readFileSync(root_dir + '/src/koffi/package.json', { encoding: 'utf-8' });
@@ -457,7 +458,7 @@ async function prepare(dist_dir) {
         if (!success) {
             console.log('');
             console.log('>> Status: ' + chalk.bold.red('FAILED'));
-            return false;
+            return null;
         }
     }
 
@@ -495,7 +496,7 @@ async function prepare(dist_dir) {
         fs.renameSync(dist_dir + '/web/koffi.dev', dist_dir + '/doc');
     }
 
-    return true;
+    return dist_dir;
 }
 
 function snapshot() {
@@ -519,6 +520,7 @@ function snapshot() {
                                        parts[1] == 'miniz' ||
                                        parts[1] == 'node-addon-api' ||
                                        parts[1] == 'raylib' ||
+                                       parts[1] == 'sqlite3' ||
                                        parts[1] == 'sqlite3mc';
         } else if (parts[0] == 'web') {
             return parts[1] == null || parts[1] == 'koffi.dev';

package/src/koffi/src/abi_arm32.cc

@@ -121,8 +121,6 @@ static void *const Trampolines[][2] = {
 };
 RG_STATIC_ASSERT(RG_LEN(Trampolines) == MaxTrampolines * 2);
 
-static RG_THREAD_LOCAL CallData *exec_call;
-
 static inline int IsHFA(const TypeInfo *type)
 {
 #ifdef __ARM_PCS_VFP
@@ -495,8 +493,6 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
 
 void CallData::Execute()
 {
-    exec_call = this;
-
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
             auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, new_sp, &old_sp) \
@@ -862,8 +858,13 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
     const TypeInfo *type = proto->ret.type;
 
     // Make the call
-    napi_value ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
-                                     [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    napi_value ret;
+    if (async) {
+        ret = (napi_value)func.Call(arguments[0], arguments.len - 1, arguments.data + 1);
+    } else {
+        ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
+                              [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    }
     Napi::Value value(env, ret);
 
     if (RG_UNLIKELY(env.IsExceptionPending()))
@@ -1058,11 +1059,6 @@ void *GetTrampoline(Size idx, const FunctionInfo *proto)
     return Trampolines[idx][vec];
 }
 
-extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
-{
-    exec_call->Relay(idx, own_sp, caller_sp, out_reg);
-}
-
 }
 
 #endif

package/src/koffi/src/abi_arm64.cc

@@ -123,8 +123,6 @@ static void *const Trampolines[][2] = {
 };
 RG_STATIC_ASSERT(RG_LEN(Trampolines) == MaxTrampolines * 2);
 
-static RG_THREAD_LOCAL CallData *exec_call;
-
 static inline int IsHFA(const TypeInfo *type)
 {
     return IsHFA(type, 1, 4);
@@ -563,8 +561,6 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
 
 void CallData::Execute()
 {
-    exec_call = this;
-
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
             auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, new_sp, &old_sp) \
@@ -1087,8 +1083,13 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
     const TypeInfo *type = proto->ret.type;
 
     // Make the call
-    napi_value ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
-                                     [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    napi_value ret;
+    if (async) {
+        ret = (napi_value)func.Call(arguments[0], arguments.len - 1, arguments.data + 1);
+    } else {
+        ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
+                              [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    }
     Napi::Value value(env, ret);
 
     if (RG_UNLIKELY(env.IsExceptionPending()))
@@ -1251,11 +1252,6 @@ void *GetTrampoline(Size idx, const FunctionInfo *proto)
     return Trampolines[idx][vec];
 }
 
-extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
-{
-    exec_call->Relay(idx, own_sp, caller_sp, out_reg);
-}
-
 }
 
 #endif

package/src/koffi/src/abi_riscv64.cc

@@ -131,8 +131,6 @@ static void *const Trampolines[][2] = {
 };
 RG_STATIC_ASSERT(RG_LEN(Trampolines) == MaxTrampolines * 2);
 
-static RG_THREAD_LOCAL CallData *exec_call;
-
 static void AnalyseParameter(ParameterInfo *param, int gpr_avail, int vec_avail)
 {
     gpr_avail = std::min(2, gpr_avail);
@@ -410,8 +408,6 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
 
 void CallData::Execute()
 {
-    exec_call = this;
-
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
             auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, new_sp, &old_sp) \
@@ -761,8 +757,13 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
     const TypeInfo *type = proto->ret.type;
 
     // Make the call
-    napi_value ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
-                                     [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    napi_value ret;
+    if (async) {
+        ret = (napi_value)func.Call(arguments[0], arguments.len - 1, arguments.data + 1);
+    } else {
+        ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
+                              [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    }
     Napi::Value value(env, ret);
 
     if (RG_UNLIKELY(env.IsExceptionPending()))
@@ -924,11 +925,6 @@ void *GetTrampoline(Size idx, const FunctionInfo *proto)
     return Trampolines[idx][fp];
 }
 
-extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
-{
-    exec_call->Relay(idx, own_sp, caller_sp, out_reg);
-}
-
 }
 
 #endif

package/src/koffi/src/abi_x64_sysv.cc

@@ -138,8 +138,6 @@ static void *const Trampolines[][2] = {
 };
 RG_STATIC_ASSERT(RG_LEN(Trampolines) == MaxTrampolines * 2);
 
-static RG_THREAD_LOCAL CallData *exec_call;
-
 static inline RegisterClass MergeClasses(RegisterClass cls1, RegisterClass cls2)
 {
     if (cls1 == cls2)
@@ -474,8 +472,6 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
 
 void CallData::Execute()
 {
-    exec_call = this;
-
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
             auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, new_sp, &old_sp) \
@@ -809,8 +805,13 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
     const TypeInfo *type = proto->ret.type;
 
     // Make the call
-    napi_value ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
-                                     [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    napi_value ret;
+    if (async) {
+        ret = (napi_value)func.Call(arguments[0], arguments.len - 1, arguments.data + 1);
+    } else {
+        ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
+                              [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    }
     Napi::Value value(env, ret);
 
     if (RG_UNLIKELY(env.IsExceptionPending()))
@@ -989,11 +990,6 @@ void *GetTrampoline(Size idx, const FunctionInfo *proto)
     return Trampolines[idx][xmm];
 }
 
-extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
-{
-    exec_call->Relay(idx, own_sp, caller_sp, out_reg);
-}
-
 }
 
 #endif

package/src/koffi/src/abi_x64_win.cc

@@ -107,8 +107,6 @@ static void *const Trampolines[][2] = {
 };
 RG_STATIC_ASSERT(RG_LEN(Trampolines) == MaxTrampolines * 2);
 
-static RG_THREAD_LOCAL CallData *exec_call;
-
 bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
 {
     func->ret.regular = IsRegularSize(func->ret.type->size, 8);
@@ -285,8 +283,6 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
 
 void CallData::Execute()
 {
-    exec_call = this;
-
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
             auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, new_sp, &old_sp) \
@@ -602,8 +598,13 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
     const TypeInfo *type = proto->ret.type;
 
     // Make the call
-    napi_value ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
-                                     [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    napi_value ret;
+    if (async) {
+        ret = (napi_value)func.Call(arguments[0], arguments.len - 1, arguments.data + 1);
+    } else {
+        ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
+                              [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    }
     Napi::Value value(env, ret);
 
     if (RG_UNLIKELY(env.IsExceptionPending()))
@@ -763,11 +764,6 @@ void *GetTrampoline(Size idx, const FunctionInfo *proto)
     return Trampolines[idx][xmm];
 }
 
-extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
-{
-    exec_call->Relay(idx, own_sp, caller_sp, out_reg);
-}
-
 }
 
 #endif

package/src/koffi/src/abi_x86.cc

@@ -113,8 +113,6 @@ static void *const Trampolines[][2] = {
 };
 RG_STATIC_ASSERT(RG_LEN(Trampolines) == MaxTrampolines * 2);
 
-static RG_THREAD_LOCAL CallData *exec_call;
-
 bool AnalyseFunction(Napi::Env env, InstanceData *instance, FunctionInfo *func)
 {
     if (!func->lib && func->convention != CallConvention::Cdecl &&
@@ -366,8 +364,6 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
 
 void CallData::Execute()
 {
-    exec_call = this;
-
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
             auto ret = (func->fast ? ForwardCallR ## Suffix(func->func, new_sp, &old_sp) \
@@ -681,8 +677,13 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
     const TypeInfo *type = proto->ret.type;
 
     // Make the call
-    napi_value ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
-                                     [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    napi_value ret;
+    if (async) {
+        ret = (napi_value)func.Call(arguments[0], arguments.len - 1, arguments.data + 1);
+    } else {
+        ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
+                              [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    }
     Napi::Value value(env, ret);
 
     if (RG_UNLIKELY(env.IsExceptionPending()))
@@ -866,11 +867,6 @@ void *GetTrampoline(Size idx, const FunctionInfo *proto)
     return Trampolines[idx][x87];
 }
 
-extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
-{
-    exec_call->Relay(idx, own_sp, caller_sp, out_reg);
-}
-
 }
 
 #endif

package/src/koffi/src/call.cc

@@ -20,9 +20,23 @@
 
 namespace RG {
 
-CallData::CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *func, InstanceMemory *mem)
+struct RelayContext {
+    CallData *call;
+
+    Size idx;
+    uint8_t *own_sp;
+    uint8_t *caller_sp;
+    BackRegisters *out_reg;
+
+    std::mutex mutex;
+    std::condition_variable cv;
+    bool done = false;
+};
+
+CallData::CallData(Napi::Env env, InstanceData *instance,
+                   const FunctionInfo *func, InstanceMemory *mem, bool async)
     : env(env), instance(instance), func(func),
-      mem(mem), old_stack_mem(mem->stack), old_heap_mem(mem->heap)
+      mem(mem), old_stack_mem(mem->stack), old_heap_mem(mem->heap), async(async)
 {
     mem->generation += !mem->depth;
     mem->depth++;
@@ -46,6 +60,43 @@ CallData::~CallData()
     if (!--mem->depth && mem->temporary) {
         delete mem;
     }
+
+    instance = nullptr;
+}
+
+void CallData::RelaySafe(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
+{
+    if (async) {
+        RelayContext ctx;
+
+        ctx.call = this;
+        ctx.idx = idx;
+        ctx.own_sp = own_sp;
+        ctx.caller_sp = caller_sp;
+        ctx.out_reg = out_reg;
+
+        napi_call_threadsafe_function(instance->broker, &ctx, napi_tsfn_blocking);
+
+        // Wait until it executes
+        std::unique_lock<std::mutex> lock(ctx.mutex);
+        while (!ctx.done) {
+            ctx.cv.wait(lock);
+        }
+    } else {
+        Relay(idx, own_sp, caller_sp, out_reg);
+    }
+}
+
+void CallData::RelayAsync(napi_env, napi_value, void *, void *udata)
+{
+    RelayContext *ctx = (RelayContext *)udata;
+
+    ctx->call->Relay(ctx->idx, ctx->own_sp, ctx->caller_sp, ctx->out_reg);
+
+    // We're done!
+    std::lock_guard<std::mutex> lock(ctx->mutex);
+    ctx->done = true;
+    ctx->cv.notify_one();
 }
 
 bool CallData::PushString(Napi::Value value, int directions, const char **out_str)

package/src/koffi/src/call.hh

@@ -42,6 +42,8 @@ class alignas(8) CallData {
     Span<uint8_t> old_stack_mem;
     Span<uint8_t> old_heap_mem;
 
+    bool async;
+
     int16_t used_trampolines = 0;
 
     LocalArray<OutArgument, MaxOutParameters> out_arguments;
@@ -68,7 +70,8 @@ class alignas(8) CallData {
     BlockAllocator call_alloc;
 
 public:
-    CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *func, InstanceMemory *mem);
+    CallData(Napi::Env env, InstanceData *instance,
+             const FunctionInfo *func, InstanceMemory *mem, bool async);
     ~CallData();
 
 #ifdef UNITY_BUILD
@@ -88,6 +91,8 @@ public:
 #undef INLINE_IF_UNITY
 
     void Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg);
+    void RelaySafe(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg);
+    static void RelayAsync(napi_env, napi_value, void *, void *udata);
 
     void DumpForward() const;