void
handle_features_reply(
uint64_t datapath_id,
uint32_t transaction_id,
uint32_t n_buffers,
uint8_t n_tables,
uint32_t capabilities,
uint32_t actions,
const list_element *phy_ports,
void *controller
) {
if ( rb_respond_to( ( VALUE ) controller, rb_intern( "features_reply" ) ) == Qfalse ) {
return;
}
VALUE attributes = rb_hash_new();
rb_hash_aset( attributes, ID2SYM( rb_intern( "datapath_id" ) ), ULL2NUM( datapath_id ) );
rb_hash_aset( attributes, ID2SYM( rb_intern( "transaction_id" ) ), UINT2NUM( transaction_id ) );
rb_hash_aset( attributes, ID2SYM( rb_intern( "n_buffers" ) ), UINT2NUM( n_buffers ) );
rb_hash_aset( attributes, ID2SYM( rb_intern( "n_tables" ) ), UINT2NUM( n_tables ) );
rb_hash_aset( attributes, ID2SYM( rb_intern( "capabilities" ) ), UINT2NUM( capabilities ) );
rb_hash_aset( attributes, ID2SYM( rb_intern( "actions" ) ), UINT2NUM( actions ) );
rb_hash_aset( attributes, ID2SYM( rb_intern( "ports" ) ), ports_from( phy_ports ) );
VALUE features_reply = rb_funcall( cFeaturesReply, rb_intern( "new" ), 1, attributes );
rb_funcall( ( VALUE ) controller, rb_intern( "features_reply" ), 2, ULL2NUM( datapath_id ), features_reply );
}
static VALUE texthash_for(VALUE self, VALUE file) {
int nbpoints, i;
VALUE list;
VALUE point_class;
TxtHashPoint *points = ph_texthash(StringValuePtr(file), &nbpoints);
point_class = rb_const_get(self, rb_intern("TextHashPoint"));
list = rb_ary_new2((long)nbpoints);
for(i = 0; i < nbpoints; i++) {
VALUE point;
VALUE args[2];
args[0] = ULL2NUM(points[i].hash);
args[1] = ULL2NUM(points[i].index);
point = rb_class_new_instance(2, args, point_class);
rb_ary_push(list, point);
}
free(points);
return list;
}
void
Init_limits(void)
{
VALUE mLimits;
mLimits = rb_define_module("Limits");
rb_define_const(mLimits, "CHAR_BIT", INT2FIX(CHAR_BIT));
rb_define_const(mLimits, "MB_LEN_MAX", INT2FIX(MB_LEN_MAX));
rb_define_const(mLimits, "CHAR_MAX", INT2FIX(CHAR_MAX));
rb_define_const(mLimits, "CHAR_MIN", INT2FIX(CHAR_MIN));
rb_define_const(mLimits, "UCHAR_MAX", INT2FIX(UCHAR_MAX));
rb_define_const(mLimits, "SHRT_MAX", INT2FIX(SHRT_MAX));
rb_define_const(mLimits, "SHRT_MIN", INT2FIX(SHRT_MIN));
rb_define_const(mLimits, "USHRT_MAX", INT2FIX(USHRT_MAX));
rb_define_const(mLimits, "INT_MAX", INT2FIX(INT_MAX));
rb_define_const(mLimits, "INT_MIN", INT2FIX(INT_MIN));
rb_define_const(mLimits, "UINT_MAX", INT2FIX(UINT_MAX));
rb_define_const(mLimits, "LONG_MAX", LL2NUM(LONG_MAX));
rb_define_const(mLimits, "LONG_MIN", LL2NUM(LONG_MIN));
rb_define_const(mLimits, "ULONG_MAX", ULL2NUM(ULONG_MAX));
rb_define_const(mLimits, "LLONG_MAX", LL2NUM(LLONG_MAX));
rb_define_const(mLimits, "LLONG_MIN", LL2NUM(LLONG_MIN));
rb_define_const(mLimits, "ULLONG_MAX", ULL2NUM(ULLONG_MAX));
}
void
handle_flow_removed( uint64_t datapath_id, flow_removed message ) {
VALUE controller = ( VALUE ) message.user_data;
if ( rb_respond_to( controller, rb_intern( "flow_removed" ) ) == Qfalse ) {
return;
}
VALUE attributes = rb_hash_new();
rb_hash_aset( attributes, ID2SYM( rb_intern( "datapath_id" ) ), ULL2NUM( datapath_id ) );
rb_hash_aset( attributes, ID2SYM( rb_intern( "transaction_id" ) ), UINT2NUM( message.transaction_id ) );
VALUE match_obj = rb_eval_string( "Match.new" );
rb_funcall( match_obj, rb_intern( "replace" ), 1, Data_Wrap_Struct( cFlowRemoved, NULL, NULL, &message.match ) );
rb_hash_aset( attributes, ID2SYM( rb_intern( "match" ) ), match_obj );
rb_hash_aset( attributes, ID2SYM( rb_intern( "cookie" ) ), ULL2NUM( message.cookie ) );
rb_hash_aset( attributes, ID2SYM( rb_intern( "priority" ) ), UINT2NUM( message.priority ) );
rb_hash_aset( attributes, ID2SYM( rb_intern( "reason" ) ), UINT2NUM( message.reason ) );
rb_hash_aset( attributes, ID2SYM( rb_intern( "duration_sec" ) ), UINT2NUM( message.duration_sec ) );
rb_hash_aset( attributes, ID2SYM( rb_intern( "duration_nsec" ) ), UINT2NUM( message.duration_nsec ) );
rb_hash_aset( attributes, ID2SYM( rb_intern( "idle_timeout" ) ), UINT2NUM( message.idle_timeout ) );
rb_hash_aset( attributes, ID2SYM( rb_intern( "packet_count" ) ), ULL2NUM( message.packet_count ) );
rb_hash_aset( attributes, ID2SYM( rb_intern( "byte_count" ) ), ULL2NUM( message.byte_count ) );
VALUE r_message = rb_funcall( cFlowRemoved, rb_intern( "new" ), 1, attributes );
rb_funcall( controller, rb_intern( "flow_removed" ), 2, ULL2NUM( datapath_id ), r_message );
}
VALUE
murmur3_x64_128_s_rawdigest(int argc, VALUE *argv, VALUE klass)
{
uint64_t out[2];
_murmur_s_digest128(argc, argv, klass, (void*)out, murmur_hash_process3_x64_128);
return rb_assoc_new(ULL2NUM(out[0]), ULL2NUM(out[1]));
}
static void
unpack_aggregate_multipart_reply( VALUE r_attributes, void *data ) {
assert( data );
const struct ofp_aggregate_stats_reply *aggregate_stats = data;
HASH_SET( r_attributes, "packet_count", ULL2NUM( aggregate_stats->packet_count ) );
HASH_SET( r_attributes, "byte_count", ULL2NUM( aggregate_stats->byte_count ) );
HASH_SET( r_attributes, "flow_count", UINT2NUM( aggregate_stats->flow_count ) );
}
void
arithmetic_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_arithmetic_resp_t *resp)
{
struct context_st *ctx = (struct context_st *)cookie;
struct bucket_st *bucket = ctx->bucket;
VALUE cas, key, val, *rv = ctx->rv, exc, res;
ID o;
ctx->nqueries--;
key = STR_NEW((const char*)resp->v.v0.key, resp->v.v0.nkey);
strip_key_prefix(bucket, key);
cas = resp->v.v0.cas > 0 ? ULL2NUM(resp->v.v0.cas) : Qnil;
o = ctx->arith > 0 ? sym_increment : sym_decrement;
exc = cb_check_error(error, "failed to perform arithmetic operation", key);
if (exc != Qnil) {
rb_ivar_set(exc, id_iv_cas, cas);
rb_ivar_set(exc, id_iv_operation, o);
if (bucket->async) {
if (bucket->on_error_proc != Qnil) {
cb_proc_call(bucket->on_error_proc, 3, o, key, exc);
} else {
if (NIL_P(bucket->exception)) {
bucket->exception = exc;
}
}
}
if (NIL_P(ctx->exception)) {
ctx->exception = cb_gc_protect(bucket, exc);
}
}
val = ULL2NUM(resp->v.v0.value);
if (bucket->async) { /* asynchronous */
if (ctx->proc != Qnil) {
res = rb_class_new_instance(0, NULL, cResult);
rb_ivar_set(res, id_iv_error, exc);
rb_ivar_set(res, id_iv_operation, o);
rb_ivar_set(res, id_iv_key, key);
rb_ivar_set(res, id_iv_value, val);
rb_ivar_set(res, id_iv_cas, cas);
cb_proc_call(ctx->proc, 1, res);
}
} else { /* synchronous */
if (NIL_P(exc)) {
if (ctx->extended) {
rb_hash_aset(*rv, key, rb_ary_new3(2, val, cas));
} else {
rb_hash_aset(*rv, key, val);
}
}
}
if (ctx->nqueries == 0) {
cb_gc_unprotect(bucket, ctx->proc);
}
(void)handle;
}
static void
unpack_table_multipart_reply( VALUE r_attributes, void *data ) {
assert( data );
const struct ofp_table_stats *table_stats = data;
HASH_SET( r_attributes, "table_id", UINT2NUM( table_stats->table_id ) );
HASH_SET( r_attributes, "active_count", UINT2NUM( table_stats->active_count ) );
HASH_SET( r_attributes, "lookup_count", ULL2NUM( table_stats->lookup_count ) );
HASH_SET( r_attributes, "matched_count", ULL2NUM( table_stats->matched_count ) );
}
void
handle_barrier_reply( uint64_t datapath_id, uint32_t transaction_id, void *user_data ) {
VALUE controller = ( VALUE ) user_data;
if ( rb_respond_to( controller, rb_intern( "barrier_reply" ) ) == Qfalse ) {
return;
}
VALUE barrier_reply = rb_funcall( cBarrierReply, rb_intern( "new" ), 2, ULL2NUM( datapath_id ), UINT2NUM( transaction_id ) );
rb_funcall( controller, rb_intern( "barrier_reply" ), 2, ULL2NUM( datapath_id ), barrier_reply );
}
static VALUE
latency_parse(VALUE self)
{
GstClockTime min_latency;
GstClockTime max_latency;
gboolean live;
gst_query_parse_latency(RVAL2GST_QUERY(self), &live, &min_latency,
&max_latency);
return rb_ary_new3(3, CBOOL2RVAL(live), ULL2NUM(min_latency),
ULL2NUM(max_latency));
}
void
rbffi_Pointer_Init(VALUE moduleFFI)
{
VALUE rbNullAddress = ULL2NUM(0);
rbffi_PointerClass = rb_define_class_under(moduleFFI, "Pointer", rbffi_AbstractMemoryClass);
rb_global_variable(&rbffi_PointerClass);
rb_define_alloc_func(rbffi_PointerClass, ptr_allocate);
rb_define_method(rbffi_PointerClass, "initialize", ptr_initialize, -1);
rb_define_method(rbffi_PointerClass, "initialize_copy", ptr_initialize_copy, 1);
rb_define_method(rbffi_PointerClass, "inspect", ptr_inspect, 0);
rb_define_method(rbffi_PointerClass, "to_s", ptr_inspect, 0);
rb_define_method(rbffi_PointerClass, "+", ptr_plus, 1);
rb_define_method(rbffi_PointerClass, "slice", ptr_slice, 2);
rb_define_method(rbffi_PointerClass, "null?", ptr_null_p, 0);
rb_define_method(rbffi_PointerClass, "address", ptr_address, 0);
rb_define_alias(rbffi_PointerClass, "to_i", "address");
rb_define_method(rbffi_PointerClass, "==", ptr_equals, 1);
rb_define_method(rbffi_PointerClass, "order", ptr_order, -1);
rb_define_method(rbffi_PointerClass, "autorelease=", ptr_autorelease, 1);
rb_define_method(rbffi_PointerClass, "autorelease?", ptr_autorelease_p, 0);
rb_define_method(rbffi_PointerClass, "free", ptr_free, 0);
rbffi_NullPointerSingleton = rb_class_new_instance(1, &rbNullAddress, rbffi_PointerClass);
rb_define_const(rbffi_PointerClass, "NULL", rbffi_NullPointerSingleton);
}
/*
* Method: data
*
* Gets the internal data stored in the entry. The data depends of the type
* of the entry:
* * Gst::IndexEntry::ID: the description of the ID, as a String.
* * Gst::IndexEntry::ASSOCIATION: an Array that contains the number of associations, a Gst::Format, the value of the format and the association flags (see Gst::Index::AssocFlags).
* * Gst::IndexEntry::FORMAT: an Array that contains a Gst::Format and its value.
* * Gst::IndexEntry::OBJECt: not yet implemented.
*
* Returns: the internal data of the entry.
*/
static VALUE
rg_data (VALUE self)
{
GstIndexEntry *entry;
VALUE data;
entry = RGST_INDEX_ENTRY (self);
switch (entry->type) {
case GST_INDEX_ENTRY_ID:
data = CSTR2RVAL (entry->data.id.description);
break;
case GST_INDEX_ENTRY_ASSOCIATION:
data = rb_ary_new ();
rb_ary_push (data, INT2FIX (entry->data.assoc.nassocs));
rb_ary_push (data, RGST_FORMAT_NEW (entry->data.assoc.assocs->format));
rb_ary_push (data, ULL2NUM (entry->data.assoc.assocs->value));
rb_ary_push (data,
GFLAGS2RVAL (entry->data.assoc.flags,
GST_TYPE_ASSOC_FLAGS));
break;
case GST_INDEX_ENTRY_FORMAT:
data = rb_ary_new ();
rb_ary_push (data, RGST_FORMAT_NEW (entry->data.format.format));
rb_ary_push (data, CSTR2RVAL (entry->data.format.key));
break;
case GST_INDEX_ENTRY_OBJECT: /* TODO */
default:
data = Qnil;
}
return data;
}
VALUE
port_from( const struct ofp_phy_port *phy_port, uint64_t datapath_id ) {
VALUE attributes = rb_hash_new();
rb_hash_aset( attributes, ID2SYM( rb_intern( "datapath_id" ) ), ULL2NUM( datapath_id ) );
rb_hash_aset( attributes, ID2SYM( rb_intern( "number" ) ), UINT2NUM( phy_port->port_no ) );
VALUE hw_addr = rb_funcall( rb_eval_string( "Pio::Mac" ), rb_intern( "new" ), 1, ULL2NUM( mac_to_uint64( phy_port->hw_addr ) ) );
rb_hash_aset( attributes, ID2SYM( rb_intern( "hw_addr" ) ), hw_addr );
rb_hash_aset( attributes, ID2SYM( rb_intern( "name" ) ), rb_str_new2( phy_port->name ) );
rb_hash_aset( attributes, ID2SYM( rb_intern( "config" ) ), UINT2NUM( phy_port->config ) );
rb_hash_aset( attributes, ID2SYM( rb_intern( "state" ) ), UINT2NUM( phy_port->state ) );
rb_hash_aset( attributes, ID2SYM( rb_intern( "curr" ) ), UINT2NUM( phy_port->curr ) );
rb_hash_aset( attributes, ID2SYM( rb_intern( "advertised" ) ), UINT2NUM( phy_port->advertised ) );
rb_hash_aset( attributes, ID2SYM( rb_intern( "supported" ) ), UINT2NUM( phy_port->supported ) );
rb_hash_aset( attributes, ID2SYM( rb_intern( "peer" ) ), UINT2NUM( phy_port->peer ) );
return rb_funcall( cPort, rb_intern( "new" ), 1, attributes );
}
void
observe_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_observe_resp_t *resp)
{
struct context_st *ctx = (struct context_st *)cookie;
struct bucket_st *bucket = ctx->bucket;
VALUE key, res, *rv = ctx->rv;
if (resp->v.v0.key) {
key = STR_NEW((const char*)resp->v.v0.key, resp->v.v0.nkey);
ctx->exception = cb_check_error(error, "failed to execute observe request", key);
if (ctx->exception) {
cb_gc_protect(bucket, ctx->exception);
}
res = rb_class_new_instance(0, NULL, cResult);
rb_ivar_set(res, id_iv_completed, Qfalse);
rb_ivar_set(res, id_iv_error, ctx->exception);
rb_ivar_set(res, id_iv_operation, sym_observe);
rb_ivar_set(res, id_iv_key, key);
rb_ivar_set(res, id_iv_cas, ULL2NUM(resp->v.v0.cas));
rb_ivar_set(res, id_iv_from_master, resp->v.v0.from_master ? Qtrue : Qfalse);
rb_ivar_set(res, id_iv_time_to_persist, ULONG2NUM(resp->v.v0.ttp));
rb_ivar_set(res, id_iv_time_to_replicate, ULONG2NUM(resp->v.v0.ttr));
switch (resp->v.v0.status) {
case LCB_OBSERVE_FOUND:
rb_ivar_set(res, id_iv_status, sym_found);
break;
case LCB_OBSERVE_PERSISTED:
rb_ivar_set(res, id_iv_status, sym_persisted);
break;
case LCB_OBSERVE_NOT_FOUND:
rb_ivar_set(res, id_iv_status, sym_not_found);
break;
default:
rb_ivar_set(res, id_iv_status, Qnil);
}
if (bucket->async) { /* asynchronous */
if (ctx->proc != Qnil) {
cb_proc_call(ctx->proc, 1, res);
}
} else { /* synchronous */
if (NIL_P(ctx->exception)) {
VALUE stats = rb_hash_aref(*rv, key);
if (NIL_P(stats)) {
stats = rb_ary_new();
rb_hash_aset(*rv, key, stats);
}
rb_ary_push(stats, res);
}
}
} else {
if (bucket->async && ctx->proc != Qnil) {
res = rb_class_new_instance(0, NULL, cResult);
rb_ivar_set(res, id_iv_completed, Qtrue);
cb_proc_call(ctx->proc, 1, res);
}
ctx->nqueries--;
cb_gc_unprotect(bucket, ctx->proc);
}
(void)handle;
}
void ruby_libvirt_typed_params_to_hash(void *voidparams, int i, VALUE hash)
{
virTypedParameterPtr params = (virTypedParameterPtr)voidparams;
VALUE val;
switch (params[i].type) {
case VIR_TYPED_PARAM_INT:
val = INT2NUM(params[i].value.i);
break;
case VIR_TYPED_PARAM_UINT:
val = UINT2NUM(params[i].value.ui);
break;
case VIR_TYPED_PARAM_LLONG:
val = LL2NUM(params[i].value.l);
break;
case VIR_TYPED_PARAM_ULLONG:
val = ULL2NUM(params[i].value.ul);
break;
case VIR_TYPED_PARAM_DOUBLE:
val = rb_float_new(params[i].value.d);
break;
case VIR_TYPED_PARAM_BOOLEAN:
val = (params[i].value.b == 0) ? Qfalse : Qtrue;
break;
case VIR_TYPED_PARAM_STRING:
val = rb_str_new2(params[i].value.s);
break;
default:
rb_raise(rb_eArgError, "Invalid parameter type");
}
rb_hash_aset(hash, rb_str_new2(params[i].field), val);
}
static VALUE value_from_default(const upb_fielddef *field) {
switch (upb_fielddef_type(field)) {
case UPB_TYPE_FLOAT: return DBL2NUM(upb_fielddef_defaultfloat(field));
case UPB_TYPE_DOUBLE: return DBL2NUM(upb_fielddef_defaultdouble(field));
case UPB_TYPE_BOOL:
return upb_fielddef_defaultbool(field) ? Qtrue : Qfalse;
case UPB_TYPE_MESSAGE: return Qnil;
case UPB_TYPE_ENUM: {
const upb_enumdef *enumdef = upb_fielddef_enumsubdef(field);
int32_t num = upb_fielddef_defaultint32(field);
const char *label = upb_enumdef_iton(enumdef, num);
if (label) {
return ID2SYM(rb_intern(label));
} else {
return INT2NUM(num);
}
}
case UPB_TYPE_INT32: return INT2NUM(upb_fielddef_defaultint32(field));
case UPB_TYPE_INT64: return LL2NUM(upb_fielddef_defaultint64(field));;
case UPB_TYPE_UINT32: return UINT2NUM(upb_fielddef_defaultuint32(field));
case UPB_TYPE_UINT64: return ULL2NUM(upb_fielddef_defaultuint64(field));
case UPB_TYPE_STRING:
case UPB_TYPE_BYTES: {
size_t size;
const char *str = upb_fielddef_defaultstr(field, &size);
return rb_str_new(str, size);
}
default: return Qnil;
}
}
static int servlet_run(lua_State *l)
{
VALUE servlet = (VALUE)lua_touserdata(l, lua_upvalueindex(1));
VALUE ptr = ULL2NUM((unsigned long long)l);
rb_funcall(servlet, rb_intern("call"), 1, ptr);
return 0;
}
VALUE layout_get_default(const upb_fielddef *field) {
switch (upb_fielddef_type(field)) {
case UPB_TYPE_FLOAT: return DBL2NUM(upb_fielddef_defaultfloat(field));
case UPB_TYPE_DOUBLE: return DBL2NUM(upb_fielddef_defaultdouble(field));
case UPB_TYPE_BOOL:
return upb_fielddef_defaultbool(field) ? Qtrue : Qfalse;
case UPB_TYPE_MESSAGE: return Qnil;
case UPB_TYPE_ENUM: {
const upb_enumdef *enumdef = upb_fielddef_enumsubdef(field);
int32_t num = upb_fielddef_defaultint32(field);
const char *label = upb_enumdef_iton(enumdef, num);
if (label) {
return ID2SYM(rb_intern(label));
} else {
return INT2NUM(num);
}
}
case UPB_TYPE_INT32: return INT2NUM(upb_fielddef_defaultint32(field));
case UPB_TYPE_INT64: return LL2NUM(upb_fielddef_defaultint64(field));;
case UPB_TYPE_UINT32: return UINT2NUM(upb_fielddef_defaultuint32(field));
case UPB_TYPE_UINT64: return ULL2NUM(upb_fielddef_defaultuint64(field));
case UPB_TYPE_STRING:
case UPB_TYPE_BYTES: {
size_t size;
const char *str = upb_fielddef_defaultstr(field, &size);
VALUE str_rb = rb_str_new(str, size);
rb_enc_associate(str_rb, (upb_fielddef_type(field) == UPB_TYPE_BYTES) ?
kRubyString8bitEncoding : kRubyStringUtf8Encoding);
rb_obj_freeze(str_rb);
return str_rb;
}
default: return Qnil;
}
}
VALUE native_slot_get(upb_fieldtype_t type,
VALUE type_class,
const void* memory) {
switch (type) {
case UPB_TYPE_FLOAT:
return DBL2NUM(DEREF(memory, float));
case UPB_TYPE_DOUBLE:
return DBL2NUM(DEREF(memory, double));
case UPB_TYPE_BOOL:
return DEREF(memory, int8_t) ? Qtrue : Qfalse;
case UPB_TYPE_STRING:
case UPB_TYPE_BYTES:
case UPB_TYPE_MESSAGE:
return DEREF(memory, VALUE);
case UPB_TYPE_ENUM: {
int32_t val = DEREF(memory, int32_t);
VALUE symbol = enum_lookup(type_class, INT2NUM(val));
if (symbol == Qnil) {
return INT2NUM(val);
} else {
return symbol;
}
}
case UPB_TYPE_INT32:
return INT2NUM(DEREF(memory, int32_t));
case UPB_TYPE_INT64:
return LL2NUM(DEREF(memory, int64_t));
case UPB_TYPE_UINT32:
return UINT2NUM(DEREF(memory, uint32_t));
case UPB_TYPE_UINT64:
return ULL2NUM(DEREF(memory, uint64_t));
default:
return Qnil;
}
}
void
handle_switch_disconnected( uint64_t datapath_id, void *user_data ) {
VALUE controller = ( VALUE ) user_data;
if ( rb_respond_to( controller, rb_intern( "switch_disconnected" ) ) == Qfalse ) {
return;
}
rb_funcall( controller, rb_intern( "switch_disconnected" ), 1, ULL2NUM( datapath_id ) );
}
static VALUE image_hash_for(VALUE self, VALUE _filename) {
char * filename = StringValuePtr(_filename);
ulong64 hash;
if (-1 == ph_dct_imagehash(filename, hash)) {
rb_raise(rb_eRuntimeError, "Unknown pHash error");
}
return ULL2NUM(hash);
}
static VALUE
packet_in_datapath_id( VALUE self ) {
packet_in *cpacket;
Data_Get_Struct( self, packet_in, cpacket );
return ULL2NUM( cpacket->datapath_id );
}
VALUE method_disk(VALUE self, VALUE path) {
VALUE disk = Qnil;
struct statfs stat;
if (statfs(StringValueCStr(path), &stat) != -1) {
disk = rb_hash_new();
rb_hash_aset(disk, SYM_TYPE, ID2SYM(rb_intern(stat.f_fstypename)));
rb_hash_aset(disk, SYM_ORIGIN, rb_str_new(stat.f_mntfromname, strlen(stat.f_mntfromname)));
rb_hash_aset(disk, SYM_MOUNT, rb_str_new(stat.f_mntonname, strlen(stat.f_mntonname)));
rb_hash_aset(disk, SYM_FREE_BYTES, ULL2NUM(stat.f_bfree * stat.f_bsize));
rb_hash_aset(disk, SYM_AVAILABLE_BYTES, ULL2NUM(stat.f_bavail * stat.f_bsize));
rb_hash_aset(disk, SYM_USED_BYTES, ULL2NUM((stat.f_blocks - stat.f_bfree) * stat.f_bsize));
rb_hash_aset(disk, SYM_TOTAL_BYTES, ULL2NUM(stat.f_blocks * stat.f_bsize));
}
return disk;
}
/**
* call-seq:
* interval.stop_instant -> Integer
*
* The integer representing the stop instant of the Interval. This value
* is not useful on its own. It is a platform dependent value.
*/
VALUE hitimes_interval_stop_instant( VALUE self )
{
hitimes_interval_t *i;
Data_Get_Struct( self, hitimes_interval_t, i );
return ULL2NUM( i->stop_instant );
}
static VALUE rb_mysql_client_thread_id(VALUE self) {
unsigned long retVal;
GET_CLIENT(self);
REQUIRE_OPEN_DB(wrapper);
retVal = mysql_thread_id(wrapper->client);
return ULL2NUM(retVal);
}
static VALUE
prof_measure_allocations(VALUE self)
{
#if defined(HAVE_LONG_LONG)
return ULL2NUM(measure_allocations());
#else
return ULONG2NUM(measure_allocations());
#endif
}
/*
* call-seq: ptr.address
* @return [Numeric] pointer's base address
* Return +self+'s base address (alias: #to_i).
*/
static VALUE
ptr_address(VALUE self)
{
Pointer* ptr;
Data_Get_Struct(self, Pointer, ptr);
return ULL2NUM((uintptr_t) ptr->memory.address);
}
VALUE na_address(VALUE self) {
struct NARRAY *ary;
void * ptr;
VALUE ret;
GetNArray(self,ary);
ptr = ary->ptr;
ret = ULL2NUM( sizeof(ptr) == 4 ? (unsigned long long int) (unsigned long int) ptr : (unsigned long long int) ptr );
return ret;
}
void
handle_openflow_error(
uint64_t datapath_id,
uint32_t transaction_id,
uint16_t type,
uint16_t code,
buffer *body,
void *user_data
) {
VALUE controller = ( VALUE ) user_data;
if ( rb_respond_to( controller, rb_intern( "openflow_error" ) ) == Qfalse ) {
return;
}
VALUE attributes = rb_hash_new();
rb_hash_aset( attributes, ID2SYM( rb_intern( "datapath_id" ) ), ULL2NUM( datapath_id ) );
rb_hash_aset( attributes, ID2SYM( rb_intern( "transaction_id" ) ), UINT2NUM( transaction_id ) );
rb_hash_aset( attributes, ID2SYM( rb_intern( "type" ) ), UINT2NUM( type ) );
rb_hash_aset( attributes, ID2SYM( rb_intern( "code" ) ), UINT2NUM( code ) );
switch ( type ) {
case OFPET_HELLO_FAILED:
case OFPET_BAD_REQUEST:
case OFPET_BAD_ACTION:
case OFPET_FLOW_MOD_FAILED:
case OFPET_PORT_MOD_FAILED:
case OFPET_QUEUE_OP_FAILED:
{
if ( body != NULL ) {
if ( body->length ) {
rb_hash_aset( attributes, ID2SYM( rb_intern( "data" ) ), rb_str_new( body->data, ( long ) body->length ) );
}
}
}
break;
default:
critical( "Un-handled error type ( type = %u ),", type );
break;
}
VALUE openflow_error = rb_funcall( cOpenflowError, rb_intern( "new" ), 1, attributes );
rb_funcall( controller, rb_intern( "openflow_error" ), 2, ULL2NUM( datapath_id ), openflow_error );
}
static VALUE rd_attr_raw_value(VALUE self)
{
rd_attr_t *attr = GetAttr(self);
Dwarf_Half form;
Dwarf_Error err;
union {
Dwarf_Addr addr;
Dwarf_Off off;
Dwarf_Unsigned udata;
Dwarf_Signed sdata;
Dwarf_Bool bool;
char *str;
} val;
VALUE top;
chkerr1(dwarf_whatform(attr->attr, &form, &err), &err, self);
switch (form) {
case DW_FORM_addr:
chkerr1(dwarf_formaddr(attr->attr, &val.addr, &err), &err, self);
return ULL2NUM(val.addr);
case DW_FORM_ref1:
case DW_FORM_ref2:
case DW_FORM_ref4:
case DW_FORM_ref8:
case DW_FORM_ref_udata:
chkerr1(dwarf_global_formref(attr->attr, &val.off, &err), &err, self);
top = rb_ivar_get(self, id_at_top);
return rdwarf_die_at(top, LL2NUM(val.off));
case DW_FORM_data1:
case DW_FORM_data2:
case DW_FORM_data4:
case DW_FORM_data8:
case DW_FORM_udata:
chkerr1(dwarf_formudata(attr->attr, &val.udata, &err), &err, self);
return ULL2NUM(val.udata);
case DW_FORM_sdata:
chkerr1(dwarf_formsdata(attr->attr, &val.sdata, &err), &err, self);
return LL2NUM(val.sdata);
case DW_FORM_flag:
chkerr1(dwarf_formflag(attr->attr, &val.bool, &err), &err, self);
return val.bool ? Qtrue : Qfalse;
case DW_FORM_strp:
case DW_FORM_string:
chkerr1(dwarf_formstring(attr->attr, &val.str, &err), &err, self);
return rb_str_new_cstr(val.str);
}
return sym_unsupported_type;
}
