2010-05-06 10:59:24 +04:00
|
|
|
#include <fiddle.h>
|
2015-11-24 00:20:56 +03:00
|
|
|
#include <ruby/thread.h>
|
2017-09-12 14:52:23 +03:00
|
|
|
|
|
|
|
int ruby_thread_has_gvl_p(void); /* from internal.h */
|
2010-05-06 10:59:24 +04:00
|
|
|
|
|
|
|
VALUE cFiddleClosure;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
void * code;
|
|
|
|
ffi_closure *pcl;
|
2010-10-30 04:08:30 +04:00
|
|
|
ffi_cif cif;
|
2010-05-06 10:59:24 +04:00
|
|
|
int argc;
|
|
|
|
ffi_type **argv;
|
|
|
|
} fiddle_closure;
|
|
|
|
|
2020-03-09 03:47:48 +03:00
|
|
|
#if defined(__OpenBSD__)
|
|
|
|
# define USE_FFI_CLOSURE_ALLOC 0
|
|
|
|
#endif
|
|
|
|
|
2020-03-04 11:28:21 +03:00
|
|
|
#if defined(USE_FFI_CLOSURE_ALLOC)
|
2020-03-04 12:13:03 +03:00
|
|
|
#elif !defined(HAVE_FFI_CLOSURE_ALLOC)
|
2020-03-04 11:28:21 +03:00
|
|
|
# define USE_FFI_CLOSURE_ALLOC 0
|
|
|
|
#else
|
|
|
|
# define USE_FFI_CLOSURE_ALLOC 1
|
|
|
|
#endif
|
|
|
|
|
2010-05-06 10:59:24 +04:00
|
|
|
static void
|
|
|
|
dealloc(void * ptr)
|
|
|
|
{
|
|
|
|
fiddle_closure * cls = (fiddle_closure *)ptr;
|
2020-03-04 11:28:21 +03:00
|
|
|
#if USE_FFI_CLOSURE_ALLOC
|
2010-05-06 10:59:24 +04:00
|
|
|
ffi_closure_free(cls->pcl);
|
2020-03-04 11:28:21 +03:00
|
|
|
#else
|
|
|
|
munmap(cls->pcl, sizeof(*cls->pcl));
|
|
|
|
#endif
|
2010-05-06 10:59:24 +04:00
|
|
|
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;
|
|
|
|
|
2015-12-09 04:01:17 +03:00
|
|
|
size += sizeof(*cls);
|
2010-05-06 10:59:24 +04:00
|
|
|
#if !defined(FFI_NO_RAW_API) || !FFI_NO_RAW_API
|
2015-12-09 04:01:17 +03:00
|
|
|
size += ffi_raw_size(&cls->cif);
|
2010-05-06 10:59:24 +04:00
|
|
|
#endif
|
2015-12-09 04:01:17 +03:00
|
|
|
size += sizeof(*cls->argv);
|
|
|
|
size += sizeof(ffi_closure);
|
|
|
|
|
2010-05-06 10:59:24 +04:00
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
|
|
|
const rb_data_type_t closure_data_type = {
|
|
|
|
"fiddle/closure",
|
2010-07-20 13:23:08 +04:00
|
|
|
{0, dealloc, closure_memsize,},
|
2010-05-06 10:59:24 +04:00
|
|
|
};
|
|
|
|
|
2015-11-24 00:20:56 +03:00
|
|
|
struct callback_args {
|
|
|
|
ffi_cif *cif;
|
|
|
|
void *resp;
|
|
|
|
void **args;
|
|
|
|
void *ctx;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void *
|
|
|
|
with_gvl_callback(void *ptr)
|
2010-05-06 10:59:24 +04:00
|
|
|
{
|
2015-11-24 00:20:56 +03:00
|
|
|
struct callback_args *x = ptr;
|
|
|
|
|
|
|
|
VALUE self = (VALUE)x->ctx;
|
2010-05-06 10:59:24 +04:00
|
|
|
VALUE rbargs = rb_iv_get(self, "@args");
|
|
|
|
VALUE ctype = rb_iv_get(self, "@ctype");
|
|
|
|
int argc = RARRAY_LENINT(rbargs);
|
2011-07-28 18:47:51 +04:00
|
|
|
VALUE params = rb_ary_tmp_new(argc);
|
2010-05-06 10:59:24 +04:00
|
|
|
VALUE ret;
|
|
|
|
VALUE cPointer;
|
|
|
|
int i, type;
|
|
|
|
|
|
|
|
cPointer = rb_const_get(mFiddle, rb_intern("Pointer"));
|
|
|
|
|
|
|
|
for (i = 0; i < argc; i++) {
|
2015-11-05 04:09:17 +03:00
|
|
|
type = NUM2INT(RARRAY_AREF(rbargs, i));
|
2010-05-06 10:59:24 +04:00
|
|
|
switch (type) {
|
|
|
|
case TYPE_VOID:
|
|
|
|
argc = 0;
|
|
|
|
break;
|
|
|
|
case TYPE_INT:
|
2015-11-24 00:20:56 +03:00
|
|
|
rb_ary_push(params, INT2NUM(*(int *)x->args[i]));
|
2010-05-06 10:59:24 +04:00
|
|
|
break;
|
2012-02-15 14:57:05 +04:00
|
|
|
case -TYPE_INT:
|
2015-11-24 00:20:56 +03:00
|
|
|
rb_ary_push(params, UINT2NUM(*(unsigned int *)x->args[i]));
|
2012-02-15 14:57:05 +04:00
|
|
|
break;
|
2010-05-06 10:59:24 +04:00
|
|
|
case TYPE_VOIDP:
|
2011-07-28 18:47:51 +04:00
|
|
|
rb_ary_push(params,
|
|
|
|
rb_funcall(cPointer, rb_intern("[]"), 1,
|
2015-11-24 00:20:56 +03:00
|
|
|
PTR2NUM(*(void **)x->args[i])));
|
2010-05-06 10:59:24 +04:00
|
|
|
break;
|
|
|
|
case TYPE_LONG:
|
2015-11-24 00:20:56 +03:00
|
|
|
rb_ary_push(params, LONG2NUM(*(long *)x->args[i]));
|
2010-05-06 10:59:24 +04:00
|
|
|
break;
|
2012-02-15 14:57:05 +04:00
|
|
|
case -TYPE_LONG:
|
2015-11-24 00:20:56 +03:00
|
|
|
rb_ary_push(params, ULONG2NUM(*(unsigned long *)x->args[i]));
|
2012-02-15 14:57:05 +04:00
|
|
|
break;
|
2010-05-06 10:59:24 +04:00
|
|
|
case TYPE_CHAR:
|
2015-11-24 00:20:56 +03:00
|
|
|
rb_ary_push(params, INT2NUM(*(signed char *)x->args[i]));
|
2012-02-15 14:57:05 +04:00
|
|
|
break;
|
|
|
|
case -TYPE_CHAR:
|
2015-11-24 00:20:56 +03:00
|
|
|
rb_ary_push(params, UINT2NUM(*(unsigned char *)x->args[i]));
|
2012-02-15 14:57:05 +04:00
|
|
|
break;
|
|
|
|
case TYPE_SHORT:
|
2015-11-24 00:20:56 +03:00
|
|
|
rb_ary_push(params, INT2NUM(*(signed short *)x->args[i]));
|
2012-02-15 14:57:05 +04:00
|
|
|
break;
|
|
|
|
case -TYPE_SHORT:
|
2015-11-24 00:20:56 +03:00
|
|
|
rb_ary_push(params, UINT2NUM(*(unsigned short *)x->args[i]));
|
2010-05-06 10:59:24 +04:00
|
|
|
break;
|
|
|
|
case TYPE_DOUBLE:
|
2015-11-24 00:20:56 +03:00
|
|
|
rb_ary_push(params, rb_float_new(*(double *)x->args[i]));
|
2010-05-06 10:59:24 +04:00
|
|
|
break;
|
|
|
|
case TYPE_FLOAT:
|
2015-11-24 00:20:56 +03:00
|
|
|
rb_ary_push(params, rb_float_new(*(float *)x->args[i]));
|
2010-05-06 10:59:24 +04:00
|
|
|
break;
|
|
|
|
#if HAVE_LONG_LONG
|
|
|
|
case TYPE_LONG_LONG:
|
2015-11-24 00:20:56 +03:00
|
|
|
rb_ary_push(params, LL2NUM(*(LONG_LONG *)x->args[i]));
|
2012-02-15 14:57:05 +04:00
|
|
|
break;
|
|
|
|
case -TYPE_LONG_LONG:
|
2015-11-24 00:20:56 +03:00
|
|
|
rb_ary_push(params, ULL2NUM(*(unsigned LONG_LONG *)x->args[i]));
|
2010-05-06 10:59:24 +04:00
|
|
|
break;
|
|
|
|
#endif
|
2020-12-25 00:02:19 +03:00
|
|
|
case TYPE_CONST_STRING:
|
|
|
|
rb_ary_push(params,
|
|
|
|
rb_str_new_cstr(*((const char **)(x->args[i]))));
|
|
|
|
break;
|
2010-05-06 10:59:24 +04:00
|
|
|
default:
|
|
|
|
rb_raise(rb_eRuntimeError, "closure args: %d", type);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-04 10:27:10 +03:00
|
|
|
ret = rb_funcall2(self, rb_intern("call"), argc, RARRAY_CONST_PTR(params));
|
2011-07-28 18:47:51 +04:00
|
|
|
RB_GC_GUARD(params);
|
2010-05-06 10:59:24 +04:00
|
|
|
|
|
|
|
type = NUM2INT(ctype);
|
|
|
|
switch (type) {
|
|
|
|
case TYPE_VOID:
|
|
|
|
break;
|
|
|
|
case TYPE_LONG:
|
2015-11-24 00:20:56 +03:00
|
|
|
*(long *)x->resp = NUM2LONG(ret);
|
2010-05-06 10:59:24 +04:00
|
|
|
break;
|
2012-02-15 14:57:05 +04:00
|
|
|
case -TYPE_LONG:
|
2015-11-24 00:20:56 +03:00
|
|
|
*(unsigned long *)x->resp = NUM2ULONG(ret);
|
2012-02-15 14:57:05 +04:00
|
|
|
break;
|
2010-05-06 10:59:24 +04:00
|
|
|
case TYPE_CHAR:
|
2011-08-09 09:31:47 +04:00
|
|
|
case TYPE_SHORT:
|
|
|
|
case TYPE_INT:
|
2015-11-24 00:20:56 +03:00
|
|
|
*(ffi_sarg *)x->resp = NUM2INT(ret);
|
2010-05-06 10:59:24 +04:00
|
|
|
break;
|
2012-02-15 14:57:05 +04:00
|
|
|
case -TYPE_CHAR:
|
|
|
|
case -TYPE_SHORT:
|
|
|
|
case -TYPE_INT:
|
2015-11-24 00:20:56 +03:00
|
|
|
*(ffi_arg *)x->resp = NUM2UINT(ret);
|
2012-02-15 14:57:05 +04:00
|
|
|
break;
|
2010-05-06 10:59:24 +04:00
|
|
|
case TYPE_VOIDP:
|
2015-11-24 00:20:56 +03:00
|
|
|
*(void **)x->resp = NUM2PTR(ret);
|
2010-05-06 10:59:24 +04:00
|
|
|
break;
|
|
|
|
case TYPE_DOUBLE:
|
2015-11-24 00:20:56 +03:00
|
|
|
*(double *)x->resp = NUM2DBL(ret);
|
2010-05-06 10:59:24 +04:00
|
|
|
break;
|
|
|
|
case TYPE_FLOAT:
|
2015-11-24 00:20:56 +03:00
|
|
|
*(float *)x->resp = (float)NUM2DBL(ret);
|
2010-05-06 10:59:24 +04:00
|
|
|
break;
|
|
|
|
#if HAVE_LONG_LONG
|
|
|
|
case TYPE_LONG_LONG:
|
2015-11-24 00:20:56 +03:00
|
|
|
*(LONG_LONG *)x->resp = NUM2LL(ret);
|
2012-02-15 14:57:05 +04:00
|
|
|
break;
|
|
|
|
case -TYPE_LONG_LONG:
|
2015-11-24 00:20:56 +03:00
|
|
|
*(unsigned LONG_LONG *)x->resp = NUM2ULL(ret);
|
2010-05-06 10:59:24 +04:00
|
|
|
break;
|
|
|
|
#endif
|
2020-12-25 00:02:19 +03:00
|
|
|
case TYPE_CONST_STRING:
|
|
|
|
/* Dangerous. Callback must keep reference of the String. */
|
|
|
|
*((const char **)(x->resp)) = StringValueCStr(ret);
|
|
|
|
break;
|
2010-05-06 10:59:24 +04:00
|
|
|
default:
|
|
|
|
rb_raise(rb_eRuntimeError, "closure retval: %d", type);
|
|
|
|
}
|
2015-11-24 00:20:56 +03:00
|
|
|
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);
|
|
|
|
}
|
2010-05-06 10:59:24 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
allocate(VALUE klass)
|
|
|
|
{
|
|
|
|
fiddle_closure * closure;
|
|
|
|
|
|
|
|
VALUE i = TypedData_Make_Struct(klass, fiddle_closure,
|
|
|
|
&closure_data_type, closure);
|
|
|
|
|
2020-03-04 11:28:21 +03:00
|
|
|
#if USE_FFI_CLOSURE_ALLOC
|
2010-05-06 10:59:24 +04:00
|
|
|
closure->pcl = ffi_closure_alloc(sizeof(ffi_closure), &closure->code);
|
2020-03-04 11:28:21 +03:00
|
|
|
#else
|
|
|
|
closure->pcl = mmap(NULL, sizeof(ffi_closure), PROT_READ | PROT_WRITE,
|
|
|
|
MAP_ANON | MAP_PRIVATE, -1, 0);
|
|
|
|
#endif
|
2010-05-06 10:59:24 +04:00
|
|
|
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
initialize(int rbargc, VALUE argv[], VALUE self)
|
|
|
|
{
|
|
|
|
VALUE ret;
|
|
|
|
VALUE args;
|
2020-12-25 00:01:12 +03:00
|
|
|
VALUE normalized_args;
|
2010-05-06 10:59:24 +04:00
|
|
|
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 *));
|
|
|
|
|
2020-12-25 00:01:12 +03:00
|
|
|
normalized_args = rb_ary_new_capa(argc);
|
2010-05-06 10:59:24 +04:00
|
|
|
for (i = 0; i < argc; i++) {
|
2020-12-25 00:01:12 +03:00
|
|
|
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));
|
2010-05-06 10:59:24 +04:00
|
|
|
}
|
|
|
|
cl->argv[argc] = NULL;
|
|
|
|
|
2020-12-25 00:01:12 +03:00
|
|
|
ret = rb_fiddle_type_ensure(ret);
|
2010-05-06 10:59:24 +04:00
|
|
|
rb_iv_set(self, "@ctype", ret);
|
2020-12-25 00:01:12 +03:00
|
|
|
rb_iv_set(self, "@args", normalized_args);
|
2010-05-06 10:59:24 +04:00
|
|
|
|
2010-10-30 04:08:30 +04:00
|
|
|
cif = &cl->cif;
|
2010-05-06 10:59:24 +04:00
|
|
|
pcl = cl->pcl;
|
|
|
|
|
2020-12-25 00:01:12 +03:00
|
|
|
result = ffi_prep_cif(cif,
|
|
|
|
NUM2INT(abi),
|
|
|
|
argc,
|
|
|
|
rb_fiddle_int_to_ffi_type(NUM2INT(ret)),
|
|
|
|
cl->argv);
|
2010-05-06 10:59:24 +04:00
|
|
|
|
|
|
|
if (FFI_OK != result)
|
|
|
|
rb_raise(rb_eRuntimeError, "error prepping CIF %d", result);
|
|
|
|
|
2020-03-04 11:28:21 +03:00
|
|
|
#if USE_FFI_CLOSURE_ALLOC
|
2010-05-06 10:59:24 +04:00
|
|
|
result = ffi_prep_closure_loc(pcl, cif, callback,
|
|
|
|
(void *)self, cl->code);
|
2020-03-04 11:28:21 +03:00
|
|
|
#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
|
2010-05-06 10:59:24 +04:00
|
|
|
|
|
|
|
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
|
2014-09-30 09:25:32 +04:00
|
|
|
Init_fiddle_closure(void)
|
2010-05-06 10:59:24 +04:00
|
|
|
{
|
2011-08-16 03:48:59 +04:00
|
|
|
#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, [])
|
2012-11-28 03:26:07 +04:00
|
|
|
* #=> #<#<Class:0x0000000150d308>:0x0000000150d240>
|
2011-08-16 03:48:59 +04:00
|
|
|
* func = Fiddle::Function.new(closure, [], Fiddle::TYPE_INT)
|
2012-11-28 03:26:07 +04:00
|
|
|
* #=> #<Fiddle::Function:0x00000001516e58>
|
2011-08-16 03:48:59 +04:00
|
|
|
* func.call
|
2012-11-28 03:26:07 +04:00
|
|
|
* #=> 10
|
2011-08-16 03:48:59 +04:00
|
|
|
*/
|
2010-05-06 10:59:24 +04:00
|
|
|
cFiddleClosure = rb_define_class_under(mFiddle, "Closure", rb_cObject);
|
|
|
|
|
|
|
|
rb_define_alloc_func(cFiddleClosure, allocate);
|
|
|
|
|
2011-08-16 03:48:59 +04:00
|
|
|
/*
|
|
|
|
* Document-method: new
|
|
|
|
*
|
2012-12-07 08:39:39 +04:00
|
|
|
* call-seq: new(ret, args, abi = Fiddle::DEFAULT)
|
2011-08-16 03:48:59 +04:00
|
|
|
*
|
|
|
|
* Construct a new Closure object.
|
|
|
|
*
|
|
|
|
* * +ret+ is the C type to be returned
|
2012-11-28 18:55:41 +04:00
|
|
|
* * +args+ is an Array of arguments, passed to the callback function
|
2011-08-16 03:48:59 +04:00
|
|
|
* * +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.
|
|
|
|
*/
|
2010-05-06 10:59:24 +04:00
|
|
|
rb_define_method(cFiddleClosure, "initialize", initialize, -1);
|
2011-08-16 03:48:59 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Document-method: to_i
|
|
|
|
*
|
|
|
|
* Returns the memory address for this closure
|
|
|
|
*/
|
2010-05-06 10:59:24 +04:00
|
|
|
rb_define_method(cFiddleClosure, "to_i", to_i, 0);
|
|
|
|
}
|
|
|
|
/* vim: set noet sw=4 sts=4 */
|