ruby-dtrace 0.2.8 → 0.3.0

data/History.txt

@@ -1,3 +1,9 @@
+== 0.3.0 / 2011-01-31
+
+ * Fix build on Ruby 1.8.7 (thanks to Laust Rud Jacobsen)
+ * Add x86_64 ports for Solaris and Mac OS X 10.6
+ * Add Universal build for Mac OS X /usr/bin/ruby
+
 == 0.2.8 / 2009-07-23
 
  * Replace string-eval provider class creation 

data/README.txt

@@ -63,12 +63,11 @@ Probes: see Dtrace::Provider
 == REQUIREMENTS
 
 * For the consumer API, platform with DTrace support (OpenSolaris, Mac
-  OS X 10.5 Leopard tested, possibly also FreeBSD).
+  OS X 10.5 Leopard and 10.6 Snow Leopard tested, possibly also FreeBSD).
 
 * For the probe API, a platform with DTrace support (as for the
-  consumer API), with a 32 bit Ruby build - i386, PowerPC (for OS X)
-  and SPARC (for Solaris) are all supported. 64 bit builds are not,
-  yet.
+  consumer API), with a 32 bit or 64 bit Ruby build - i386/x86_64,
+  PowerPC (for OS X) and SPARC (for Solaris) are all supported.
   
 * root, or some/all of the dtrace privileges on Solaris: dtrace_user,
   dtrace_proc and dtrace_kernel.
@@ -79,7 +78,7 @@ Probes: see Dtrace::Provider
 
 == LICENSE
 
-Copyright (c) 2008, 2009 Chris Andrews <chris@nodnol.org>
+Copyright (c) 2008, 2009, 2011 Chris Andrews <chris@nodnol.org>
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/ext/dof/Makefile

@@ -4,63 +4,65 @@ SHELL = /bin/sh
 #### Start of system configuration section. ####
 
 srcdir = .
-topdir = /opt/local/lib/ruby/1.8/i686-darwin9.7.0
+topdir = /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/1.8/universal-darwin10.0
 hdrdir = $(topdir)
 VPATH = $(srcdir):$(topdir):$(hdrdir)
-prefix = $(DESTDIR)/opt/local
 exec_prefix = $(prefix)
-sitedir = $(prefix)/lib/ruby/site_ruby
-rubylibdir = $(libdir)/ruby/$(ruby_version)
-docdir = $(datarootdir)/doc/$(PACKAGE)
-dvidir = $(docdir)
-datarootdir = $(prefix)/share
-archdir = $(rubylibdir)/$(arch)
-sbindir = $(exec_prefix)/sbin
+prefix = $(DESTDIR)/System/Library/Frameworks/Ruby.framework/Versions/1.8/usr
+sharedstatedir = $(prefix)/com
+mandir = $(DESTDIR)/usr/share/man
 psdir = $(docdir)
-vendordir = $(prefix)/lib/ruby/vendor_ruby
+oldincludedir = $(DESTDIR)/usr/include
 localedir = $(datarootdir)/locale
+bindir = $(exec_prefix)/bin
+libexecdir = $(exec_prefix)/libexec
+sitedir = $(DESTDIR)/Library/Ruby/Site
 htmldir = $(docdir)
-datadir = $(datarootdir)
+vendorarchdir = $(vendorlibdir)/$(sitearch)
 includedir = $(prefix)/include
-infodir = $(datarootdir)/info
+infodir = $(DESTDIR)/usr/share/info
+vendorlibdir = $(vendordir)/$(ruby_version)
 sysconfdir = $(prefix)/etc
 libdir = $(exec_prefix)/lib
-mandir = $(DESTDIR)/opt/local/share/man
-sharedstatedir = $(prefix)/com
-oldincludedir = $(DESTDIR)/usr/include
+sbindir = $(exec_prefix)/sbin
+rubylibdir = $(libdir)/ruby/$(ruby_version)
+docdir = $(datarootdir)/doc/$(PACKAGE)
+dvidir = $(docdir)
+vendordir = $(libdir)/ruby/vendor_ruby
+datarootdir = $(prefix)/share
 pdfdir = $(docdir)
+archdir = $(rubylibdir)/$(arch)
 sitearchdir = $(sitelibdir)/$(sitearch)
-vendorarchdir = $(vendorlibdir)/$(vendorarch)
+datadir = $(datarootdir)
 localstatedir = $(prefix)/var
-bindir = $(exec_prefix)/bin
-vendorlibdir = $(vendordir)/$(ruby_version)
 sitelibdir = $(sitedir)/$(ruby_version)
-libexecdir = $(exec_prefix)/libexec
 
-CC = /usr/bin/gcc-4.0
+CC = gcc
 LIBRUBY = $(LIBRUBY_SO)
 LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
 LIBRUBYARG_SHARED = -l$(RUBY_SO_NAME)
-LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)-static
+LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)
 
 RUBY_EXTCONF_H = 
-CFLAGS   =  -fno-common -O2  -fno-common -pipe -fno-common -D_LONGLONG_TYPE -g 
+CFLAGS   =  -fno-common -arch i386 -arch x86_64 -g -Os -pipe -fno-common -DENABLE_DTRACE  -fno-common  -pipe -fno-common $(cflags) -D_LONGLONG_TYPE -g 
 INCFLAGS = -I. -I$(topdir) -I$(hdrdir) -I$(srcdir)
 DEFS     = 
-CPPFLAGS = -DHAVE_SYS_DTRACE_H -I/opt/local/include $(DEFS)
+CPPFLAGS = -DHAVE_SYS_DTRACE_H  -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE $(DEFS) $(cppflags)
 CXXFLAGS = $(CFLAGS) 
-DLDFLAGS = -L. -L/opt/local/lib  
-LDSHARED = cc -dynamic -bundle -undefined suppress -flat_namespace
+ldflags  = -L. -arch i386 -arch x86_64 
+dldflags = 
+archflag = 
+DLDFLAGS = $(ldflags) $(dldflags) $(archflag)
+LDSHARED = cc -arch i386 -arch x86_64 -pipe -bundle -undefined dynamic_lookup
 AR = ar
 EXEEXT = 
 
 RUBY_INSTALL_NAME = ruby
 RUBY_SO_NAME = ruby
-arch = i686-darwin9.7.0
-sitearch = i686-darwin9.7.0
-vendorarch = i686-darwin9.7.0
+arch = universal-darwin10.0
+sitearch = universal-darwin10.0
 ruby_version = 1.8
-ruby = /opt/local/bin/ruby
+ruby = /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/bin/ruby
 RUBY = $(ruby)
 RM = rm -f
 MAKEDIRS = mkdir -p
@@ -84,7 +86,7 @@ extout =
 extout_prefix = 
 target_prefix = 
 LOCAL_LIBS = 
-LIBS = $(LIBRUBYARG_SHARED)  -lpthread -ldl -lobjc  
+LIBS = $(LIBRUBYARG_SHARED)  -lpthread -ldl  
 SRCS = constants.c dof_api.c dof_helper.c file.c generator.c header.c parser.c section.c
 OBJS = constants.o dof_api.o dof_helper.o file.o generator.o header.o parser.o section.o
 TARGET = dof_api
@@ -92,6 +94,7 @@ DLLIB = $(TARGET).bundle
 EXTSTATIC = 
 STATIC_LIB = 
 
+BINDIR        = $(bindir)
 RUBYCOMMONDIR = $(sitedir)$(target_prefix)
 RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
 RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
@@ -145,7 +148,7 @@ site-install-rb: install-rb
 .c.o:
 	$(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) -c $<
 
-$(DLLIB): $(OBJS) Makefile
+$(DLLIB): $(OBJS)
 	@-$(RM) $@
 	$(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
 

data/ext/dof/parser.c

@@ -145,7 +145,7 @@ _dof_parse_dof_probe_t_array(VALUE self, char *dof, dof_sec_t *sec)
     count++;
 
     probe_data = rb_hash_new();
-    sprintf(addr_str, "%p", probe.dofpr_addr);
+    sprintf(addr_str, "%p", (void *)probe.dofpr_addr);
     rb_hash_aset(probe_data, ID2SYM(rb_intern("addr")), rb_str_new2(addr_str));
     rb_hash_aset(probe_data, ID2SYM(rb_intern("func")), rb_hash_aref(strtab, INT2FIX(probe.dofpr_func)));
     rb_hash_aset(probe_data, ID2SYM(rb_intern("name")), rb_hash_aref(strtab, INT2FIX(probe.dofpr_name)));

data/ext/dof/section.c

@@ -69,12 +69,12 @@ VALUE dof_generate_probes(VALUE self) {
     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_addr  =     (uint64_t)NUM2LL(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"))));

data/ext/dtrace_hdl.c

@@ -77,7 +77,7 @@ VALUE dtrace_hdl_alloc(VALUE klass)
     return obj;
   }
   else {
-    rb_raise(eDtraceException, "unable to open dtrace (not root?)");
+    rb_raise(eDtraceException, "unable to open dtrace: %s (not root?)", strerror(err));
   }
 }
 
@@ -440,7 +440,10 @@ VALUE dtrace_hdl_work(int argc, VALUE *argv, VALUE self)
   handlers.rec    = rec_consumer;
   handlers.handle = self;
 
-  status = dtrace_work(handle->hdl, NULL, _probe_consumer, _rec_consumer, &handlers);
+  FILE *devnull = fopen("/dev/null", "w");
+  status = dtrace_work(handle->hdl, devnull, _probe_consumer, _rec_consumer, &handlers);
+  fclose(devnull);
+
   if (status < 0)
     rb_raise(eDtraceException, (dtrace_errmsg(handle->hdl, dtrace_errno(handle->hdl))));
 

data/ext/dtrace_probe.c

@@ -0,0 +1,10 @@
+/* Ruby-Dtrace
+ * (c) 2008-2011 Chris Andrews <chris@nodnol.org>
+ */
+
+/*
+ * dtrace_probe.c is built for the target architecture from one of the
+ * variants in the per-arch subdirectories. See extconf.rb for build 
+ * details.
+ *
+ */

data/ext/extconf.rb

@@ -1,29 +1,72 @@
 require 'mkmf'
 require 'rbconfig'
 
-def symlink(old, new)
-  begin
-    File.symlink(old, new)
-  rescue Errno::EEXIST
-    File.unlink(new)
-    retry
-  end
-end
+$CFLAGS += " -D_LONGLONG_TYPE"
 
-$CFLAGS += " -D_LONGLONG_TYPE -g"
-have_library("dtrace", "dtrace_open")
+# Need to specify full path to dtrace.h or we'll pick up ruby's
+# dtrace.h on Solaris or other builds with the runtime probes included.
+have_library("dtrace", "dtrace_open", "/usr/include/dtrace.h")
 
-# Update machine-dependent symlinks in the source, based on $Config::CONFIG and `uname -p`
+# Figure out target platform
 os  = Config::CONFIG['target_os']
 os.gsub!  /[0-9.]+$/, ''
 
-# On OSX, this is "powerpc", even on Intel...
-#cpu = Config::CONFIG['target_cpu']
+# Snow Leopard handling: detect Universal build and invoke dual build of dtrace_probe.c
 cpu = `uname -p`.chomp
+if cpu == "i386"
+  ldflags = Config::CONFIG['LDFLAGS']
+  if ldflags =~ /i386/ && ldflags =~ /x86_64/
+    puts "Universal build detected"
+    apple_universal = true
+  end
+end
+
+arch = "#{cpu}-#{os}"
 
-dir = "#{cpu}-#{os}"
-symlink "#{dir}/dtrace_probe.c", "dtrace_probe.c"
+# Set up generated Makefile to build everything except dtrace_probe.c
+$srcs = %w{ dtrace_aggdata.c
+            dtrace_dropdata.c
+            dtrace_process.c
+            dtrace_recdesc.c
+            dtrace_api.c
+            dtrace_errdata.c
+            dtrace_probedata.c
+            dtrace_program.c
+            dtrace_util.c
+            dtrace_bufdata.c
+            dtrace_hdl.c
+            dtrace_probedesc.c
+            dtrace_programinfo.c
+           }
+
+$objs = []
+for f in $srcs
+  obj = File.basename(f, ".*") << ".o"
+  $objs.push(obj)
+end
+
+$objs.push "dtrace_probe.o"
 
 # Create makefile in the usual way
 create_makefile("dtrace_api")
 
+# Then append rule(s) to create dtrace_probe.c
+begin
+  mfile = open("Makefile", "ab")
+  mfile.puts
+  
+  if apple_universal
+    # create i386 .o and x86_64.o
+    mfile.print "dtrace_probe_i386-darwin.o:\n\t$(CC) $(INCFLAGS) -arch i386 -o dtrace_probe_i386-darwin.o -c i386-darwin/dtrace_probe.c\n\n"
+    mfile.print "dtrace_probe_x86_64-darwin.o:\n\t$(CC) $(INCFLAGS) -arch x86_64 -o dtrace_probe_x86_64-darwin.o  -c x86_64-darwin/dtrace_probe.c\n\n"
+
+    # link those into a universal dtrace_probe.o
+    mfile.print "dtrace_probe.o: dtrace_probe_i386-darwin.o dtrace_probe_x86_64-darwin.o\n" +
+                "\tlipo -create -output dtrace_probe.o dtrace_probe_x86_64-darwin.o dtrace_probe_i386-darwin.o"
+  else
+    # just selected arch
+    mfile.print "dtrace_probe.o:\n\t$(CC) $(INCFLAGS) $(CXXFLAGS) -c #{arch}/dtrace_probe.c\n\n"
+  end
+ensure
+  mfile.close
+end

data/ext/i386-darwin/dtrace_probe.c

@@ -250,8 +250,8 @@ 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) {
+  probe_addr = (void *)FIX2UINT(rb_funcall(self, rb_intern("addr"), 0));
+  switch (FIX2INT(argc)) {
     case 0:
       offset = 40; /* 32 + 6 + 2 */
       break;
@@ -262,7 +262,7 @@ VALUE dtraceprobe_probe_offset(VALUE self, VALUE file_addr, VALUE argc)
       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);
+  return INT2FIX((uint32_t)probe_addr - (uint32_t)FIX2UINT(file_addr) + offset);
 }
 
 /* 

data/ext/powerpc-darwin/dtrace_probe.c

@@ -0,0 +1,470 @@
+/* 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 256
+#define IS_ENABLED_FUNC_LEN 32
+
+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] = {
+    /* stmw    r30,0xfff8(r1) */
+    0xbf, 0xc1, 0xff, 0xf8, 
+    /* stwu    r1,0xffd0(r1) */
+    0x94, 0x21, 0xff, 0xd0, 
+    /* or      r30,r1,r1 */
+    0x7c, 0x3e, 0x0b, 0x78, 
+    /* li      r0,0x0 */
+    0x38, 0x00, 0x00, 0x00,
+    /* or      r3,r0,r0 */
+    0x7c, 0x03, 0x03, 0x78, 
+    /* lwz     r1,0x0(r1) */
+    0x80, 0x21, 0x00, 0x00, 
+    /* lmw     r30,0xfff8(r1) */
+    0xbb, 0xc1, 0xff, 0xf8, 
+    /* blr */
+    0x4e, 0x80, 0x00, 0x20
+  };
+
+  /* Now build probe tracepoint */
+  switch (argc) {
+
+  case 0:
+    {
+      uint8_t probe_insns[FUNC_SIZE] = {
+	/* stmw    r30,0xfff8(r1) */
+	0xbf, 0xc1, 0xff, 0xf8, 
+	/* stwu    r1,0xffd0(r1) */
+	0x94, 0x21, 0xff, 0xd0, 
+	/* or      r30,r1,r1 */
+	0x7c, 0x3e, 0x0b, 0x78, 
+	/* lwz     r1,0x0(r1) */
+	0x80, 0x21, 0x00, 0x00,
+	/* lmw     r30,0xfff8(r1) */
+	0xbb, 0xc1, 0xff, 0xf8, 
+	/* blr */
+	0x4e, 0x80, 0x00, 0x20	
+      };
+      install_insns(probe_insns, &insns[IS_ENABLED_FUNC_LEN], 6);
+    }
+    break;
+
+  case 1:
+    {
+      uint8_t probe_insns[FUNC_SIZE] = {
+	/* stmw    r30,0xfff8(r1) */
+	0xbf, 0xc1, 0xff, 0xf8, 
+	/* stwu    r1,0xffd0(r1) */
+	0x94, 0x21, 0xff, 0xd0, 
+	/* or      r30,r1,r1 */
+	0x7c, 0x3e, 0x0b, 0x78,
+	/* stw     r3,0x48(r30) */
+	0x90, 0x7e, 0x00, 0x48, 
+	/* lwz     r1,0x0(r1) */
+	0x80, 0x21, 0x00, 0x00, 
+	/* lmw     r30,0xfff8(r1) */
+	0xbb, 0xc1, 0xff, 0xf8,
+	/* blr */
+	0x4e, 0x80, 0x00, 0x20
+      };
+      install_insns(probe_insns, &insns[IS_ENABLED_FUNC_LEN], 7);
+    }
+    break;
+
+  case 2:
+    {
+      uint8_t probe_insns[FUNC_SIZE] = {
+	/* stmw    r30,0xfff8(r1) */
+	0xbf, 0xc1, 0xff, 0xf8, 
+	/* stwu    r1,0xffd0(r1) */
+	0x94, 0x21, 0xff, 0xd0, 
+	/* or      r30,r1,r1 */
+	0x7c, 0x3e, 0x0b, 0x78, 
+	/* stw     r3,0x48(r30) */
+	0x90, 0x7e, 0x00, 0x48, 
+	/* stw     r4,0x4c(r30) */
+	0x90, 0x9e, 0x00, 0x4c, 
+	/* lwz     r1,0x0(r1) */
+	0x80, 0x21, 0x00, 0x00, 
+	/* lmw     r30,0xfff8(r1) */
+	0xbb, 0xc1, 0xff, 0xf8, 
+	/* blr */
+	0x4e, 0x80, 0x00, 0x20
+      };
+      install_insns(probe_insns, &insns[IS_ENABLED_FUNC_LEN], 8);
+    }
+    break;
+
+  case 3:
+    {
+      uint8_t probe_insns[FUNC_SIZE] = {
+	/* stmw    r30,0xfff8(r1) */
+	0xbf, 0xc1, 0xff, 0xf8, 
+	/* stwu    r1,0xffd0(r1) */
+	0x94, 0x21, 0xff, 0xd0, 
+	/* or      r30,r1,r1 */
+	0x7c, 0x3e, 0x0b, 0x78,
+	/* stw     r3,0x48(r30) */
+	0x90, 0x7e, 0x00, 0x48, 
+	/* stw     r4,0x4c(r30) */
+	0x90, 0x9e, 0x00, 0x4c, 
+	/* stw     r5,0x50(r30) */
+	0x90, 0xbe, 0x00, 0x50, 
+	/* lwz     r1,0x0(r1) */
+	0x80, 0x21, 0x00, 0x00,
+	/* lmw     r30,0xfff8(r1) */
+	0xbb, 0xc1, 0xff, 0xf8, 
+	/* blr */
+	0x4e, 0x80, 0x00, 0x20
+      };
+      install_insns(probe_insns, &insns[IS_ENABLED_FUNC_LEN], 9);
+    }
+    break;
+
+  case 4:
+    {
+      uint8_t probe_insns[FUNC_SIZE] = {
+	/* stmw    r30,0xfff8(r1) */
+	0xbf, 0xc1, 0xff, 0xf8, 
+	/* stwu    r1,0xffd0(r1) */
+	0x94, 0x21, 0xff, 0xd0, 
+	/* or      r30,r1,r1 */
+	0x7c, 0x3e, 0x0b, 0x78,
+	/* stw     r3,0x48(r30) */
+	0x90, 0x7e, 0x00, 0x48, 
+	/* stw     r4,0x4c(r30) */
+	0x90, 0x9e, 0x00, 0x4c, 
+	/* stw     r5,0x50(r30) */
+	0x90, 0xbe, 0x00, 0x50, 
+	/* stw     r5,0x50(r30) */
+	0x90, 0xde, 0x00, 0x54,
+	/* lwz     r1,0x0(r1) */
+	0x80, 0x21, 0x00, 0x00,
+	/* lmw     r30,0xfff8(r1) */
+	0xbb, 0xc1, 0xff, 0xf8, 
+	/* blr */
+	0x4e, 0x80, 0x00, 0x20
+      };
+      install_insns(probe_insns, &insns[IS_ENABLED_FUNC_LEN], 10);
+    }
+    break;
+
+  case 5:
+    {
+      uint8_t probe_insns[FUNC_SIZE] = { 
+	/* stmw    r30,0xfff8(r1) */
+	0xbf, 0xc1, 0xff, 0xf8, 
+	/* stwu    r1,0xffd0(r1) */
+	0x94, 0x21, 0xff, 0xd0, 
+	/* or      r30,r1,r1 */
+	0x7c, 0x3e, 0x0b, 0x78,
+	/* stw     r3,0x48(r30) */
+	0x90, 0x7e, 0x00, 0x48, 
+	/* stw     r4,0x4c(r30) */
+	0x90, 0x9e, 0x00, 0x4c, 
+	/* stw     r5,0x50(r30) */
+	0x90, 0xbe, 0x00, 0x50, 
+	/* stw     r6,0x54(r30) */
+	0x90, 0xde, 0x00, 0x54,
+	/* stw     r7,0x58(r30) */
+	0x90, 0xfe, 0x00, 0x58,
+	/* lwz     r1,0x0(r1) */
+	0x80, 0x21, 0x00, 0x00,
+	/* lmw     r30,0xfff8(r1) */
+	0xbb, 0xc1, 0xff, 0xf8, 
+	/* blr */
+	0x4e, 0x80, 0x00, 0x20
+     };
+      install_insns(probe_insns, &insns[IS_ENABLED_FUNC_LEN], 11);
+    }
+    break;
+
+  case 6:
+    {
+      uint8_t probe_insns[FUNC_SIZE] = {
+	/* stmw    r30,0xfff8(r1) */
+	0xbf, 0xc1, 0xff, 0xf8, 
+	/* stwu    r1,0xffd0(r1) */
+	0x94, 0x21, 0xff, 0xd0, 
+	/* or      r30,r1,r1 */
+	0x7c, 0x3e, 0x0b, 0x78,
+	/* stw     r3,0x48(r30) */
+	0x90, 0x7e, 0x00, 0x48, 
+	/* stw     r4,0x4c(r30) */
+	0x90, 0x9e, 0x00, 0x4c, 
+	/* stw     r5,0x50(r30) */
+	0x90, 0xbe, 0x00, 0x50, 
+	/* stw     r6,0x54(r30) */
+	0x90, 0xde, 0x00, 0x54,
+	/* stw     r7,0x58(r30) */
+	0x90, 0xfe, 0x00, 0x58,
+	/* stw     r8,0x5c(r30) */
+	0x91, 0x1e, 0x00, 0x5c,
+	/* lwz     r1,0x0(r1) */
+	0x80, 0x21, 0x00, 0x00,
+	/* lmw     r30,0xfff8(r1) */
+	0xbb, 0xc1, 0xff, 0xf8, 
+	/* blr */
+	0x4e, 0x80, 0x00, 0x20
+      };
+      install_insns(probe_insns, &insns[IS_ENABLED_FUNC_LEN], 12);
+    }
+    break;
+
+  case 7:
+    {
+      uint8_t probe_insns[FUNC_SIZE] = {
+	/* stmw    r30,0xfff8(r1) */
+	0xbf, 0xc1, 0xff, 0xf8, 
+	/* stwu    r1,0xffd0(r1) */
+	0x94, 0x21, 0xff, 0xd0, 
+	/* or      r30,r1,r1 */
+	0x7c, 0x3e, 0x0b, 0x78,
+	/* stw     r3,0x48(r30) */
+	0x90, 0x7e, 0x00, 0x48, 
+	/* stw     r4,0x4c(r30) */
+	0x90, 0x9e, 0x00, 0x4c, 
+	/* stw     r5,0x50(r30) */
+	0x90, 0xbe, 0x00, 0x50, 
+	/* stw     r6,0x54(r30) */
+	0x90, 0xde, 0x00, 0x54,
+	/* stw     r7,0x58(r30) */
+	0x90, 0xfe, 0x00, 0x58,
+	/* stw     r8,0x5c(r30) */
+	0x91, 0x1e, 0x00, 0x5c,
+	/* stw     r9,0x60(r30) */
+	0x91, 0x3e, 0x00, 0x60,	
+	/* lwz     r1,0x0(r1) */
+	0x80, 0x21, 0x00, 0x00,
+	/* lmw     r30,0xfff8(r1) */
+	0xbb, 0xc1, 0xff, 0xf8, 
+	/* blr */
+	0x4e, 0x80, 0x00, 0x20
+      };
+      install_insns(probe_insns, &insns[IS_ENABLED_FUNC_LEN], 13);
+    }
+    break;
+
+  case 8:
+    {
+      uint8_t probe_insns[FUNC_SIZE] = {
+	/* stmw    r30,0xfff8(r1) */
+	0xbf, 0xc1, 0xff, 0xf8, 
+	/* stwu    r1,0xffd0(r1) */
+	0x94, 0x21, 0xff, 0xd0, 
+	/* or      r30,r1,r1 */
+	0x7c, 0x3e, 0x0b, 0x78,
+	/* stw     r3,0x48(r30) */
+	0x90, 0x7e, 0x00, 0x48, 
+	/* stw     r4,0x4c(r30) */
+	0x90, 0x9e, 0x00, 0x4c, 
+	/* stw     r5,0x50(r30) */
+	0x90, 0xbe, 0x00, 0x50, 
+	/* stw     r6,0x54(r30) */
+	0x90, 0xde, 0x00, 0x54,
+	/* stw     r7,0x58(r30) */
+	0x90, 0xfe, 0x00, 0x58,
+	/* stw     r8,0x5c(r30) */
+	0x91, 0x1e, 0x00, 0x5c,
+	/* stw     r9,0x60(r30) */
+	0x91, 0x3e, 0x00, 0x60,	
+	/* stw     r10,0x64(r30) */
+	0x91, 0x5e, 0x00, 0x64,
+	/* lwz     r1,0x0(r1) */
+	0x80, 0x21, 0x00, 0x00,
+	/* lmw     r30,0xfff8(r1) */
+	0xbb, 0xc1, 0xff, 0xf8, 
+	/* blr */
+	0x4e, 0x80, 0x00, 0x20
+      };
+      install_insns(probe_insns, &insns[IS_ENABLED_FUNC_LEN], 14);
+    }
+    break;
+
+  default:
+    rb_raise(eDtraceException, "probe argc max is 8");
+    return Qnil;
+    break;
+  }
+
+  /* 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;
+}
+
+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 ((int)(*probe->func)()) ? Qtrue : Qfalse;
+}
+
+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));
+  offset = IS_ENABLED_FUNC_LEN + 8 + (FIX2INT(argc) * 4);
+  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) + 12);
+}