closure.c

Go to the documentation of this file.

#include <fiddle.h>
#include <ruby/thread.h>
 
int ruby_thread_has_gvl_p(void); /* from internal.h */
 
VALUE cFiddleClosure;
 
typedef struct {
    void * code;
    ffi_closure *pcl;
    ffi_cif cif;
    int argc;
    ffi_type **argv;
} fiddle_closure;
 
#if defined(__OpenBSD__)
# define USE_FFI_CLOSURE_ALLOC 0
#endif
 
#if defined(USE_FFI_CLOSURE_ALLOC)
#elif !defined(HAVE_FFI_CLOSURE_ALLOC)
# define USE_FFI_CLOSURE_ALLOC 0
#else
# define USE_FFI_CLOSURE_ALLOC 1
#endif
 
static void
dealloc(void * ptr)
{
    fiddle_closure * cls = (fiddle_closure *)ptr;
#if USE_FFI_CLOSURE_ALLOC
    ffi_closure_free(cls->pcl);
#else
    munmap(cls->pcl, sizeof(*cls->pcl));
#endif
    if (cls->argv) xfree(cls->argv);
    xfree(cls);
}
 
static size_t
closure_memsize(const void * ptr)
{
    fiddle_closure * cls = (fiddle_closure *)ptr;
    size_t size = 0;
 
    size += sizeof(*cls);
#if !defined(FFI_NO_RAW_API) || !FFI_NO_RAW_API
    size += ffi_raw_size(&cls->cif);
#endif
    size += sizeof(*cls->argv);
    size += sizeof(ffi_closure);
 
    return size;
}
 
const rb_data_type_t closure_data_type = {
    "fiddle/closure",
    {0, dealloc, closure_memsize,},
};
 
struct callback_args {
    ffi_cif *cif;
    void *resp;
    void **args;
    void *ctx;
};
 
static void *
with_gvl_callback(void *ptr)
{
    struct callback_args *x = ptr;
 
    VALUE self      = (VALUE)x->ctx;
    VALUE rbargs    = rb_iv_get(self, "@args");
    VALUE ctype     = rb_iv_get(self, "@ctype");
    int argc        = RARRAY_LENINT(rbargs);
    VALUE params    = rb_ary_tmp_new(argc);
    VALUE ret;
    VALUE cPointer;
    int i, type;
 
    cPointer = rb_const_get(mFiddle, rb_intern("Pointer"));
 
    for (i = 0; i < argc; i++) {
        type = NUM2INT(RARRAY_AREF(rbargs, i));
        switch (type) {
          case TYPE_VOID:
            argc = 0;
            break;
          case TYPE_INT:
            rb_ary_push(params, INT2NUM(*(int *)x->args[i]));
            break;
          case -TYPE_INT:
            rb_ary_push(params, UINT2NUM(*(unsigned int *)x->args[i]));
            break;
          case TYPE_VOIDP:
            rb_ary_push(params,
                        rb_funcall(cPointer, rb_intern("[]"), 1,
                                   PTR2NUM(*(void **)x->args[i])));
            break;
          case TYPE_LONG:
            rb_ary_push(params, LONG2NUM(*(long *)x->args[i]));
            break;
          case -TYPE_LONG:
            rb_ary_push(params, ULONG2NUM(*(unsigned long *)x->args[i]));
            break;
          case TYPE_CHAR:
            rb_ary_push(params, INT2NUM(*(signed char *)x->args[i]));
            break;
          case -TYPE_CHAR:
            rb_ary_push(params, UINT2NUM(*(unsigned char *)x->args[i]));
            break;
          case TYPE_SHORT:
            rb_ary_push(params, INT2NUM(*(signed short *)x->args[i]));
            break;
          case -TYPE_SHORT:
            rb_ary_push(params, UINT2NUM(*(unsigned short *)x->args[i]));
            break;
          case TYPE_DOUBLE:
            rb_ary_push(params, rb_float_new(*(double *)x->args[i]));
            break;
          case TYPE_FLOAT:
            rb_ary_push(params, rb_float_new(*(float *)x->args[i]));
            break;
#if HAVE_LONG_LONG
          case TYPE_LONG_LONG:
            rb_ary_push(params, LL2NUM(*(LONG_LONG *)x->args[i]));
            break;
          case -TYPE_LONG_LONG:
            rb_ary_push(params, ULL2NUM(*(unsigned LONG_LONG *)x->args[i]));
            break;
#endif
          case TYPE_CONST_STRING:
            rb_ary_push(params,
                        rb_str_new_cstr(*((const char **)(x->args[i]))));
            break;
          default:
            rb_raise(rb_eRuntimeError, "closure args: %d", type);
        }
    }
 
    ret = rb_funcall2(self, rb_intern("call"), argc, RARRAY_CONST_PTR(params));
    RB_GC_GUARD(params);
 
    type = NUM2INT(ctype);
    switch (type) {
      case TYPE_VOID:
        break;
      case TYPE_LONG:
        *(long *)x->resp = NUM2LONG(ret);
        break;
      case -TYPE_LONG:
        *(unsigned long *)x->resp = NUM2ULONG(ret);
        break;
      case TYPE_CHAR:
      case TYPE_SHORT:
      case TYPE_INT:
        *(ffi_sarg *)x->resp = NUM2INT(ret);
        break;
      case -TYPE_CHAR:
      case -TYPE_SHORT:
      case -TYPE_INT:
        *(ffi_arg *)x->resp = NUM2UINT(ret);
        break;
      case TYPE_VOIDP:
        *(void **)x->resp = NUM2PTR(ret);
        break;
      case TYPE_DOUBLE:
        *(double *)x->resp = NUM2DBL(ret);
        break;
      case TYPE_FLOAT:
        *(float *)x->resp = (float)NUM2DBL(ret);
        break;
#if HAVE_LONG_LONG
      case TYPE_LONG_LONG:
        *(LONG_LONG *)x->resp = NUM2LL(ret);
        break;
      case -TYPE_LONG_LONG:
        *(unsigned LONG_LONG *)x->resp = NUM2ULL(ret);
        break;
#endif
      case TYPE_CONST_STRING:
        /* Dangerous. Callback must keep reference of the String. */
        *((const char **)(x->resp)) = StringValueCStr(ret);
        break;
      default:
        rb_raise(rb_eRuntimeError, "closure retval: %d", type);
    }
    return 0;
}
 
static void
callback(ffi_cif *cif, void *resp, void **args, void *ctx)
{
    struct callback_args x;
 
    x.cif = cif;
    x.resp = resp;
    x.args = args;
    x.ctx = ctx;
 
    if (ruby_thread_has_gvl_p()) {
        (void)with_gvl_callback(&x);
    } else {
        (void)rb_thread_call_with_gvl(with_gvl_callback, &x);
    }
}
 
static VALUE
allocate(VALUE klass)
{
    fiddle_closure * closure;
 
    VALUE i = TypedData_Make_Struct(klass, fiddle_closure,
            &closure_data_type, closure);
 
#if USE_FFI_CLOSURE_ALLOC
    closure->pcl = ffi_closure_alloc(sizeof(ffi_closure), &closure->code);
#else
    closure->pcl = mmap(NULL, sizeof(ffi_closure), PROT_READ | PROT_WRITE,
        MAP_ANON | MAP_PRIVATE, -1, 0);
#endif
 
    return i;
}
 
static VALUE
initialize(int rbargc, VALUE argv[], VALUE self)
{
    VALUE ret;
    VALUE args;
    VALUE normalized_args;
    VALUE abi;
    fiddle_closure * cl;
    ffi_cif * cif;
    ffi_closure *pcl;
    ffi_status result;
    int i, argc;
 
    if (2 == rb_scan_args(rbargc, argv, "21", &ret, &args, &abi))
        abi = INT2NUM(FFI_DEFAULT_ABI);
 
    Check_Type(args, T_ARRAY);
 
    argc = RARRAY_LENINT(args);
 
    TypedData_Get_Struct(self, fiddle_closure, &closure_data_type, cl);
 
    cl->argv = (ffi_type **)xcalloc(argc + 1, sizeof(ffi_type *));
 
    normalized_args = rb_ary_new_capa(argc);
    for (i = 0; i < argc; i++) {
        VALUE arg = rb_fiddle_type_ensure(RARRAY_AREF(args, i));
        rb_ary_push(normalized_args, arg);
        cl->argv[i] = rb_fiddle_int_to_ffi_type(NUM2INT(arg));
    }
    cl->argv[argc] = NULL;
 
    ret = rb_fiddle_type_ensure(ret);
    rb_iv_set(self, "@ctype", ret);
    rb_iv_set(self, "@args", normalized_args);
 
    cif = &cl->cif;
    pcl = cl->pcl;
 
    result = ffi_prep_cif(cif,
                          NUM2INT(abi),
                          argc,
                          rb_fiddle_int_to_ffi_type(NUM2INT(ret)),
                          cl->argv);
 
    if (FFI_OK != result)
        rb_raise(rb_eRuntimeError, "error prepping CIF %d", result);
 
#if USE_FFI_CLOSURE_ALLOC
    result = ffi_prep_closure_loc(pcl, cif, callback,
                (void *)self, cl->code);
#else
    result = ffi_prep_closure(pcl, cif, callback, (void *)self);
    cl->code = (void *)pcl;
    i = mprotect(pcl, sizeof(*pcl), PROT_READ | PROT_EXEC);
    if (i) {
        rb_sys_fail("mprotect");
    }
#endif
 
    if (FFI_OK != result)
        rb_raise(rb_eRuntimeError, "error prepping closure %d", result);
 
    return self;
}
 
static VALUE
to_i(VALUE self)
{
    fiddle_closure * cl;
    void *code;
 
    TypedData_Get_Struct(self, fiddle_closure, &closure_data_type, cl);
 
    code = cl->code;
 
    return PTR2NUM(code);
}
 
void
Init_fiddle_closure(void)
{
#if 0
    mFiddle = rb_define_module("Fiddle"); /* let rdoc know about mFiddle */
#endif
 
    /*
     * Document-class: Fiddle::Closure
     *
     * == Description
     *
     * An FFI closure wrapper, for handling callbacks.
     *
     * == Example
     *
     *   closure = Class.new(Fiddle::Closure) {
     *     def call
     *       10
     *     end
     *   }.new(Fiddle::TYPE_INT, [])
     *      #=> #<#<Class:0x0000000150d308>:0x0000000150d240>
     *   func = Fiddle::Function.new(closure, [], Fiddle::TYPE_INT)
     *      #=> #<Fiddle::Function:0x00000001516e58>
     *   func.call
     *      #=> 10
     */
    cFiddleClosure = rb_define_class_under(mFiddle, "Closure", rb_cObject);
 
    rb_define_alloc_func(cFiddleClosure, allocate);
 
    /*
     * Document-method: new
     *
     * call-seq: new(ret, args, abi = Fiddle::DEFAULT)
     *
     * Construct a new Closure object.
     *
     * * +ret+ is the C type to be returned
     * * +args+ is an Array of arguments, passed to the callback function
     * * +abi+ is the abi of the closure
     *
     * If there is an error in preparing the ffi_cif or ffi_prep_closure,
     * then a RuntimeError will be raised.
     */
    rb_define_method(cFiddleClosure, "initialize", initialize, -1);
 
    /*
     * Document-method: to_i
     *
     * Returns the memory address for this closure
     */
    rb_define_method(cFiddleClosure, "to_i", to_i, 0);
}
/* vim: set noet sw=4 sts=4 */