chrisa-ruby-dtrace 0.2.0

data/ext/dtrace_probedata.c

@@ -0,0 +1,267 @@
+/* Ruby-Dtrace
+ * (c) 2007 Chris Andrews <chris@nodnol.org>
+ */
+
+#include "dtrace_api.h"
+
+RUBY_EXTERN VALUE eDtraceException;
+RUBY_EXTERN VALUE cDtraceProbeDesc;
+
+/* :nodoc: */
+VALUE dtraceprobedata_init(VALUE self)
+{
+  dtrace_probedata_t *data;
+
+  Data_Get_Struct(self, dtrace_probedata_t, data);
+  return 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 *pd;
+
+  Data_Get_Struct(self, dtrace_probedata_t, data);
+  pd = data->dtpda_pdesc;
+
+  if (pd) {
+    dtraceprobe = Data_Wrap_Struct(cDtraceProbeDesc, 0, NULL, (dtrace_probedesc_t *)pd);
+    return dtraceprobe;
+  }
+
+  return Qnil;
+}
+
+/* Returns the CPU which generated this data */
+VALUE dtraceprobedata_cpu(VALUE self)
+{
+  dtrace_probedata_t *data;
+  processorid_t cpu;
+
+  Data_Get_Struct(self, dtrace_probedata_t, data);
+  
+  if (data) {
+    cpu = data->dtpda_cpu;
+    return INT2FIX(cpu);
+  }
+  else {
+    return Qnil;
+  }
+}
+
+/* Returns the indent level given to this data by DTrace */
+VALUE dtraceprobedata_indent(VALUE self)
+{
+  dtrace_probedata_t *data;
+  int indent;
+
+  Data_Get_Struct(self, dtrace_probedata_t, data);
+
+  if (data) {
+    indent = data->dtpda_indent;
+    return INT2FIX(indent / 2);
+  }
+  else {
+    return Qnil;
+  }
+}
+
+/* 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;
+}
+
+/* Returns the flow kind given to this data by DTrace */
+VALUE dtraceprobedata_flow(VALUE self)
+{
+  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:
+    return Qnil;
+  }
+}
+
+/* 
+ * 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_handle_t *handle;
+  dtrace_actkind_t act;
+  int i;
+  caddr_t addr;
+  VALUE dtracerecord;
+  VALUE dtrace;
+  VALUE v;
+
+  Data_Get_Struct(self, dtrace_probedata_t, data);
+  dtrace = rb_iv_get(self, "@handle");
+  Data_Get_Struct(dtrace, dtrace_handle_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;
+      
+      switch (act) {
+      case DTRACEACT_STACK:
+      case DTRACEACT_USTACK:
+      case DTRACEACT_JSTACK:
+	/* Stack records come from bufdata */
+	/* v = _handle_stack_record(handle->hdl, addr, rec); */
+	/* v = _handle_ustack_record(handle->hdl, 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)));
+	  break;
+	case 2:
+	  v = INT2FIX((int)(*((uint16_t *)addr)));
+	  break;
+	case 4:
+	  v = INT2FIX(*((int32_t *)addr));
+	  break;
+	case 8:
+	  v = INT2FIX(*((int64_t *)addr));
+	  break;
+	default:
+	  v = handle_bytedata(addr, rec->dtrd_size);
+	  break;
+	}
+      }
+	
+      if (v) {
+	dtracerecord = rb_class_new_instance(0, NULL, rb_path2class("Dtrace::Record"));
+	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_probedesc.c

@@ -0,0 +1,78 @@
+/* Ruby-Dtrace
+ * (c) 2007 Chris Andrews <chris@nodnol.org>
+ */
+
+#include "dtrace_api.h"
+
+/* :nodoc: */
+VALUE dtraceprobedesc_init(VALUE self)
+{
+  dtrace_probedesc_t *pdp;
+
+  Data_Get_Struct(self, dtrace_probedesc_t, pdp);
+  return self;
+}
+
+/*
+ * Returns the id of the probedesc. Corresponds to the ID displayed by
+ * dtrace -l
+ */
+VALUE dtraceprobedesc_probe_id(VALUE self)
+{
+  dtrace_probedesc_t *pdp;
+
+  Data_Get_Struct(self, dtrace_probedesc_t, pdp);
+  return INT2NUM(pdp->dtpd_id);
+}
+
+/*
+ * Returns the name of the probe's provider.
+ */
+VALUE dtraceprobedesc_provider(VALUE self)
+{
+  VALUE string;
+  dtrace_probedesc_t *pdp;
+
+  Data_Get_Struct(self, dtrace_probedesc_t, pdp);
+  string = rb_str_new2(pdp->dtpd_provider);
+  return string;
+}
+
+/*
+ * Returns the name of the module where the probe is defined.
+ */
+VALUE dtraceprobedesc_mod(VALUE self)
+{
+  VALUE string;
+  dtrace_probedesc_t *pdp;
+
+  Data_Get_Struct(self, dtrace_probedesc_t, pdp);
+  string = rb_str_new2(pdp->dtpd_mod);
+  return string;
+}
+
+/*
+ * Returns the name of the function where the probe is defined.
+ */
+VALUE dtraceprobedesc_func(VALUE self)
+{
+  VALUE string;
+  dtrace_probedesc_t *pdp;
+
+  Data_Get_Struct(self, dtrace_probedesc_t, pdp);
+  string = rb_str_new2(pdp->dtpd_func);
+  return string;
+}
+
+/*
+ * Returns the name of the probe.
+ */
+VALUE dtraceprobedesc_name(VALUE self)
+{
+  VALUE string;
+  dtrace_probedesc_t *pdp;
+
+  Data_Get_Struct(self, dtrace_probedesc_t, pdp);
+  string = rb_str_new2(pdp->dtpd_name);
+  return string;
+}

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_program.c

@@ -0,0 +1,62 @@
+/* Ruby-Dtrace
+ * (c) 2007 Chris Andrews <chris@nodnol.org>
+ */
+
+#include "dtrace_api.h"
+
+RUBY_EXTERN VALUE eDtraceException;
+RUBY_EXTERN VALUE cDtraceProgramInfo;
+
+/* :nodoc: */
+VALUE dtraceprogram_init(VALUE self)
+{
+  dtrace_prog_t *prog;
+
+  Data_Get_Struct(self, dtrace_prog_t, prog);
+  return self;
+}
+
+/*
+ * Execute the D program. Returns a DtraceProgramInfo object if
+ * successful, otherwise raises a DtraceException.
+ */
+VALUE dtraceprogram_exec(VALUE self)
+{
+  dtrace_prog_t *prog;
+  dtrace_proginfo_t *proginfo;
+  dtrace_handle_t *handle;
+  VALUE dtrace;
+  VALUE dtraceprograminfo;
+  int ret;
+
+  Data_Get_Struct(self, dtrace_prog_t, prog);
+  dtrace = rb_iv_get(self, "@handle");
+  Data_Get_Struct(dtrace, dtrace_handle_t, handle);
+  
+  proginfo = ALLOC(dtrace_proginfo_t);
+  if (!proginfo) {
+    rb_raise(eDtraceException, "alloc failed");
+    return Qnil;
+  }
+
+  ret = dtrace_program_exec(handle->hdl, prog, proginfo);
+
+  if (ret == 0) {
+    dtraceprograminfo = Data_Wrap_Struct(cDtraceProgramInfo, 0, NULL, proginfo);
+    rb_iv_set(self, "@proginfo", dtraceprograminfo);
+  }
+
+  if (ret < 0)
+    rb_raise(eDtraceException, dtrace_errmsg(handle->hdl, dtrace_errno(handle->hdl)));
+  
+  return Qnil;
+}
+
+/*
+ * Return this program's DtraceProgramInfo object. Returns nil unless
+ * the program has been executed.
+ */
+VALUE dtraceprogram_info(VALUE self)
+{
+  return rb_iv_get(self, "@proginfo");
+}

data/ext/dtrace_programinfo.c

@@ -0,0 +1,60 @@
+/* Ruby-Dtrace
+ * (c) 2007 Chris Andrews <chris@nodnol.org>
+ */
+
+#include "dtrace_api.h"
+
+/* :nodoc: */
+VALUE dtraceprograminfo_init(VALUE self)
+{
+  dtrace_proginfo_t *proginfo;
+
+  Data_Get_Struct(self, dtrace_proginfo_t, proginfo);
+  return self;
+}
+
+/*
+ * Returns the number of aggregates associated with this program.
+ */
+VALUE dtraceprograminfo_aggregates_count(VALUE self) 
+{
+  dtrace_proginfo_t *proginfo;
+
+  Data_Get_Struct(self, dtrace_proginfo_t, proginfo);
+  return INT2NUM(proginfo->dpi_aggregates);
+}
+
+/*
+ * Returns the number of record generating probes associated with this
+ * program.
+ */
+VALUE dtraceprograminfo_recgens_count(VALUE self)
+{
+  dtrace_proginfo_t *proginfo;
+
+  Data_Get_Struct(self, dtrace_proginfo_t, proginfo);
+  return INT2NUM(proginfo->dpi_recgens);
+}
+
+/*
+ * Returns the number of probes matched by this program.
+ */
+VALUE dtraceprograminfo_matches_count(VALUE self)
+{
+  dtrace_proginfo_t *proginfo;
+
+  Data_Get_Struct(self, dtrace_proginfo_t, proginfo);
+  return INT2NUM(proginfo->dpi_matches);
+}
+
+/*
+ * Returns the number of speculations specified by this program.
+ */
+VALUE dtraceprograminfo_speculations_count(VALUE self)
+{
+  dtrace_proginfo_t *proginfo;
+
+  Data_Get_Struct(self, dtrace_proginfo_t, proginfo);
+  return INT2NUM(proginfo->dpi_speculations);
+}
+

data/ext/dtrace_recdesc.c

@@ -0,0 +1,46 @@
+/* Ruby-Dtrace
+ * (c) 2007 Chris Andrews <chris@nodnol.org>
+ */
+
+#include "dtrace_api.h"
+
+/* :nodoc: */
+VALUE dtracerecdesc_init(VALUE self)
+{
+  dtrace_recdesc_t *recdesc;
+
+  Data_Get_Struct(self, dtrace_recdesc_t, recdesc);
+  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/ext/dtrace_util.c

@@ -0,0 +1,92 @@
+/* Ruby-Dtrace
+ * (c) 2007 Chris Andrews <chris@nodnol.org>
+ */
+
+#include "dtrace_api.h"
+#include <ctype.h>
+
+RUBY_EXTERN VALUE eDtraceException;
+
+/*
+ * Most of this function lifted from libdtrace/common/dt_consume.c
+ * dt_print_bytes().
+ */
+VALUE handle_bytedata(caddr_t addr, uint32_t nbytes)
+{
+  /*
+   * If the byte stream is a series of printable characters, followed by
+   * a terminating byte, we print it out as a string.  Otherwise, we
+   * assume that it's something else and just print the bytes.
+   */
+  int i, j;
+  char *c = addr;
+
+  VALUE robj;
+
+  if (nbytes == 0) {
+    return rb_str_new2("");
+  }
+
+  for (i = 0; i < nbytes; i++) {
+    /*
+     * We define a "printable character" to be one for which
+     * isprint(3C) returns non-zero, isspace(3C) returns non-zero,
+     * or a character which is either backspace or the bell.
+     * Backspace and the bell are regrettably special because
+     * they fail the first two tests -- and yet they are entirely
+     * printable.  These are the only two control characters that
+     * have meaning for the terminal and for which isprint(3C) and
+     * isspace(3C) return 0.
+     */
+    if (isprint(c[i]) || isspace(c[i]) ||
+	c[i] == '\b' || c[i] == '\a')
+      continue;
+
+    if (c[i] == '\0' && i > 0) {
+      /*
+       * This looks like it might be a string.  Before we
+       * assume that it is indeed a string, check the
+       * remainder of the byte range; if it contains
+       * additional non-nul characters, we'll assume that
+       * it's a binary stream that just happens to look like
+       * a string.
+       */
+      for (j = i + 1; j < nbytes; j++) {
+	if (c[j] != '\0')
+	  break;
+      }
+
+      if (j != nbytes)
+	break;
+
+      /* It's a string */
+      return (rb_str_new2((char *)addr));
+    }
+
+    break;
+  }
+
+  if (i == nbytes) {
+    /*
+     * The byte range is all printable characters, but there is
+     * no trailing nul byte.  We'll assume that it's a string.
+     */
+    char *s = malloc(nbytes + 1);
+    if (!s) {
+      rb_raise(eDtraceException, "out of memory: failed to allocate string value");
+      return (Qnil);
+    }
+    (void) strncpy(s, c, nbytes);
+    s[nbytes] = '\0';
+    robj = rb_str_new2(s);
+    free(s);
+    return (robj);
+  }
+
+  /* return byte array */
+  robj = rb_ary_new();
+  for (i = 0; i < nbytes; i++)
+    rb_ary_push(robj, INT2FIX(addr[i]));
+
+  return (robj);
+}  

data/ext/extconf.rb

@@ -0,0 +1,28 @@
+require 'mkmf'
+require 'rbconfig'
+
+def symlink(old, new)
+  if File.exists?(new) && File.symlink?(new)
+    File.unlink(new)
+  end
+  File.symlink(old, new)
+end
+
+$CFLAGS += " -D_LONGLONG_TYPE -g"
+have_library("dtrace", "dtrace_open")
+
+# Update machine-dependent symlinks in the source, based on $Config::CONFIG
+
+cpu = Config::CONFIG['target_cpu']
+os  = Config::CONFIG['target_os']
+
+cpu.gsub! /^i[4-6]86/, 'i386'
+os.gsub!  /[0-9.]+$/, ''
+
+dir = "#{cpu}-#{os}"
+symlink "#{dir}/dtrace_probe.c", "dtrace_probe.c"
+
+# Create makefile in the usual way
+
+create_makefile("dtrace_api")
+