ffi 1.9.24 → 1.16.3

data/ext/ffi_c/ClosurePool.c

@@ -0,0 +1,333 @@
+/*
+ * Copyright (c) 2009, 2010 Wayne Meissner
+ * Copyright (c) 2008-2013, Ruby FFI project contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * 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.
+ *     * Neither the name of the Ruby FFI project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * 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 <COPYRIGHT HOLDER> 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.
+ */
+
+#ifndef _MSC_VER
+#include <sys/param.h>
+#endif
+#include <sys/types.h>
+#if defined(__CYGWIN__) || !defined(_WIN32)
+#  include <sys/mman.h>
+#endif
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+#if defined(__CYGWIN__) || !defined(_WIN32)
+#  include <unistd.h>
+#else
+#  include <winsock2.h>
+#  define _WINSOCKAPI_
+#  include <windows.h>
+#endif
+#include <errno.h>
+#include <ruby.h>
+
+#include <ffi.h>
+#include "rbffi.h"
+#include "compat.h"
+
+#include "Function.h"
+#include "Types.h"
+#include "Type.h"
+#include "LastError.h"
+#include "Call.h"
+
+#include "ClosurePool.h"
+
+#ifndef roundup
+#  define roundup(x, y)   ((((x)+((y)-1))/(y))*(y))
+#endif
+
+typedef struct Memory {
+    void* code;
+    void* data;
+    struct Memory* next;
+} Memory;
+
+struct ClosurePool_ {
+    void* ctx;
+    int closureSize;
+    bool (*prep)(void* ctx, void *code, Closure* closure, char* errbuf, size_t errbufsize);
+    struct Memory* blocks; /* Keeps track of all the allocated memory for this pool */
+    Closure* list;
+    long refcnt;
+};
+
+static long pageSize;
+
+static void* allocatePage(void);
+static bool freePage(void *);
+static bool protectPage(void *);
+
+ClosurePool*
+rbffi_ClosurePool_New(int closureSize,
+        bool (*prep)(void* ctx, void *code, Closure* closure, char* errbuf, size_t errbufsize),
+        void* ctx)
+{
+    ClosurePool* pool;
+
+    pool = xcalloc(1, sizeof(*pool));
+    pool->closureSize = closureSize;
+    pool->ctx = ctx;
+    pool->prep = prep;
+    pool->refcnt = 1;
+
+    return pool;
+}
+
+void
+cleanup_closure_pool(ClosurePool* pool)
+{
+    Memory* memory;
+
+    for (memory = pool->blocks; memory != NULL; ) {
+        Memory* next = memory->next;
+#if !USE_FFI_ALLOC
+        freePage(memory->code);
+#else
+        ffi_closure_free(memory->code);
+#endif
+        free(memory->data);
+        free(memory);
+        memory = next;
+    }
+    xfree(pool);
+}
+
+void
+rbffi_ClosurePool_Free(ClosurePool* pool)
+{
+    if (pool != NULL) {
+        long refcnt = --(pool->refcnt);
+        if (refcnt == 0) {
+            cleanup_closure_pool(pool);
+        }
+    }
+}
+
+#if !USE_FFI_ALLOC
+
+Closure*
+rbffi_Closure_Alloc(ClosurePool* pool)
+{
+    Closure *list = NULL;
+    Memory* block = NULL;
+    void *code = NULL;
+    char errmsg[256];
+    int nclosures;
+    long trampolineSize;
+    int i;
+
+    if (pool->list != NULL) {
+        Closure* closure = pool->list;
+        pool->list = pool->list->next;
+        pool->refcnt++;
+
+        return closure;
+    }
+
+    trampolineSize = roundup(pool->closureSize, 8);
+    nclosures = (int) (pageSize / trampolineSize);
+    block = calloc(1, sizeof(*block));
+    list = calloc(nclosures, sizeof(*list));
+    code = allocatePage();
+
+    if (block == NULL || list == NULL || code == NULL) {
+        snprintf(errmsg, sizeof(errmsg), "failed to allocate a page. errno=%d (%s)", errno, strerror(errno));
+        goto error;
+    }
+
+    for (i = 0; i < nclosures; ++i) {
+        Closure* closure = &list[i];
+        closure->next = &list[i + 1];
+        closure->pool = pool;
+        closure->code = ((char *)code + (i * trampolineSize));
+        closure->pcl  = closure->code;
+
+        if (!(*pool->prep)(pool->ctx, closure->code, closure, errmsg, sizeof(errmsg))) {
+            goto error;
+        }
+    }
+
+    if (!protectPage(code)) {
+        goto error;
+    }
+
+    /* Track the allocated page + Closure memory area */
+    block->data = list;
+    block->code = code;
+    block->next = pool->blocks;
+    pool->blocks = block;
+
+    /* Thread the new block onto the free list, apart from the first one. */
+    list[nclosures - 1].next = pool->list;
+    pool->list = list->next;
+    pool->refcnt++;
+
+    /* Use the first one as the new handle */
+    return list;
+
+error:
+    free(block);
+    free(list);
+    if (code != NULL) {
+        freePage(code);
+    }
+
+
+    rb_raise(rb_eRuntimeError, "%s", errmsg);
+    return NULL;
+}
+
+#else
+
+Closure*
+rbffi_Closure_Alloc(ClosurePool* pool)
+{
+    Closure *closure = NULL;
+    Memory* block = NULL;
+    void *code = NULL;
+    void *pcl = NULL;
+    char errmsg[256];
+
+    block = calloc(1, sizeof(*block));
+    closure = calloc(1, sizeof(*closure));
+    pcl = ffi_closure_alloc(sizeof(ffi_closure), &code);
+
+    if (block == NULL || closure == NULL || pcl == NULL) {
+        snprintf(errmsg, sizeof(errmsg), "failed to allocate a page. errno=%d (%s)", errno, strerror(errno));
+        goto error;
+    }
+
+    closure->pool = pool;
+    closure->code = code;
+    closure->pcl = pcl;
+
+    if (!(*pool->prep)(pool->ctx, closure->code, closure, errmsg, sizeof(errmsg))) {
+        goto error;
+    }
+
+    /* Track the allocated page + Closure memory area */
+    block->data = closure;
+    block->code = pcl;
+    pool->blocks = block;
+
+    /* Thread the new block onto the free list, apart from the first one. */
+    pool->refcnt++;
+
+    return closure;
+
+error:
+    free(block);
+    free(closure);
+    if (pcl != NULL) {
+        ffi_closure_free(pcl);
+    }
+
+    rb_raise(rb_eRuntimeError, "%s", errmsg);
+    return NULL;
+}
+
+#endif /* !USE_FFI_ALLOC */
+
+void
+rbffi_Closure_Free(Closure* closure)
+{
+    if (closure != NULL) {
+        ClosurePool* pool = closure->pool;
+        long refcnt;
+        /* Just push it on the front of the free list */
+        closure->next = pool->list;
+        pool->list = closure;
+        refcnt = --(pool->refcnt);
+        if (refcnt == 0) {
+            cleanup_closure_pool(pool);
+        }
+    }
+}
+
+void*
+rbffi_Closure_CodeAddress(Closure* handle)
+{
+    return handle->code;
+}
+
+
+static long
+getPageSize()
+{
+#if !defined(__CYGWIN__) && (defined(_WIN32) || defined(__WIN32__))
+    SYSTEM_INFO si;
+    GetSystemInfo(&si);
+    return si.dwPageSize;
+#else
+    return sysconf(_SC_PAGESIZE);
+#endif
+}
+
+#if !USE_FFI_ALLOC
+
+static void*
+allocatePage(void)
+{
+#if !defined(__CYGWIN__) && (defined(_WIN32) || defined(__WIN32__))
+    return VirtualAlloc(NULL, pageSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+#else
+    void *page = mmap(NULL, pageSize, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
+    return (page != (void *) -1) ? page : NULL;
+#endif
+}
+
+static bool
+freePage(void *addr)
+{
+#if !defined(__CYGWIN__) && (defined(_WIN32) || defined(__WIN32__))
+    return VirtualFree(addr, 0, MEM_RELEASE);
+#else
+    return munmap(addr, pageSize) == 0;
+#endif
+}
+
+static bool
+protectPage(void* page)
+{
+#if !defined(__CYGWIN__) && (defined(_WIN32) || defined(__WIN32__))
+    DWORD oldProtect;
+    return VirtualProtect(page, pageSize, PAGE_EXECUTE_READ, &oldProtect);
+#else
+    return mprotect(page, pageSize, PROT_READ | PROT_EXEC) == 0;
+#endif
+}
+
+#endif /* !USE_FFI_ALLOC */
+
+void
+rbffi_ClosurePool_Init(VALUE module)
+{
+    pageSize = getPageSize();
+}
+

data/ext/ffi_c/{Closure.h → ClosurePool.h}

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2009, 2010 Wayne Meissner
- * Copyright (c) 2008-2016, Ruby FFI project contributors
+ * Copyright (c) 2008-2013, Ruby FFI project contributors
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -26,22 +26,34 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef RUBYFFI_CLOSURE_H
-#define RUBYFFI_CLOSURE_H
+#ifndef RUBYFFI_CLOSUREPOOL_H
+#define RUBYFFI_CLOSUREPOOL_H
 
-#include <ruby.h>
+typedef struct ClosurePool_ ClosurePool;
+typedef struct Closure_ Closure;
 
-typedef struct Closure_ {
-    void* info;              /* Data to pass when calling */
-    void* function;          /* Function to call */
-    void* libffi_trampoline; /* Calls .function */
-    void *libffi_closure;    /* Allocates .libffi_trampoline */
-} 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;      /* Executable address for the native trampoline code location */
+    void* pcl;       /* Writeable address for the native trampoline code location */
 
-Closure* rbffi_Closure_Alloc();
+    struct ClosurePool_* pool;
+    Closure* next;
+};
+
+void rbffi_ClosurePool_Init(VALUE module);
+
+ClosurePool* rbffi_ClosurePool_New(int closureSize, 
+        bool (*prep)(void* ctx, void *code, Closure* closure, char* errbuf, size_t errbufsize),
+        void* ctx);
+
+void rbffi_ClosurePool_Free(ClosurePool *);
+
+Closure* rbffi_Closure_Alloc(ClosurePool *);
 void rbffi_Closure_Free(Closure *);
 
-void rbffi_Closure_Init(VALUE ffiModule);
+void* rbffi_Closure_GetCodeAddress(Closure *);
 
-#endif /* RUBYFFI_CLOSURE_H */
+#endif /* RUBYFFI_CLOSUREPOOL_H */
 

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>
 
@@ -55,17 +50,45 @@
 
 typedef struct LibrarySymbol_ {
     Pointer base;
-    VALUE library;
     VALUE name;
 } LibrarySymbol;
 
-static VALUE library_initialize(VALUE self, VALUE libname, VALUE libflags);
-static void library_free(Library* lib);
 
+static VALUE library_initialize(VALUE self, VALUE libname, VALUE libflags);
+static void library_free(void *);
+static size_t library_memsize(const void *);
 
 static VALUE symbol_allocate(VALUE klass);
 static VALUE symbol_new(VALUE library, void* address, VALUE name);
-static void symbol_mark(LibrarySymbol* sym);
+static void symbol_mark(void *data);
+static void symbol_compact(void *data);
+static size_t symbol_memsize(const void *data);
+
+static const rb_data_type_t rbffi_library_data_type = {
+    .wrap_struct_name = "FFI::DynamicLibrary",
+    .function = {
+        .dmark = NULL,
+        .dfree = library_free,
+        .dsize = library_memsize,
+    },
+    // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+    // macro to update VALUE references, as to trigger write barriers.
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | FFI_RUBY_TYPED_FROZEN_SHAREABLE
+};
+
+static const rb_data_type_t library_symbol_data_type = {
+    .wrap_struct_name = "FFI::DynamicLibrary::Symbol",
+    .function = {
+        .dmark = symbol_mark,
+        .dfree = RUBY_TYPED_DEFAULT_FREE,
+        .dsize = symbol_memsize,
+        ffi_compact_callback( symbol_compact )
+    },
+    .parent = &rbffi_pointer_data_type,
+    // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+    // macro to update VALUE references, as to trigger write barriers.
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | FFI_RUBY_TYPED_FROZEN_SHAREABLE
+};
 
 static VALUE LibraryClass = Qnil, SymbolClass = Qnil;
 
@@ -85,7 +108,7 @@ static VALUE
 library_allocate(VALUE klass)
 {
     Library* library;
-    return Data_Make_Struct(klass, Library, NULL, library_free, library);
+    return TypedData_Make_Struct(klass, Library, &rbffi_library_data_type, library);
 }
 
 /*
@@ -118,9 +141,9 @@ library_initialize(VALUE self, VALUE libname, VALUE libflags)
 
     Check_Type(libflags, T_FIXNUM);
 
-    Data_Get_Struct(self, Library, library);
+    TypedData_Get_Struct(self, Library, &rbffi_library_data_type, library);
     flags = libflags != Qnil ? NUM2UINT(libflags) : 0;
-    
+
     library->handle = dl_open(libname != Qnil ? StringValueCStr(libname) : NULL, flags);
     if (library->handle == NULL) {
         char errmsg[1024];
@@ -138,7 +161,9 @@ library_initialize(VALUE self, VALUE libname, VALUE libflags)
         library->handle = RTLD_DEFAULT;
     }
 #endif
-    rb_iv_set(self, "@name", libname != Qnil ? libname : rb_str_new2("[current process]"));
+    rb_iv_set(self, "@name", libname != Qnil ? rb_str_new_frozen(libname) : rb_str_new2("[current process]"));
+
+    rb_obj_freeze(self);
     return self;
 }
 
@@ -149,9 +174,9 @@ library_dlsym(VALUE self, VALUE name)
     void* address = NULL;
     Check_Type(name, T_STRING);
 
-    Data_Get_Struct(self, Library, library);
+    TypedData_Get_Struct(self, Library, &rbffi_library_data_type, library);
     address = dl_sym(library->handle, StringValueCStr(name));
-    
+
     return address != NULL ? symbol_new(self, address, name) : Qnil;
 }
 
@@ -164,12 +189,14 @@ library_dlerror(VALUE self)
 {
     char errmsg[1024];
     dl_error(errmsg, sizeof(errmsg));
-    return rb_tainted_str_new2(errmsg);
+    return rb_str_new2(errmsg);
 }
 
 static void
-library_free(Library* library)
+library_free(void *data)
 {
+    Library *library = (Library*)data;
+
     /* dlclose() on MacOS tends to segfault - avoid it */
 #ifndef __APPLE__
     if (library->handle != NULL) {
@@ -179,6 +206,12 @@ library_free(Library* library)
     xfree(library);
 }
 
+static size_t
+library_memsize(const void *data)
+{
+    return sizeof(Library);
+}
+
 #if (defined(_WIN32) || defined(__WIN32__)) && !defined(__CYGWIN__)
 static void*
 dl_open(const char* name, int flags)
@@ -194,8 +227,19 @@ dl_open(const char* name, int flags)
 static void
 dl_error(char* buf, int size)
 {
-    FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(),
-            0, buf, size, NULL);
+    // Get the last error code
+    DWORD error = GetLastError();
+
+    // Get the associated message
+    LPSTR message = NULL;
+    FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER, 
+                   NULL, error, 0, (LPSTR)&message, 0, NULL);
+
+    // Update the passed in buffer
+    snprintf(buf, size, "Failed with error %d: %s", error, message);
+
+    // Free the allocated message
+    LocalFree(message);
 }
 #endif
 
@@ -203,10 +247,9 @@ static VALUE
 symbol_allocate(VALUE klass)
 {
     LibrarySymbol* sym;
-    VALUE obj = Data_Make_Struct(klass, LibrarySymbol, NULL, -1, sym);
-    sym->name = Qnil;
-    sym->library = Qnil;
-    sym->base.rbParent = Qnil;
+    VALUE obj = TypedData_Make_Struct(klass, LibrarySymbol, &library_symbol_data_type, sym);
+    RB_OBJ_WRITE(obj, &sym->base.rbParent, Qnil);
+    RB_OBJ_WRITE(obj, &sym->name, Qnil);
 
     return obj;
 }
@@ -229,23 +272,39 @@ static VALUE
 symbol_new(VALUE library, void* address, VALUE name)
 {
     LibrarySymbol* sym;
-    VALUE obj = Data_Make_Struct(SymbolClass, LibrarySymbol, symbol_mark, -1, sym);
+    VALUE obj = TypedData_Make_Struct(SymbolClass, LibrarySymbol, &library_symbol_data_type, sym);
 
     sym->base.memory.address = address;
     sym->base.memory.size = LONG_MAX;
     sym->base.memory.typeSize = 1;
     sym->base.memory.flags = MEM_RD | MEM_WR;
-    sym->library = library;
-    sym->name = name;
+    RB_OBJ_WRITE(obj, &sym->base.rbParent, library);
+    RB_OBJ_WRITE(obj, &sym->name, rb_str_new_frozen(name));
 
+    rb_obj_freeze(obj);
     return obj;
 }
 
 static void
-symbol_mark(LibrarySymbol* sym)
+symbol_mark(void *data)
 {
-    rb_gc_mark(sym->library);
-    rb_gc_mark(sym->name);
+    LibrarySymbol *sym = (LibrarySymbol *)data;
+    rb_gc_mark_movable(sym->base.rbParent);
+    rb_gc_mark_movable(sym->name);
+}
+
+static void
+symbol_compact(void *data)
+{
+    LibrarySymbol *sym = (LibrarySymbol *)data;
+    ffi_gc_location(sym->base.rbParent);
+    ffi_gc_location(sym->name);
+}
+
+static size_t
+symbol_memsize(const void *data)
+{
+    return sizeof(LibrarySymbol);
 }
 
 /*
@@ -259,8 +318,8 @@ symbol_inspect(VALUE self)
     LibrarySymbol* sym;
     char buf[256];
 
-    Data_Get_Struct(self, LibrarySymbol, sym);
-    snprintf(buf, sizeof(buf), "#<FFI::Library::Symbol name=%s address=%p>",
+    TypedData_Get_Struct(self, LibrarySymbol, &library_symbol_data_type, sym);
+    snprintf(buf, sizeof(buf), "#<FFI::DynamicLibrary::Symbol name=%s address=%p>",
              StringValueCStr(sym->name), sym->base.memory.address);
     return rb_str_new2(buf);
 }
@@ -336,4 +395,3 @@ rbffi_DynamicLibrary_Init(VALUE moduleFFI)
 #undef DEF
 
 }
-