memprof 0.1.3 → 0.2.0

data/ext/x86_64.c

@@ -0,0 +1,124 @@
+#if defined (_ARCH_x86_64_)
+
+#include <stdint.h>
+#include <string.h>
+
+#include "arch.h"
+#include "x86_gen.h"
+
+/* This is the stage 1 inline trampoline for hooking the inlined add_freelist
+ * function .
+ *
+ * NOTE: The original instruction mov %reg, freelist is 7 bytes wide,
+ * whereas jmpq $displacement is only 5 bytes wide. We *must* pad out
+ * the next two bytes. This will be important to remember below.
+ */
+struct inline_st1_tramp {
+  unsigned char jmp;
+  int32_t displacement;
+  unsigned char pad[2];
+} __attribute__((__packed__)) inline_st1_tramp = {
+  .jmp  = '\xe9',
+  .displacement = 0,
+  .pad = {'\x90','\x90'},
+};
+
+struct inline_st1_base {
+  unsigned char rex;
+  unsigned char mov;
+  unsigned char src_reg;
+  int32_t displacement;
+} __attribute__((__packed__)) inline_st1_mov = {
+  .rex = 0,
+  .mov = '\x89',
+  .src_reg = 0,
+  .displacement = 0
+};
+
+/*
+ *  inline tramp stuff below
+ */
+static int
+arch_check_ins(struct inline_st1_base *base)
+{
+  /* is it a mov instruction? */
+  if (base->mov == 0x89 &&
+
+      /* maybe. read the REX byte to find out for sure */
+      (base->rex == 0x48 ||
+       base->rex == 0x4c)) {
+
+      /* success */
+      return 1;
+  }
+
+  return 0;
+}
+
+int
+arch_insert_inline_st2_tramp(void *addr, void *marker, void *trampoline, void *table_entry)
+{
+  struct inline_st1_base *base = addr;
+  struct inline_tramp_st2_entry *entry = table_entry;
+
+  if (!arch_check_ins(base))
+    return 1;
+
+  /* Sanity check. Ensure that the displacement from freelist to the next
+   * instruction matches the mov_target. If so, we know this mov is
+   * updating freelist.
+   */
+  if (marker - (void *)(base + 1) == base->displacement) {
+    /* Before the stage 1 trampoline gets written, we need to generate
+     * the code for the stage 2 trampoline. Let's copy over the REX byte
+     * and the byte which mentions the source register into the stage 2
+     * trampoline.
+     */
+    default_inline_st2_tramp.rex = base->rex;
+    default_inline_st2_tramp.src_reg = base->src_reg;
+
+    /* Setup the stage 1 trampoline. Calculate the displacement to
+     * the stage 2 trampoline from the next instruction.
+     *
+     * REMEMBER!!!! The next instruction will be NOP after our stage 1
+     * trampoline is written. This is 5 bytes into the structure, even
+     * though the original instruction we overwrote was 7 bytes.
+     */
+    inline_st1_tramp.displacement = table_entry - (void *)(addr + 5);
+
+    copy_instructions(addr, &inline_st1_tramp, sizeof(inline_st1_tramp));
+
+    /* Finish setting up the stage 2 trampoline. */
+
+    /* calculate the displacement to freelist from the next instruction.
+     *
+     * This is used to replicate the original instruction we overwrote.
+     */
+    default_inline_st2_tramp.mov_displacement = marker - (void *)&(entry->frame);
+
+    /* fill in the displacement to freelist from the next instruction.
+     *
+     * This is to arrange for the new value in freelist to be in %rdi, and as such
+     * be the first argument to the C handler. As per the amd64 ABI.
+     */
+    default_inline_st2_tramp.frame.rdi_source_displacement = marker - (void *)&(entry->frame.push_rbx);
+
+    /* jmp back to the instruction after stage 1 trampoline was inserted
+     *
+     * This can be 5 or 7, it doesn't matter. If its 5, we'll hit our 2
+     * NOPS. If its 7, we'll land directly on the next instruction.
+     */
+    default_inline_st2_tramp.jmp_displacement = (addr + sizeof(*base)) -
+                                                 (table_entry + sizeof(default_inline_st2_tramp));
+
+    /* write the address of our C level trampoline in to the structure */
+    default_inline_st2_tramp.frame.addr = trampoline;
+
+    memcpy(table_entry, &default_inline_st2_tramp, sizeof(default_inline_st2_tramp));
+
+    return 0;
+  }
+
+  return 1;
+}
+#endif

data/ext/x86_64.h

@@ -0,0 +1,78 @@
+#if !defined(_x86_64_h_)
+#define _x86_64_h_
+
+#include <stdint.h>
+#include "arch.h"
+
+/*
+ * This is the "normal" stage 2 trampoline with a default entry pre-filled
+ */
+static struct tramp_st2_entry {
+  unsigned char rbx_save;
+  unsigned char mov[2];
+  void *addr;
+  unsigned char call[2];
+  unsigned char rbx_restore;
+  unsigned char ret;
+} __attribute__((__packed__)) default_st2_tramp = {
+  .rbx_save      = 0x53,                // push rbx
+  .mov           = {'\x48', '\xbb'},    // mov addr into rbx
+  .addr          = 0,                   // ^^^
+  .call         = {'\xff', '\xd3'},     // call rbx
+  .rbx_restore   = 0x5b,                // pop rbx
+  .ret           = 0xc3,                // ret
+};
+
+/*
+ * This is the inline stage 2 trampoline with a default entry pre-filled
+ */
+static struct inline_tramp_st2_entry {
+  unsigned char rex;
+  unsigned char mov;
+  unsigned char src_reg;
+  uint32_t mov_displacement;
+
+  struct {
+    unsigned char push_rdi;
+    unsigned char mov_rdi[3];
+    uint32_t rdi_source_displacement;
+    unsigned char push_rbx;
+    unsigned char push_rbp;
+    unsigned char save_rsp[3];
+    unsigned char align_rsp[4];
+    unsigned char mov[2];
+    void *addr;
+    unsigned char call[2];
+    unsigned char leave;
+    unsigned char rbx_restore;
+    unsigned char rdi_restore;
+  } __attribute__((__packed__)) frame;
+
+  unsigned char jmp;
+  uint32_t jmp_displacement;
+} __attribute__((__packed__)) default_inline_st2_tramp = {
+  .rex     = 0x48,
+  .mov     = 0x89,
+  .src_reg = 0x05,
+  .mov_displacement = 0,
+
+  .frame = {
+    .push_rdi = 0x57,
+    .mov_rdi = {'\x48', '\x8b', '\x3d'},
+    .rdi_source_displacement = 0,
+    .push_rbx = 0x53,
+    .push_rbp = 0x55,
+    .save_rsp = {'\x48', '\x89', '\xe5'},
+    .align_rsp = {'\x48', '\x83', '\xe4', '\xf0'},
+    .mov = {'\x48', '\xbb'},
+    .addr = 0,
+    .call = {'\xff', '\xd3'},
+    .leave = 0xc9,
+    .rbx_restore = 0x5b,
+    .rdi_restore = 0x5f,
+  },
+
+  .jmp  = 0xe9,
+  .jmp_displacement = 0,
+};
+#endif

data/ext/x86_gen.h

@@ -0,0 +1,100 @@
+#if !defined(_x86_gen_)
+#define _x86_gen_
+
+#include <sys/mman.h>
+#include <stdint.h>
+#include "arch.h"
+
+/* This structure makes it easier to find and update call instructions that
+ * will become the stage 1 trampoline
+ */
+struct st1_base {
+  unsigned char call;
+  int32_t displacement;
+} __attribute__((__packed__)) st1_mov = {
+  .call        =  '\xe8',
+  .displacement =  0,
+};
+
+struct plt_entry {
+    unsigned char jmp[2];
+    uint32_t jmp_disp;
+    unsigned char pad[10];
+} __attribute__((__packed__));
+
+static inline void *
+page_align(void *addr)
+{
+  return (void *)((size_t)addr & ~(0xFFFF));
+}
+
+static void
+copy_instructions(void *to, void *from, size_t count)
+{
+  void *aligned_addr = page_align(to);
+  mprotect(aligned_addr, (to - aligned_addr) + 10, PROT_READ|PROT_WRITE|PROT_EXEC);
+  memcpy(to, from, count);
+  mprotect(aligned_addr, (to - aligned_addr) + 10, PROT_READ|PROT_EXEC);
+
+  return;
+}
+
+#define WRITE_INSTRUCTIONS(start, len, stmt) do { \
+  mprotect(start, len, PROT_READ | PROT_WRITE | PROT_EXEC); \
+  stmt; \
+  mprotect(start, len, PROT_READ | PROT_EXEC); \
+} while (0)
+
+void
+arch_insert_st1_tramp(void *start, void *trampee, void *tramp)
+{
+  int32_t fn_addr = 0;
+  struct st1_base *check = (struct st1_base *)start;
+  void *aligned_addr = page_align(&(check->displacement));
+
+  if (check->call == 0xe8) {
+    fn_addr = check->displacement;
+    if ((trampee - (void *)(check + 1)) == fn_addr) {
+      WRITE_INSTRUCTIONS(aligned_addr,
+                         ((void *)&(check->displacement) - aligned_addr) + 10,
+                         (check->displacement = (tramp - (void *)(check + 1))));
+    }
+  }
+
+  return;
+}
+
+static void *
+get_got_addr(struct plt_entry *plt)
+{
+  return (void *)&(plt->pad) + plt->jmp_disp;
+}
+
+void
+arch_overwrite_got(void *plt, void *tramp)
+{
+  memcpy(get_got_addr(plt), &tramp, sizeof(void *));
+  return;
+}
+
+void *
+arch_get_st2_tramp(size_t *size)
+{
+  if (size) {
+    *size = sizeof(struct tramp_st2_entry);
+  }
+
+  return &default_st2_tramp;
+}
+
+
+void *
+arch_get_inline_st2_tramp(size_t *size)
+{
+  if (size) {
+    *size = sizeof(struct inline_tramp_st2_entry);
+  }
+
+  return &default_inline_st2_tramp;
+}
+#endif

data/memprof.gemspec

@@ -1,6 +1,6 @@
 spec = Gem::Specification.new do |s|
   s.name = 'memprof'
-  s.version = '0.1.3'
+  s.version = '0.2.0'
   s.date = '2009-12-14'
   s.summary = 'Ruby Memory Profiler'
   s.description = "Ruby memory profiler similar to bleak_house, but without patches to the Ruby VM"
@@ -12,12 +12,21 @@ spec = Gem::Specification.new do |s|
   s.files = %w[
     .gitignore
     README
+    ext/arch.h
     ext/bin_api.h
     ext/elf.c
     ext/extconf.rb
+    ext/i386.c
+    ext/i386.h
     ext/mach.c
     ext/memprof.c
+    ext/src/libdwarf-20091118.tar.gz
     ext/src/libelf-0.8.13.tar.gz
+    ext/src/yajl-1.0.8.tar.gz
+    ext/x86_64.c
+    ext/x86_64.h
+    ext/x86_gen.h
     memprof.gemspec
+    spec/memprof_spec.rb
   ]
 end

data/spec/memprof_spec.rb

@@ -0,0 +1,85 @@
+require File.dirname(__FILE__) + "/../ext/memprof"
+
+require 'rubygems'
+require 'bacon'
+Bacon.summary_on_exit
+
+require 'tempfile'
+
+describe Memprof do
+  @tempfile = Tempfile.new('memprof_spec')
+
+  def filename
+    @tempfile.path
+  end
+
+  def filedata
+    File.read(filename)
+  end
+
+  before do
+    Memprof.stop
+  end
+
+  should 'print stats to a file' do
+    Memprof.start
+    "abc"
+    Memprof.stats(filename)
+
+    filedata.strip.should == "1 #{__FILE__}:#{__LINE__-3}:String"
+  end
+
+  should 'allow calling ::stats multiple times' do
+    Memprof.start
+    []
+    Memprof.stats(filename)
+    []
+    Memprof.stats(filename)
+
+    filedata.strip.split("\n").size.should == 2
+  end
+
+  should 'clear stats after ::stats!' do
+    Memprof.start
+    []
+    Memprof.stats!(filename)
+    Memprof.stats(filename)
+
+    filedata.strip.should.be.empty
+  end
+
+  should 'collect stats via ::track' do
+    Memprof.track(filename) do
+      "abc"
+    end
+
+    filedata.should =~ /1 #{__FILE__}:#{__LINE__-3}:String/
+  end
+
+  should 'dump objects as json' do
+    Memprof.start
+    1.23+1
+    Memprof.dump(filename)
+
+    filedata.should =~ /"source": "#{__FILE__}:#{__LINE__-3}"/
+    filedata.should =~ /"type": "float"/
+    filedata.should =~ /"data": 2\.23/
+  end
+
+  should 'raise error when calling ::stats or ::dump without ::start' do
+    lambda{ Memprof.stats }.should.raise(RuntimeError).message.should =~ /Memprof.start/
+    lambda{ Memprof.dump }.should.raise(RuntimeError).message.should =~ /Memprof.start/
+  end
+
+  should 'dump out the entire heap' do
+    Memprof.stop
+    Memprof.dump_all(filename)
+
+    File.open(filename, 'r').each_line do |line|
+      if line =~ /"data": "dump out the entire heap"/
+        break :found
+      end
+    end.should == :found
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: memprof
 version: !ruby/object:Gem::Version 
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors: 
 - Joe Damato
@@ -26,13 +26,22 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - README
+- ext/arch.h
 - ext/bin_api.h
 - ext/elf.c
 - ext/extconf.rb
+- ext/i386.c
+- ext/i386.h
 - ext/mach.c
 - ext/memprof.c
+- ext/src/libdwarf-20091118.tar.gz
 - ext/src/libelf-0.8.13.tar.gz
+- ext/src/yajl-1.0.8.tar.gz
+- ext/x86_64.c
+- ext/x86_64.h
+- ext/x86_gen.h
 - memprof.gemspec
+- spec/memprof_spec.rb
 has_rdoc: true
 homepage: http://github.com/ice799/memprof
 licenses: []