chrisa-ruby-dtrace 0.2.0 → 0.2.1

data/examples/scsi.rb

@@ -381,7 +381,7 @@ prog.execute
 t.go
 
 begin
-  c = DtraceConsumer.new(t)
+  c = Dtrace::Consumer.new(t)
   
   c.consume do |d|
     records = d.data

data/ext/dof/header.c

@@ -9,6 +9,7 @@
 
 RUBY_EXTERN eDtraceDofException;
 
+/* :nodoc: */
 VALUE dof_generate_header(VALUE self) {
   dof_hdr_t hdr;
   uint32_t secnum;
@@ -69,6 +70,7 @@ VALUE dof_generate_header(VALUE self) {
   return hdr_data;
 }
 
+/* :nodoc: */
 VALUE dof_header_len(VALUE self) {
   uint64_t hdrlen;
   uint32_t secnum;

data/ext/dof/section.c

@@ -9,6 +9,7 @@
 
 RUBY_EXTERN eDtraceDofException;
 
+/* :nodoc: */
 VALUE dof_generate_section_header(VALUE self) {
   VALUE hdr_data;
   dof_sec_t hdr;
@@ -30,6 +31,7 @@ VALUE dof_generate_section_header(VALUE self) {
   return hdr_data;
 }
 
+/* :nodoc: */
 VALUE dof_generate_comments(VALUE self) {
   VALUE dof;
   VALUE comments = rb_iv_get(self, "@data");
@@ -45,6 +47,7 @@ VALUE dof_generate_comments(VALUE self) {
   return dof;
 }
 
+/* :nodoc: */
 VALUE dof_generate_probes(VALUE self) {
   VALUE dof;
   VALUE probes = rb_iv_get(self, "@data");
@@ -88,6 +91,7 @@ VALUE dof_generate_probes(VALUE self) {
   return dof;
 }
 
+/* :nodoc: */
 VALUE dof_generate_strtab(VALUE self) {
   VALUE dof;
   VALUE strings = rb_iv_get(self, "@data");
@@ -114,6 +118,7 @@ VALUE dof_generate_strtab(VALUE self) {
   return dof;
 }
   
+/* :nodoc: */
 VALUE dof_generate_utsname(VALUE self) {
   VALUE dof;
   struct utsname u;
@@ -127,6 +132,7 @@ VALUE dof_generate_utsname(VALUE self) {
   return dof;
 }
 
+/* :nodoc: */
 VALUE dof_generate_prargs(VALUE self) {
   VALUE dof;
   VALUE args = rb_iv_get(self, "@data");
@@ -154,6 +160,7 @@ VALUE dof_generate_prargs(VALUE self) {
   return dof;
 }
 
+/* :nodoc: */
 VALUE dof_generate_proffs(VALUE self) {
   VALUE dof;
   VALUE args = rb_iv_get(self, "@data");
@@ -179,6 +186,7 @@ VALUE dof_generate_proffs(VALUE self) {
   return dof;
 }
 
+/* :nodoc: */
 VALUE dof_generate_prenoffs(VALUE self) {
   VALUE dof;
   VALUE args = rb_iv_get(self, "@data");
@@ -220,6 +228,7 @@ dof_attr_t _dof_generate_dof_attr_t(VALUE data) {
   return attr;
 }
 
+/* :nodoc: */
 VALUE dof_generate_provider(VALUE self) {
   VALUE dof;
   VALUE provider = rb_iv_get(self, "@data");
@@ -247,6 +256,7 @@ VALUE dof_generate_provider(VALUE self) {
   return dof;
 }
 
+/* :nodoc: */
 VALUE dof_generate_reltab(VALUE self) {
   VALUE dof;
   VALUE relos = rb_iv_get(self, "@data");
@@ -281,6 +291,7 @@ VALUE dof_generate_reltab(VALUE self) {
   return dof;
 }
 
+/* :nodoc: */
 VALUE dof_generate_relhdr(VALUE self) {
   VALUE dof;
   VALUE relhdr = rb_iv_get(self, "@data");

data/ext/i386-darwin/dtrace_probe.c

@@ -0,0 +1,276 @@
+/* Ruby-Dtrace
+ * (c) 2008 Chris Andrews <chris@nodnol.org>
+ */
+
+#include "dtrace_api.h"
+
+#include <errno.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+
+RUBY_EXTERN VALUE eDtraceException;
+
+#define FUNC_SIZE 128 /* 32 bytes of is_enabled, plus then good for 16
+			 arguments: 16 + 7 * argc */
+#define IS_ENABLED_FUNC_LEN 32
+
+/* :nodoc: */
+VALUE dtraceprobe_init(VALUE self, VALUE rargc)
+{
+  dtrace_probe_t *probe;
+  uint8_t *ip;
+  int i;
+  int argc = FIX2INT(rargc);
+
+  Data_Get_Struct(self, dtrace_probe_t, probe);
+
+  /* First initialise the is_enabled tracepoint */
+  uint8_t insns[FUNC_SIZE] = {
+    0x55, 0x89, 0xe5, 0x83, 0xec, 0x08,
+    0x33, 0xc0,
+    0x90, 0x90, 0x90,
+    0xc9, 0xc3
+  };
+
+#define OP_PUSHL_EBP      0x55
+#define OP_MOVL_ESP_EBP_U 0x89
+#define OP_MOVL_ESP_EBP_L 0xe5
+#define OP_SUBL_N_ESP_U   0x83
+#define OP_SUBL_N_ESP_L   0xec
+#define OP_PUSHL_N_EBP_U  0xff
+#define OP_PUSHL_N_EBP_L  0x75
+#define OP_NOP            0x90
+#define OP_ADDL_ESP_U     0x83
+#define OP_ADDL_ESP_L     0xc4
+#define OP_LEAVE          0xc9
+#define OP_RET            0xc3
+#define OP_MOVL_EAX_U     0x8b
+#define OP_MOVL_EAX_L     0x45
+#define OP_MOVL_ESP       0x89
+
+  /* Set up probe function */
+  ip = insns + IS_ENABLED_FUNC_LEN;
+
+  *ip++ = OP_PUSHL_EBP;
+  *ip++ = OP_MOVL_ESP_EBP_U;
+  *ip++ = OP_MOVL_ESP_EBP_L;
+  *ip++ = OP_SUBL_N_ESP_U;
+  *ip++ = OP_SUBL_N_ESP_L;
+
+  switch(argc) {
+  case 0:
+  case 1:
+  case 2:
+  case 3:
+  case 4:
+  case 5:
+  case 6:
+    *ip++ = 0x18;
+    break;
+  case 7:
+  case 8:
+    *ip++ = 0x28;
+    break;
+  }
+
+  /* args */
+  for (i = (4*argc - 4); i >= 0; i -= 4) {
+    /* mov 0xN(%ebp),%eax */
+    *ip++ = OP_MOVL_EAX_U;
+    *ip++ = OP_MOVL_EAX_L;
+    *ip++ = i + 8; 
+    /* mov %eax,N(%esp) */
+    *ip++ = OP_MOVL_ESP;
+    if (i > 0) {
+      *ip++ = 0x44;
+      *ip++ = 0x24;
+      *ip++ = i;
+    }
+    else {
+      *ip++ = 0x04;
+      *ip++ = 0x24;
+    }
+  }
+  
+  /* tracepoint */
+  *ip++ = 0x90;
+  *ip++ = 0x0f;
+  *ip++ = 0x1f;
+  *ip++ = 0x40;
+  *ip++ = 0x00;
+
+  /* ret */
+  *ip++ = OP_LEAVE;
+  *ip++ = OP_RET;
+
+  /* allocate memory on a page boundary, for mprotect */
+  probe->func = (void *)valloc(FUNC_SIZE);
+  if (probe->func < 0) {
+    rb_raise(eDtraceException, "malloc failed: %s\n", strerror(errno));
+    return Qnil;
+  }
+  
+  if ((mprotect((void *)probe->func, FUNC_SIZE, PROT_READ | PROT_WRITE | PROT_EXEC)) < 0) {
+    rb_raise(eDtraceException, "mprotect failed: %s\n", strerror(errno));
+    return Qnil;
+  }
+  
+  if ((memcpy(probe->func, insns, FUNC_SIZE)) < 0) {
+    rb_raise(eDtraceException, "memcpy failed: %s\n", strerror(errno));
+    return Qnil;
+  }    
+  
+  return self;
+}
+
+VALUE dtraceprobe_free(void *arg)
+{
+  dtrace_probe_t *probe = (dtrace_probe_t *)arg;
+  
+  if (probe) {
+    free(probe);
+  }
+}
+ 
+VALUE dtraceprobe_alloc(VALUE klass)
+{
+  VALUE obj;
+  dtrace_probe_t *probe;
+
+  probe = ALLOC(dtrace_probe_t);
+  if (!probe) {
+    rb_raise(eDtraceException, "alloc failed");
+    return Qnil;
+  }
+
+  /* no mark function: no ruby objects hung off this struct */
+  obj = Data_Wrap_Struct(klass, NULL, dtraceprobe_free, probe);
+  return obj;
+}
+
+/*
+ * Returns the address of the probe's generated code.
+ */
+VALUE dtraceprobe_addr(VALUE self)
+{
+  dtrace_probe_t *probe;
+  
+  Data_Get_Struct(self, dtrace_probe_t, probe);
+  return INT2FIX(probe->func);
+}
+
+/*
+ * Returns whether or not this probe is currently enabled, by invoking
+ * the is-enabled tracepoint attached to the probe.
+ */
+VALUE dtraceprobe_is_enabled(VALUE self)
+{
+  dtrace_probe_t *probe;
+  
+  Data_Get_Struct(self, dtrace_probe_t, probe);
+  return INT2FIX((int)(*probe->func)());
+}
+
+/*
+ * Fires the probe, converting arguments based on the data provided -
+ * no validation is done against the probe's declared types.
+ */
+VALUE dtraceprobe_fire(int argc, VALUE *ruby_argv, VALUE self) {
+  dtrace_probe_t *probe;
+  int i;
+  void *argv[8]; // probe argc max for now.
+  void (*func)();
+
+  Data_Get_Struct(self, dtrace_probe_t, probe);
+
+  /* munge Ruby values to either char *s or ints. */
+  for (i = 0; i < argc; i++) {
+    switch (TYPE(ruby_argv[i])) {
+    case T_STRING:
+      argv[i] = (void *)RSTRING(ruby_argv[i])->ptr;
+      break;
+    case T_FIXNUM:
+      argv[i] = (void *)FIX2INT(ruby_argv[i]);
+      break;
+    default:
+      rb_raise(eDtraceException, "type of arg[%d] is not string or fixnum", i);
+      break;
+    }
+  }
+  
+  func = (void (*)())(probe->func + IS_ENABLED_FUNC_LEN);
+
+  switch (argc) {
+  case 0:
+    (void)(*func)();
+    break;
+  case 1:
+    (void)(*func)(argv[0]);
+    break;
+  case 2:
+    (void)(*func)(argv[0], argv[1]);
+    break;
+  case 3:
+    (void)(*func)(argv[0], argv[1], argv[2]);
+    break;
+  case 4:
+    (void)(*func)(argv[0], argv[1], argv[2], argv[3]);
+    break;
+  case 5:
+    (void)(*func)(argv[0], argv[1], argv[2], argv[3], 
+		  argv[4]);
+    break;
+  case 6:
+    (void)(*func)(argv[0], argv[1], argv[2], argv[3],
+		  argv[4], argv[5]);
+    break;
+  case 7:
+    (void)(*func)(argv[0], argv[1], argv[2], argv[3],
+		  argv[4], argv[5], argv[6]);
+    break;
+  case 8:
+    (void)(*func)(argv[0], argv[1], argv[2], argv[3],
+		  argv[4], argv[5], argv[6], argv[7]);
+    break;
+  default:
+    rb_raise(eDtraceException, "probe argc max is 8");
+    break;
+  }
+  
+  return Qnil;
+}
+
+/* 
+ * Returns the offset for this probe in the PROFFS section, based on
+ * the location of the DOF, and the location of this probe.
+ */
+VALUE dtraceprobe_probe_offset(VALUE self, VALUE file_addr, VALUE argc)
+{
+  void *probe_addr;
+  int offset;
+  probe_addr = (void *)FIX2INT(rb_funcall(self, rb_intern("addr"), 0));
+  switch FIX2INT(argc) {
+    case 0:
+      offset = 40; /* 32 + 6 + 2 */
+      break;
+    case 1:
+      offset = 46; /* 32 + 6 + 6 + 2 */
+      break;
+    default:
+      offset = 46 + (FIX2INT(argc)-1) * 7; /* 32 + 6 + 6 + 7 per subsequent arg + 2 */
+      break;
+    }
+  return INT2FIX((int)probe_addr - (int)FIX2INT(file_addr) + offset);
+}
+
+/* 
+ * Returns the offset for this probe's is-enabled tracepoint in the
+ * PRENOFFS section, based on the location of the DOF, and the
+ * location of this probe.
+ */
+VALUE dtraceprobe_is_enabled_offset(VALUE self, VALUE file_addr)
+{
+  void *probe_addr;
+  probe_addr = (void *)FIX2INT(rb_funcall(self, rb_intern("addr"), 0));
+  return INT2FIX((int)probe_addr - (int)FIX2INT(file_addr) + 8);
+}

data/ext/i386-solaris/dtrace_probe.c

@@ -0,0 +1,225 @@
+/* Ruby-Dtrace
+ * (c) 2008 Chris Andrews <chris@nodnol.org>
+ */
+
+#include "dtrace_api.h"
+
+#include <errno.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+
+RUBY_EXTERN VALUE eDtraceException;
+
+#define FUNC_SIZE 96 /* 32 bytes of is_enabled, plus then good for 16
+			arguments: 16 + 3 * argc */
+#define IS_ENABLED_FUNC_LEN 32
+
+/* :nodoc: */
+VALUE dtraceprobe_init(VALUE self, VALUE rargc)
+{
+  dtrace_probe_t *probe;
+  uint8_t *ip;
+  int i;
+  int argc = FIX2INT(rargc);
+
+  Data_Get_Struct(self, dtrace_probe_t, probe);
+
+  /* First initialise the is_enabled tracepoint */
+  uint8_t insns[FUNC_SIZE] = {
+    0x55, 0x89, 0xe5, 0x83, 0xec, 0x08,
+    0x33, 0xc0,
+    0x90, 0x90, 0x90,
+    0x89, 0x45, 0xfc, 0x83, 0x7d, 0xfc,
+    0x00, 0x0f, 0x95, 0xc0, 0x0f, 0xb6,
+    0xc0, 0x89, 0x45, 0xfc, 0x8b, 0x45,
+    0xfc, 
+    0xc9, 0xc3
+  };
+
+#define OP_PUSHL_EBP     0x55
+#define OP_MOVL_ESP_EBP  0x89, 0xe5
+#define OP_SUBL_N_ESP    0x83, 0xec
+#define OP_PUSHL_N_EBP_U 0xff
+#define OP_PUSHL_N_EBP_L 0x75
+#define OP_NOP           0x90
+#define OP_ADDL_ESP_U    0x83
+#define OP_ADDL_ESP_L    0xc4
+#define OP_LEAVE         0xc9
+#define OP_RET           0xc3
+
+  /* Set up probe function */
+  ip = insns + IS_ENABLED_FUNC_LEN;
+
+  uint8_t func_in[7] = {
+    OP_PUSHL_EBP, OP_MOVL_ESP_EBP, OP_SUBL_N_ESP, 0x08, NULL
+
+  };
+  
+  uint8_t func_out[3] = {
+    OP_LEAVE, OP_RET, NULL
+  };
+  
+  for (i = 0; func_in[i]; i++)
+    *ip++ = func_in[i];
+
+  for (i = (4 + 4*argc); i >= 0x08; i -= 4) {
+    *ip++ = OP_PUSHL_N_EBP_U;
+    *ip++ = OP_PUSHL_N_EBP_L;
+    *ip++ = i;
+  }
+
+  for (i = 0; i <=5; i++)
+    *ip++ = OP_NOP;
+
+  *ip++ = OP_ADDL_ESP_U;
+  *ip++ = OP_ADDL_ESP_L;
+  *ip++ = argc * 4;
+  
+  for (i = 0; func_out[i]; i++)
+    *ip++ = func_out[i];
+
+  /* allocate memory on a page boundary, for mprotect */
+  probe->func = (void *)memalign(PAGESIZE, FUNC_SIZE);
+  if (probe->func < 0) {
+    rb_raise(eDtraceException, "malloc failed: %s\n", strerror(errno));
+    return Qnil;
+  }
+  
+  if ((mprotect((void *)probe->func, FUNC_SIZE, PROT_READ | PROT_WRITE | PROT_EXEC)) < 0) {
+    rb_raise(eDtraceException, "mprotect failed: %s\n", strerror(errno));
+    return Qnil;
+  }
+  
+  if ((memcpy(probe->func, insns, FUNC_SIZE)) < 0) {
+    rb_raise(eDtraceException, "memcpy failed: %s\n", strerror(errno));
+    return Qnil;
+  }    
+  
+  return self;
+}
+
+VALUE dtraceprobe_free(void *arg)
+{
+  dtrace_probe_t *probe = (dtrace_probe_t *)arg;
+  
+  if (probe) {
+    free(probe);
+  }
+}
+ 
+VALUE dtraceprobe_alloc(VALUE klass)
+{
+  VALUE obj;
+  dtrace_probe_t *probe;
+
+  probe = ALLOC(dtrace_probe_t);
+  if (!probe) {
+    rb_raise(eDtraceException, "alloc failed");
+    return Qnil;
+  }
+
+  /* no mark function: no ruby objects hung off this struct */
+  obj = Data_Wrap_Struct(klass, NULL, dtraceprobe_free, probe);
+  return obj;
+}
+
+VALUE dtraceprobe_addr(VALUE self)
+{
+  dtrace_probe_t *probe;
+  
+  Data_Get_Struct(self, dtrace_probe_t, probe);
+  return INT2FIX(probe->func);
+}
+
+VALUE dtraceprobe_is_enabled(VALUE self)
+{
+  dtrace_probe_t *probe;
+  
+  Data_Get_Struct(self, dtrace_probe_t, probe);
+  return INT2FIX((int)(*probe->func)());
+}
+
+VALUE dtraceprobe_fire(int argc, VALUE *ruby_argv, VALUE self) {
+  dtrace_probe_t *probe;
+  int i;
+  void *argv[8]; // probe argc max for now.
+  void (*func)();
+
+  Data_Get_Struct(self, dtrace_probe_t, probe);
+
+  /* munge Ruby values to either char *s or ints. */
+  for (i = 0; i < argc; i++) {
+    switch (TYPE(ruby_argv[i])) {
+    case T_STRING:
+      argv[i] = (void *)RSTRING(ruby_argv[i])->ptr;
+      break;
+    case T_FIXNUM:
+      argv[i] = (void *)FIX2INT(ruby_argv[i]);
+      break;
+    default:
+      rb_raise(eDtraceException, "type of arg[%d] is not string or fixnum", i);
+      break;
+    }
+  }
+  
+  func = (void (*)())(probe->func + IS_ENABLED_FUNC_LEN);
+
+  switch (argc) {
+  case 0:
+    (void)(*func)();
+    break;
+  case 1:
+    (void)(*func)(argv[0]);
+    break;
+  case 2:
+    (void)(*func)(argv[0], argv[1]);
+    break;
+  case 3:
+    (void)(*func)(argv[0], argv[1], argv[2]);
+    break;
+  case 4:
+    (void)(*func)(argv[0], argv[1], argv[2], argv[3]);
+    break;
+  case 5:
+    (void)(*func)(argv[0], argv[1], argv[2], argv[3], 
+		  argv[4]);
+    break;
+  case 6:
+    (void)(*func)(argv[0], argv[1], argv[2], argv[3],
+		  argv[4], argv[5]);
+    break;
+  case 7:
+    (void)(*func)(argv[0], argv[1], argv[2], argv[3],
+		  argv[4], argv[5], argv[6]);
+    break;
+  case 8:
+    (void)(*func)(argv[0], argv[1], argv[2], argv[3],
+		  argv[4], argv[5], argv[6], argv[7]);
+    break;
+  default:
+    rb_raise(eDtraceException, "probe argc max is 8");
+    break;
+  }
+  
+  return Qnil;
+}
+
+VALUE dtraceprobe_probe_offset(VALUE self, VALUE rfile, VALUE argc)
+{
+  /*
+   * compute offset into stub: see dtrace_probe.c
+   *
+   * 32 bytes - length of is_enabled function
+   * +
+   * 6 bytes - function entry
+   * +
+   * 3 bytes per argument - arg->stack push
+   *
+   */
+  return INT2FIX(32 + 6 + FIX2INT(argc) * 3);
+}
+
+VALUE dtraceprobe_is_enabled_offset(VALUE self, VALUE rfile)
+{
+  return INT2FIX(8);
+}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: chrisa-ruby-dtrace
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors: 
 - Chris Andrews
@@ -17,8 +17,9 @@ description:
 email: chris@nodnol.org
 executables: []
 
-extensions: []
-
+extensions: 
+- ext/extconf.rb
+- ext/dof/extconf.rb
 extra_rdoc_files: []
 
 files: 
@@ -44,7 +45,6 @@ files:
 - ext/dtrace_dropdata.c
 - ext/dtrace_errdata.c
 - ext/dtrace_hdl.c
-- ext/dtrace_probe.c
 - ext/dtrace_probedata.c
 - ext/dtrace_probedesc.c
 - ext/dtrace_process.c
@@ -53,12 +53,10 @@ files:
 - ext/dtrace_recdesc.c
 - ext/dtrace_util.c
 - ext/extconf.rb
-- ext/i386-solaris2.11
-- ext/i386-solaris2.11/dtrace_probe.c
-- ext/i686-darwin8.10.1
-- ext/i686-darwin8.10.1/dtrace_probe.c
-- ext/sparc-solaris2.10
-- ext/sparc-solaris2.10/dtrace_probe.c
+- ext/i386-solaris
+- ext/i386-solaris/dtrace_probe.c
+- ext/i386-darwin
+- ext/i386-darwin/dtrace_probe.c
 - ext/stubs.txt
 - lib/dtrace
 - lib/dtrace/aggregate.rb
@@ -82,7 +80,6 @@ files:
 - lib/dtrace/stackrecord.rb
 - lib/dtrace/tracer.rb
 - lib/dtrace/version.rb
-- lib/dtrace/version.rb~
 - lib/dtrace.rb
 - lib/dtraceconsumer.rb
 - plugin/dtrace
@@ -142,6 +139,7 @@ rdoc_options: []
 
 require_paths: 
 - lib
+- ext
 required_ruby_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
@@ -160,6 +158,6 @@ rubyforge_project: ruby-dtrace
 rubygems_version: 1.0.1
 signing_key: 
 specification_version: 2
-summary: ruby-dtrace is Ruby bindings for Dtrace, which lets you write D-based programs in Ruby, and add probes to your Ruby programs.
+summary: Ruby-DTrace is Ruby bindings for Dtrace, which allows you to add DTrace probes to your Ruby programs, and to write D-based programs with Ruby.
 test_files: []