ruby-dtrace 0.0.2 → 0.0.3

data/ext/dtrace_probedata.c

@@ -16,92 +16,225 @@ VALUE dtraceprobedata_init(VALUE self)
   return self;
 }
 
-VALUE dtraceprobedata_probedesc(VALUE self)
+static VALUE _handle_ustack_record(dtrace_hdl_t *handle, caddr_t addr, const dtrace_recdesc_t *rec)
 {
+  VALUE stack;
+  stack = rb_ary_new();
+
+  /* TODO, apple and solaris ustack */
+  return stack;
+}
+
+static VALUE _handle_stack_record(dtrace_hdl_t *handle, caddr_t addr, const dtrace_recdesc_t *rec)
+{
+  VALUE stack = Qnil;
+  int size, i;
+  int depth;
+  uint64_t pc;
+  dtrace_syminfo_t dts;
+  char c[PATH_MAX * 2];
+
+#ifdef __APPLE__
+  __GElf_Sym sym;
+#else
+  GElf_Sym sym;
+#endif
+
+  size = rec->dtrd_size / rec->dtrd_arg;
+  depth = rec->dtrd_arg;
+
+  stack = rb_ary_new();
+
+  for (i = 0; i < depth; i++) {
+    
+    switch (size) {
+    case sizeof (uint32_t):
+      pc = *((uint32_t *)addr);
+      break;
+
+    case sizeof (uint64_t):
+      pc = *((uint64_t *)addr);
+      break;
+
+    default:
+      rb_raise(eDtraceException, "bad stack pc");
+      return Qnil;
+    }
+
+    if (pc == (uint64_t)NULL)
+      break;
+
+    addr += size;
+
+    if (dtrace_lookup_by_addr(handle, pc, &sym, &dts) == 0) {
+      if (pc > sym.st_value) {
+	(void) snprintf(c, sizeof (c), "%s`%s+0x%llx",
+			dts.dts_object, dts.dts_name,
+			pc - sym.st_value);
+      }
+      else {
+	(void) snprintf(c, sizeof (c), "%s`%s",
+			dts.dts_object, dts.dts_name);
+      }
+    } 
+    else {
+      if (dtrace_lookup_by_addr(handle, pc, NULL, &dts) == 0) {
+	(void) snprintf(c, sizeof (c), "%s`0x%llx",
+			dts.dts_object, pc);
+      }
+      else {
+	(void) snprintf(c, sizeof (c), "0x%llx", pc);
+      }
+    }
+
+    rb_ary_push(stack, rb_str_new2(c));
+  }
+
+  return stack;
+}
+
+/*
+ * Returns the enabled probe id which generated this data
+ */
+VALUE dtraceprobedata_epid(VALUE self)
+{
+  dtrace_probedata_t *data;
+
+  Data_Get_Struct(self, dtrace_probedata_t, data);
+  return INT2FIX(data->dtpda_edesc->dtepd_epid);
+}
+
+/* 
+ * Returns the DtraceProbe for the probe which generated this data 
+ */
+VALUE dtraceprobedata_probe(VALUE self)
+{
+  VALUE dtraceprobe;
   dtrace_probedata_t *data;
-  dtrace_probedesc_t *pdp;
-  VALUE probe;
+  dtrace_probedesc_t *pd;
 
   Data_Get_Struct(self, dtrace_probedata_t, data);
+  pd = data->dtpda_pdesc;
 
-  pdp = data->dtpda_pdesc;
-  probe = Data_Wrap_Struct(cDtraceProbe, 0, NULL, (dtrace_probedesc_t *)pdp);
+  if (pd) {
+    dtraceprobe = Data_Wrap_Struct(cDtraceProbe, 0, NULL, (dtrace_probedesc_t *)pd);
+    return dtraceprobe;
+  }
 
-  return probe;
+  return Qnil;
 }
 
-static VALUE _handle_stack_record(const caddr_t addr, const dtrace_recdesc_t *rec)
+/* Returns the CPU which generated this data */
+VALUE dtraceprobedata_cpu(VALUE self)
 {
-  dtrace_actkind_t act;
-  uint64_t *pc;
-  pid_t pid = -1;
-  int size; /* size of raw bytes not including trailing zeros */
-  int i; /* index of last non-zero byte */
-  VALUE raw;
+  dtrace_probedata_t *data;
+  processorid_t cpu;
 
-  for (i = rec->dtrd_size - 1; (i >= 0) && !addr[i]; --i) {
+  Data_Get_Struct(self, dtrace_probedata_t, data);
+  
+  if (data) {
+    cpu = data->dtpda_cpu;
+    return INT2FIX(cpu);
   }
-  size = (i + 1);
+  else {
+    return Qnil;
+  }
+}
+
+/* Returns the indent level given to this data by DTrace */
+VALUE dtraceprobedata_indent(VALUE self)
+{
+  dtrace_probedata_t *data;
+  int indent;
 
-  raw = rb_ary_new();
-  for (i = 0; i < size; i++)
-    rb_ary_push(raw, INT2FIX(addr[i]));
+  Data_Get_Struct(self, dtrace_probedata_t, data);
 
-  act = rec->dtrd_action;
-  switch (act) {
-  case DTRACEACT_STACK:
-    break;
-  case DTRACEACT_USTACK:
-  case DTRACEACT_JSTACK:
-    /* Get pid of user process */
-    pc = (uint64_t *)(uintptr_t)addr;
-    pid = (pid_t)*pc;
-    break;
-  default:
-    rb_raise(eDtraceException, "Expected stack action, got %d\n", act);
+  if (data) {
+    indent = data->dtpda_indent;
+    return INT2FIX(indent / 2);
   }
+  else {
+    return Qnil;
+  }
+}
 
-  return raw;
+/* Returns the prefix given to this data by DTrace */
+VALUE dtraceprobedata_prefix(VALUE self)
+{
+  dtrace_probedata_t *data;
+  const char *prefix;
+
+  Data_Get_Struct(self, dtrace_probedata_t, data);
+  prefix = data->dtpda_prefix;
+
+  if (prefix) 
+    return rb_str_new2(prefix);
+  else
+    return Qnil;
 }
 
-static int
-_is_stack_action(dtrace_actkind_t act)
+/* Returns the flow kind given to this data by DTrace */
+VALUE dtraceprobedata_flow(VALUE self)
 {
-  int stack_action;
-  switch (act) {
-  case DTRACEACT_STACK:
-  case DTRACEACT_USTACK:
-  case DTRACEACT_JSTACK:
-    stack_action = 1;
+  dtrace_probedata_t *data;
+
+  Data_Get_Struct(self, dtrace_probedata_t, data);
+
+  switch (data->dtpda_flow) {
+  case DTRACEFLOW_ENTRY:
+    return rb_str_new2("->");
+    break;
+  case DTRACEFLOW_RETURN:
+    return rb_str_new2("<-");
     break;
   default:
-    stack_action = 0;
+    return Qnil;
   }
-  return (stack_action);
 }
 
+/* 
+ * Yields each record in this DtraceProbedata in turn. Records are
+ * yielded as either DtraceRecords or DtraceStackRecords as
+ * appropriate for the type of action.
+ */
 VALUE dtraceprobedata_each_record(VALUE self)
 {
   dtrace_probedata_t *data;
   dtrace_eprobedesc_t *eprobe;
   dtrace_recdesc_t *rec;
+  dtrace_hdl_t *handle;
+  dtrace_actkind_t act;
   int i;
+  caddr_t addr;
   VALUE dtracerecord;
+  VALUE dtracehandle;
   VALUE v;
-  caddr_t addr;
 
   Data_Get_Struct(self, dtrace_probedata_t, data);
+  dtracehandle = rb_iv_get(self, "@handle");
+  Data_Get_Struct(dtracehandle, dtrace_hdl_t, handle);
+
   eprobe = data->dtpda_edesc;
   
   for (i = 0; i < eprobe->dtepd_nrecs; i++) {
+    v = 0;
     rec = &eprobe->dtepd_rec[i];
     if (rec->dtrd_size > 0) {
+      act = rec->dtrd_action;
       addr = data->dtpda_data + rec->dtrd_offset;
-	
-      if (_is_stack_action(rec->dtrd_action)) {
-	v = _handle_stack_record(addr, rec);
-      }
-      else {
+      
+      switch (act) {
+      case DTRACEACT_STACK:
+      case DTRACEACT_USTACK:
+      case DTRACEACT_JSTACK:
+	/* Stack records come from bufdata */
+	/* v = _handle_stack_record(handle, addr, rec); */
+	/* v = _handle_ustack_record(handle, addr, rec); */
+	break;
+      case DTRACEACT_PRINTA:
+	/* don't want the probedata record for a printa() action */
+	break;
+      default:
 	switch (rec->dtrd_size) {
 	case 1:
 	  v = INT2FIX((int)(*((uint8_t *)addr)));
@@ -121,9 +254,14 @@ VALUE dtraceprobedata_each_record(VALUE self)
 	}
       }
 	
-      dtracerecord = rb_class_new_instance(0, NULL, rb_path2class("DtraceRecord"));
-      rb_iv_set(dtracerecord, "@value", v);
-      rb_yield(dtracerecord);
+      if (v) {
+	dtracerecord = rb_class_new_instance(0, NULL, rb_path2class("DtraceRecord"));
+	rb_iv_set(dtracerecord, "@value", v);
+	rb_iv_set(dtracerecord, "@from", rb_str_new2("probedata"));
+	rb_iv_set(dtracerecord, "@index", INT2FIX(i));
+	rb_iv_set(dtracerecord, "@action", INT2FIX(act));
+	rb_yield(dtracerecord);
+      }
     }
   }
 }

data/ext/dtrace_process.c

@@ -0,0 +1,37 @@
+/* Ruby-Dtrace
+ * (c) 2007 Chris Andrews <chris@nodnol.org>
+ */
+
+#include "dtrace_api.h"
+
+/* :nodoc: */
+VALUE dtrace_process_init(VALUE self)
+{
+  dtrace_process_t *process;
+
+  Data_Get_Struct(self, dtrace_process_t, process);
+  if (process)
+    return self;
+  else
+    return Qnil;
+}
+
+/* :nodoc: */
+void dtrace_process_release(dtrace_process_t *process)
+{
+  dtrace_proc_release(process->handle, process->proc);
+  free(process);
+}
+
+/*
+ * Start or restart the process. Call this having configured tracing
+ * for the process, using $target in the D program.
+ */
+VALUE dtrace_process_continue(VALUE self)
+{
+  dtrace_process_t *process;
+
+  Data_Get_Struct(self, dtrace_process_t, process);
+  dtrace_proc_continue(process->handle, process->proc);
+}
+

data/ext/dtrace_recdesc.c

@@ -13,3 +13,34 @@ VALUE dtracerecdesc_init(VALUE self)
   return self;
 }
 
+/* 
+ * Returns the type of action which generated this recdesc.
+ * (exit, printf, printa or "other" for all other actions).
+ */
+VALUE dtracerecdesc_action(VALUE self)
+{
+  dtrace_recdesc_t *recdesc;
+  VALUE v;
+  Data_Get_Struct(self, dtrace_recdesc_t, recdesc);
+
+  if (recdesc){
+    switch (recdesc->dtrd_action) {
+    case DTRACEACT_EXIT:
+      v = rb_str_new2("exit");
+      break;
+    case DTRACEACT_PRINTF:
+      v = rb_str_new2("printf");
+      break;
+    case DTRACEACT_PRINTA:
+      v = rb_str_new2("printa");
+      break;
+    default:
+      v = rb_str_new2("other");
+      break;
+    }
+    return v;
+  }
+  else {
+    return Qnil;
+  }
+}

data/lib/dtrace.rb

@@ -7,10 +7,62 @@ require 'dtrace_api'
 require 'dtracerecord'
 require 'dtraceconsumer'
 require 'dtraceaggregate'
+require 'dtraceaggregateset'
 require 'dtraceprobedata'
 require 'dtraceprobe'
+require 'dtracestackrecord'
+require 'dtraceprintfrecord'
+require 'dtracedata'
+
+# A DTrace handle. Provides methods for inspecting available probes,
+# compiling and running programs, and for setting up callbacks to
+# receive trace data.
+#
+# The general structure of a Dtrace-based program is:
+#
+# * Create a handle with Dtrace.new
+# * Set options
+# * Compile the program, possibly inspecting the return DtraceProgramInfo
+# * Execute the program
+# * Start tracing
+# * Consume data, either directly by setting up callbacks, or using a DtraceConsumer.
+# * Stop tracing
+#
+# === Listing probes
+#
+#   d.each_probe do |p|
+#     puts "#{p.provider}:#{p.mod}:#{p.func}:#{p.name}"
+#   end
+#
+# === Setting options
+#
+#   d.setopt("bufsize", "8m")
+#   d.setopt("aggsize", "4m")
+#   d.setopt("stackframes", "5")
+#   d.setopt("strsize", "131072")
+#
+# === Compiling a program
+#
+#   d.compile "syscall:::entry { trace(execname); stack(); }"
+#   d.execute
+#
+# === Setting up callbacks
+#
+#   d.buf_consumer(prob {|buf| yield buf })
+#   d.work(proc {|probe| yield probe }, proc {|rec| yield rec })
+#
+# === Creating a process
+#
+#   p = t.createprocess([ '/usr/bin/true' ])
+#   t.go
+#   p.continue
+#
+#   c = DtraceConsumer.new(t)
+#   c.consume do |d|
+#     ..
+#   end
 
 class Dtrace
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end
 

data/lib/dtraceaggregate.rb

@@ -3,11 +3,35 @@
 # (c) 2007 Chris Andrews <chris@nodnol.org>
 #
 
+# Represents an aggregation record built from a series of
+# DtraceAggData records.
+#
+# Intended to to built up by calling +add_record+ repeatedly with
+# DtraceAggData objects until a completed DtraceAggregate is returned.
+# (until a complete record is available, +add_record+ returns nil).
+#
+# See dtraceconsumer.rb for an example of this.
 class DtraceAggregate
-  attr_accessor :value, :tuple
+  attr_reader :value, :tuple
 
+  # Create an empty DtraceAggregate: use +add_record+ to add data.
   def initialize
     @tuple = Array.new
   end
+  
+  # Add a DtraceAggData record to this aggregate. Returns nil until it
+  # receives a record of aggtype "last", when it returns the complete
+  # DtraceAggregate.
+  def add_record(r)
+    case r.aggtype
+    when "tuple"
+      @tuple << r.value
+    when "value"
+      @value = r.value
+    when "last"
+      return self
+    end
+    nil
+  end
 
 end