ruby-dtrace 0.0.6 → 0.2.8

data/lib/dtrace/dof.rb

@@ -0,0 +1,8 @@
+#
+# Ruby-Dtrace
+# (c) 2008 Chris Andrews <chris@nodnol.org>
+#
+
+require 'dof/dof_api'
+require 'dtrace/dof/section'
+require 'dtrace/dof/file'

data/lib/dtrace/dof/file.rb

@@ -0,0 +1,64 @@
+#
+# Ruby-Dtrace
+# (c) 2008 Chris Andrews <chris@nodnol.org>
+#
+
+class Dtrace::Dof::File
+  include Dtrace::Dof::Constants
+  attr_accessor :sections
+
+  def initialize
+    @sections = []
+  end
+
+  def generate
+    hdr = Dtrace::Dof::Header.new
+    hdr.secnum = @sections.length
+    filesz = hdr.hdrlen
+    loadsz = filesz
+    dof_version = 1
+
+    @sections.each do |s|
+      # Presence of is_enabled probes forces DOF version 2.
+      if s.section_type == DOF_SECT_PRENOFFS
+        dof_version = 2
+      end
+      
+      length = s.generate
+      s.offset = filesz
+
+      pad = 0
+      if s.align > 1
+        i = s.offset.to_f % s.align
+        if i > 0
+          pad = (s.align - i).to_i
+          s.offset = pad + s.offset
+          s.pad = "\000" * pad
+        end
+      end
+
+      s.size = length
+
+      loadsz += (s.size + pad) if (s.flags & 1) == 1 # DOF_SECF_LOAD
+      filesz += (s.size + pad)
+
+    end
+    
+    hdr.loadsz = loadsz
+    hdr.filesz = filesz
+    hdr.dof_version = dof_version
+
+    self << hdr.generate
+    
+    @sections.each do |s|
+      self << s.generate_header
+    end
+      
+    @sections.each do |s|
+      self << s.pad if s.pad
+      self << s.dof
+    end
+
+  end
+end
+  

data/lib/dtrace/dof/section.rb

@@ -0,0 +1,75 @@
+#
+# Ruby-Dtrace
+# (c) 2008 Chris Andrews <chris@nodnol.org>
+#
+
+require 'dtrace/dof/section/strtab'
+
+class Dtrace::Dof::Section
+  include Dtrace::Dof::Constants
+  attr_writer :entsize
+  attr_accessor :flags, :data, :offset, :align, :pad, :size
+  attr_reader :section_type, :dof
+  
+  def initialize(type, index)
+    @section_type  = type
+    @index         = index
+    @flags         = 1 # DOF_SECF_LOAD
+    @data          = {}
+  end
+
+  def generate
+    case @section_type
+    when DOF_SECT_COMMENTS
+      @align = 1
+      @dof = dof_generate_comments
+    when DOF_SECT_STRTAB
+      @align = 1
+      @dof = dof_generate_strtab
+    when DOF_SECT_PROBES
+      @align = 8
+      @dof = dof_generate_probes
+    when DOF_SECT_PRARGS
+      @align = 1
+      @dof = dof_generate_prargs
+    when DOF_SECT_PROFFS
+      @align = 4
+      @dof = dof_generate_proffs
+    when DOF_SECT_PRENOFFS
+      @align = 4
+      @dof = dof_generate_prenoffs
+    when DOF_SECT_PROVIDER
+      @align = 4
+      @dof = dof_generate_provider
+    when DOF_SECT_RELTAB
+      @align = 8
+      @dof = dof_generate_reltab
+    when DOF_SECT_URELHDR
+      @align = 4
+      @dof = dof_generate_relhdr
+    when DOF_SECT_UTSNAME
+      @align = 1
+      @dof = dof_generate_utsname
+    else
+      @dof = ''
+    end
+
+    @entsize = compute_entsize
+    
+    return @dof.length
+  end
+
+  def compute_entsize
+    begin
+      if @data.class == Array
+        entsize = @dof.length / @data.length
+      else
+        entsize = 0
+      end
+    rescue ZeroDivisionError
+      entsize = 0
+    end
+    entsize
+  end
+
+end

data/lib/dtrace/dof/section/strtab.rb

@@ -0,0 +1,28 @@
+#
+# Ruby-Dtrace
+# (c) 2008 Chris Andrews <chris@nodnol.org>
+#
+
+class Dtrace::Dof::Section::Strtab < Dtrace::Dof::Section
+  def initialize(index)
+    super(DOF_SECT_STRTAB, index)
+    self.data = []
+    @idx = 1
+  end
+
+  def add(string)
+    idx = @idx
+    string = string.to_s
+    @idx += (string.length + 1)
+    self.data << string
+    return idx
+  end
+
+  def length
+    return @idx
+  end
+
+  def compute_entsize 
+    0
+  end
+end

data/lib/{dtraceprintfrecord.rb → dtrace/printfrecord.rb}

@@ -3,6 +3,8 @@
 # (c) 2007 Chris Andrews <chris@nodnol.org>
 #
 # A DTrace record for the formatted part of a printf() action. 
-class DtracePrintfRecord
-  attr_accessor :value
+class Dtrace
+  class PrintfRecord
+    attr_accessor :value
+  end
 end

data/lib/dtrace/probe.rb

@@ -1,12 +1,10 @@
 #
 # Ruby-Dtrace
-# (c) 2007 Chris Andrews <chris@nodnol.org>
-#
+# (c) 2008 Chris Andrews <chris@nodnol.org>
 
 class Dtrace
-  # DTrace::Probe - Using dynamically created USDT probes in Ruby
-  # programs:
-  #
+  # Using dynamically created USDT probes in Ruby programs.
+  # 
   # Having created the following probes with Dtrace::Provider:
   #
   #   74777 action_controller12297 action_controller.so process_finish process-finish
@@ -46,4 +44,3 @@ class Dtrace
   class Probe
   end
 end
-

data/lib/dtrace/probedata.rb

@@ -0,0 +1,23 @@
+#
+# Ruby-Dtrace
+# (c) 2007 Chris Andrews <chris@nodnol.org>
+#
+
+class Dtrace
+  class ProbeData
+    
+    def records
+      records = Array.new
+      self.each_record do |rec|
+        records << rec
+      end
+      records
+    end
+
+    def to_s
+      rs = self.records
+      rs.map {|r| r.value }.join ', '
+    end
+
+  end
+end

data/lib/dtrace/probedesc.rb

@@ -0,0 +1,15 @@
+#
+# Ruby-Dtrace
+# (c) 2007 Chris Andrews <chris@nodnol.org>
+#
+
+class Dtrace
+  class ProbeDesc
+    
+    def to_s
+      "#{provider}:#{mod}:#{func}:#{name}"
+    end
+
+  end
+end
+    

data/lib/dtrace/provider.rb

@@ -1,61 +1,28 @@
 #
 # Ruby-Dtrace
-# (c) 2007 Chris Andrews <chris@nodnol.org>
+# (c) 2008 Chris Andrews <chris@nodnol.org>
 #
 
+require 'dtrace'
+require 'dtrace/dof'
 require 'dtrace/probe'
-require 'dtrace/provider/solaris'
-require 'dtrace/provider/osx'
-require 'pathname'
-require 'tempfile'
-
-DTRACE = '/usr/sbin/dtrace'
+require 'dtrace/provider/probedef'
+require 'dtrace/provider/klass'
 
 class Dtrace
 
   # A DTrace provider. Allows creation of USDT probes on a running
-  # Ruby program, by dynamically creating an extension module
-  # implementing the probes, and compiling and loading it. You can use
-  # this with a Ruby interpreter compiled with the core DTrace probes,
-  # but you don't have to.
-  #
-  # This requires the DTrace and Ruby toolchains to be available:
-  # dtrace(1M), and the compiler and linker used to build Ruby. The
-  # process is similar to RubyInline, but the actual RubyInline
-  # library is not required (the build process for DTrace USDT probes
-  # is sufficiently differnent to a standard Ruby extension that it's
-  # not worth using it).
-  #
-  # Both Solaris and OSX 10.5 are supported. Other DTrace-supporting
-  # platforms can be added by creating a new class under
-  # Dtrace::Provider and implementing or overriding the required steps
-  # in the build process.
+  # Ruby program. You can use this with a Ruby interpreter compiled
+  # with the core DTrace probes, but you don't have to.
   #
   # Firing probes is explained in Dtrace::Probe.
   #
-  # There are some limitations:
-  #
-  # You cannot choose all the components of the probe name: you can
-  # choose the provider and probe name, but the module and function
-  # components will be derived by DTrace, and won't be meaningful
-  # (they'll refer to the shim extension that gets created, not to
-  # anything in your Ruby program). It seems unlikely it's possible to
-  # change this. 
-  #
-  # You cannot currently set D attributes: they're hardcoded to a
-  # default set. This will change. 
-  #
-  # The extension will currently be rebuilt every time the provider is
-  # created, as there's not yet any support for packaging the provider
-  # in some way. This will change, to something along the lines of
-  # what RubyInline does to allow a pre-built extension to be used.
-  #
   class Provider
+    include Dtrace::Dof::Constants
 
-    class BuildError < StandardError; end
+    Typemap = { :string => 'char *', :integer => 'int' } 
 
-    # Creates a DTrace provider. Causes a shim extension to be built
-    # and loaded, implementing the probes. 
+    # Creates a DTrace provider.
     #
     # Example:
     # 
@@ -71,12 +38,15 @@ class Dtrace
     # create yields a Provider for the current platform, on which you
     # can call probe, to create the individual probes. 
     # 
-    def self.create(name)
-      if RUBY_PLATFORM =~ /darwin/
-        provider = Dtrace::Provider::OSX.new(name)
-      else
-        provider = Dtrace::Provider::Solaris.new(name)
-      end
+    # You can override the module name in the created probes, by
+    # passing in an hash:
+    #
+    #   Dtrace::Provider.create :foo, { :module => 'somemodule' } do |p|
+    #     p.probe...
+    #   end
+    def self.create(name, options={})
+      options[:module] ||= 'ruby'
+      provider = Dtrace::Provider.new(name, options[:module])
       yield provider
       provider.enable
     end
@@ -88,61 +58,192 @@ class Dtrace
     # :string  (char *)
     # :integer (int)
     #
-    # The probe will be named based on the provider name and the
-    # probe's name:
-    #
-    #   provider_name:provider_name.so:probe_name:probe-name
+    # Providing an options hash as the second argument allows you to
+    # override the function name, otherwise it will be taken from the
+    # caller of this function:
     #
-    # See the limitations explained elsewhere for an explanation of
-    # this redundancy in probe names.
+    #   p.probe :foo, { :function => 'somefunction' }, :int, ...
     #
     def probe(name, *types) 
-      typemap = { :string => 'char *', :integer => 'int' } 
-      @probes[name] = types.map {|t| typemap[t]} 
+      options = {}
+      if types[0].respond_to? :keys
+        options = types.shift
+      end
+      caller = Kernel.caller[0].match(/`(.*)'/)
+      if caller
+        options[:function] ||= caller[1]
+      else
+        options[:function] ||= name
+      end
+
+      pd = Dtrace::Provider::ProbeDef.new(name, options[:function])
+      types.each do |t|
+        if Typemap[t].nil?
+          raise Dtrace::Exception.new("type '#{t}' invalid")
+        else
+          pd.args << Typemap[t]
+        end
+      end
+
+      @probe_defs << pd
     end
 
-    def initialize(name)
-      @name   = name.to_s
-      @class  = camelize(name)
-      @probes = {}
+    def initialize(provider_name, module_name)
+      @name       = provider_name.to_s
+      @module     = module_name.to_s
+      @class      = camelize(provider_name)
+      @probe_defs = []
+    end
+
+    # attempt to turn the probe_count into the eventual size of DOF
+    # we'll need, based on the current state of the strtab.
+    def dof_size
+      probes = @probe_defs.length
+      args = (@probe_defs.inject(0) {|sum, pd| sum + pd.args.length }) + 1
+      
+      size = 0
+      [
+       DOF_DOFHDR_SIZE,
+       DOF_SECHDR_SIZE *  6,          # we have 6 sections, see provider.rb
+       @strtab.length,                # we're told the size of the string table
+       (DOF_PROBE_SIZE * probes),     # probes
+       (DOF_PRARGS_SIZE * args),      # prargs
+       (DOF_PROFFS_SIZE * probes),    # proffs
+       (DOF_PRENOFFS_SIZE * probes),  # prenoffs
+       DOF_PROVIDER_SIZE              # provider
+      ].each do |sec|
+        size += sec
+        i = size.to_f % 8 # assume longest alignment, 8, will overestimate but not by much
+        if i > 0
+          size += (8 - i).to_i
+        end
+      end
+      size
     end
 
     def enable
-      Tempfile.open("dtrace_probe_#{@name}") do |f|
-        p = Pathname.new(f.path)
-        @tempdir = "#{p.dirname}/#{@name}" 
-        begin
-          Dir.mkdir @tempdir
-        rescue Errno::EEXIST
-          nil
+      @strtab = Dtrace::Dof::Section::Strtab.new(0)
+      provider_name_idx = @strtab.add(@name)
+
+      f = Dtrace::Dof::File.new
+      f.sections << @strtab
+
+      s = Dtrace::Dof::Section.new(DOF_SECT_PROBES, 1)
+      probes = Array.new
+      stubs = Hash.new
+      argidx = 0
+      offidx = 0
+      @probe_defs.each do |pd|
+        argc = pd.argc
+        
+        argv = 0
+        pd.args.each do |type|
+          i = @strtab.add(type)
+          argv = i if argv == 0
         end
+        
+        probe = Dtrace::Probe.new(argc)
+        probes <<
+          {
+          :name     => @strtab.add(pd.name),
+          :func     => @strtab.add(pd.function),
+          :noffs    => 1,
+          :enoffidx => offidx,
+          :argidx   => argidx,
+          :nenoffs  => 1,
+          :offidx   => offidx,
+          :addr     => probe.addr,
+          :nargc    => argc,
+          :xargc    => argc,
+          :nargv    => argv,
+          :xargv    => argv,
+        }
+        
+        stubs[pd.name] = probe
+        argidx += argc
+        offidx += 1
+      end
+      s.data = probes
+      f.sections << s
 
-        # Probe setup is split up for easy overriding
-        definition
-        header
-        source
-        ruby_object
-        dtrace_object
-        link
-        load
+      s = Dtrace::Dof::Section.new(DOF_SECT_PRARGS, 2)
+      s.data = Array.new
+      @probe_defs.each do |pd|
+        pd.args.each_with_index do |arg, i|
+          s.data << i
+        end
       end
-    end
+      if s.data.empty?
+        s.data = [ 0 ]
+      end
+      f.sections << s
+      
+      # After last addition to strtab, but before first offset!
+      f.allocate(self.dof_size)
 
-    protected
+      s = Dtrace::Dof::Section.new(DOF_SECT_PROFFS, 3)
+      s.data = Array.new
+      @probe_defs.each do |pd|
+        s.data << stubs[pd.name].probe_offset(f.addr, pd.argc)
+      end
+      if s.data.empty?
+        s.data = [ 0 ]
+      end
+      f.sections << s
 
-    def run(cmd)
-      result = `#{cmd}`
-      if $? != 0
-        raise BuildError.new("Error running:\n#{cmd}\n\n#{result}")
+      s = Dtrace::Dof::Section.new(DOF_SECT_PRENOFFS, 4)
+      s.data = Array.new
+      @probe_defs.each do |pd|
+        s.data << stubs[pd.name].is_enabled_offset(f.addr)
       end
-    end
+      if s.data.empty?
+        s.data = [ 0 ]
+      end
+      f.sections << s
+      
+      s = Dtrace::Dof::Section.new(DOF_SECT_PROVIDER, 5)
+      s.data = {
+        :strtab => 0,
+        :probes => 1,
+        :prargs => 2,
+        :proffs => 3,
+        :prenoffs => 4,
+        :name => provider_name_idx,
+        :provattr => { 
+          :name  => DTRACE_STABILITY_EVOLVING,
+          :data  => DTRACE_STABILITY_EVOLVING,
+          :class => DTRACE_STABILITY_EVOLVING 
+        },
+        :modattr  => { 
+          :name => DTRACE_STABILITY_PRIVATE,
+          :data => DTRACE_STABILITY_PRIVATE,
+          :class => DTRACE_STABILITY_EVOLVING 
+        },
+        :funcattr => { 
+          :name => DTRACE_STABILITY_PRIVATE,
+          :data => DTRACE_STABILITY_PRIVATE,
+          :class => DTRACE_STABILITY_EVOLVING
+        },
+        :nameattr => { 
+          :name => DTRACE_STABILITY_EVOLVING,
+          :data => DTRACE_STABILITY_EVOLVING,
+          :class => DTRACE_STABILITY_EVOLVING
+        },
+        :argsattr => {
+          :name => DTRACE_STABILITY_EVOLVING,
+          :data => DTRACE_STABILITY_EVOLVING,
+          :class => DTRACE_STABILITY_EVOLVING
+        },
+      }
+      f.sections << s
+
+      f.generate
+      Dtrace::Dof.loaddof(f, @module)
+      
+      provider = Dtrace::Provider::Klass.new(f, stubs)
+      Dtrace::Probe.const_set(@class, provider)
 
-    def hdrdir
-      %w(srcdir archdir).map { |name|
-        dir = Config::CONFIG[name]
-      }.find { |dir|
-        dir and File.exist? File.join(dir, "/ruby.h")
-      } or abort "ERROR: Can't find header dir for ruby. Exiting..."
+      provider
     end
 
     private
@@ -151,86 +252,6 @@ class Dtrace
       # Pinched from ActiveSupport's Inflector
       lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
     end
-
-    # compose provider definition .d file
-    def definition
-      stability = <<EOS
-#pragma D attributes Evolving/Evolving/Common provider #{@name} provider
-#pragma D attributes Private/Private/Common provider #{@name} module
-#pragma D attributes Private/Private/Common provider #{@name} function
-#pragma D attributes Evolving/Evolving/Common provider #{@name} name
-#pragma D attributes Evolving/Evolving/Common provider #{@name} args
-EOS
-      File.open("#{@tempdir}/probes.d", 'w') do |io|
-        io << "provider #{@name} {\n"
-        @probes.each_pair do |name, types|
-          probename = name.to_s.gsub(/_/, '__')
-          typesdesc = types.join(', ')
-          probedesc = "  probe #{probename}(#{typesdesc});\n"
-          io << probedesc
-        end
-        io << "\n};\n\n#{stability}"
-      end
-    end
-
-    def header
-      run "#{DTRACE} -h -s #{@tempdir}/probes.d -o #{@tempdir}/probes.h"
-    end
-
-    # Generate the C source for the provider class
-    def source
-      rb2c = { 'char *' => 'STR2CSTR', 'int' => 'FIX2INT' }
-      
-      File.open("#{@tempdir}/probes.c", 'w') do |io|
-        io.puts '#include "ruby.h"'
-        io.puts "#include \"#{@tempdir}/probes.h\""
-
-        @probes.each_pair do |name, types|
-          defn_args = []
-          call_args = []
-          types.each_with_index { |type, i| defn_args << "#{type} arg#{i}" }
-          types.each_with_index { |type, i| call_args << "#{rb2c[type]}(rb_ary_entry(args, #{i}))" }
-          
-          io.puts <<EOC
-static VALUE #{name}(VALUE self) {
-  if (#{@name.upcase}_#{name.to_s.upcase}_ENABLED()) {
-    VALUE args = rb_yield(self);
-    #{@name.upcase}_#{name.to_s.upcase}(#{call_args.join(', ')});
-  }
-  return Qnil;
-}
-EOC
-        end
-        io.puts <<EOC
-static VALUE fire(VALUE self, VALUE args) {
-  return args;
-}
-
-void Init_#{@name}() {
-  VALUE c = rb_cObject;
-  rb_define_method(c, "fire", (VALUE(*)(ANYARGS))fire, -2);
-EOC
-        
-        @probes.each_pair do |name, types|
-          io.puts "  rb_define_singleton_method(c, \"#{name}\", (VALUE(*)(ANYARGS))#{name}, 0);"
-        end
-        
-        io.puts '}'
-      end
-    end
-    
-    def load
-      # Load the generated extension with a full path (saves adjusting
-      # $:) Done in the context of an anonymous class, since the
-      # module does not itself define a class.  TODO: find a way of
-      # doing this without string eval...
-      lib = "#{@tempdir}/#{@name}"
-      c = Class.new
-      c.module_eval do 
-        require lib
-      end
-      eval "Dtrace::Probe::#{@class} = c"
-    end
     
   end
 end