ffi 1.13.1 → 1.15.0

data/ext/ffi_c/ClosurePool.h

@@ -35,7 +35,9 @@ typedef struct Closure_ Closure;
 struct Closure_ {
     void* info;      /* opaque handle for storing closure-instance specific data */
     void* function;  /* closure-instance specific function, called by custom trampoline */
-    void* code;      /* The native trampoline code location */
+    void* code;      /* Executable address for the native trampoline code location */
+    void* pcl;       /* Writeable address for the native trampoline code location */
+
     struct ClosurePool_* pool;
     Closure* next;
 };

data/ext/ffi_c/DynamicLibrary.c

@@ -29,9 +29,7 @@
 
 #include <sys/types.h>
 #include <stdio.h>
-#ifndef _MSC_VER
-#  include <stdint.h>
-#endif
+#include <stdint.h>
 #if (defined(_WIN32) || defined(__WIN32__)) && !defined(__CYGWIN__)
 # include <winsock2.h>
 # define _WINSOCKAPI_
@@ -41,9 +39,6 @@
 # include <dlfcn.h>
 #endif
 #include <ruby.h>
-#if defined(_MSC_VER) && !defined(INT8_MIN)
-#  include "win32/stdint.h"
-#endif
 
 #include <ffi.h>
 

data/ext/ffi_c/Function.c

@@ -37,15 +37,8 @@
 #endif
 
 #include <stdio.h>
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-# if !defined(INT8_MIN)
-#  include "win32/stdint.h"
-# endif
-#endif
+#include <stdint.h>
+#include <stdbool.h>
 #include <ruby.h>
 #include <ruby/thread.h>
 
@@ -256,11 +249,11 @@ VALUE
 rbffi_Function_ForProc(VALUE rbFunctionInfo, VALUE proc)
 {
     VALUE callback, cbref, cbTable;
-    Function* fp;
 
     cbref = RTEST(rb_ivar_defined(proc, id_cb_ref)) ? rb_ivar_get(proc, id_cb_ref) : Qnil;
     /* If the first callback reference has the same function function signature, use it */
     if (cbref != Qnil && CLASS_OF(cbref) == rbffi_FunctionClass) {
+        Function* fp;
         Data_Get_Struct(cbref, Function, fp);
         if (fp->rbFunctionInfo == rbFunctionInfo) {
             return cbref;
@@ -279,14 +272,27 @@ rbffi_Function_ForProc(VALUE rbFunctionInfo, VALUE proc)
         rb_ivar_set(proc, id_cb_ref, callback);
     } else {
         /* The proc instance has been used as more than one type of callback, store extras in a hash */
-        cbTable = rb_hash_new();
-        rb_ivar_set(proc, id_cbtable, cbTable);
+        if(cbTable == Qnil) {
+          cbTable = rb_hash_new();
+          rb_ivar_set(proc, id_cbtable, cbTable);
+        }
         rb_hash_aset(cbTable, rbFunctionInfo, callback);
     }
 
     return callback;
 }
 
+#if !defined(_WIN32) && defined(DEFER_ASYNC_CALLBACK)
+static void
+after_fork_callback(void)
+{
+    /* Ensure that a new dispatcher thread is started in a forked process */
+    async_cb_thread = Qnil;
+    pthread_mutex_init(&async_cb_mutex, NULL);
+    pthread_cond_init(&async_cb_cond, NULL);
+}
+#endif
+
 static VALUE
 function_init(VALUE self, VALUE rbFunctionInfo, VALUE rbProc)
 {
@@ -314,7 +320,16 @@ function_init(VALUE self, VALUE rbFunctionInfo, VALUE rbProc)
 
 #if defined(DEFER_ASYNC_CALLBACK)
         if (async_cb_thread == Qnil) {
+
+#if !defined(_WIN32)
+            if( pthread_atfork(NULL, NULL, after_fork_callback) ){
+                rb_warn("FFI: unable to register fork callback");
+            }
+#endif
+
             async_cb_thread = rb_thread_create(async_cb_event, NULL);
+            /* Name thread, for better debugging */
+            rb_funcall(async_cb_thread, rb_intern("name="), 1, rb_str_new2("FFI Callback Dispatcher"));
         }
 #endif
 
@@ -530,7 +545,9 @@ async_cb_event(void* unused)
         rb_thread_call_without_gvl(async_cb_wait, &w, async_cb_stop, &w);
         if (w.cb != NULL) {
             /* Start up a new ruby thread to run the ruby callback */
-            rb_thread_create(async_cb_call, w.cb);
+            VALUE new_thread = rb_thread_create(async_cb_call, w.cb);
+            /* Name thread, for better debugging */
+            rb_funcall(new_thread, rb_intern("name="), 1, rb_str_new2("FFI Callback Runner"));
         }
     }
 
@@ -716,7 +733,6 @@ invoke_callback(VALUE data)
                 break;
 
             case NATIVE_FUNCTION:
-            case NATIVE_CALLBACK:
             case NATIVE_STRUCT:
                 param = rbffi_NativeValue_ToRuby(paramType, rbParamType, parameters[i]);
                 break;
@@ -792,7 +808,6 @@ invoke_callback(VALUE data)
             break;
 
         case NATIVE_FUNCTION:
-        case NATIVE_CALLBACK:
             if (TYPE(rbReturnValue) == T_DATA && rb_obj_is_kind_of(rbReturnValue, rbffi_PointerClass)) {
 
                 *((void **) retval) = ((AbstractMemory *) DATA_PTR(rbReturnValue))->address;
@@ -849,7 +864,7 @@ callback_prep(void* ctx, void* code, Closure* closure, char* errmsg, size_t errm
     FunctionType* fnInfo = (FunctionType *) ctx;
     ffi_status ffiStatus;
 
-    ffiStatus = ffi_prep_closure_loc(code, &fnInfo->ffi_cif, callback_invoke, closure, code);
+    ffiStatus = ffi_prep_closure_loc(closure->pcl, &fnInfo->ffi_cif, callback_invoke, closure, code);
     if (ffiStatus != FFI_OK) {
         snprintf(errmsg, errmsgsize, "ffi_prep_closure_loc failed.  status=%#x", ffiStatus);
         return false;

data/ext/ffi_c/Function.h

@@ -34,11 +34,7 @@
 extern "C" {
 #endif
 
-#ifndef _MSC_VER
 # include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-#endif
 
 #include <ffi.h>
 

data/ext/ffi_c/FunctionInfo.c

@@ -33,12 +33,8 @@
 #include <sys/types.h>
 #include <stdio.h>
 
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-#endif
+#include <stdint.h>
+#include <stdbool.h>
 
 #include <errno.h>
 #include <ruby.h>

data/ext/ffi_c/LastError.c

@@ -33,12 +33,8 @@
 #endif
 #include <sys/types.h>
 #include <stdio.h>
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-#endif
+#include <stdint.h>
+#include <stdbool.h>
 #include <errno.h>
 #include <ruby.h>
 

data/ext/ffi_c/MemoryPointer.c

@@ -28,13 +28,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef _MSC_VER
-# include <stdbool.h>
-# include <stdint.h>
-#else
-# include "win32/stdbool.h"
-# include "win32/stdint.h"
-#endif
+#include <stdbool.h>
+#include <stdint.h>
 #include <limits.h>
 #include <ruby.h>
 #include "rbffi.h"

data/ext/ffi_c/MemoryPointer.h

@@ -31,11 +31,7 @@
 #ifndef RBFFI_MEMORYPOINTER_H
 #define	RBFFI_MEMORYPOINTER_H
 
-#ifndef _MSC_VER
 # include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-#endif
 #include <ruby.h>
 
 #ifdef	__cplusplus

data/ext/ffi_c/MethodHandle.c

@@ -34,13 +34,8 @@
 # include <sys/mman.h>
 #endif
 #include <stdio.h>
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdint.h"
-# include "win32/stdbool.h"
-#endif
+#include <stdint.h>
+#include <stdbool.h>
 #ifndef _WIN32
 # include <unistd.h>
 #endif
@@ -117,6 +112,7 @@ rbffi_MethodHandle_Free(MethodHandle* handle)
 {
     if (handle != NULL) {
         rbffi_Closure_Free(handle->closure);
+        xfree(handle);
     }
 }
 
@@ -140,7 +136,7 @@ prep_trampoline(void* ctx, void* code, Closure* closure, char* errmsg, size_t er
 #if defined(USE_RAW)
     ffiStatus = ffi_prep_raw_closure(code, &mh_cif, attached_method_invoke, closure);
 #else
-    ffiStatus = ffi_prep_closure_loc(code, &mh_cif, attached_method_invoke, closure, code);
+    ffiStatus = ffi_prep_closure_loc(closure->pcl, &mh_cif, attached_method_invoke, closure, code);
 #endif
     if (ffiStatus != FFI_OK) {
         snprintf(errmsg, errmsgsize, "ffi_prep_closure_loc failed.  status=%#x", ffiStatus);

data/ext/ffi_c/Platform.c

@@ -31,13 +31,8 @@
 # include <sys/param.h>
 #endif
 # include <sys/types.h>
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdint.h"
-# include "win32/stdbool.h"
-#endif
+#include <stdint.h>
+#include <stdbool.h>
 #include <ruby.h>
 #include <ctype.h>
 #include "rbffi_endian.h"

data/ext/ffi_c/Pointer.c

@@ -27,13 +27,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdint.h"
-# include "win32/stdbool.h"
-#endif
+#include <stdint.h>
+#include <stdbool.h>
 #include <limits.h>
 #include <ruby.h>
 #include "rbffi.h"
@@ -157,14 +152,14 @@ ptr_initialize_copy(VALUE self, VALUE other)
 {
     AbstractMemory* src;
     Pointer* dst;
-    
+
     Data_Get_Struct(self, Pointer, dst);
     src = POINTER(other);
     if (src->size == LONG_MAX) {
         rb_raise(rb_eRuntimeError, "cannot duplicate unbounded memory area");
         return Qnil;
     }
-    
+
     if ((dst->memory.flags & (MEM_RD | MEM_WR)) != (MEM_RD | MEM_WR)) {
         rb_raise(rb_eRuntimeError, "cannot duplicate unreadable/unwritable memory area");
         return Qnil;
@@ -180,13 +175,13 @@ ptr_initialize_copy(VALUE self, VALUE other)
         rb_raise(rb_eNoMemError, "failed to allocate memory size=%lu bytes", src->size);
         return Qnil;
     }
-    
+
     dst->allocated = true;
     dst->autorelease = true;
     dst->memory.address = (void *) (((uintptr_t) dst->storage + 0x7) & (uintptr_t) ~0x7ULL);
     dst->memory.size = src->size;
     dst->memory.typeSize = src->typeSize;
-    
+
     /* finally, copy the actual memory contents */
     memcpy(dst->memory.address, src->address, src->size);
 
@@ -199,7 +194,7 @@ slice(VALUE self, long offset, long size)
     AbstractMemory* ptr;
     Pointer* p;
     VALUE retval;
-    
+
     Data_Get_Struct(self, AbstractMemory, ptr);
     checkBounds(ptr, offset, size == LONG_MAX ? 1 : size);
 
@@ -214,7 +209,7 @@ slice(VALUE self, long offset, long size)
     return retval;
 }
 
-/* 
+/*
  * Document-method: +
  * call-seq: ptr + offset
  * @param [Numeric] offset
@@ -237,7 +232,7 @@ ptr_plus(VALUE self, VALUE offset)
  * @param [Numeric] offset
  * @param [Numeric] length
  * @return [Pointer]
- * Return a new {Pointer} from an existing one. This pointer points on same contents 
+ * Return a new {Pointer} from an existing one. This pointer points on same contents
  * from +offset+ for a length +length+.
  */
 static VALUE
@@ -256,7 +251,7 @@ ptr_inspect(VALUE self)
 {
     char buf[100];
     Pointer* ptr;
-    
+
     Data_Get_Struct(self, Pointer, ptr);
 
     if (ptr->memory.size != LONG_MAX) {
@@ -295,7 +290,7 @@ static VALUE
 ptr_equals(VALUE self, VALUE other)
 {
     Pointer* ptr;
-    
+
     Data_Get_Struct(self, Pointer, ptr);
 
     if (NIL_P(other)) {
@@ -314,7 +309,7 @@ static VALUE
 ptr_address(VALUE self)
 {
     Pointer* ptr;
-    
+
     Data_Get_Struct(self, Pointer, ptr);
 
     return ULL2NUM((uintptr_t) ptr->memory.address);
@@ -331,9 +326,9 @@ ptr_address(VALUE self)
  * @overload order
  *  @return [:big, :little] endianness of +self+
  * @overload order(order)
- *  @param  [Symbol] order endianness to set (+:little+, +:big+ or +:network+). +:big+ and +:network+ 
+ *  @param  [Symbol] order endianness to set (+:little+, +:big+ or +:network+). +:big+ and +:network+
  *   are synonymous.
- *  @return [self]
+ *  @return a new pointer with the new order
  */
 static VALUE
 ptr_order(int argc, VALUE* argv, VALUE self)
@@ -358,6 +353,8 @@ ptr_order(int argc, VALUE* argv, VALUE self)
 
             } else if (id == rb_intern("big") || id == rb_intern("network")) {
                 order = BIG_ENDIAN;
+            } else {
+                rb_raise(rb_eArgError, "unknown byte order");
             }
         }
         if (order != BYTE_ORDER) {
@@ -395,7 +392,7 @@ ptr_free(VALUE self)
 
     } else {
         VALUE caller = rb_funcall(rb_funcall(Qnil, rb_intern("caller"), 0), rb_intern("first"), 0);
-        
+
         rb_warn("calling free on non allocated pointer %s from %s", RSTRING_PTR(ptr_inspect(self)), RSTRING_PTR(rb_str_to_str(caller)));
     }
 
@@ -408,7 +405,7 @@ ptr_type_size(VALUE self)
     Pointer* ptr;
 
     Data_Get_Struct(self, Pointer, ptr);
-    
+
     return INT2NUM(ptr->memory.typeSize);
 }
 
@@ -440,7 +437,7 @@ ptr_autorelease_p(VALUE self)
     Pointer* ptr;
 
     Data_Get_Struct(self, Pointer, ptr);
-    
+
     return ptr->autorelease ? Qtrue : Qfalse;
 }
 
@@ -472,9 +469,11 @@ rbffi_Pointer_Init(VALUE moduleFFI)
      * Pointer class is used to manage C pointers with ease. A {Pointer} object is defined by his
      * {#address} (as a C pointer). It permits additions with an integer for pointer arithmetic.
      *
-     * ==Autorelease
-     * A pointer object may autorelease his contents when freed (by default). This behaviour may be
-     * changed with {#autorelease=} method.
+     * == Autorelease
+     * By default a pointer object frees its content when it's garbage collected.
+     * Therefore it's usually not necessary to call {#free} explicit.
+     * This behaviour may be changed with {#autorelease=} method.
+     * If it's set to +false+, the memory isn't freed by the garbage collector, but stays valid until +free()+ is called on C level or when the process terminates.
      */
     rbffi_PointerClass = rb_define_class_under(moduleFFI, "Pointer", ffi_AbstractMemory);
     /*

data/ext/ffi_c/Pointer.h

@@ -30,11 +30,7 @@
 #ifndef RBFFI_POINTER_H
 #define	RBFFI_POINTER_H
 
-#ifndef _MSC_VER
 # include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-#endif
 
 #ifdef	__cplusplus
 extern "C" {

data/ext/ffi_c/Struct.c

@@ -31,12 +31,9 @@
 #include <sys/types.h>
 #ifndef _MSC_VER
 # include <sys/param.h>
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-# include "win32/stdint.h"
 #endif
+#include <stdint.h>
+#include <stdbool.h>
 #include <ruby.h>
 #include "rbffi.h"
 #include "compat.h"
@@ -290,7 +287,7 @@ struct_field(Struct* s, VALUE fieldName)
         VALUE rbField = rb_hash_aref(layout->rbFieldMap, fieldName);
         if (unlikely(NIL_P(rbField))) {
             VALUE str = rb_funcall2(fieldName, id_to_s, 0, NULL);
-            rb_raise(rb_eArgError, "No such field '%s'", StringValuePtr(str));
+            rb_raise(rb_eArgError, "No such field '%s'", StringValueCStr(str));
         }
         /* Write the retrieved coder to the cache */
         p_ce->fieldName = fieldName;