koffi 2.2.3-beta.3 → 2.2.4

package/src/koffi/src/abi_x86_fwd.S

@@ -27,10 +27,10 @@
     .cfi_startproc
     .cfi_def_cfa esp, 4
     ENDBR32
-    push %ebx
+    push %ebp
     .cfi_def_cfa esp, 8
-    movl %esp, %ebx
-    .cfi_def_cfa ebx, 8
+    movl %esp, %ebp
+    .cfi_def_cfa ebp, 8
     movl 16(%esp), %eax
     movl %esp, 0(%eax)
     movl 8(%esp), %eax
@@ -48,8 +48,8 @@
 # The return value is passed back untouched.
 .macro epilogue
     call *%eax
-    movl %ebx, %esp
-    pop %ebx
+    movl %ebp, %esp
+    pop %ebp
     .cfi_def_cfa esp, 4
     ret
     .cfi_endproc
@@ -168,10 +168,10 @@ CallSwitchStack:
     .cfi_startproc
     .cfi_def_cfa esp, 4
     ENDBR32
-    push %ebx
+    push %ebp
     .cfi_def_cfa esp, 8
-    movl %esp, %ebx
-    .cfi_def_cfa ebx, 8
+    movl %esp, %ebp
+    .cfi_def_cfa ebp, 8
     movl 28(%esp), %edx
     movl 24(%esp), %ecx
     movl %esp, %eax
@@ -180,16 +180,16 @@ CallSwitchStack:
     movl %eax, 4(%ecx)
     movl 20(%esp), %esp
     subl $28, %esp
-    movl 8(%ebx), %eax
+    movl 8(%ebp), %eax
     movl %eax, 0(%esp)
-    movl 12(%ebx), %eax
+    movl 12(%ebp), %eax
     movl %eax, 4(%esp)
-    movl 16(%ebx), %eax
+    movl 16(%ebp), %eax
     movl %eax, 8(%esp)
     call *%edx
-    mov %ebx, %esp
+    mov %ebp, %esp
     .cfi_def_cfa esp, 8
-    pop %ebx
+    pop %ebp
     .cfi_def_cfa esp, 4
     ret
     .cfi_endproc

package/src/koffi/src/abi_x86_fwd.asm

@@ -29,8 +29,8 @@ public ForwardCallRD
 ; Save ESP in EBX (non-volatile), and use carefully assembled stack provided by caller.
 prologue macro
     endbr32
-    push ebx
-    mov ebx, esp
+    push ebp
+    mov ebp, esp
     mov eax, dword ptr [esp+16]
     mov dword ptr [eax+0], esp
     mov eax, dword ptr [esp+8]
@@ -48,8 +48,8 @@ endm
 ; The return value is passed back untouched.
 epilogue macro
     call eax
-    mov esp, ebx
-    pop ebx
+    mov esp, ebp
+    pop ebp
     ret
 endm
 
@@ -153,8 +153,8 @@ endm
 ; stack pointer, call Node.js/V8 and go back to ours.
 CallSwitchStack proc
     endbr32
-    push ebx
-    mov ebx, esp
+    push ebp
+    mov ebp, esp
     mov edx, dword ptr [esp+28]
     mov ecx, dword ptr [esp+24]
     mov eax, esp
@@ -163,15 +163,15 @@ CallSwitchStack proc
     mov dword ptr [ecx+4], eax
     mov esp, dword ptr [esp+20]
     sub esp, 28
-    mov eax, dword ptr [ebx+8]
+    mov eax, dword ptr [ebp+8]
     mov dword ptr [esp+0], eax
-    mov eax, dword ptr [ebx+12]
+    mov eax, dword ptr [ebp+12]
     mov dword ptr [esp+4], eax
-    mov eax, dword ptr [ebx+16]
+    mov eax, dword ptr [ebp+16]
     mov dword ptr [esp+8], eax
     call edx
-    mov esp, ebx
-    pop ebx
+    mov esp, ebp
+    pop ebp
     ret
 CallSwitchStack endp
 

package/src/koffi/src/ffi.cc

@@ -33,6 +33,9 @@
     #include <dlfcn.h>
     #include <unistd.h>
     #include <sys/mman.h>
+    #ifndef MAP_STACK
+        #define MAP_STACK 0
+    #endif
 #endif
 
 #include <napi.h>
@@ -1019,60 +1022,39 @@ static InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, S
     InstanceMemory *mem = new InstanceMemory();
     RG_DEFER_N(mem_guard) { delete mem; };
 
-#if defined(_WIN32)
-    {
-        struct FiberContext {
-            InstanceMemory *mem;
-            void *self;
-            bool was_fiber;
-        };
+    stack_size = AlignLen(stack_size, Kibibytes(64));
 
-        FiberContext ctx;
-        bool is_fiber = IsThreadAFiber();
+#if defined(_WIN32)
+    static const int PageSize = ([]() {
+        SYSTEM_INFO info = {};
 
-        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();
-            }
-        };
+        GetNativeSystemInfo(&info);
+        RG_ASSERT(info.dwPageSize);
 
-        // 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;
+        return (int)info.dwPageSize;
+    })();
 
-            TEB *teb = GetTEB();
+    // Allocate stack memory
+    {
+        mem->stack.len = stack_size;
+        mem->stack.ptr = (uint8_t *)VirtualAlloc(nullptr, mem->stack.len + 2 * PageSize, MEM_RESERVE, PAGE_NOACCESS);
 
-            ctx->mem->stack.ptr = (uint8_t *)teb->DeallocationStack;
-            ctx->mem->stack.len = (uint8_t *)teb->StackBase - ctx->mem->stack.ptr;
+        RG_CRITICAL(mem->stack.ptr, "Failed to allocate %1 of memory", mem->stack.len);
 
-            SwitchToFiber(ctx->self);
-        }, &ctx);
+        bool success = true;
 
-        if (!mem->fiber) {
-            LogError("Failed to create Win32 fiber: %1", GetWin32ErrorString());
-            return nullptr;
-        }
+        success &= !!VirtualAlloc(mem->stack.ptr + 0 * PageSize, PageSize, MEM_COMMIT, PAGE_NOACCESS);
+        success &= !!VirtualAlloc(mem->stack.ptr + 1 * PageSize, PageSize, MEM_COMMIT, PAGE_READWRITE | PAGE_GUARD);
+        success &= !!VirtualAlloc(mem->stack.ptr + 2 * PageSize, mem->stack.len, MEM_COMMIT, PAGE_READWRITE);
 
-        SwitchToFiber(mem->fiber);
+        RG_CRITICAL(success, "Cannot commit stack memory: %1", GetWin32ErrorString());
     }
-
-    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);
+#endif
 
 #ifdef __OpenBSD__
     // Make sure the SP points inside the MAP_STACK area, or (void) functions may crash on OpenBSD i386
@@ -1741,8 +1723,8 @@ void FunctionInfo::Unref() const
 InstanceMemory::~InstanceMemory()
 {
 #ifdef _WIN32
-    if (fiber) {
-        DeleteFiber(fiber);
+    if (stack.ptr) {
+        VirtualFree(stack.ptr, 0, MEM_RELEASE);
     }
     if (heap.ptr) {
         VirtualFree(heap.ptr, 0, MEM_RELEASE);
@@ -1773,16 +1755,11 @@ static InstanceData *CreateInstance(Napi::Env env)
     }
     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);
+#ifdef _WIN32
+    TEB *teb = GetTEB();
 
-    instance->main_stack_max = *(void **)((uint8_t *)teb + 0x04); // StackBase
-    instance->main_stack_min = *(void **)((uint8_t *)teb + 0xE0C); // DeallocationStack
+    instance->main_stack_max = teb->StackBase;
+    instance->main_stack_min = teb->DeallocationStack;
 #endif
 
     err_guard.Disable();

package/src/koffi/src/ffi.hh

@@ -232,10 +232,6 @@ struct InstanceMemory {
 
     int16_t depth;
     bool temporary;
-
-#ifdef _WIN32
-    void *fiber;
-#endif
 };
 
 struct InstanceData {

package/src/koffi/test/CMakeLists.txt

@@ -116,3 +116,10 @@ if(MSVC)
     target_compile_options(misc PRIVATE /wd4116)
     target_link_options(misc PRIVATE "/DEF:${CMAKE_CURRENT_SOURCE_DIR}/misc.def")
 endif()
+
+# ---- Win32 ----
+
+if(WIN32)
+    add_library(win32 SHARED win32.c)
+    set_target_properties(win32 PROPERTIES PREFIX "")
+endif()

package/src/koffi/test/win32.c

@@ -0,0 +1,39 @@
+// 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/.
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <inttypes.h>
+#include <string.h>
+#include <stdarg.h>
+
+#define NOMINMAX
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+#define EXPORT __declspec(dllexport)
+
+EXPORT int DivideBySafe(int a, int b)
+{
+    __try {
+        return a / b;
+    } __except (GetExceptionCode() == EXCEPTION_INT_DIVIDE_BY_ZERO) {
+        return -42;
+    }
+}
+
+EXPORT int CallThrough(int (*func)(void))
+{
+    int ret = func();
+    return ret;
+}

package/src/koffi/test/win32.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+// 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/.
+
+const koffi = require('./build/koffi.node');
+const assert = require('assert');
+const util = require('util');
+
+const CallThroughFunc = koffi.callback('int CallThroughFunc()');
+
+main();
+
+async function main() {
+    try {
+        await test();
+        console.log('Success!');
+    } catch (err) {
+        console.error(err);
+        process.exit(1);
+    }
+}
+
+async function test() {
+    let lib_filename = __dirname + '/build/win32.dll';
+    let lib = koffi.load(lib_filename);
+
+    const DivideBySafe = lib.func('int DivideBySafe(int a, int b)');
+    const CallThrough = lib.func('int CallThrough(CallThroughFunc *func)');
+
+    // Sync SEH support
+    assert.equal(DivideBySafe(12, 3), 4);
+    assert.equal(DivideBySafe(84, 0), -42);
+
+    // Async SEH support
+    {
+        let results = await Promise.all([
+            util.promisify(DivideBySafe.async)(90, -9),
+            util.promisify(DivideBySafe.async)(227, 0)
+        ]);
+
+        assert.equal(results[0], -10);
+        assert.equal(results[1], -42);
+    }
+
+    // Test SEH inside callback
+    assert.equal(CallThrough(() => DivideBySafe(16, 2)), 8);
+    assert.equal(CallThrough(() => DivideBySafe(16 * 2, 0)), -42);
+
+    // Test SEH inside callback running async
+    {
+        let results = await Promise.all([
+            util.promisify(CallThrough.async)(() => DivideBySafe(75, -5)),
+            util.promisify(CallThrough.async)(() => DivideBySafe(7, 5 - 5))
+        ]);
+
+        assert.equal(results[0], -15);
+        assert.equal(results[1], -42);
+    }
+}

package/src/koffi/tools/qemu.js

@@ -571,7 +571,7 @@ async function upload(snapshot_dir, func) {
         }
 
         let status = copied ? chalk.bold.green('[ok]') : chalk.bold.red('[error]');
-        log(machine, 'Copy', status);
+        log(machine, 'Upload', status);
     }));
 
     return success;
@@ -605,7 +605,7 @@ async function test() {
                 let ret = await exec_remote(machine, cmd, cwd);
                 let time = Number((process.hrtime.bigint() - start) / 1000000n);
 
-                if (ret.code == 0) {
+                if (ret.code === 0) {
                     log(machine, `${suite} > ${name}`, chalk.bold.green(`[${(time / 1000).toFixed(2)}s]`));
                 } else {
                     log(machine, `${suite} > ${name}`, chalk.bold.red('[error]'));
@@ -654,8 +654,6 @@ async function stop(all = true) {
 
     console.log('>> Sending shutdown commands...');
     await Promise.all(machines.map(async machine => {
-        if (ignore.has(machine))
-            return;
         if (machine.qemu == null)
             return;
         if (!machine.started && !all)
@@ -916,19 +914,32 @@ function log(machine, action, status) {
 }
 
 async function exec_remote(machine, cmd, cwd = null) {
+    if (typeof cmd == 'string') {
+        cmd = {
+            command: cmd,
+            repeat: 1
+        };
+    }
+
     try {
+        let ret = { code: 0 };
+
         if (machine.platform == 'win32') {
+            let cmd_line = cmd.command;
+
             if (cwd != null) {
                 cwd = cwd.replaceAll('/', '\\');
-                cmd = `cd "${cwd}" && ${cmd}`;
+                cmd_line = `cd "${cwd}" && ${cmd_line}`;
             }
 
-            let ret = await machine.ssh.execCommand(cmd);
-            return ret;
+            for (let i = 0; ret.code === 0 && i < cmd.repeat; i++)
+                ret = await machine.ssh.execCommand(cmd_line);
         } else {
-            let ret = await machine.ssh.execCommand(cmd, { cwd: cwd });
-            return ret;
+            for (let i = 0; ret.code === 0 && i < cmd.repeat; i++)
+                ret = await machine.ssh.execCommand(cmd.command, { cwd: cwd });
         }
+
+        return ret;
     } catch (err) {
         console.log(err);
         return err;

package/src/koffi/tools/registry/machines.json

@@ -230,7 +230,11 @@
                     "Test Async": "C:\\Node32\\node32.cmd node test/async.js",
                     "Test Callbacks": "C:\\Node32\\node32.cmd node test/callbacks.js",
                     "Test Raylib": "seatsh C:\\Node32\\node32.cmd node test/raylib.js",
-                    "Test SQLite": "C:\\Node32\\node32.cmd node test/sqlite.js"
+                    "Test SQLite": "C:\\Node32\\node32.cmd node test/sqlite.js",
+                    "Test Win32": {
+                        "command": "C:\\Node32\\node32.cmd node test/win32.js",
+                        "repeat": 8
+                    }
                 }
             },
 
@@ -244,7 +248,11 @@
                     "Test Async": "C:\\Node64\\node64.cmd node test/async.js",
                     "Test Callbacks": "C:\\Node64\\node64.cmd node test/callbacks.js",
                     "Test Raylib": "seatsh C:\\Node64\\node64.cmd node test/raylib.js",
-                    "Test SQLite": "C:\\Node64\\node64.cmd node test/sqlite.js"
+                    "Test SQLite": "C:\\Node64\\node64.cmd node test/sqlite.js",
+                    "Test Win32": {
+                        "command": "C:\\Node64\\node64.cmd node test/win32.js",
+                        "repeat": 8
+                    }
                 }
             }
         }

package/doc/memory.md

@@ -1,33 +0,0 @@
-# Memory usage
-
-## How it works
-
-For synchronous/normal calls, Koffi uses two preallocated memory blocks:
-
-- One to construct the C stack and assign registers, subsequently used by the platform-specific assembly code (1 MiB by default)
-- One to allocate strings and big objects/structs (2 MiB by default)
-
-Unless very big strings or objects (at least more than one page of memory) are used, Koffi does not directly allocate any extra memory during calls or callbacks. However, please note that the JS engine (V8) might.
-
-The size (in bytes) of these preallocated blocks can be changed. Use `koffi.config()` to get an object with the settings, and `koffi.config(obj)` to apply new settings.
-
-```js
-let config = koffi.config();
-console.log(config);
-```
-
-The same is true for asynchronous calls. When an asynchronous call is made, Koffi will allocate new blocks unless there is an unused (resident) set of blocks still available. Once the asynchronous call is finished, these blocks are freed if there are more than `resident_async_pools` sets of blocks left around.
-
-There cannot be more than `max_async_calls` running at the same time.
-
-## Default settings
-
-Setting              | Default | Description
--------------------- | ------- | -----------------------------------------------
-sync_stack_size      | 1 MiB   | Stack size for synchronous calls
-sync_heap_size       | 2 MiB   | Heap size for synchronous calls
-async_stack_size     | 256 kiB | Stack size for asynchronous calls
-async_heap_size      | 512 kiB | Heap size for asynchronous calls
-resident_async_pools | 2       | Number of resident pools for asynchronous calls
-max_async_calls      | 64      | Maximum number of ongoing asynchronous calls
-max_type_size        | 64 MiB  | Maximum size of Koffi types (for arrays and structs)