ffi 1.0.2 → 1.0.3

data/History.txt

@@ -1,3 +1,6 @@
+== 1.0.3 / 2010-12-28
+* Re-add support for ruby 1.8.x
+
 == 1.0.0 / 2010-11-30
 * Major improvements
   * Better handling of non-ruby thread callbacks

data/Rakefile

@@ -75,7 +75,7 @@ PROJ.name = 'ffi'
 PROJ.authors = 'Wayne Meissner'
 PROJ.email = 'wmeissner@gmail.com'
 PROJ.url = 'http://wiki.github.com/ffi/ffi'
-PROJ.version = '1.0.2'
+PROJ.version = '1.0.3'
 PROJ.rubyforge.name = 'ffi'
 PROJ.readme_file = 'README.rdoc'
 
@@ -90,11 +90,11 @@ PROJ.ann.email[:server] = 'smtp.gmail.com'
 PROJ.gem.need_tar = false
 PROJ.gem.files = %w(History.txt LICENSE README.rdoc Rakefile) + Dir.glob("{ext,gen,lib,spec,tasks}/**/*")
 PROJ.gem.platform = Gem::Platform::RUBY
-PROJ.gem.required_ruby_version = ">= 1.9.2"
+#PROJ.gem.required_ruby_version = ">= 1.9.2"
 
 # Override Mr. Bones autogenerated extensions and force ours in
 PROJ.gem.extras['extensions'] = %w(ext/ffi_c/extconf.rb gen/Rakefile)
-PROJ.gem.extras['required_ruby_version'] = ">= 1.9.2"
+#PROJ.gem.extras['required_ruby_version'] = ">= 1.9.2"
 
 # RDoc
 PROJ.rdoc.exclude << '^ext\/'
@@ -116,23 +116,23 @@ TEST_DEPS = [ LIBTEST ]
 if RUBY_PLATFORM == "java"
   desc "Run all specs"
   task :specs => TEST_DEPS do
-    sh %{#{Gem.ruby} -S spec #{Dir["spec/ffi/*_spec.rb"].join(" ")} -fs --color}
+    sh %{#{Gem.ruby} -S rspec #{Dir["spec/ffi/*_spec.rb"].join(" ")} -fs --color}
   end
   desc "Run rubinius specs"
   task :rbxspecs => TEST_DEPS do
-    sh %{#{Gem.ruby} -S spec #{Dir["spec/ffi/rbx/*_spec.rb"].join(" ")} -fs --color}
+    sh %{#{Gem.ruby} -S rspec #{Dir["spec/ffi/rbx/*_spec.rb"].join(" ")} -fs --color}
   end
 else
   TEST_DEPS.unshift :compile
   desc "Run all specs"
   task :specs => TEST_DEPS do
     ENV["MRI_FFI"] = "1"
-    sh %{#{Gem.ruby} -Ilib -I#{BUILD_EXT_DIR} -S spec #{Dir["spec/ffi/*_spec.rb"].join(" ")} -fs --color}
+    sh %{#{Gem.ruby} -Ilib -I#{BUILD_EXT_DIR} -S rspec #{Dir["spec/ffi/*_spec.rb"].join(" ")} -fs --color}
   end
   desc "Run rubinius specs"
   task :rbxspecs => TEST_DEPS do
     ENV["MRI_FFI"] = "1"
-    sh %{#{Gem.ruby} -Ilib -I#{BUILD_EXT_DIR} -S spec #{Dir["spec/ffi/rbx/*_spec.rb"].join(" ")} -fs --color}
+    sh %{#{Gem.ruby} -Ilib -I#{BUILD_EXT_DIR} -S rspec #{Dir["spec/ffi/rbx/*_spec.rb"].join(" ")} -fs --color}
   end
 end
 

data/ext/ffi_c/AbstractMemory.c

@@ -133,10 +133,10 @@ memory_get_array_of_##name(VALUE self, VALUE offset, VALUE length) \
     long count = NUM2LONG(length); \
     long off = NUM2LONG(offset); \
     AbstractMemory* memory = MEMORY(self); \
+    VALUE retVal = rb_ary_new2(count); \
     long i; \
     checkRead(memory); \
     checkBounds(memory, off, count * sizeof(type)); \
-    VALUE retVal = rb_ary_new2(count); \
     for (i = 0; i < count; ++i) { \
         type tmp; \
         memcpy(&tmp, memory->address + off + (i * sizeof(type)), sizeof(tmp)); \
@@ -165,7 +165,6 @@ SWAPU16(uint16_t x)
     return bswap16(x);
 }
 
-#define SWAP16(x) (x)
 #if __GNUC__ < 4
 #define bswap32(x) \
        (((x << 24) & 0xff000000) | \
@@ -208,10 +207,10 @@ SWAPU64(uint64_t x)
 }
 
 #else
-# define SWAPU32(x) __builtin_bswap32(x)
-# define SWAPS32(x) __builtin_bswap32(x)
-# define SWAPS64(x) __builtin_bswap64(x)
-# define SWAPU64(x) __builtin_bswap64(x)
+# define SWAPS32(x) ((int32_t) __builtin_bswap32(x))
+# define SWAPU32(x) ((uint32_t) __builtin_bswap32(x))
+# define SWAPS64(x) ((int64_t) __builtin_bswap64(x))
+# define SWAPU64(x) ((uint64_t) __builtin_bswap64(x))
 #endif
 
 #if LONG_MAX > INT_MAX

data/ext/ffi_c/Call.c

@@ -43,6 +43,7 @@
 #include "LastError.h"
 #include "Call.h"
 #include "MappedType.h"
+#include "Thread.h"
 
 #ifdef USE_RAW
 #  ifndef __i386__
@@ -239,13 +240,13 @@ rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, Type** paramTypes,
 }
 
 
-#if defined(HAVE_NATIVETHREAD) && defined(HAVE_RB_THREAD_BLOCKING_REGION)
-
 typedef struct BlockingCall_ {
     void* function;
     FunctionType* info;
     void **ffiValues;
-    FFIStorage* retval;
+    void* retval;
+    void* stkretval;
+    void* params;
 } BlockingCall;
 
 static VALUE
@@ -257,7 +258,28 @@ call_blocking_function(void* data)
 
     return Qnil;
 }
-#endif
+
+static VALUE
+do_blocking_call(void *data)
+{
+    rbffi_thread_blocking_region(call_blocking_function, data, (void *) -1, NULL);
+
+    return Qnil;
+}
+
+static VALUE
+cleanup_blocking_call(void *data)
+{
+    BlockingCall* bc = (BlockingCall *) data;
+
+    memcpy(bc->stkretval, bc->retval, MAX(bc->info->ffi_cif.rtype->size, FFI_SIZEOF_ARG));
+    xfree(bc->params);
+    xfree(bc->ffiValues);
+    xfree(bc->retval);
+    xfree(bc);
+
+    return Qnil;
+}
 
 VALUE
 rbffi_CallFunction(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
@@ -265,38 +287,61 @@ rbffi_CallFunction(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
     void* retval;
     void** ffiValues;
     FFIStorage* params;
+    VALUE rbReturnValue;
 
-    ffiValues = ALLOCA_N(void *, fnInfo->parameterCount);
-    params = ALLOCA_N(FFIStorage, fnInfo->parameterCount);
-    retval = alloca(MAX(fnInfo->ffi_cif.rtype->size, FFI_SIZEOF_ARG));
-
-    rbffi_SetupCallParams(argc, argv,
-        fnInfo->parameterCount, fnInfo->parameterTypes, params, ffiValues,
-        fnInfo->callbackParameters, fnInfo->callbackCount, fnInfo->rbEnums);
+#if !defined(HAVE_RUBY_THREAD_HAS_GVL_P)
+    rbffi_thread_t oldThread;
+#endif
 
-#if defined(HAVE_NATIVETHREAD) && defined(HAVE_RB_THREAD_BLOCKING_REGION)
+    retval = alloca(MAX(fnInfo->ffi_cif.rtype->size, FFI_SIZEOF_ARG));
+    
     if (unlikely(fnInfo->blocking)) {
-        BlockingCall bc;
+        BlockingCall* bc;
+
+        // due to the way thread switching works on older ruby variants, we
+        // cannot allocate anything passed to the blocking function on the stack
+        ffiValues = ALLOC_N(void *, fnInfo->parameterCount);
+        params = ALLOC_N(FFIStorage, fnInfo->parameterCount);
+        bc = ALLOC_N(BlockingCall, 1);
+        bc->info = fnInfo;
+        bc->function = function;
+        bc->ffiValues = ffiValues;
+        bc->params = params;
+        bc->retval = xmalloc(MAX(fnInfo->ffi_cif.rtype->size, FFI_SIZEOF_ARG));
+        bc->stkretval = retval;
+
+        rbffi_SetupCallParams(argc, argv,
+            fnInfo->parameterCount, fnInfo->parameterTypes, params, ffiValues,
+            fnInfo->callbackParameters, fnInfo->callbackCount, fnInfo->rbEnums);
+        
+        rb_ensure(do_blocking_call, (VALUE) bc, cleanup_blocking_call, (VALUE) bc);
+        
+    } else {
 
-        bc.info = fnInfo;
-        bc.function = function;
-        bc.ffiValues = ffiValues;
-        bc.retval = retval;
+        ffiValues = ALLOCA_N(void *, fnInfo->parameterCount);
+        params = ALLOCA_N(FFIStorage, fnInfo->parameterCount);
 
-        rb_thread_blocking_region(call_blocking_function, &bc, (void *) -1, NULL);
-    } else {
+        rbffi_SetupCallParams(argc, argv,
+            fnInfo->parameterCount, fnInfo->parameterTypes, params, ffiValues,
+            fnInfo->callbackParameters, fnInfo->callbackCount, fnInfo->rbEnums);
+
+#if !defined(HAVE_RUBY_THREAD_HAS_GVL_P)
+        oldThread = rbffi_active_thread;
+        rbffi_active_thread = rbffi_thread_self();
+#endif
+        retval = alloca(MAX(fnInfo->ffi_cif.rtype->size, FFI_SIZEOF_ARG));
         ffi_call(&fnInfo->ffi_cif, FFI_FN(function), retval, ffiValues);
-    }
-#else
-    ffi_call(&fnInfo->ffi_cif, FFI_FN(function), retval, ffiValues);
+
+#if !defined(HAVE_RUBY_THREAD_HAS_GVL_P)
+        rbffi_active_thread = oldThread;
 #endif
+    }
 
     if (unlikely(!fnInfo->ignoreErrno)) {
         rbffi_save_errno();
     }
 
-    return rbffi_NativeValue_ToRuby(fnInfo->returnType, fnInfo->rbReturnType, retval,
-        fnInfo->rbEnums);
+    return rbffi_NativeValue_ToRuby(fnInfo->returnType, fnInfo->rbReturnType, retval);
 }
 
 static inline void*

data/ext/ffi_c/ClosurePool.c

@@ -1,28 +1,20 @@
 /*
- * Copyright (c) 2009, Wayne Meissner
+ * Copyright (c) 2009, 2010 Wayne Meissner
  * All rights reserved.
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
+ * This file is part of ruby-ffi.
  *
- * * Redistributions of source code must retain the above copyright notice, this
- *   list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright notice
- *   this list of conditions and the following disclaimer in the documentation
- *   and/or other materials provided with the distribution.
- * * The name of the author or authors may not be used to endorse or promote
- *   products derived from this software without specific prior written permission.
+ * This code is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3 only, as
+ * published by the Free Software Foundation.
  *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * This code 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 Lesser General Public License
+ * version 3 for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include <sys/param.h>
@@ -40,9 +32,6 @@
 #endif
 #include <errno.h>
 #include <ruby.h>
-#if defined(HAVE_NATIVETHREAD) && !defined(_WIN32) && !defined(__WIN32__)
-# include <pthread.h>
-#endif
 
 #include <ffi.h>
 #include "rbffi.h"
@@ -57,10 +46,6 @@
 #include "ClosurePool.h"
 
 
-#if defined(HAVE_NATIVETHREAD) && !defined(_WIN32) && !defined(__WIN32__)
-#  define USE_PTHREAD_LOCAL
-#endif
-
 #ifndef roundup
 #  define roundup(x, y)   ((((x)+((y)-1))/(y))*(y))
 #endif
@@ -78,22 +63,11 @@ struct ClosurePool_ {
     void* ctx;
     int closureSize;
     bool (*prep)(void* ctx, void *code, Closure* closure, char* errbuf, size_t errbufsize);
-#if defined (HAVE_NATIVETHREAD) && !defined(_WIN32)
-    pthread_mutex_t mutex;
-#endif
     struct Memory* blocks; /* Keeps track of all the allocated memory for this pool */
     Closure* list;
     long refcnt;
 };
 
-#if defined(HAVE_NATIVETHREAD) && !defined(_WIN32)
-#  define pool_lock(p) pthread_mutex_lock(&(p)->mutex)
-#  define pool_unlock(p)  pthread_mutex_unlock(&(p)->mutex)
-#else
-#  define pool_lock(p)
-#  define pool_unlock(p)
-#endif
-
 static int pageSize;
 
 static void* allocatePage(void);
@@ -113,10 +87,6 @@ rbffi_ClosurePool_New(int closureSize,
     pool->prep = prep;
     pool->refcnt = 1;
     
-#if defined(HAVE_NATIVETHREAD) && !defined(_WIN32)
-    pthread_mutex_init(&pool->mutex, NULL);
-#endif
-
     return pool;
 }
 
@@ -140,10 +110,7 @@ rbffi_ClosurePool_Free(ClosurePool* pool)
 {
     if (pool != NULL) {
         int refcnt;
-        pool_lock(pool);
         refcnt = --(pool->refcnt);
-        pool_unlock(pool);
-
         if (refcnt == 0) {
             cleanup_closure_pool(pool);
         }
@@ -160,13 +127,11 @@ rbffi_Closure_Alloc(ClosurePool* pool)
     int nclosures, trampolineSize;
     int i;
 
-    pool_lock(pool);
     if (pool->list != NULL) {
         Closure* closure = pool->list;
         pool->list = pool->list->next;
         pool->refcnt++;
-        pool_unlock(pool);
-
+    
         return closure;
     }
 
@@ -177,7 +142,6 @@ rbffi_Closure_Alloc(ClosurePool* pool)
     code = allocatePage();
     
     if (block == NULL || list == NULL || code == NULL) {
-        pool_unlock(pool);
         snprintf(errmsg, sizeof(errmsg), "failed to allocate a page. errno=%d (%s)", errno, strerror(errno));
         goto error;
     }
@@ -208,13 +172,10 @@ rbffi_Closure_Alloc(ClosurePool* pool)
     pool->list = list->next;
     pool->refcnt++;
 
-    pool_unlock(pool);
-
     /* Use the first one as the new handle */
     return list;
 
 error:
-    pool_unlock(pool);
     free(block);
     free(list);
     if (code != NULL) {
@@ -232,13 +193,10 @@ rbffi_Closure_Free(Closure* closure)
     if (closure != NULL) {
         ClosurePool* pool = closure->pool;
         int refcnt;
-        pool_lock(pool);
         // Just push it on the front of the free list
         closure->next = pool->list;
         pool->list = closure;
         refcnt = --(pool->refcnt);
-        pool_unlock(pool);
-
         if (refcnt == 0) {
             cleanup_closure_pool(pool);
         }

data/ext/ffi_c/Function.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2009, Wayne Meissner
+ * Copyright (c) 2009, 2010 Wayne Meissner
 
  * All rights reserved.
  *
@@ -35,6 +35,7 @@
 #if defined(HAVE_NATIVETHREAD) && !defined(_WIN32)
 #include <pthread.h>
 #endif
+#include <fcntl.h>
 
 #include "rbffi.h"
 #include "compat.h"
@@ -49,6 +50,7 @@
 #include "ClosurePool.h"
 #include "Function.h"
 #include "MappedType.h"
+#include "Thread.h"
 
 typedef struct Function_ {
     AbstractMemory memory;
@@ -67,12 +69,10 @@ static void callback_invoke(ffi_cif* cif, void* retval, void** parameters, void*
 static bool callback_prep(void* ctx, void* code, Closure* closure, char* errmsg, size_t errmsgsize);
 static void* callback_with_gvl(void* data);
 
-#if defined(HAVE_NATIVETHREAD) && defined(HAVE_RB_THREAD_BLOCKING_REGION)
-# define DEFER_ASYNC_CALLBACK 1
-#endif
+#define DEFER_ASYNC_CALLBACK 1
 
 #if defined(DEFER_ASYNC_CALLBACK)
-static VALUE async_cb_event(void);
+static VALUE async_cb_event(void *);
 static VALUE async_cb_call(void *);
 #endif
 
@@ -96,7 +96,7 @@ struct gvl_callback {
     Closure* closure;
     void*    retval;
     void**   parameters;
-
+    bool done;
 #if defined(DEFER_ASYNC_CALLBACK)
     struct gvl_callback* next;
 # ifndef _WIN32
@@ -112,8 +112,11 @@ struct gvl_callback {
 #if defined(DEFER_ASYNC_CALLBACK)
 static struct gvl_callback* async_cb_list = NULL;
 # ifndef _WIN32
-static pthread_mutex_t async_cb_mutex = PTHREAD_MUTEX_INITIALIZER;
-static pthread_cond_t async_cb_cond = PTHREAD_COND_INITIALIZER;
+    static pthread_mutex_t async_cb_mutex = PTHREAD_MUTEX_INITIALIZER;
+    static pthread_cond_t async_cb_cond = PTHREAD_COND_INITIALIZER;
+#  if !defined(HAVE_RB_THREAD_BLOCKING_REGION)
+    static int async_cb_pipe[2];
+#  endif
 # else
 static HANDLE async_cb_cond;
 static CRITICAL_SECTION async_cb_lock;
@@ -265,9 +268,15 @@ function_init(VALUE self, VALUE rbFunctionInfo, VALUE rbProc)
         }
 
 #if defined(DEFER_ASYNC_CALLBACK)
+# if !defined(HAVE_RB_THREAD_BLOCKING_REGION)
+        pipe(async_cb_pipe);
+        fcntl(async_cb_pipe[0], F_SETFL, fcntl(async_cb_pipe[0], F_GETFL) | O_NONBLOCK);
+        fcntl(async_cb_pipe[1], F_SETFL, fcntl(async_cb_pipe[1], F_GETFL) | O_NONBLOCK);
+# endif
         if (async_cb_thread == Qnil) {
             async_cb_thread = rb_thread_create(async_cb_event, NULL);
         }
+
 #endif
 
         fn->closure = rbffi_Closure_Alloc(fn->info->closurePool);
@@ -380,12 +389,9 @@ callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data)
     cb.closure = (Closure *) user_data;
     cb.retval = retval;
     cb.parameters = parameters;
+    cb.done = false;
 
-#ifdef HAVE_RUBY_THREAD_HAS_GVL_P
-    if (ruby_thread_has_gvl_p()) {
-#else
-    if (1) {
-#endif
+    if (rbffi_thread_has_gvl_p()) {
         callback_with_gvl(&cb);
     
 #if defined(HAVE_RUBY_NATIVE_THREAD_P) && defined (HAVE_RB_THREAD_CALL_WITH_GVL)
@@ -394,21 +400,38 @@ callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data)
 #endif
 #if defined(DEFER_ASYNC_CALLBACK) && !defined(_WIN32)
     } else {
+        bool empty = false;
+
         pthread_mutex_init(&cb.async_mutex, NULL);
         pthread_cond_init(&cb.async_cond, NULL);
 
-        pthread_mutex_lock(&cb.async_mutex);
-
         // Now signal the async callback thread
         pthread_mutex_lock(&async_cb_mutex);
+        empty = async_cb_list == NULL;
         cb.next = async_cb_list;
         async_cb_list = &cb;
-        pthread_cond_signal(&async_cb_cond);
         pthread_mutex_unlock(&async_cb_mutex);
 
+#if !defined(HAVE_RB_THREAD_BLOCKING_REGION)
+        // Only signal if the list was empty
+        if (empty) {
+            char c;
+            write(async_cb_pipe[1], &c, 1);
+        }
+#else
+        pthread_cond_signal(&async_cb_cond);
+#endif
+
         // Wait for the thread executing the ruby callback to signal it is done
-        pthread_cond_wait(&cb.async_cond, &cb.async_mutex);
-#elif defined(DEFER_ASYNC_CALLBACK) && !defined(_WIN32)
+        pthread_mutex_lock(&cb.async_mutex);
+        while (!cb.done) {
+            pthread_cond_wait(&cb.async_cond, &cb.async_mutex);
+        }
+        pthread_mutex_unlock(&cb.async_mutex);
+        pthread_cond_destroy(&cb.async_cond);
+        pthread_mutex_destroy(&cb.async_mutex);
+
+#elif defined(DEFER_ASYNC_CALLBACK) && defined(_WIN32)
     } else {
         cb.async_event = CreateEvent(NULL, FALSE, FALSE, NULL);
         
@@ -436,8 +459,9 @@ struct async_wait {
 static VALUE async_cb_wait(void *);
 static void async_cb_stop(void *);
 
+#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
 static VALUE
-async_cb_event(void)
+async_cb_event(void* unused)
 {
     struct async_wait w = { 0 };
 
@@ -453,6 +477,40 @@ async_cb_event(void)
     return Qnil;
 }
 
+#else
+static VALUE
+async_cb_event(void* unused)
+{
+    while (true) {
+        struct gvl_callback* cb;
+        char buf[64];
+
+        if (read(async_cb_pipe[0], buf, sizeof(buf)) < 0) {
+            rb_thread_wait_fd(async_cb_pipe[0]);
+            while (read(async_cb_pipe[0], buf, sizeof (buf)) < 0) {
+                if (rb_io_wait_readable(async_cb_pipe[0]) != Qtrue) {
+                    return Qfalse;
+                }
+            }
+        }
+
+        pthread_mutex_lock(&async_cb_mutex);
+        cb = async_cb_list;
+        async_cb_list = NULL;
+        pthread_mutex_unlock(&async_cb_mutex);
+
+        while (cb != NULL) {
+            struct gvl_callback* next = cb->next;
+            // Start up a new ruby thread to run the ruby callback
+            rb_thread_create(async_cb_call, cb);
+            cb = next;
+        }
+    }
+
+    return Qnil;
+}
+#endif
+
 #ifdef _WIN32
 static VALUE
 async_cb_wait(void *data)
@@ -538,6 +596,7 @@ async_cb_call(void *data)
     SetEvent(cb->async_event);
 #else
     pthread_mutex_lock(&cb->async_mutex);
+    cb->done = true;
     pthread_cond_signal(&cb->async_cond);
     pthread_mutex_unlock(&cb->async_mutex);
 #endif
@@ -624,7 +683,7 @@ callback_with_gvl(void* data)
             case NATIVE_FUNCTION:
             case NATIVE_CALLBACK:
             case NATIVE_STRUCT:
-                param = rbffi_NativeValue_ToRuby(paramType, rbParamType, parameters[i], Qnil);
+                param = rbffi_NativeValue_ToRuby(paramType, rbParamType, parameters[i]);
                 break;
 
             default: