chrisa-ruby-dtrace 0.2.0

data/ext/dof/section.c

@@ -0,0 +1,302 @@
+/* 
+ * Ruby-Dtrace
+ * (c) 2008 Chris Andrews <chris@nodnol.org>
+ */
+
+#include "dof.h"
+#include <errno.h>
+#include <string.h>
+
+RUBY_EXTERN eDtraceDofException;
+
+VALUE dof_generate_section_header(VALUE self) {
+  VALUE hdr_data;
+  dof_sec_t hdr;
+  uint32_t type;
+  uint64_t offset;
+  uint64_t size;
+  VALUE data;
+  uint32_t entsize;
+
+  memset(&hdr, 0, sizeof(hdr));
+  hdr.dofs_flags   = FIX2INT(rb_iv_get(self, "@flags"));
+  hdr.dofs_type    = FIX2INT(rb_iv_get(self, "@section_type"));
+  hdr.dofs_offset  = FIX2INT(rb_iv_get(self, "@offset"));
+  hdr.dofs_size    = FIX2INT(rb_iv_get(self, "@size"));
+  hdr.dofs_entsize = FIX2INT(rb_iv_get(self, "@entsize"));
+  hdr.dofs_align   = FIX2INT(rb_iv_get(self, "@align"));
+
+  hdr_data = rb_str_new((const char *)&hdr, sizeof(hdr));
+  return hdr_data;
+}
+
+VALUE dof_generate_comments(VALUE self) {
+  VALUE dof;
+  VALUE comments = rb_iv_get(self, "@data");
+
+  if (NIL_P(comments) ) {
+    rb_raise(eDtraceDofException, "no comments in dof_generate_comments");
+    return Qnil;
+  }
+  
+  Check_Type(comments, T_STRING);
+
+  dof = rb_str_new(RSTRING(comments)->ptr, RSTRING(comments)->len + 1);
+  return dof;
+}
+
+VALUE dof_generate_probes(VALUE self) {
+  VALUE dof;
+  VALUE probes = rb_iv_get(self, "@data");
+  VALUE probe;
+  int i;
+  
+  if (NIL_P(probes) ) {
+    rb_raise(eDtraceDofException, "no probes in dof_generate_probes");
+    return Qnil;
+  }
+  Check_Type(probes, T_ARRAY);
+ 
+  dof = rb_str_new2("");
+
+  for (i = 0; i < rb_ary_len(probes); i++) {
+    probe = rb_ary_entry(probes, i);
+
+    Check_Type(probe, T_HASH);
+
+    dof_probe_t p;
+    memset(&p, 0, sizeof(p));
+    
+    p.dofpr_addr  =     (uint64_t)FIX2INT(rb_hash_aref(probe, ID2SYM(rb_intern("addr"))));
+    p.dofpr_func  = (dof_stridx_t)FIX2INT(rb_hash_aref(probe, ID2SYM(rb_intern("func"))));
+    p.dofpr_name  = (dof_stridx_t)FIX2INT(rb_hash_aref(probe, ID2SYM(rb_intern("name"))));
+    p.dofpr_nargv = (dof_stridx_t)FIX2INT(rb_hash_aref(probe, ID2SYM(rb_intern("nargv"))));
+    p.dofpr_xargv = (dof_stridx_t)FIX2INT(rb_hash_aref(probe, ID2SYM(rb_intern("xargv"))));
+    
+    p.dofpr_argidx   = (uint32_t)FIX2INT(rb_hash_aref(probe, ID2SYM(rb_intern("argidx"))));
+    p.dofpr_offidx   = (uint32_t)FIX2INT(rb_hash_aref(probe, ID2SYM(rb_intern("offidx"))));
+    p.dofpr_nargc    =  (uint8_t)FIX2INT(rb_hash_aref(probe, ID2SYM(rb_intern("nargc"))));
+    p.dofpr_xargc    =  (uint8_t)FIX2INT(rb_hash_aref(probe, ID2SYM(rb_intern("xargc"))));
+    p.dofpr_noffs    = (uint16_t)FIX2INT(rb_hash_aref(probe, ID2SYM(rb_intern("noffs"))));
+    p.dofpr_enoffidx = (uint32_t)FIX2INT(rb_hash_aref(probe, ID2SYM(rb_intern("enoffidx"))));
+    p.dofpr_nenoffs  = (uint16_t)FIX2INT(rb_hash_aref(probe, ID2SYM(rb_intern("nenoffs"))));
+
+    VALUE p_dof = rb_str_new((const char *)&p, sizeof(p));
+    rb_str_concat(dof, p_dof);
+  }
+
+  return dof;
+}
+
+VALUE dof_generate_strtab(VALUE self) {
+  VALUE dof;
+  VALUE strings = rb_iv_get(self, "@data");
+  VALUE string;
+  int i;
+  
+  if (NIL_P(strings) ) {
+    rb_raise(eDtraceDofException, "no strings in dof_generate_strtab");
+    return Qnil;
+  }
+  Check_Type(strings, T_ARRAY);
+ 
+  dof = rb_str_new("", 0);
+  rb_str_concat(dof, rb_str_new("\0", 1));
+ 
+  for (i = 0; i < rb_ary_len(strings); i++) {
+    string = rb_ary_entry(strings, i);
+
+    Check_Type(string, T_STRING);
+
+    rb_str_concat(dof, rb_str_new(RSTRING(string)->ptr, RSTRING(string)->len + 1));
+  }
+  
+  return dof;
+}
+  
+VALUE dof_generate_utsname(VALUE self) {
+  VALUE dof;
+  struct utsname u;
+
+  if (uname(&u) < 0) {
+    rb_raise(eDtraceDofException, "uname failed: %s", strerror(errno));
+    return Qnil;
+  }
+  
+  dof = rb_str_new((const char *)&u, sizeof(struct utsname));
+  return dof;
+}
+
+VALUE dof_generate_prargs(VALUE self) {
+  VALUE dof;
+  VALUE args = rb_iv_get(self, "@data");
+  VALUE rarg;
+  uint8_t arg;
+  int i;
+  
+  if (NIL_P(args) ) {
+    rb_raise(eDtraceDofException, "no args in dof_generate_prargs");
+    return Qnil;
+  }
+  Check_Type(args, T_ARRAY);
+ 
+  dof = rb_str_new("", 0);
+ 
+  for (i = 0; i < rb_ary_len(args); i++) {
+    rarg = rb_ary_entry(args, i);
+    Check_Type(rarg, T_FIXNUM);
+    if (FIX2INT(rarg) >= 0 && FIX2INT(rarg) < 256) {
+      arg = FIX2INT(rarg);
+      rb_str_concat(dof, rb_str_new((char *)&arg, 1));
+    }
+  }
+  
+  return dof;
+}
+
+VALUE dof_generate_proffs(VALUE self) {
+  VALUE dof;
+  VALUE args = rb_iv_get(self, "@data");
+  VALUE rarg;
+  uint32_t arg;
+  int i;
+  
+  if (NIL_P(args) ) {
+    rb_raise(eDtraceDofException, "no args in dof_generate_proffs");
+    return Qnil;
+  }
+  Check_Type(args, T_ARRAY);
+ 
+  dof = rb_str_new("", 0);
+ 
+  for (i = 0; i < rb_ary_len(args); i++) {
+    rarg = rb_ary_entry(args, i);
+    Check_Type(rarg, T_FIXNUM);
+    arg = FIX2INT(rarg);
+    rb_str_concat(dof, rb_str_new((char *)&arg, 4));
+  }
+  
+  return dof;
+}
+
+VALUE dof_generate_prenoffs(VALUE self) {
+  VALUE dof;
+  VALUE args = rb_iv_get(self, "@data");
+  VALUE rarg;
+  uint32_t arg;
+  int i;
+  
+  if (NIL_P(args) ) {
+    rb_raise(eDtraceDofException, "no args in dof_generate_prenoffs");
+    return Qnil;
+  }
+  Check_Type(args, T_ARRAY);
+ 
+  dof = rb_str_new("", 0);
+ 
+  for (i = 0; i < rb_ary_len(args); i++) {
+    rarg = rb_ary_entry(args, i);
+    Check_Type(rarg, T_FIXNUM);
+    arg = FIX2INT(rarg);
+    rb_str_concat(dof, rb_str_new((char *)&arg, 4));
+  }
+  
+  return dof;
+}
+
+dof_attr_t _dof_generate_dof_attr_t(VALUE data) {
+  dof_attr_t attr = 0;
+  uint8_t n = 0;
+  uint8_t d = 0;
+  uint8_t c = 0;
+
+  Check_Type(data, T_HASH);
+
+  n = FIX2INT(rb_hash_aref(data, ID2SYM(rb_intern("name"))));
+  d = FIX2INT(rb_hash_aref(data, ID2SYM(rb_intern("data"))));
+  c = FIX2INT(rb_hash_aref(data, ID2SYM(rb_intern("class"))));
+
+  attr = DOF_ATTR(n, d, c);
+  return attr;
+}
+
+VALUE dof_generate_provider(VALUE self) {
+  VALUE dof;
+  VALUE provider = rb_iv_get(self, "@data");
+  dof_provider_t p;
+  
+  if (NIL_P(provider) ) {
+    rb_raise(eDtraceDofException, "no data in dof_generate_provider");
+    return Qnil;
+  }
+  Check_Type(provider, T_HASH);
+    
+  p.dofpv_strtab   = (dof_secidx_t)FIX2INT(rb_hash_aref(provider, ID2SYM(rb_intern("strtab"))));
+  p.dofpv_probes   = (dof_secidx_t)FIX2INT(rb_hash_aref(provider, ID2SYM(rb_intern("probes"))));
+  p.dofpv_prargs   = (dof_secidx_t)FIX2INT(rb_hash_aref(provider, ID2SYM(rb_intern("prargs"))));
+  p.dofpv_proffs   = (dof_secidx_t)FIX2INT(rb_hash_aref(provider, ID2SYM(rb_intern("proffs"))));
+  p.dofpv_name     = (dof_stridx_t)FIX2INT(rb_hash_aref(provider, ID2SYM(rb_intern("name"))));
+  p.dofpv_provattr = _dof_generate_dof_attr_t(rb_hash_aref(provider, ID2SYM(rb_intern("provattr"))));
+  p.dofpv_modattr  = _dof_generate_dof_attr_t(rb_hash_aref(provider, ID2SYM(rb_intern("modattr"))));
+  p.dofpv_funcattr = _dof_generate_dof_attr_t(rb_hash_aref(provider, ID2SYM(rb_intern("funcattr"))));
+  p.dofpv_nameattr = _dof_generate_dof_attr_t(rb_hash_aref(provider, ID2SYM(rb_intern("nameattr"))));
+  p.dofpv_argsattr = _dof_generate_dof_attr_t(rb_hash_aref(provider, ID2SYM(rb_intern("argsattr"))));
+  p.dofpv_prenoffs = (dof_secidx_t)FIX2INT(rb_hash_aref(provider, ID2SYM(rb_intern("prenoffs"))));
+  
+  dof = rb_str_new((const char *)&p, sizeof(p));
+  return dof;
+}
+
+VALUE dof_generate_reltab(VALUE self) {
+  VALUE dof;
+  VALUE relos = rb_iv_get(self, "@data");
+  VALUE relo;
+  int i;
+  
+  if (NIL_P(relos) ) {
+    rb_raise(eDtraceDofException, "no relos in dof_generate_reltab");
+    return Qnil;
+  }
+  Check_Type(relos, T_ARRAY);
+ 
+  dof = rb_str_new2("");
+
+  for (i = 0; i < rb_ary_len(relos); i++) {
+    relo = rb_ary_entry(relos, i);
+
+    Check_Type(relo, T_HASH);
+
+    dof_relodesc_t r;
+    memset(&r, 0, sizeof(r));
+    
+    r.dofr_name   = (dof_stridx_t)FIX2INT(rb_hash_aref(relo, ID2SYM(rb_intern("name"))));
+    r.dofr_type   =     (uint32_t)FIX2INT(rb_hash_aref(relo, ID2SYM(rb_intern("type"))));
+    r.dofr_offset =     (uint64_t)FIX2INT(rb_hash_aref(relo, ID2SYM(rb_intern("offset"))));
+    r.dofr_data   =     (uint64_t)FIX2INT(rb_hash_aref(relo, ID2SYM(rb_intern("data"))));
+    
+    VALUE r_dof = rb_str_new((const char *)&r, sizeof(r));
+    rb_str_concat(dof, r_dof);
+  }
+
+  return dof;
+}
+
+VALUE dof_generate_relhdr(VALUE self) {
+  VALUE dof;
+  VALUE relhdr = rb_iv_get(self, "@data");
+  dof_relohdr_t r;
+  
+  if (NIL_P(relhdr) ) {
+    rb_raise(eDtraceDofException, "no data in dof_generate_relhdr");
+    return Qnil;
+  }
+  Check_Type(relhdr, T_HASH);
+  
+  r.dofr_strtab = (dof_secidx_t)FIX2INT(rb_hash_aref(relhdr, ID2SYM(rb_intern("strtab"))));
+  r.dofr_relsec = (dof_secidx_t)FIX2INT(rb_hash_aref(relhdr, ID2SYM(rb_intern("relsec"))));
+  r.dofr_tgtsec = (dof_secidx_t)FIX2INT(rb_hash_aref(relhdr, ID2SYM(rb_intern("tgtsec"))));  
+    
+  dof = rb_str_new((const char *)&r, sizeof(r));
+  return dof;
+}
+

data/ext/dtrace_aggdata.c

@@ -0,0 +1,142 @@
+/* Ruby-Dtrace
+ * (c) 2007 Chris Andrews <chris@nodnol.org>
+ */
+
+#include "dtrace_api.h"
+
+RUBY_EXTERN VALUE eDtraceException;
+
+/* :nodoc: */
+VALUE dtraceaggdata_init(VALUE self)
+{
+  dtrace_bufdata_t *data;
+
+  Data_Get_Struct(self, dtrace_bufdata_t, data);
+  return self;
+}
+
+/* Returns the value of this aggregate, be it the aggregation value,
+   or a member of an aggregation key tuple. */
+VALUE dtraceaggdata_value(VALUE self)
+{
+  dtrace_bufdata_t *bufdata;
+  const dtrace_aggdata_t *aggdata;
+  const dtrace_aggdesc_t *aggdesc;
+  const dtrace_recdesc_t *rec;
+  const char *s;
+  dtrace_actkind_t act = DTRACEACT_NONE;
+  int64_t aggid;
+  uint64_t normal;
+  caddr_t addr;
+  int64_t value;
+  VALUE v = Qnil;
+
+  Data_Get_Struct(self, dtrace_bufdata_t, bufdata);
+  aggdata = bufdata->dtbda_aggdata;
+  s = bufdata->dtbda_buffered;
+  rec = bufdata->dtbda_recdesc;
+  
+  if (aggdata == NULL) {
+    rb_raise(eDtraceException, "null aggdata");
+    return Qnil;
+  }
+
+  aggdesc = aggdata->dtada_desc;
+
+  if (aggdesc == NULL) {
+    rb_raise(eDtraceException, "null aggdesc");
+    return Qnil;
+  }
+
+  aggid = *((int64_t *)(aggdata->dtada_data +
+			aggdesc->dtagd_rec[0].dtrd_offset));
+  if (aggid < 0) {
+    rb_raise(eDtraceException, "negative aggregation ID");
+    return Qnil;
+  }
+
+  act = rec->dtrd_action;
+
+  if (bufdata->dtbda_flags & DTRACE_BUFDATA_AGGKEY) {
+  
+    switch (act) {
+    case DTRACEACT_STACK:
+    case DTRACEACT_USTACK:
+    case DTRACEACT_JSTACK:
+      /* todo */
+      break;
+    case DTRACEACT_USYM:
+    case DTRACEACT_UADDR:
+    case DTRACEACT_UMOD:
+    case DTRACEACT_SYM:
+    case DTRACEACT_MOD:
+      /* todo */
+      break;
+    default:
+      v = handle_bytedata((aggdata->dtada_data + rec->dtrd_offset), rec->dtrd_size);
+    }
+  
+    
+  } else if (bufdata->dtbda_flags & DTRACE_BUFDATA_AGGVAL) {
+    
+    normal = aggdata->dtada_normal;
+    addr = aggdata->dtada_data + rec->dtrd_offset;
+
+    if (act == DTRACEAGG_AVG) {
+      uint64_t *data = (uint64_t *)addr;
+      value = (data[0] ? (long long)(data[1] / normal / data[0]) : 0);
+    } else {
+      value = (*((int64_t *)addr)) / normal;
+    }
+
+    if (act == DTRACEAGG_QUANTIZE || act == DTRACEAGG_LQUANTIZE) {
+      v = Qnil; // dtj_new_distribution(data, rec, jc);
+    } else {
+      switch (act) {
+      case DTRACEAGG_COUNT:
+	if (value < 0)
+	  rb_raise(eDtraceException, "count value is negative");
+	v = INT2FIX(value);
+	break;
+      case DTRACEAGG_AVG:
+      case DTRACEAGG_MIN:
+      case DTRACEAGG_MAX:
+      case DTRACEAGG_SUM:
+	v = INT2FIX(value);
+	break;
+      default:
+	v = Qnil;
+	rb_raise(eDtraceException, "unexpected aggregation action: %d", act);
+      }
+    }
+
+  } else if (bufdata->dtbda_flags & DTRACE_BUFDATA_AGGVAL) {
+
+    v = Qnil;
+
+  }
+
+  return v;
+}
+
+/* Return the type of this DtraceAggData: tuple, value or last. Used
+   to form tuples and values into DtraceAggregate objects. */
+VALUE dtraceaggdata_aggtype(VALUE self)
+{
+  dtrace_bufdata_t *bufdata;
+  VALUE v;
+
+  Data_Get_Struct(self, dtrace_bufdata_t, bufdata);
+
+  if (bufdata->dtbda_flags & DTRACE_BUFDATA_AGGKEY)
+    v = rb_str_new2("tuple");
+  else if (bufdata->dtbda_flags & DTRACE_BUFDATA_AGGVAL)
+    v = rb_str_new2("value");
+  else if (bufdata->dtbda_flags & DTRACE_BUFDATA_AGGLAST)
+    v = rb_str_new2("last");
+  else
+    v = rb_str_new2("unknown");
+
+  return v;
+}
+  

data/ext/dtrace_api.c

@@ -0,0 +1,119 @@
+/* Ruby-Dtrace
+ * (c) 2007 Chris Andrews <chris@nodnol.org>
+ */
+
+#include "dtrace_api.h"
+
+VALUE cDtrace;
+VALUE cDtraceProbeDesc;
+VALUE cDtraceProgram;
+VALUE cDtraceProgramInfo;
+VALUE cDtraceAggData;
+VALUE cDtraceRecDesc;
+VALUE cDtraceProbeData;
+VALUE cDtraceBufData;
+VALUE cDtraceProcess;
+VALUE cDtraceDropData;
+VALUE cDtraceErrData;
+VALUE cDtraceProbe;
+
+VALUE eDtraceException;
+
+void Init_dtrace_api() {
+
+  cDtrace = rb_define_class("Dtrace",          rb_cObject);
+  rb_define_method(cDtrace, "initialize",      dtrace_init,                0); // in dtrace_hdl.c
+  rb_define_method(cDtrace, "each_probe",      dtrace_each_probe,          0); // in dtrace_hdl.c
+  rb_define_method(cDtrace, "compile",         dtrace_strcompile,         -1); // in dtrace_hdl.c
+  rb_define_method(cDtrace, "stop",            dtrace_hdl_stop,            0); // in dtrace_hdl.c
+  rb_define_method(cDtrace, "status",          dtrace_hdl_status,          0); // in dtrace_hdl.c
+  rb_define_method(cDtrace, "go",              dtrace_hdl_go,              0); // in dtrace_hdl.c
+  rb_define_method(cDtrace, "error",           dtrace_hdl_error,           0); // in dtrace_hdl.c
+  rb_define_method(cDtrace, "setopt",          dtrace_hdl_setopt,          2); // in dtrace_hdl.c
+  rb_define_method(cDtrace, "sleep",           dtrace_hdl_sleep,           0); // in dtrace_hdl.c
+  rb_define_method(cDtrace, "work",            dtrace_hdl_work,           -1); // in dtrace_hdl.c
+  rb_define_method(cDtrace, "buf_consumer",    dtrace_hdl_buf_consumer,    1); // in dtrace_hdl.c
+  rb_define_method(cDtrace, "drop_consumer",   dtrace_hdl_drop_consumer,   1); // in dtrace_hdl.c
+  rb_define_method(cDtrace, "err_consumer",    dtrace_hdl_err_consumer,    1); // in dtrace_hdl.c
+  rb_define_method(cDtrace, "createprocess",   dtrace_hdl_createprocess,   1); // in dtrace_hdl.c
+  rb_define_method(cDtrace, "grabprocess",     dtrace_hdl_grabprocess,     1); // in dtrace_hdl.c
+  rb_define_alloc_func(cDtrace, dtrace_hdl_alloc);
+
+  cDtraceProcess = rb_define_class_under(cDtrace, "Process", rb_cObject);
+  rb_define_method(cDtraceProcess, "initialize",    dtrace_process_init,     0); // in dtrace_process.c
+  rb_define_method(cDtraceProcess, "continue",      dtrace_process_continue, 0); // in dtrace_process.c
+
+  cDtraceProbeDesc = rb_define_class_under(cDtrace, "ProbeDesc", rb_cObject);
+  rb_define_method(cDtraceProbeDesc, "initialize", dtraceprobedesc_init,     0); // in dtrace_probedesc.c
+  rb_define_method(cDtraceProbeDesc, "probe_id",   dtraceprobedesc_probe_id, 0); // in dtrace_probedesc.c
+  rb_define_method(cDtraceProbeDesc, "provider",   dtraceprobedesc_provider, 0); // in dtrace_probedesc.c
+  rb_define_method(cDtraceProbeDesc, "mod",        dtraceprobedesc_mod,      0); // in dtrace_probedesc.c
+  rb_define_method(cDtraceProbeDesc, "func",       dtraceprobedesc_func,     0); // in dtrace_probedesc.c
+  rb_define_method(cDtraceProbeDesc, "name",       dtraceprobedesc_name,     0); // in dtrace_probedesc.c
+
+  cDtraceProbeData = rb_define_class_under(cDtrace, "ProbeData", rb_cObject);
+  rb_define_method(cDtraceProbeData, "initialize",  dtraceprobedata_init,        0); // in dtrace_probedata.c
+  rb_define_method(cDtraceProbeData, "epid",        dtraceprobedata_epid,        0); // in dtrace_probedata.c
+  rb_define_method(cDtraceProbeData, "probe",       dtraceprobedata_probe,       0); // in dtrace_probedata.c
+  rb_define_method(cDtraceProbeData, "cpu",         dtraceprobedata_cpu,         0); // in dtrace_probedata.c
+  rb_define_method(cDtraceProbeData, "indent",      dtraceprobedata_indent,      0); // in dtrace_probedata.c
+  rb_define_method(cDtraceProbeData, "prefix",      dtraceprobedata_prefix,      0); // in dtrace_probedata.c
+  rb_define_method(cDtraceProbeData, "flow",        dtraceprobedata_flow,        0); // in dtrace_probedata.c
+  rb_define_method(cDtraceProbeData, "each_record", dtraceprobedata_each_record, 0); // in dtrace_probedata.c
+
+  cDtraceBufData = rb_define_class_under(cDtrace, "BufData", rb_cObject);
+  rb_define_method(cDtraceBufData, "initialize",  dtracebufdata_init,   0); // in dtrace_bufdata.c
+  rb_define_method(cDtraceBufData, "epid",        dtracebufdata_epid,   0); // in dtrace_bufdata.c
+  rb_define_method(cDtraceBufData, "probe",       dtracebufdata_probe,  0); // in dtrace_bufdata.c
+  rb_define_method(cDtraceBufData, "record",      dtracebufdata_record, 0); // in dtrace_bufdata.c
+
+  cDtraceProgram = rb_define_class_under(cDtrace, "Program", rb_cObject);
+  rb_define_method(cDtraceProgram, "initialize",         dtraceprogram_init, 0); // in dtrace_program.c
+  rb_define_method(cDtraceProgram, "execute",            dtraceprogram_exec, 0); // in dtrace_program.c
+  rb_define_method(cDtraceProgram, "info",               dtraceprogram_info, 0); // in dtrace_program.c
+
+  cDtraceProgramInfo = rb_define_class_under(cDtrace, "ProgramInfo", rb_cObject);
+  rb_define_method(cDtraceProgramInfo, "initialize",         dtraceprograminfo_init,               0); // in dtrace_programinfo.c 
+  rb_define_method(cDtraceProgramInfo, "aggregates_count",   dtraceprograminfo_aggregates_count,   0); // in dtrace_programinfo.c
+  rb_define_method(cDtraceProgramInfo, "recgens_count",      dtraceprograminfo_recgens_count,      0); // in dtrace_programinfo.c
+  rb_define_method(cDtraceProgramInfo, "matches_count",      dtraceprograminfo_matches_count,      0); // in dtrace_programinfo.c
+  rb_define_method(cDtraceProgramInfo, "speculations_count", dtraceprograminfo_speculations_count, 0); // in dtrace_programinfo.c
+
+  cDtraceAggData = rb_define_class_under(cDtrace, "AggData", rb_cObject);
+  rb_define_method(cDtraceAggData, "initialize",         dtraceaggdata_init,    0); // in dtrace_aggdata.c 
+  rb_define_method(cDtraceAggData, "value",              dtraceaggdata_value,   0); // in dtrace_aggdata.c
+  rb_define_method(cDtraceAggData, "aggtype",            dtraceaggdata_aggtype, 0); // in dtrace_aggdata.c
+
+  cDtraceRecDesc = rb_define_class_under(cDtrace, "RecDesc", rb_cObject);
+  rb_define_method(cDtraceRecDesc, "initialize",         dtracerecdesc_init,   0); // in dtrace_recdesc.c 
+  rb_define_method(cDtraceRecDesc, "action",             dtracerecdesc_action, 0); // in dtrace_recdesc.c 
+
+  cDtraceDropData = rb_define_class_under(cDtrace, "DropData", rb_cObject);
+  rb_define_method(cDtraceDropData, "initialize",  dtracedropdata_init,   0); // in dtrace_dropdata.c 
+  rb_define_method(cDtraceDropData, "cpu",         dtracedropdata_cpu,    0); // in dtrace_dropdata.c 
+  rb_define_method(cDtraceDropData, "drops",       dtracedropdata_drops,  0); // in dtrace_dropdata.c 
+  rb_define_method(cDtraceDropData, "total",       dtracedropdata_total,  0); // in dtrace_dropdata.c 
+  rb_define_method(cDtraceDropData, "msg",         dtracedropdata_msg,    0); // in dtrace_dropdata.c 
+  rb_define_method(cDtraceDropData, "kind",        dtracedropdata_kind,   0); // in dtrace_dropdata.c 
+
+  cDtraceErrData = rb_define_class_under(cDtrace, "ErrData", rb_cObject);
+  rb_define_method(cDtraceErrData, "initialize",  dtraceerrdata_init,    0); // in dtrace_errdata.c 
+  rb_define_method(cDtraceErrData, "cpu",         dtraceerrdata_cpu,     0); // in dtrace_errdata.c 
+  rb_define_method(cDtraceErrData, "action",      dtraceerrdata_action,  0); // in dtrace_errdata.c 
+  rb_define_method(cDtraceErrData, "offset",      dtraceerrdata_offset,  0); // in dtrace_errdata.c 
+  rb_define_method(cDtraceErrData, "fault",       dtraceerrdata_fault,   0); // in dtrace_errdata.c 
+  rb_define_method(cDtraceErrData, "addr",        dtraceerrdata_addr,    0); // in dtrace_errdata.c 
+  rb_define_method(cDtraceErrData, "msg",         dtraceerrdata_msg,     0); // in dtrace_errdata.c 
+
+  cDtraceProbe = rb_define_class_under(cDtrace, "Probe", rb_cObject);
+  rb_define_method(cDtraceProbe, "initialize",        dtraceprobe_init,              1); // in dtrace_probe.c
+  rb_define_method(cDtraceProbe, "addr",              dtraceprobe_addr,              0); // in dtrace_probe.c
+  rb_define_method(cDtraceProbe, "fire",              dtraceprobe_fire,             -1); // in dtrace_probe.c
+  rb_define_method(cDtraceProbe, "is_enabled?",       dtraceprobe_is_enabled,        0); // in dtrace_probe.c
+  rb_define_method(cDtraceProbe, "probe_offset",      dtraceprobe_probe_offset,      2); // in dtrace_probe.c
+  rb_define_method(cDtraceProbe, "is_enabled_offset", dtraceprobe_is_enabled_offset, 1); // in dtrace_probe.c
+  rb_define_alloc_func(cDtraceProbe, dtraceprobe_alloc);
+  
+  eDtraceException = rb_define_class_under(cDtrace, "Exception", rb_eStandardError);
+}
+