ruby-dtrace 0.2.8 → 0.3.0

data/ext/x86_64-darwin/dtrace_probe.c

@@ -0,0 +1,177 @@
+/* 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 ARGC_MAX 6
+#define FUNC_SIZE 256
+#define IS_ENABLED_FUNC_LEN 12
+
+void install_insns(uint8_t *probe_insns, uint8_t *insns, int count)
+{
+  int i,j;
+  uint8_t *ip;
+  ip = insns;
+  for (j = 1; j <= count; j++) {
+    for (i = 0; i < 4; i++) {
+      *ip++ = *probe_insns++;
+    }
+  }
+}
+
+/* :nodoc: */
+VALUE dtraceprobe_init(VALUE self, VALUE rargc)
+{
+  dtrace_probe_t *probe;
+  uint8_t *ip;
+  int i;
+  int argc = FIX2INT(rargc);
+  uint8_t probe_insns[FUNC_SIZE];
+
+  Data_Get_Struct(self, dtrace_probe_t, probe);
+
+  /* First initialise the is_enabled tracepoint */
+  uint8_t insns[FUNC_SIZE] = {
+    0x55, 0x48, 0x89, 0xe5, 
+    0x48, 0x33, 0xc0, 0x90, 
+    0x90, 0xc9, 0xc3, 0x00
+  };
+
+  if (argc <= ARGC_MAX) {
+    {
+      uint8_t probe_insns[FUNC_SIZE] = {
+	0x55, 0x48, 0x89, 0xe5, 
+	0x90, 0x0f, 0x1f, 0x40, 
+	0x00, 0xc9, 0xc3, 0x0f, 
+	0x1f, 0x44, 0x00, 0x00
+      };
+      install_insns(probe_insns, &insns[IS_ENABLED_FUNC_LEN], 4);
+    }
+  }
+  else {
+    rb_raise(eDtraceException, "probe argc max is %d", ARGC_MAX);
+    return Qnil;
+  }
+
+  /* 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->func);
+    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 LL2NUM((uint64_t)(probe->func));
+}
+
+VALUE dtraceprobe_is_enabled(VALUE self)
+{
+  dtrace_probe_t *probe;
+  
+  Data_Get_Struct(self, dtrace_probe_t, probe);
+  return ((int)(*probe->func)()) ? Qtrue : Qfalse;
+}
+
+VALUE dtraceprobe_fire(int argc, VALUE *ruby_argv, VALUE self) {
+  dtrace_probe_t *probe;
+  int i;
+  void *argv[ARGC_MAX]; // 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);
+  (void)(*func)(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
+  
+  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;
+  offset = 6 + IS_ENABLED_FUNC_LEN;
+  probe_addr = (void *)NUM2LL(rb_funcall(self, rb_intern("addr"), 0));
+  return INT2FIX((uint64_t)probe_addr - (uint64_t)NUM2LL(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 *)NUM2LL(rb_funcall(self, rb_intern("addr"), 0));
+  return INT2FIX((uint64_t)probe_addr - (uint64_t)NUM2LL(file_addr) + 6);
+}

data/ext/x86_64-solaris/dtrace_probe.c

@@ -0,0 +1,159 @@
+/* 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 ARGC_MAX 6
+#define FUNC_SIZE 256
+#define IS_ENABLED_FUNC_LEN 8
+
+void install_insns(uint8_t *probe_insns, uint8_t *insns, int count)
+{
+  int i,j;
+  uint8_t *ip;
+  ip = insns;
+  for (j = 1; j <= count; j++) {
+    for (i = 0; i < 4; i++) {
+      *ip++ = *probe_insns++;
+    }
+  }
+}
+
+/* :nodoc: */
+VALUE dtraceprobe_init(VALUE self, VALUE rargc)
+{
+  dtrace_probe_t *probe;
+  uint8_t *ip;
+  int i;
+  int argc = FIX2INT(rargc);
+  uint8_t probe_insns[FUNC_SIZE];
+
+  Data_Get_Struct(self, dtrace_probe_t, probe);
+
+  /* First initialise the is_enabled tracepoint */
+  uint8_t insns[FUNC_SIZE] = {
+    0x48, 0x33, 0xc0, 0xc3,
+    0x90, 0x00, 0x00, 0x00
+  };
+
+  if (argc <= ARGC_MAX) {
+    {
+      uint8_t probe_insns[FUNC_SIZE] = {
+	0xc3, 0x90, 0x90, 0x90,
+	0x90, 0x00, 0x00, 0x00
+      };
+      install_insns(probe_insns, &insns[IS_ENABLED_FUNC_LEN], 2);
+    }
+  }
+  else {
+    rb_raise(eDtraceException, "probe argc max is %d", ARGC_MAX);
+    return Qnil;
+  }
+
+  /* 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->func);
+    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 LL2NUM((uint64_t)(probe->func));
+}
+
+VALUE dtraceprobe_is_enabled(VALUE self)
+{
+  dtrace_probe_t *probe;
+  
+  Data_Get_Struct(self, dtrace_probe_t, probe);
+  return ((int)(*probe->func)()) ? Qtrue : Qfalse;
+}
+
+VALUE dtraceprobe_fire(int argc, VALUE *ruby_argv, VALUE self) {
+  dtrace_probe_t *probe;
+  int i;
+  void *argv[ARGC_MAX]; // 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);
+  (void)(*func)(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
+  
+  return Qnil;
+}
+
+VALUE dtraceprobe_probe_offset(VALUE self, VALUE rfile, VALUE argc)
+{
+  return INT2FIX(IS_ENABLED_FUNC_LEN);
+}
+
+VALUE dtraceprobe_is_enabled_offset(VALUE self, VALUE rfile)
+{
+  return INT2FIX(1);
+}

data/lib/dtrace/version.rb

@@ -1,9 +1,9 @@
 #
 # Ruby-Dtrace
-# (c) 2007 Chris Andrews <chris@nodnol.org>
+# (c) 2007-2011 Chris Andrews <chris@nodnol.org>
 #
 
 class Dtrace
-  VERSION = '0.2.8'
+  VERSION = '0.3.0'
 end
 

data/test/test_dof_providers.rb

@@ -30,7 +30,9 @@ class TestDofProviders < Test::Unit::TestCase
                 :addr     => 0,
                 :nargc    => 0,
                 :func     => 6,
-                :xargc    => 0
+                :xargc    => 0,
+                :nargv    => 0,
+                :xargv    => 0
               },
              ]
     f.sections << s
@@ -229,7 +231,9 @@ class TestDofProviders < Test::Unit::TestCase
                 :addr     => 0,
                 :nargc    => 0,
                 :func     => 6,
-                :xargc    => 0
+                :xargc    => 0,
+                :nargv    => 0,
+                :xargv    => 0
               },
              ]
     f.sections << s

data/test/test_dof_strtabs.rb

@@ -38,7 +38,9 @@ class TestDofStrtabs < Test::Unit::TestCase
                 :offidx   => 0,
                 :addr     => 0,
                 :nargc    => 0,
-                :xargc    => 0
+                :xargc    => 0,
+                :nargv    => 0,
+                :xargv    => 0
               },
              ]
     f.sections << s

data/test/test_dtrace_probe.rb

@@ -47,7 +47,9 @@ class TestDtraceProbe < Test::Unit::TestCase
                 :addr     => addr,
                 :nargc    => 0,
                 :func     => 6,
-                :xargc    => 0
+                :xargc    => 0,
+                :nargv    => 0,
+                :xargv    => 0
               },
              ]
     f.sections << s
@@ -316,7 +318,9 @@ EOD
                 :addr     => addr,
                 :nargc    => 0,
                 :func     => 6,
-                :xargc    => 0
+                :xargc    => 0,
+                :nargv    => 0,
+                :xargv    => 0
               },
              ]
     f.sections << s

data/test/test_dtrace_probes.rb

@@ -185,7 +185,7 @@ EOD
     
   end
 
-  def test_all_argcs
+  def test_six_argcs
     Dtrace::Provider.create :foo5 do |p|
       p.probe :bar1, :integer
       p.probe :bar2, :integer, :integer
@@ -195,10 +195,6 @@ EOD
                      :integer
       p.probe :bar6, :integer, :integer, :integer, :integer,
                      :integer, :integer
-      p.probe :bar7, :integer, :integer, :integer, :integer,
-                     :integer, :integer, :integer
-      p.probe :bar8, :integer, :integer, :integer, :integer,
-                     :integer, :integer, :integer, :integer
     end
     
     t = Dtrace.new 
@@ -254,28 +250,6 @@ foo5*:ruby:*:bar6
   trace(arg5);
 }
 
-foo5*:ruby:*:bar7
-{
-  trace(arg0);
-  trace(arg1);
-  trace(arg2);
-  trace(arg3);
-  trace(arg4);
-  trace(arg5);
-  trace(arg6);
-}
-
-foo5*:ruby:*:bar8
-{
-  trace(arg0);
-  trace(arg1);
-  trace(arg2);
-  trace(arg3);
-  trace(arg4);
-  trace(arg5);
-  trace(arg6);
-  trace(arg7);
-}
 EOD
     
     prog = t.compile progtext
@@ -301,19 +275,13 @@ EOD
     Dtrace::Probe::Foo5.bar6 do |p|
       p.fire(61, 62, 63, 64, 65, 66)
     end
-    Dtrace::Probe::Foo5.bar7 do |p|
-      p.fire(71, 72, 73, 74, 75, 76, 77)
-    end
-   Dtrace::Probe::Foo5.bar8 do |p|
-     p.fire(81, 82, 83, 84, 85, 86, 87, 88)
-   end
 
     data = []
     c.consume_once do |d|
       data << d
     end
-
-    assert_equal 8, data.length
+    
+    assert_equal 6, data.length
 
     assert_equal 11, data[0].data[0].value
 
@@ -341,30 +309,13 @@ EOD
     assert_equal 64, data[5].data[3].value
     assert_equal 65, data[5].data[4].value
     assert_equal 66, data[5].data[5].value
-
-    assert_equal 71, data[6].data[0].value
-    assert_equal 72, data[6].data[1].value
-    assert_equal 73, data[6].data[2].value
-    assert_equal 74, data[6].data[3].value
-    assert_equal 75, data[6].data[4].value
-    assert_equal 76, data[6].data[5].value
-    assert_equal 77, data[6].data[6].value
-
-    assert_equal 81, data[7].data[0].value
-    assert_equal 82, data[7].data[1].value
-    assert_equal 83, data[7].data[2].value
-    assert_equal 84, data[7].data[3].value
-    assert_equal 85, data[7].data[4].value
-    assert_equal 86, data[7].data[5].value
-    assert_equal 87, data[7].data[6].value
-    assert_equal 88, data[7].data[7].value
     
   end
 
-  def test_all_eight_args_chars
+  def test_all_six_args_chars
     Dtrace::Provider.create :foo6 do |p|
-      p.probe :bar, :string, :string, :string, :string,
-                    :string, :string, :string, :string
+      p.probe :bar, 
+              :string, :string, :string, :string, :string, :string
     end
     
     t = Dtrace.new 
@@ -379,8 +330,6 @@ foo6*:ruby:*:bar
   trace(copyinstr(arg3));
   trace(copyinstr(arg4));
   trace(copyinstr(arg5));
-  trace(copyinstr(arg6));
-  trace(copyinstr(arg7));
 }
 EOD
     
@@ -390,8 +339,7 @@ EOD
     c = Dtrace::Consumer.new(t)
 
     Dtrace::Probe::Foo6.bar do |p|
-      p.fire('one',  'two', 'three', 'four',
-             'five', 'six', 'seven', 'eight')
+      p.fire('one',  'two', 'three', 'four', 'five', 'six')
     end    
 
     data = []
@@ -406,9 +354,6 @@ EOD
     assert_equal 'four',  data[0].data[3].value
     assert_equal 'five',  data[0].data[4].value
     assert_equal 'six',   data[0].data[5].value
-    assert_equal 'seven', data[0].data[6].value
-    assert_equal 'eight', data[0].data[7].value
-    
   end
-
+  
 end