ruby-dtrace 0.0.6 → 0.2.8

data/ext/dof/constants.c

@@ -0,0 +1,57 @@
+/* 
+ * Ruby-Dtrace
+ * (c) 2008 Chris Andrews <chris@nodnol.org>
+ */
+
+#include "dof.h"
+
+void 
+_init_constants(VALUE dtrace_dof)
+{
+  VALUE c = rb_define_module_under(dtrace_dof, "Constants");
+
+  rb_define_const(c, "DOF_DOFHDR_SIZE",   INT2FIX(sizeof(dof_hdr_t)));
+  rb_define_const(c, "DOF_SECHDR_SIZE",   INT2FIX(sizeof(dof_sec_t)));
+  rb_define_const(c, "DOF_PROBE_SIZE",    INT2FIX(sizeof(dof_probe_t)));
+  rb_define_const(c, "DOF_PRARGS_SIZE",   INT2FIX(sizeof(uint8_t)));
+  rb_define_const(c, "DOF_PROFFS_SIZE",   INT2FIX(sizeof(uint32_t)));
+  rb_define_const(c, "DOF_PRENOFFS_SIZE", INT2FIX(sizeof(uint32_t)));
+  rb_define_const(c, "DOF_PROVIDER_SIZE", INT2FIX(sizeof(dof_provider_t)));
+
+  rb_define_const(c, "DOF_SECT_NONE",      INT2FIX(DOF_SECT_NONE));
+  rb_define_const(c, "DOF_SECT_COMMENTS",  INT2FIX(DOF_SECT_COMMENTS));
+  rb_define_const(c, "DOF_SECT_SOURCE",    INT2FIX(DOF_SECT_SOURCE));
+  rb_define_const(c, "DOF_SECT_ECBDESC",   INT2FIX(DOF_SECT_ECBDESC));
+  rb_define_const(c, "DOF_SECT_PROBEDESC", INT2FIX(DOF_SECT_PROBEDESC));
+  rb_define_const(c, "DOF_SECT_ACTDESC",   INT2FIX(DOF_SECT_ACTDESC));
+  rb_define_const(c, "DOF_SECT_DIFOHDR",   INT2FIX(DOF_SECT_DIFOHDR));
+  rb_define_const(c, "DOF_SECT_DIF",       INT2FIX(DOF_SECT_DIF));
+  rb_define_const(c, "DOF_SECT_STRTAB",    INT2FIX(DOF_SECT_STRTAB));
+  rb_define_const(c, "DOF_SECT_VARTAB",    INT2FIX(DOF_SECT_VARTAB));
+  rb_define_const(c, "DOF_SECT_RELTAB",    INT2FIX(DOF_SECT_RELTAB));
+  rb_define_const(c, "DOF_SECT_TYPTAB",    INT2FIX(DOF_SECT_TYPTAB));
+  rb_define_const(c, "DOF_SECT_URELHDR",   INT2FIX(DOF_SECT_URELHDR));
+  rb_define_const(c, "DOF_SECT_KRELHDR",   INT2FIX(DOF_SECT_KRELHDR));
+  rb_define_const(c, "DOF_SECT_OPTDESC",   INT2FIX(DOF_SECT_OPTDESC));
+  rb_define_const(c, "DOF_SECT_PROVIDER",  INT2FIX(DOF_SECT_PROVIDER));
+  rb_define_const(c, "DOF_SECT_PROBES",    INT2FIX(DOF_SECT_PROBES));
+  rb_define_const(c, "DOF_SECT_PRARGS",    INT2FIX(DOF_SECT_PRARGS));
+  rb_define_const(c, "DOF_SECT_PROFFS",    INT2FIX(DOF_SECT_PROFFS));
+  rb_define_const(c, "DOF_SECT_INTTAB",    INT2FIX(DOF_SECT_INTTAB));
+  rb_define_const(c, "DOF_SECT_UTSNAME",   INT2FIX(DOF_SECT_UTSNAME));
+  rb_define_const(c, "DOF_SECT_XLTAB",     INT2FIX(DOF_SECT_XLTAB));
+  rb_define_const(c, "DOF_SECT_XLMEMBERS", INT2FIX(DOF_SECT_XLMEMBERS));
+  rb_define_const(c, "DOF_SECT_XLIMPORT",  INT2FIX(DOF_SECT_XLIMPORT));
+  rb_define_const(c, "DOF_SECT_XLEXPORT",  INT2FIX(DOF_SECT_XLEXPORT));
+  rb_define_const(c, "DOF_SECT_PREXPORT",  INT2FIX(DOF_SECT_PREXPORT));
+  rb_define_const(c, "DOF_SECT_PRENOFFS",  INT2FIX(DOF_SECT_PRENOFFS));
+
+  rb_define_const(c, "DTRACE_STABILITY_INTERNAL",  INT2FIX(DTRACE_STABILITY_INTERNAL));
+  rb_define_const(c, "DTRACE_STABILITY_PRIVATE",   INT2FIX(DTRACE_STABILITY_PRIVATE));
+  rb_define_const(c, "DTRACE_STABILITY_OBSOLETE",  INT2FIX(DTRACE_STABILITY_OBSOLETE));
+  rb_define_const(c, "DTRACE_STABILITY_EXTERNAL",  INT2FIX(DTRACE_STABILITY_EXTERNAL));
+  rb_define_const(c, "DTRACE_STABILITY_UNSTABLE",  INT2FIX(DTRACE_STABILITY_UNSTABLE));
+  rb_define_const(c, "DTRACE_STABILITY_EVOLVING",  INT2FIX(DTRACE_STABILITY_EVOLVING));
+  rb_define_const(c, "DTRACE_STABILITY_STABLE",    INT2FIX(DTRACE_STABILITY_STABLE));
+  rb_define_const(c, "DTRACE_STABILITY_STANDARD",  INT2FIX(DTRACE_STABILITY_STANDARD));
+}

data/ext/dof/dof.h

@@ -0,0 +1,56 @@
+/* 
+ * Ruby-Dtrace
+ * (c) 2008 Chris Andrews <chris@nodnol.org>
+ */
+
+#include <ruby.h>
+#include <sys/utsname.h>
+#include <sys/dtrace.h>
+
+/* Handle missing RARRAY_LEN etc */
+#ifdef RARRAY_LEN
+static inline long   rb_str_len(VALUE s) {return RSTRING_LEN(s);}
+static inline char  *rb_str_ptr(VALUE s) {return RSTRING_PTR(s);}
+static inline long   rb_ary_len(VALUE s) {return  RARRAY_LEN(s);}
+static inline VALUE *rb_ary_ptr(VALUE s) {return  RARRAY_PTR(s);}
+#else
+static inline long   rb_str_len(VALUE s) {return RSTRING(s)->len;}
+static inline char  *rb_str_ptr(VALUE s) {return RSTRING(s)->ptr;}
+static inline long   rb_ary_len(VALUE s) {return  RARRAY(s)->len;}
+static inline VALUE *rb_ary_ptr(VALUE s) {return  RARRAY(s)->ptr;}
+#endif // RARRAY_LEN
+
+/* Struct to contain Dof::File allocated memory */
+typedef struct dof_file {
+  char *dof;
+  uint32_t len;
+  uint32_t offset;
+} dof_file_t;
+
+VALUE dof_parse(VALUE self, VALUE dof);
+
+/* Section generate methods */
+VALUE dof_generate_comments(VALUE self);
+VALUE dof_generate_probes(VALUE self);
+VALUE dof_generate_strtab(VALUE self);
+VALUE dof_generate_utsname(VALUE self);
+VALUE dof_generate_prargs(VALUE self);
+VALUE dof_generate_proffs(VALUE self);
+VALUE dof_generate_prenoffs(VALUE self);
+VALUE dof_generate_provider(VALUE self);
+VALUE dof_generate_reltab(VALUE self);
+VALUE dof_generate_relhdr(VALUE self);
+
+VALUE dof_generate_section_header(VALUE self);
+
+VALUE dof_generate_header(VALUE self);
+VALUE dof_header_len(VALUE self);
+
+VALUE dof_file_alloc(VALUE klass);
+VALUE dof_file_allocate_dof(VALUE self, VALUE size);
+VALUE dof_file_append(VALUE self, VALUE data);
+VALUE dof_file_addr(VALUE self);
+VALUE dof_file_data(VALUE self);
+
+VALUE dof_loaddof(VALUE self, VALUE dof, VALUE module_name);
+

data/ext/dof/dof_api.c

@@ -0,0 +1,58 @@
+/* 
+ * Ruby-Dtrace
+ * (c) 2008 Chris Andrews <chris@nodnol.org>
+ */
+
+#include "dof.h"
+
+VALUE cDtraceDofParser;
+VALUE cDtraceDofGenerator;
+VALUE cDtraceDofSection;
+VALUE cDtraceDofHeader;
+VALUE cDtraceDofFile;
+VALUE eDtraceDofException;
+
+void Init_dof_api() {
+  VALUE dtrace = rb_define_class("Dtrace", rb_cObject);
+  VALUE dof    = rb_define_class_under(dtrace, "Dof", rb_cObject);
+
+  rb_define_singleton_method(dof, "loaddof", dof_loaddof, 2); // in dof_helper.c
+  
+  eDtraceDofException = rb_define_class_under(dof, "Exception", rb_eStandardError);
+
+  cDtraceDofParser    = rb_define_class_under(dof, "Parser",    rb_cObject);
+  cDtraceDofGenerator = rb_define_class_under(dof, "Generator", rb_cObject);
+
+  rb_define_singleton_method(cDtraceDofParser, "parse", dof_parse, 1); // in parser.c
+
+  cDtraceDofSection = rb_define_class_under(dof, "Section", rb_cObject);
+  rb_define_method(cDtraceDofSection, "dof_generate_comments",  dof_generate_comments,  0); // in section.c
+  rb_define_method(cDtraceDofSection, "dof_generate_probes",    dof_generate_probes,    0); // in section.c
+  rb_define_method(cDtraceDofSection, "dof_generate_strtab",    dof_generate_strtab,    0); // in section.c
+  rb_define_method(cDtraceDofSection, "dof_generate_utsname",   dof_generate_utsname,   0); // in section.c
+  rb_define_method(cDtraceDofSection, "dof_generate_prargs",    dof_generate_prargs,    0); // in section.c
+  rb_define_method(cDtraceDofSection, "dof_generate_proffs",    dof_generate_proffs,    0); // in section.c
+  rb_define_method(cDtraceDofSection, "dof_generate_prenoffs",  dof_generate_prenoffs,  0); // in section.c
+  rb_define_method(cDtraceDofSection, "dof_generate_provider",  dof_generate_provider,  0); // in section.c
+  rb_define_method(cDtraceDofSection, "dof_generate_reltab",    dof_generate_reltab,    0); // in section.c
+  rb_define_method(cDtraceDofSection, "dof_generate_relhdr",    dof_generate_relhdr,    0); // in section.c
+  rb_define_method(cDtraceDofSection, "generate_header",        dof_generate_section_header, 0); // in section.c
+
+  cDtraceDofHeader = rb_define_class_under(dof, "Header", rb_cObject);
+  rb_define_attr(cDtraceDofHeader, "loadsz", 1, 1);
+  rb_define_attr(cDtraceDofHeader, "filesz", 1, 1);
+  rb_define_attr(cDtraceDofHeader, "secnum", 1, 1);
+  rb_define_attr(cDtraceDofHeader, "hdrlen", 1, 0);
+  rb_define_attr(cDtraceDofHeader, "dof_version", 0, 1);
+  rb_define_method(cDtraceDofHeader, "generate", dof_generate_header, 0); // in header.c
+  rb_define_method(cDtraceDofHeader, "hdrlen",   dof_header_len,      0); // in header.c
+
+  cDtraceDofFile = rb_define_class_under(dof, "File", rb_cObject);
+  rb_define_alloc_func(cDtraceDofFile, dof_file_alloc);           // in file.c
+  rb_define_method(cDtraceDofFile, "allocate", dof_file_allocate_dof, 1); // in file.c
+  rb_define_method(cDtraceDofFile, "<<",       dof_file_append,       1); // in file.c
+  rb_define_method(cDtraceDofFile, "addr",     dof_file_addr,         0); // in file.c
+  rb_define_method(cDtraceDofFile, "data",     dof_file_data,         0); // in file.c
+
+  _init_constants(dof);
+}

data/ext/dof/dof_helper.c

@@ -0,0 +1,82 @@
+/* Ruby-Dtrace
+ * (c) 2008 Chris Andrews <chris@nodnol.org>
+ */
+
+#include "dof.h"
+
+#include <errno.h>
+#include <string.h>
+#include <fcntl.h>
+
+RUBY_EXTERN VALUE eDtraceDofException;
+
+#ifdef __APPLE__
+static const char *helper = "/dev/dtracehelper";
+
+int _loaddof(int fd, dof_helper_t *dh)
+{
+  int ret;
+  uint8_t buffer[sizeof(dof_ioctl_data_t) + sizeof(dof_helper_t)];
+  dof_ioctl_data_t* ioctlData = (dof_ioctl_data_t*)buffer;
+
+  ioctlData->dofiod_count = 1LL;
+  memcpy(&ioctlData->dofiod_helpers[0], dh, sizeof(dof_helper_t));
+
+  user_addr_t val = (user_addr_t)(unsigned long)ioctlData;
+  ret = ioctl(fd, DTRACEHIOC_ADDDOF, &val);
+  
+  return ret;
+}
+
+#else /* Solaris */
+
+/* ignore Sol10 GA ... */
+static const char *helper = "/dev/dtrace/helper";
+
+int _loaddof(int fd, dof_helper_t *dh)
+{
+  return ioctl(fd, DTRACEHIOC_ADDDOF, dh);
+}
+
+#endif
+
+/* Load the given Dtrace::Dof::File into the kernel, against the given
+   module name. */
+VALUE dof_loaddof(VALUE self, VALUE dof_file, VALUE module_name)
+{
+  dof_helper_t dh;
+  int fd;
+  int gen;
+  dof_file_t *file;
+  dof_hdr_t *dof;
+
+  Data_Get_Struct(dof_file, dof_file_t, file);
+  dof = (dof_hdr_t *)file->dof;
+
+  if (dof->dofh_ident[DOF_ID_MAG0] != DOF_MAG_MAG0 ||
+      dof->dofh_ident[DOF_ID_MAG1] != DOF_MAG_MAG1 ||
+      dof->dofh_ident[DOF_ID_MAG2] != DOF_MAG_MAG2 ||
+      dof->dofh_ident[DOF_ID_MAG3] != DOF_MAG_MAG3) {
+    rb_raise(eDtraceDofException, "DOF corrupt: bad magic");
+    return Qnil;
+  }
+
+  dh.dofhp_dof  = (uintptr_t)dof;
+  dh.dofhp_addr = (uintptr_t)dof;
+  (void) snprintf(dh.dofhp_mod, sizeof (dh.dofhp_mod), RSTRING(module_name)->ptr);
+
+  if ((fd = open(helper, O_RDWR)) < 0) {
+    rb_raise(eDtraceDofException, "failed to open helper device %s: %s", 
+	     helper, strerror(errno));
+    return Qnil;
+  }
+  else {
+    if ((gen = _loaddof(fd, &dh)) < 0)
+      rb_raise(eDtraceDofException, "DTrace ioctl failed: %s", strerror(errno));
+
+    (void) close(fd);
+  }
+
+  return Qnil;
+}
+  

data/ext/dof/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+$CFLAGS += " -D_LONGLONG_TYPE -g"
+have_header("sys/dtrace.h")
+create_makefile("dof_api")

data/ext/dof/file.c

@@ -0,0 +1,90 @@
+/* 
+ * Ruby-Dtrace
+ * (c) 2008 Chris Andrews <chris@nodnol.org>
+ */
+
+#include "dof.h"
+
+RUBY_EXTERN eDtraceDofException;
+
+static VALUE dof_file_free(void *arg)
+{
+  dof_file_t *file = (dof_file_t *)arg;
+
+  if (file) {
+    free(file->dof);
+    free(file);
+  }
+}
+
+/* :nodoc: */
+VALUE dof_file_alloc(VALUE klass)
+{
+  VALUE obj;
+  dof_file_t *file;
+
+  file = (dof_file_t *)ALLOC(dof_file_t);
+  if (file == NULL) {
+    rb_raise(eDtraceDofException, "failed to allocate dof_file_t");
+    return Qnil;
+  }
+  file->dof = NULL;
+  file->len = 0;
+  file->offset = 0;
+  
+  obj = Data_Wrap_Struct(klass, NULL, dof_file_free, file);
+  return obj;
+}
+
+/* :nodoc: */
+VALUE dof_file_allocate_dof(VALUE self, VALUE size)
+{
+  dof_file_t *file;
+  Data_Get_Struct(self, dof_file_t, file);
+
+  file->len = FIX2INT(size);
+  file->dof = (char *)ALLOC_N(char, file->len);
+  if (file->dof == NULL) {
+    rb_raise(eDtraceDofException, "failed to allocate %d bytes for DOF", file->len);
+    return Qnil;
+  }
+
+  return Qnil;
+}
+
+/* Appends the given string to the DOF file. */
+VALUE dof_file_append(VALUE self, VALUE data)
+{
+  dof_file_t *file;
+  Data_Get_Struct(self, dof_file_t, file);
+
+  if ((file->offset + RSTRING(data)->len) > file->len) {
+    rb_raise(eDtraceDofException, "DOF allocation insufficient: %d > %d",
+	     (file->offset + RSTRING(data)->len), file->len);
+    return Qnil;
+  }
+  
+  memcpy((file->dof + file->offset), RSTRING(data)->ptr, RSTRING(data)->len);
+  file->offset += RSTRING(data)->len;
+}
+
+/* Returns the memory address of the DOF file. */
+VALUE dof_file_addr(VALUE self)
+{
+  dof_file_t *file;
+  Data_Get_Struct(self, dof_file_t, file);
+  if (file->dof == NULL) {
+    rb_raise(eDtraceDofException, "must allocate DOF buffer before calling addr");
+    return Qnil;
+  }
+  return INT2FIX(file->dof);
+}
+
+/* Returns the DOF itself. */
+VALUE dof_file_data(VALUE self)
+{
+  dof_file_t *file;
+  Data_Get_Struct(self, dof_file_t, file);
+  return rb_str_new(file->dof, file->offset);
+}  
+

data/ext/dof/generator.c

@@ -0,0 +1,9 @@
+/* 
+ * Ruby-Dtrace
+ * (c) 2008 Chris Andrews <chris@nodnol.org>
+ */
+
+#include "dof.h"
+
+RUBY_EXTERN eDtraceDofException;
+

data/ext/dof/header.c

@@ -0,0 +1,79 @@
+/* 
+ * Ruby-Dtrace
+ * (c) 2008 Chris Andrews <chris@nodnol.org>
+ */
+
+#include "dof.h"
+#include <errno.h>
+#include <string.h>
+
+RUBY_EXTERN eDtraceDofException;
+
+/* :nodoc: */
+VALUE dof_generate_header(VALUE self) {
+  dof_hdr_t hdr;
+  uint32_t secnum;
+  uint64_t loadsz;
+  uint64_t filesz;
+  uint64_t hdrlen;
+  VALUE hdr_data;
+  uint8_t dof_version;
+
+  /* DOF versioning: Apple always needs version 3, but Solaris can use
+     1 or 2 depending on whether is-enabled probes are needed. */
+#ifdef __APPLE__
+  dof_version = DOF_VERSION_3;
+#else
+  switch(FIX2INT(rb_iv_get(self, "@dof_version"))) {
+  case 1:
+    dof_version = DOF_VERSION_1;
+    break;
+  case 2:
+    dof_version = DOF_VERSION_2;
+    break;
+  default:
+    dof_version = DOF_VERSION;
+  }
+#endif
+  
+  memset(&hdr, 0, sizeof(hdr));
+  
+  hdr.dofh_ident[DOF_ID_MAG0] = DOF_MAG_MAG0;
+  hdr.dofh_ident[DOF_ID_MAG1] = DOF_MAG_MAG1;
+  hdr.dofh_ident[DOF_ID_MAG2] = DOF_MAG_MAG2;
+  hdr.dofh_ident[DOF_ID_MAG3] = DOF_MAG_MAG3;
+
+  hdr.dofh_ident[DOF_ID_MODEL]    = DOF_MODEL_NATIVE;
+  hdr.dofh_ident[DOF_ID_ENCODING] = DOF_ENCODE_NATIVE;
+  hdr.dofh_ident[DOF_ID_VERSION]  = dof_version;
+  hdr.dofh_ident[DOF_ID_DIFVERS]  = DIF_VERSION;
+  hdr.dofh_ident[DOF_ID_DIFIREG]  = DIF_DIR_NREGS;
+  hdr.dofh_ident[DOF_ID_DIFTREG]  = DIF_DTR_NREGS;
+  
+  hdr.dofh_hdrsize = sizeof(dof_hdr_t);
+  hdr.dofh_secsize = sizeof(dof_sec_t);
+  
+  secnum = FIX2INT(rb_iv_get(self, "@secnum"));
+  hdr.dofh_secnum = secnum;
+
+  hdr.dofh_loadsz = FIX2INT(rb_iv_get(self, "@loadsz"));
+  hdr.dofh_filesz = FIX2INT(rb_iv_get(self, "@filesz"));
+  
+  hdrlen = (sizeof(dof_hdr_t) + secnum * sizeof(dof_sec_t));
+  rb_iv_set(self, "@hdrlen", INT2FIX(hdrlen));
+  hdr.dofh_secoff = sizeof(dof_hdr_t);
+
+  hdr_data = rb_str_new((const char *)&hdr, sizeof(hdr));
+  return hdr_data;
+}
+
+/* :nodoc: */
+VALUE dof_header_len(VALUE self) {
+  uint64_t hdrlen;
+  uint32_t secnum;
+
+  secnum = FIX2INT(rb_iv_get(self, "@secnum"));
+  hdrlen = (sizeof(dof_hdr_t) + secnum * sizeof(dof_sec_t));
+  
+  return INT2FIX(hdrlen);
+}

data/ext/dof/mkmf.log

@@ -0,0 +1,10 @@
+have_header: checking for sys/dtrace.h... -------------------- yes
+
+"/usr/bin/cpp-4.0 -I. -I/opt/local/lib/ruby/1.8/i686-darwin9.7.0 -I. -I/opt/local/include  -O2  -fno-common -pipe -fno-common -D_LONGLONG_TYPE -g  conftest.c -o conftest.i"
+checked program was:
+/* begin */
+1: #include <sys/dtrace.h>
+/* end */
+
+--------------------
+