memprof 0.3.0 → 0.3.1

data/bin/memprof

@@ -26,7 +26,8 @@ class MemprofUploader
       opts.on("-n", "--name <name>",        "Name for your dump               (required)")      {|arg| @name = arg }
       opts.on("-k", "--key <key>",          "Memprof.com API key              (required)")      {|arg| @key = arg }
       opts.on("-d", "--[no-]delete",        "Delete dump file after uploading (default true)")  {|arg| @delete_dump = arg }
-      opts.on("-s", "--seconds <seconds>",  "Seconds to wait for the dump     (default 60)")     {|arg| @secs = arg}
+      opts.on("-s", "--seconds <seconds>",
+                    Integer,                "Seconds to wait for the dump     (default 300)")   {|arg| @secs = arg }
       opts.on("-t", "--[no-]test",          "Test run (don't actually upload) (default false)") {|arg| @test = arg }
       opts.on("-f", "--file <path>",        "Upload specific json dump        (optional)")      {|arg| @file = arg }
       opts.on("--put-my-data-on-the-internet",  "Confirm that you understand\n" +
@@ -48,7 +49,7 @@ class MemprofUploader
     @delete_dump = true if @delete_dump.nil?
 
     # Make this default to 60 if the user didn't pass the number of seconds.
-    @secs = 60 if @secs.nil?
+    @secs ||= 300
 
     if @file
       fail_with("File not found: #{@file}") unless File.exists?(@file)
@@ -96,13 +97,14 @@ class MemprofUploader
     # We'll compare against this later to see which is the new file.
     old_files = Dir.glob("/tmp/memprof-#{pid}-*")
     signal_process(pid)
-    puts "Waiting 5 seconds for process #{pid} to create a new dump..."
+    timeout = 30
+    puts "Waiting #{timeout} seconds for process #{pid} to create a new dump..."
 
     file = nil
 
-    5.times do |i|
+    timeout.times do |i|
       sleep 1 unless file = (Dir.glob("/tmp/memprof-#{pid}-*") - old_files).first and break
-      fail_with("Timed out after waiting 5 seconds. Make sure you added require '#{File.expand_path('../../lib/memprof/signal', __FILE__)}' to your application.") if i+1 == 5
+      fail_with("Timed out after waiting #{timeout} seconds. Make sure you added require '#{File.expand_path('../../lib/memprof/signal', __FILE__)}' to your application.") if i+1 == timeout
     end
 
     puts "\nFound file #{file}"

data/ext/arch.h

@@ -13,6 +13,8 @@
 #error "Unsupported architecture! Cannot continue compilation."
 #endif
 
+#include "x86_gen.h"
+
 /*
  * arch_get_st2_tramp - architecture specific stage 2 trampoline getter
  *

data/ext/elf.c

@@ -15,8 +15,8 @@
 #include <libgen.h>
 #include <limits.h>
 #include <link.h>
-#include <stdio.h>
 #include <stdlib.h>
+#include <stdio.h>
 #include <string.h>
 #include <sysexits.h>
 #include <unistd.h>
@@ -135,6 +135,7 @@ get_got_addr(struct plt_entry *plt)
 {
   assert(plt != NULL);
   /* the jump is relative to the start of the next instruction. */
+  dbg_printf("PLT addr: %p, .got.plt slot: %p\n", plt, (void *)&(plt->pad) + plt->jmp_disp);
   return (void *)&(plt->pad) + plt->jmp_disp;
 }
 
@@ -151,8 +152,9 @@ overwrite_got(void *plt, const void *tramp)
   assert(tramp != NULL);
   void *ret = NULL;
 
-  memcpy(&ret, get_got_addr(plt), sizeof(ret));
-  memcpy(get_got_addr(plt), &tramp, sizeof(void *));
+  memcpy(&ret, get_got_addr(plt), sizeof(void *));
+  copy_instructions(get_got_addr(plt), &tramp, sizeof(void *));
+  dbg_printf("GOT value overwritten to: %p\n", tramp);
   return ret;
 }
 
@@ -189,7 +191,6 @@ for_each_dso_cb(struct link_map *map, void *data)
     dbg_printf("found an empty string (skipping)\n");
     return CB_CONTINUE;
   }
-
   memset(&curr_lib, 0, sizeof(curr_lib));
   dbg_printf("trying to open elf object: %s\n", map->l_name);
   curr_lib.filename = map->l_name;

data/ext/extconf.rb

@@ -160,7 +160,8 @@ if have_header('mach-o/dyld.h')
     # 'rb_newobj',
     # 'freelist',
     # 'heaps',
-    # 'heaps_used'
+    # 'heaps_used',
+    # 'finalizer_table'
   ]
 
   expressions = []
@@ -218,7 +219,14 @@ if ENV['MEMPROF_DEBUG'] == '1'
 end
 
 if is_elf or is_macho
+  $objs = Dir['{.,*}/*.c'].map{ |file| file.gsub(/\.c(pp)?$/, '.o') }
   create_makefile('memprof')
+
+  makefile = File.read('Makefile')
+  makefile.gsub!('-c $<', '-o $(patsubst %.c,%.o,$<) -c $<')
+  makefile.gsub!(/(CLEANOBJS\s*=)/, '\1 */*.o')
+
+  File.open('Makefile', 'w+'){ |f| f.puts(makefile) }
 else
   raise 'unsupported platform'
 end

data/ext/mach.c

@@ -508,7 +508,5 @@ bin_init()
   assert(mach_config.symbol_table != NULL);
   assert(mach_config.string_table != NULL);
   assert(mach_config.symbol_count > 0);
-
-  free(file);
 }
 #endif

data/ext/memprof.c

@@ -20,6 +20,7 @@
 
 #include "arch.h"
 #include "bin_api.h"
+#include "tracer.h"
 #include "tramp.h"
 #include "util.h"
 
@@ -334,152 +335,17 @@ memprof_track(int argc, VALUE *argv, VALUE self)
   return Qnil;
 }
 
-struct memprof_malloc_stats {
-  size_t malloc_bytes_requested;
-  size_t calloc_bytes_requested;
-  size_t realloc_bytes_requested;
-
-  size_t malloc_bytes_actual;
-  size_t calloc_bytes_actual;
-  size_t realloc_bytes_actual;
-  size_t free_bytes_actual;
-
-  size_t malloc_calls;
-  size_t calloc_calls;
-  size_t realloc_calls;
-  size_t free_calls;
-};
-
-static struct memprof_malloc_stats memprof_malloc_stats;
-static void *orig_malloc, *orig_realloc, *orig_calloc, *orig_free;
-static size_t (*malloc_usable_size)(void *ptr);
-
-static void *
-malloc_tramp(size_t size)
-{
-  void *ret = NULL;
-  memprof_malloc_stats.malloc_bytes_requested += size;
-  memprof_malloc_stats.malloc_calls++;
-  ret = malloc(size);
-  memprof_malloc_stats.malloc_bytes_actual += malloc_usable_size(ret);
-  return ret;
-}
-
-static void *
-calloc_tramp(size_t nmemb, size_t size)
-{
-  void *ret = NULL;
-  memprof_malloc_stats.calloc_bytes_requested += (nmemb * size);
-  memprof_malloc_stats.calloc_calls++;
-  ret = calloc(nmemb, size);
-  memprof_malloc_stats.calloc_bytes_actual += malloc_usable_size(ret);
-  return ret;
-}
-
-static void *
-realloc_tramp(void *ptr, size_t size)
-{
-  /* TODO need to check malloc_usable_size of before/after i guess? */
-  void *ret = NULL;
-  memprof_malloc_stats.realloc_bytes_requested += size;
-  memprof_malloc_stats.realloc_calls++;
-  ret = realloc(ptr, size);
-  memprof_malloc_stats.realloc_bytes_actual += malloc_usable_size(ptr);
-  return ret;
-}
-
-static void
-free_tramp(void *ptr)
-{
-  /* TODO use malloc_usable_size to track bytes freed? */
-  memprof_malloc_stats.free_bytes_actual += malloc_usable_size(ptr);
-  memprof_malloc_stats.free_calls++;
-  free(ptr);
-}
-
-static void
-memprof_start_track_bytes()
-{
-  struct tramp_st2_entry tmp;
-
-  if (!malloc_usable_size) {
-    if ((malloc_usable_size =
-          bin_find_symbol("MallocExtension_GetAllocatedSize", NULL, 1)) == NULL) {
-      malloc_usable_size = bin_find_symbol("malloc_usable_size", NULL, 1);
-      dbg_printf("tcmalloc was not found...\n");
-    }
-    assert(malloc_usable_size != NULL);
-    dbg_printf("malloc_usable_size: %p\n", malloc_usable_size);
-  }
-
-  tmp.addr = malloc_tramp;
-  bin_update_image("malloc", &tmp, &orig_malloc);
-  assert(orig_malloc != NULL);
-  dbg_printf("orig_malloc: %p\n", orig_malloc);
-
-  tmp.addr = realloc_tramp;
-  bin_update_image("realloc", &tmp, &orig_realloc);
-  dbg_printf("orig_realloc: %p\n", orig_realloc);
-
-  tmp.addr = calloc_tramp;
-  bin_update_image("calloc", &tmp, &orig_calloc);
-  dbg_printf("orig_calloc: %p\n", orig_calloc);
-
-  tmp.addr = free_tramp;
-  bin_update_image("free", &tmp, &orig_free);
-  assert(orig_free != NULL);
-  dbg_printf("orig_free: %p\n", orig_free);
-}
-
-static void
-memprof_stop_track_bytes()
-{
-  struct tramp_st2_entry tmp;
-
-  tmp.addr = orig_malloc;
-  bin_update_image("malloc", &tmp, NULL);
-
-  tmp.addr = orig_realloc;
-  bin_update_image("realloc", &tmp, NULL);
-
-  tmp.addr = orig_calloc;
-  bin_update_image("calloc", &tmp, NULL);
-
-  tmp.addr = orig_free;
-  bin_update_image("free", &tmp, NULL);
-}
-
-static void
-memprof_reset_track_bytes()
-{
-  memset(&memprof_malloc_stats, 0, sizeof(memprof_malloc_stats));
-}
-
 static VALUE
-memprof_track_bytes(int argc, VALUE *argv, VALUE self)
+memprof_track_fun(int argc, VALUE *argv, VALUE self)
 {
   if (!rb_block_given_p())
     rb_raise(rb_eArgError, "block required");
 
-  memprof_start_track_bytes();
+  trace_invoke_all(TRACE_START);
   rb_yield(Qnil);
-  fprintf(stderr, "================ Requested ====================\n");
-  fprintf(stderr, "Malloced: %zd, Realloced: %zd, Calloced: %zd\n",
-      memprof_malloc_stats.malloc_bytes_requested, memprof_malloc_stats.realloc_bytes_requested,
-      memprof_malloc_stats.calloc_bytes_requested);
-  fprintf(stderr, "================ Actual ====================\n");
-  fprintf(stderr, "Malloced: %zd, Realloced: %zd, Calloced: %zd, Freed: %zd\n",
-      memprof_malloc_stats.malloc_bytes_actual, memprof_malloc_stats.realloc_bytes_actual,
-      memprof_malloc_stats.calloc_bytes_actual, memprof_malloc_stats.free_bytes_actual);
-  fprintf(stderr, "================ Call count ====================\n");
-  fprintf(stderr, "Calls to malloc: %zd, realloc: %zd, calloc: %zd, free: %zd\n",
-      memprof_malloc_stats.malloc_calls,
-      memprof_malloc_stats.realloc_calls,
-      memprof_malloc_stats.calloc_calls,
-      memprof_malloc_stats.free_calls);
-
-  memprof_reset_track_bytes();
-  memprof_stop_track_bytes();
+  trace_invoke_all(TRACE_DUMP);
+  trace_invoke_all(TRACE_STOP);
+  trace_invoke_all(TRACE_RESET);
   return Qnil;
 }
 
@@ -1410,6 +1276,17 @@ globals_each_dump(st_data_t key, st_data_t record, st_data_t arg)
   return ST_CONTINUE;
 }
 
+static int
+finalizers_each_dump(st_data_t key, st_data_t val, st_data_t arg)
+{
+  yajl_gen gen = (yajl_gen)arg;
+  yajl_gen_array_open(gen);
+  yajl_gen_value(gen, (VALUE)key);
+  yajl_gen_value(gen, (VALUE)val);
+  yajl_gen_array_close(gen);
+  return ST_CONTINUE;
+}
+
 static void
 memprof_dump_globals(yajl_gen gen)
 {
@@ -1562,6 +1439,29 @@ memprof_dump_ps(yajl_gen gen)
   }
 }
 
+static void
+memprof_dump_finalizers(yajl_gen gen)
+{
+  st_table *finalizer_table = *(st_table **)memprof_config.finalizer_table;
+  if (finalizer_table) {
+    yajl_gen_map_open(gen);
+
+    yajl_gen_cstr(gen, "_id");
+    yajl_gen_cstr(gen, "finalizers");
+
+    yajl_gen_cstr(gen, "type");
+    yajl_gen_cstr(gen, "finalizers");
+
+    yajl_gen_cstr(gen, "data");
+    yajl_gen_array_open(gen);
+    st_foreach(finalizer_table, finalizers_each_dump, (st_data_t)gen);
+    yajl_gen_array_close(gen);
+
+    yajl_gen_map_close(gen);
+    yajl_gen_reset(gen);
+  }
+}
+
 static void
 json_print(void *ctx, const char * str, unsigned int len)
 {
@@ -1648,6 +1548,7 @@ memprof_dump_all(int argc, VALUE *argv, VALUE self)
 
   track_objs = 0;
 
+  memprof_dump_finalizers(gen);
   memprof_dump_globals(gen);
   memprof_dump_stack(gen);
 
@@ -1727,6 +1628,8 @@ init_memprof_config_extended() {
   /* Stuff for dumping the heap */
   memprof_config.heaps                      = bin_find_symbol("heaps", NULL, 0);
   memprof_config.heaps_used                 = bin_find_symbol("heaps_used", NULL, 0);
+  memprof_config.finalizer_table            = bin_find_symbol("finalizer_table", NULL, 0);
+
 #ifdef sizeof__RVALUE
   memprof_config.sizeof_RVALUE              = sizeof__RVALUE;
 #else
@@ -1869,21 +1772,21 @@ init_memprof_config_extended() {
     }
     if (memprof_config.gc_sweep_size == 0)
       errors_printed += fprintf(stderr,
-        "Failed to determine the size of gc_sweep/garbage_collect_0/garbage_collect: %ld\n",
+        "Failed to determine the size of gc_sweep/garbage_collect_0/garbage_collect: %zd\n",
         memprof_config.gc_sweep_size);
     if (memprof_config.finalize_list == NULL)
       errors_printed += fprintf(stderr,
         "Failed to locate finalize_list\n");
     if (memprof_config.finalize_list_size == 0)
       errors_printed += fprintf(stderr,
-        "Failed to determine the size of finalize_list: %ld\n",
+        "Failed to determine the size of finalize_list: %zd\n",
         memprof_config.finalize_list_size);
     if (memprof_config.rb_gc_force_recycle == NULL)
       errors_printed += fprintf(stderr,
         "Failed to locate rb_gc_force_recycle\n");
     if (memprof_config.rb_gc_force_recycle_size == 0)
       errors_printed += fprintf(stderr,
-        "Failed to determine the size of rb_gc_force_recycle: %ld\n",
+        "Failed to determine the size of rb_gc_force_recycle: %zd\n",
         memprof_config.rb_gc_force_recycle_size);
     if (memprof_config.freelist == NULL)
       errors_printed += fprintf(stderr,
@@ -1915,7 +1818,7 @@ Init_memprof()
   rb_define_singleton_method(memprof, "track", memprof_track, -1);
   rb_define_singleton_method(memprof, "dump", memprof_dump, -1);
   rb_define_singleton_method(memprof, "dump_all", memprof_dump_all, -1);
-  rb_define_singleton_method(memprof, "track_bytes", memprof_track_bytes, -1);
+  rb_define_singleton_method(memprof, "track_fun", memprof_track_fun, -1);
 
   objs = st_init_numtable();
   init_memprof_config_base();
@@ -1923,6 +1826,8 @@ Init_memprof()
   init_memprof_config_extended();
   create_tramp_table();
 
+  install_malloc_tracer();
+
   gc_hook = Data_Wrap_Struct(rb_cObject, sourcefile_marker, NULL, NULL);
   rb_global_variable(&gc_hook);
 

data/ext/tracer.c

@@ -0,0 +1,99 @@
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "tracer.h"
+#include "util.h"
+
+/*
+   XXX if we ever need a linked list for anything else ever, remove this crap
+       and switch to a generic macro-based linked list implementation
+*/
+struct tracer_list {
+  struct tracer *tracer;
+  struct tracer_list *next;
+};
+
+static struct tracer_list *tracer_list = NULL;
+
+int
+trace_insert(struct tracer *trace)
+{
+  assert(trace != NULL);
+
+  struct tracer_list *entry = malloc(sizeof(*entry));
+  entry->tracer = trace;
+
+  entry->next = tracer_list;
+  tracer_list = entry;
+  return 0;
+}
+
+int
+trace_remove(const char *id)
+{
+  struct tracer_list *tmp, *prev;
+  tmp = prev = tracer_list;
+
+  while (tmp) {
+    if (strcmp(id, tmp->tracer->id) == 0) {
+      tmp->next = tmp->next;
+      free(tmp->tracer->id);
+      free(tmp->tracer);
+      free(tmp);
+      return 0;
+    }
+    prev = tmp;
+    tmp = tmp->next;
+  }
+
+  return 1;
+}
+
+static void
+do_trace_invoke(struct tracer *trace, trace_fn fn)
+{
+  switch (fn) {
+    case TRACE_START:
+      trace->start();
+      break;
+    case TRACE_STOP:
+      trace->stop();
+      break;
+    case TRACE_RESET:
+      trace->reset();
+      break;
+    case TRACE_DUMP:
+      trace->dump();
+      break;
+    default:
+      dbg_printf("invoked a non-existant trace function type: %d", fn);
+      assert(1==0);
+  }
+
+  return;
+}
+
+int
+trace_invoke_all(trace_fn fn)
+{
+  struct tracer_list *tmp = tracer_list;
+  while (tmp) {
+    do_trace_invoke(tmp->tracer, fn);
+    tmp = tmp->next;
+  }
+  return 0;
+}
+
+int
+trace_invoke(const char *id, trace_fn fn)
+{
+  struct tracer_list *tmp = tracer_list;
+  while (tmp) {
+    if (strcmp(id, tmp->tracer->id) == 0) {
+      do_trace_invoke(tmp->tracer, fn);
+    }
+    tmp = tmp->next;
+  }
+  return 0;
+}

data/ext/tracer.h

@@ -0,0 +1,33 @@
+#if !defined(__TRACER__H_)
+#define __TRACER__H_
+
+struct tracer {
+  char *id;
+  void (*start)();
+  void (*stop)();
+  void (*reset)();
+  void (*dump)();
+};
+
+typedef enum {
+  TRACE_START,
+  TRACE_STOP,
+  TRACE_RESET,
+  TRACE_DUMP,
+} trace_fn;
+
+int
+trace_insert(struct tracer *trace);
+
+int
+trace_remove(const char *id);
+
+int
+trace_invoke_all(trace_fn fn);
+
+int
+trace_invoke(const char *id, trace_fn fn);
+
+/* for now, these will live here */
+extern void install_malloc_tracer();
+#endif

data/ext/tracers/malloc.c

@@ -0,0 +1,163 @@
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "arch.h"
+#include "bin_api.h"
+#include "tracer.h"
+#include "util.h"
+
+struct memprof_malloc_stats {
+  size_t malloc_bytes_requested;
+  size_t calloc_bytes_requested;
+  size_t realloc_bytes_requested;
+
+  size_t malloc_bytes_actual;
+  size_t calloc_bytes_actual;
+  size_t realloc_bytes_actual;
+  size_t free_bytes_actual;
+
+  size_t malloc_calls;
+  size_t calloc_calls;
+  size_t realloc_calls;
+  size_t free_calls;
+};
+
+static struct tracer tracer;
+static struct memprof_malloc_stats memprof_malloc_stats;
+static void *(*orig_malloc)(size_t), *(*orig_realloc)(void *, size_t),
+            *(*orig_calloc)(size_t, size_t), (*orig_free)(void *);
+static size_t (*malloc_usable_size)(void *ptr);
+
+static void *
+malloc_tramp(size_t size)
+{
+  void *ret = NULL;
+  memprof_malloc_stats.malloc_bytes_requested += size;
+  memprof_malloc_stats.malloc_calls++;
+  ret = orig_malloc(size);
+  memprof_malloc_stats.malloc_bytes_actual += malloc_usable_size(ret);
+  return ret;
+}
+
+static void *
+calloc_tramp(size_t nmemb, size_t size)
+{
+  void *ret = NULL;
+  memprof_malloc_stats.calloc_bytes_requested += (nmemb * size);
+  memprof_malloc_stats.calloc_calls++;
+  ret = (*orig_calloc)(nmemb, size);
+  memprof_malloc_stats.calloc_bytes_actual += malloc_usable_size(ret);
+  return ret;
+}
+
+static void *
+realloc_tramp(void *ptr, size_t size)
+{
+  /* TODO need to check malloc_usable_size of before/after i guess? */
+  void *ret = NULL;
+  memprof_malloc_stats.realloc_bytes_requested += size;
+  memprof_malloc_stats.realloc_calls++;
+  ret = orig_realloc(ptr, size);
+  memprof_malloc_stats.realloc_bytes_actual += malloc_usable_size(ptr);
+  return ret;
+}
+
+static void
+free_tramp(void *ptr)
+{
+  memprof_malloc_stats.free_bytes_actual += malloc_usable_size(ptr);
+  memprof_malloc_stats.free_calls++;
+  orig_free(ptr);
+}
+
+static void
+malloc_trace_stop()
+{
+  struct tramp_st2_entry tmp;
+
+  tmp.addr = orig_malloc;
+  bin_update_image("malloc", &tmp, NULL);
+
+  tmp.addr = orig_realloc;
+  bin_update_image("realloc", &tmp, NULL);
+
+  if (orig_calloc) {
+    tmp.addr = orig_calloc;
+    bin_update_image("calloc", &tmp, NULL);
+  }
+
+  tmp.addr = orig_free;
+  bin_update_image("free", &tmp, NULL);
+}
+
+static void
+malloc_trace_reset()
+{
+  memset(&memprof_malloc_stats, 0, sizeof(memprof_malloc_stats));
+}
+
+static void
+malloc_trace_dump()
+{
+  fprintf(stderr, "================ Requested ====================\n");
+  fprintf(stderr, "Malloced: %zd, Realloced: %zd, Calloced: %zd\n",
+      memprof_malloc_stats.malloc_bytes_requested, memprof_malloc_stats.realloc_bytes_requested,
+      memprof_malloc_stats.calloc_bytes_requested);
+  fprintf(stderr, "================ Actual ====================\n");
+  fprintf(stderr, "Malloced: %zd, Realloced: %zd, Calloced: %zd, Freed: %zd\n",
+      memprof_malloc_stats.malloc_bytes_actual, memprof_malloc_stats.realloc_bytes_actual,
+      memprof_malloc_stats.calloc_bytes_actual, memprof_malloc_stats.free_bytes_actual);
+  fprintf(stderr, "================ Call count ====================\n");
+  fprintf(stderr, "Calls to malloc: %zd, realloc: %zd, calloc: %zd, free: %zd\n",
+      memprof_malloc_stats.malloc_calls,
+      memprof_malloc_stats.realloc_calls,
+      memprof_malloc_stats.calloc_calls,
+      memprof_malloc_stats.free_calls);
+}
+
+static void
+malloc_trace_start()
+{
+  struct tramp_st2_entry tmp;
+
+  if (!malloc_usable_size) {
+    if ((malloc_usable_size =
+          bin_find_symbol("MallocExtension_GetAllocatedSize", NULL, 1)) == NULL) {
+      malloc_usable_size = bin_find_symbol("malloc_usable_size", NULL, 1);
+      dbg_printf("tcmalloc was not found...\n");
+    }
+    assert(malloc_usable_size != NULL);
+    dbg_printf("malloc_usable_size: %p\n", malloc_usable_size);
+  }
+
+  tmp.addr = malloc_tramp;
+  bin_update_image("malloc", &tmp, (void **)(&orig_malloc));
+  assert(orig_malloc != NULL);
+  dbg_printf("orig_malloc: %p\n", orig_malloc);
+
+  tmp.addr = realloc_tramp;
+  bin_update_image("realloc", &tmp,(void **)(&orig_realloc));
+  dbg_printf("orig_realloc: %p\n", orig_realloc);
+
+  tmp.addr = calloc_tramp;
+  bin_update_image("calloc", &tmp, (void **)(&orig_calloc));
+  dbg_printf("orig_calloc: %p\n", orig_calloc);
+
+  tmp.addr = free_tramp;
+  bin_update_image("free", &tmp, (void **)(&orig_free));
+  assert(orig_free != NULL);
+  dbg_printf("orig_free: %p\n", orig_free);
+}
+
+void install_malloc_tracer()
+{
+  tracer.start = malloc_trace_start;
+  tracer.stop = malloc_trace_stop;
+  tracer.reset = malloc_trace_reset;
+  tracer.dump = malloc_trace_dump;
+  tracer.id = strdup("malloc_tracer");
+
+  trace_insert(&tracer);
+}

data/ext/util.h

@@ -2,7 +2,11 @@
 #define __util_h__
 
 #if defined(_MEMPROF_DEBUG)
-#define dbg_printf(...) fprintf(stderr, __VA_ARGS__)
+#include <stdio.h>
+#define dbg_printf(...) do {\
+  fprintf(stderr, "%s:%d  ", __FILE__, __LINE__);\
+  fprintf(stderr, __VA_ARGS__);\
+  } while (0)
 #else
 #define dbg_printf(...)
 #endif
@@ -33,6 +37,7 @@ struct memprof_config {
 
   void *heaps;
   void *heaps_used;
+  void *finalizer_table;
 
   size_t sizeof_RVALUE;
   size_t sizeof_heaps_slot;

data/ext/x86_gen.c

@@ -0,0 +1,73 @@
+#include <assert.h>
+#include <stdint.h>
+#include "arch.h"
+#include "x86_gen.h"
+
+/*
+ * arch_insert_st1_tramp - architecture specific stage 1 trampoline insert
+ *
+ * Given:
+ *      - a start address (start),
+ *      - the absolute address of the function to intercept (trampee),
+ *      - the absolute address of the code to execute instead (tramp),
+ *
+ * This function will:
+ *    - interpret address start as a struct st1_base,
+ *    - check that the instruction at call is actually a call
+ *    - if so, check that the target of the call is trampee
+ *    - and change the target to tramp
+ *
+ * Returns 0 on success, 1 otherwise.
+ */
+int
+arch_insert_st1_tramp(void *start, void *trampee, void *tramp)
+{
+  assert(start != NULL);
+  assert(trampee != NULL);
+  assert(tramp != NULL);
+
+  int32_t fn_addr = 0;
+  struct st1_base *check = start;
+
+  if (check->call == 0xe8) {
+    fn_addr = check->displacement;
+    if ((trampee - (void *)(check + 1)) == fn_addr) {
+      WRITE_INSTRUCTIONS(&check->displacement,
+                         sizeof(*check),
+                         (check->displacement = (tramp - (void *)(check + 1))));
+      return 0;
+    }
+  }
+
+  return 1;
+}
+
+/*
+ * arch_get_st2_tramp - architecture specific stage 2 tramp accessor. This
+ * function returns a pointer to the default stage 2 trampoline setting size
+ * if a non-NULL pointer was passed in.
+ */
+void *
+arch_get_st2_tramp(size_t *size)
+{
+  if (size) {
+    *size = sizeof(default_st2_tramp);
+  }
+
+  return &default_st2_tramp;
+}
+
+/*
+ * arch_get_inline_st2_tramp - architecture specific inline stage 2 tramp
+ * accessor. This function returns a pointer to the default inline stage 2
+ *  trampoline setting size if a non-NULL pointer was passed in.
+ */
+void *
+arch_get_inline_st2_tramp(size_t *size)
+{
+  if (size) {
+    *size = sizeof(default_inline_st2_tramp);
+  }
+
+  return &default_inline_st2_tramp;
+}

data/ext/x86_gen.h

@@ -2,8 +2,10 @@
 #define _x86_gen_
 
 #include <assert.h>
-#include <sys/mman.h>
 #include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
 #include "arch.h"
 
 /*
@@ -15,7 +17,7 @@
  *
  * For example:   callq <0xdeadbeef> #rb_newobj
  */
-struct st1_base {
+static struct st1_base {
   unsigned char call;
   int32_t displacement;
 } __attribute__((__packed__)) st1_mov = {
@@ -53,8 +55,24 @@ copy_instructions(void *dest, void *src, size_t count)
 
   mprotect(aligned_addr, (dest - aligned_addr) + count, PROT_READ|PROT_WRITE|PROT_EXEC);
   memcpy(dest, src, count);
-  mprotect(aligned_addr, (dest - aligned_addr) + count, PROT_READ|PROT_EXEC);
 
+  /*
+   *  XXX This has to be commented out because setting certian sections to
+   *      readonly (.got.plt, et al.) will cause the rtld to die.
+   *
+   *      There is no way to get the current permissions bits for a page.
+   *
+   *      The way to solve this is:
+   *
+   *        1.) copy_instructions can take a final_permissions mask and each
+   *            overwrite site can put in the 'Right Thing'
+   *
+   *        2.) Each overwrite site can look up the 'Right Thing' in the object
+   *            header and pass it in, ensuring the desired permissions are
+   *            set after.
+   *
+   *  mprotect(aligned_addr, (dest - aligned_addr) + count, PROT_READ|PROT_EXEC);
+   */
   return;
 }
 
@@ -70,72 +88,4 @@ copy_instructions(void *dest, void *src, size_t count)
   mprotect(aligned_addr, count, PROT_READ | PROT_EXEC); \
 } while (0)
 
-/*
- * arch_insert_st1_tramp - architecture specific stage 1 trampoline insert
- *
- * Given:
- *      - a start address (start),
- *      - the absolute address of the function to intercept (trampee),
- *      - the absolute address of the code to execute instead (tramp),
- *
- * This function will:
- *    - interpret address start as a struct st1_base,
- *    - check that the instruction at call is actually a call
- *    - if so, check that the target of the call is trampee
- *    - and change the target to tramp
- *
- * Returns 0 on success, 1 otherwise.
- */
-int
-arch_insert_st1_tramp(void *start, void *trampee, void *tramp)
-{
-  assert(start != NULL);
-  assert(trampee != NULL);
-  assert(tramp != NULL);
-
-  int32_t fn_addr = 0;
-  struct st1_base *check = start;
-
-  if (check->call == 0xe8) {
-    fn_addr = check->displacement;
-    if ((trampee - (void *)(check + 1)) == fn_addr) {
-      WRITE_INSTRUCTIONS(&check->displacement,
-                         sizeof(*check),
-                         (check->displacement = (tramp - (void *)(check + 1))));
-      return 0;
-    }
-  }
-
-  return 1;
-}
-
-/*
- * arch_get_st2_tramp - architecture specific stage 2 tramp accessor. This
- * function returns a pointer to the default stage 2 trampoline setting size
- * if a non-NULL pointer was passed in.
- */
-void *
-arch_get_st2_tramp(size_t *size)
-{
-  if (size) {
-    *size = sizeof(default_st2_tramp);
-  }
-
-  return &default_st2_tramp;
-}
-
-/*
- * arch_get_inline_st2_tramp - architecture specific inline stage 2 tramp
- * accessor. This function returns a pointer to the default inline stage 2
- *  trampoline setting size if a non-NULL pointer was passed in.
- */
-void *
-arch_get_inline_st2_tramp(size_t *size)
-{
-  if (size) {
-    *size = sizeof(default_inline_st2_tramp);
-  }
-
-  return &default_inline_st2_tramp;
-}
 #endif

data/memprof.gemspec

@@ -1,7 +1,7 @@
 spec = Gem::Specification.new do |s|
   s.name = 'memprof'
-  s.version = '0.3.0'
-  s.date = '2010-03-15'
+  s.version = '0.3.1'
+  s.date = '2010-04-13'
   s.summary = 'Ruby Memory Profiler'
   s.description = "Ruby memory profiler similar to bleak_house, but without patches to the Ruby VM"
   s.homepage = "http://github.com/ice799/memprof"

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 3
-  - 0
-  version: 0.3.0
+  - 1
+  version: 0.3.1
 platform: ruby
 authors: 
 - Joe Damato
@@ -17,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-15 00:00:00 -07:00
+date: 2010-04-13 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -73,12 +73,16 @@ files:
 - ext/src/libdwarf-20091118.tar.gz
 - ext/src/libelf-0.8.13.tar.gz
 - ext/src/yajl-1.0.9.tar.gz
+- ext/tracer.c
+- ext/tracer.h
+- ext/tracers/malloc.c
 - ext/tramp.c
 - ext/tramp.h
 - ext/util.c
 - ext/util.h
 - ext/x86_64.c
 - ext/x86_64.h
+- ext/x86_gen.c
 - ext/x86_gen.h
 - lib/memprof/middleware.rb
 - lib/memprof/signal.rb