memprof 0.2.7 → 0.2.9

data/README

@@ -28,8 +28,6 @@ Memprof.stats also takes an (optional) file name to write the output to a file.
 
 Supported systems
 =================
-**This only works on unstripped binaries.**
-
 Currently supporting:
 
   Linux (enable-shared AND disable-shared):
@@ -40,19 +38,28 @@ Currently supporting:
     x86_64 builds of Ruby Enterprise Edition 1.8.6/1.8.7
     x86_64 builds of MRI Ruby
 
+    Support for unstripped binaries and stripped binaries if (and only if) the
+    symbol files live in /usr/lib/debug/
+
+    You can get symbol files for system Rubies by installing -dbg packages.
+
+    For example, on ubuntu: apt-get install libruby1.8-dbg
+
+  Snow Leopard:
+    x86_64 builds of Ruby Enterprise Edition 1.8.7
+    x86_64 builds of MRI Ruby  (enable-shared and disable-shared)
+    Unstripped binaries only!
+
 Experimental (somewhat broken) support:
 
   Linux and OSX:
     i386/i686 support.
 
   Snow Leopard:
-    OSX system Ruby, distributed with Snow Leopard.
+    OSX system Ruby, distributed with Snow Leopard
 
 Coming soon:
 
-  Linux:
-    Tracking object allocationns in C extensions.
-
   Official support for Ruby 1.9
   Official support for i386/i686
 
@@ -61,3 +68,5 @@ CREDITS
 Jake Douglas for the Mach O/snow leopard support.
 
 Aman Gupta for various bug fixes and other cleanup.
+
+Rob Benson for 1.9 support and cleanup.

data/ext/bin_api.h

@@ -3,14 +3,6 @@
 #include <stddef.h>
 #include <stdint.h>
 
-/*
- * Instead of getting the pagesize from sysconf over and over again, pollute
- * the global namespace with a dangerous name.
- *
- * XXX change this
- */
-extern size_t pagesize;
-
 /*
  * Some useful foward declarations for function protoypes here and elsewhere.
  */
@@ -100,5 +92,5 @@ bin_type_member_offset(const char *type, const char *member);
  * Returns 0 on success.
  */
 int
-bin_update_image(const char *trampee_addr, struct tramp_st2_entry *tramp);
+bin_update_image(const char *trampee, struct tramp_st2_entry *tramp);
 #endif

data/ext/elf.c

@@ -2,14 +2,17 @@
 #define _GNU_SOURCE
 #include "bin_api.h"
 #include "arch.h"
+#include "util.h"
 
 #include <assert.h>
 #include <dwarf.h>
 #include <err.h>
 #include <error.h>
+#include <errno.h>
 #include <fcntl.h>
 #include <libdwarf.h>
 #include <libelf/gelf.h>
+#include <libgen.h>
 #include <limits.h>
 #include <link.h>
 #include <stdio.h>
@@ -19,10 +22,18 @@
 #include <unistd.h>
 
 #include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+extern struct memprof_config memprof_config;
 
 /* The size of a PLT entry */
 #define PLT_ENTRY_SZ  (16)
 
+/* The system-wide debug symbol directory */
+/* XXX this should be set via extconf and not hardcoded */
+#define DEBUGDIR   "/usr/lib/debug"
+
 /* Keep track of whether this ruby is built with a shared library or not */
 static int libruby = 0;
 
@@ -32,6 +43,7 @@ static Dwarf_Debug dwrf = NULL;
 static struct elf_info *ruby_info = NULL;
 
 struct elf_info {
+  int fd;
   Elf *elf;
 
   GElf_Addr base_addr;
@@ -48,6 +60,10 @@ struct elf_info {
   size_t plt_size;
   size_t plt_count;
 
+  GElf_Addr debuglink_addr;
+  size_t debuglink_sz;
+  Elf_Data *debuglink_data;
+
   GElf_Ehdr ehdr;
 
   Elf_Data *dynsym;
@@ -58,8 +74,28 @@ struct elf_info {
   Elf_Data *symtab_data;
 
   const char *filename;
+
+  struct elf_info *debug_data;
 };
 
+/* These callback return statuses are used to tell the invoker of the callback
+ * (walk_linkmap) whether to continue walking or bail out.
+ */
+typedef enum {
+  CB_CONTINUE,
+  CB_EXIT,
+} linkmap_cb_status;
+
+/* A callback type that specifies a function that can be fired on each link map
+ * entry.
+ */
+typedef linkmap_cb_status (*linkmap_cb)(struct link_map *, void *);
+
+static void open_elf(struct elf_info *info);
+static int dissect_elf(struct elf_info *info, int find_debug);
+static void *find_plt_addr(const char *symname, struct elf_info *info);
+static void walk_linkmap(linkmap_cb cb, void *data);
+
 /*
  * plt_entry - procedure linkage table entry
  *
@@ -106,7 +142,7 @@ get_got_addr(struct plt_entry *plt)
  * in the GOT that the PLT entry uses with the address in tramp.
  */
 static void
-overwrite_got(void *plt, void *tramp)
+overwrite_got(void *plt, const void *tramp)
 {
   assert(plt != NULL);
   assert(tramp != NULL);
@@ -114,6 +150,79 @@ overwrite_got(void *plt, void *tramp)
   return;
 }
 
+struct plt_hook_data {
+  const char *sym;
+  const void *tramp;
+};
+
+static linkmap_cb_status
+hook_func_cb(struct link_map *map, void *data)
+{
+  struct plt_hook_data *hook_data = data;
+  struct elf_info curr_lib;
+  void *trampee_addr = NULL;
+
+  /* skip a few things we don't care about */
+  if (strstr(map->l_name, "linux-vdso")) {
+    dbg_printf("found vdso (skipping): %s\n", map->l_name);
+    return CB_CONTINUE;
+  } else if (strstr(map->l_name, "ld-linux")) {
+    dbg_printf("found ld-linux (skipping): %s\n", map->l_name);
+    return CB_CONTINUE;
+  } else if (strstr(map->l_name, "libruby")) {
+    dbg_printf("found libruby (skipping): %s\n", map->l_name);
+    return CB_CONTINUE;
+  } else if (strstr(map->l_name, "memprof")) {
+    dbg_printf("found memprof (skipping): %s\n", map->l_name);
+    return CB_CONTINUE;
+  } else if (!map->l_name || map->l_name[0] == '\0') {
+    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;
+  open_elf(&curr_lib);
+
+  if (curr_lib.elf == NULL) {
+    dbg_printf("opening the elf object (%s) failed! (skipping)\n", map->l_name);
+    return CB_CONTINUE;
+  }
+
+  curr_lib.base_addr = map->l_addr;
+  curr_lib.filename = map->l_name;
+
+  if (dissect_elf(&curr_lib, 0) == 2) {
+    dbg_printf("elf file, %s hit an unrecoverable error (skipping)\n", map->l_name);
+    elf_end(curr_lib.elf);
+    close(curr_lib.fd);
+    return CB_CONTINUE;
+  }
+
+  dbg_printf("dissected the elf file: %s, base: %lx\n",
+      curr_lib.filename, (unsigned long)curr_lib.base_addr);
+
+  if ((trampee_addr = find_plt_addr(hook_data->sym, &curr_lib)) != NULL) {
+    dbg_printf("found: %s @ %p\n", hook_data->sym, trampee_addr);
+    overwrite_got(trampee_addr, hook_data->tramp);
+  }
+
+  elf_end(curr_lib.elf);
+  close(curr_lib.fd);
+  return CB_CONTINUE;
+}
+
+static void
+hook_required_objects(void *tramp)
+{
+  struct plt_hook_data data;
+  data.sym = "rb_newobj";
+  data.tramp = tramp;
+  walk_linkmap(hook_func_cb, &data);
+  return;
+}
+
 /*
  * do_bin_allocate_page - internal page allocation routine
  *
@@ -131,7 +240,7 @@ static void *
 do_bin_allocate_page(struct elf_info *info)
 {
   void * ret = NULL, *addr = NULL;
-  uint16_t count = 0;
+  uint32_t count = 0;
 
   if (!info)
     return NULL;
@@ -141,10 +250,10 @@ do_bin_allocate_page(struct elf_info *info)
      * a page.
      */
     addr = info->text_segment + info->text_segment_len;
-    for (; count < UINT_MAX; addr += pagesize, count += pagesize) {
-      ret = mmap(addr, pagesize, PROT_WRITE|PROT_READ|PROT_EXEC, MAP_ANON|MAP_PRIVATE, -1, 0);
+    for (; count < USHRT_MAX; addr += memprof_config.pagesize, count += memprof_config.pagesize) {
+      ret = mmap(addr, memprof_config.pagesize, PROT_WRITE|PROT_READ|PROT_EXEC, MAP_ANON|MAP_PRIVATE, -1, 0);
       if (ret != MAP_FAILED) {
-        memset(ret, 0x90, pagesize);
+        memset(ret, 0x90, memprof_config.pagesize);
         return ret;
       }
     }
@@ -153,7 +262,7 @@ do_bin_allocate_page(struct elf_info *info)
      * grab a page in the lower 4gb of the address space.
      */
     assert((size_t)info->text_segment <= UINT_MAX);
-    return mmap(NULL, pagesize, PROT_WRITE|PROT_READ|PROT_EXEC, MAP_ANON|MAP_PRIVATE|MAP_32BIT, -1, 0);
+    return mmap(NULL, memprof_config.pagesize, PROT_WRITE|PROT_READ|PROT_EXEC, MAP_ANON|MAP_PRIVATE|MAP_32BIT, -1, 0);
   }
 
   return NULL;
@@ -185,7 +294,8 @@ bin_allocate_page()
 static inline GElf_Addr
 get_plt_addr(struct elf_info *info, size_t ndx) {
   assert(info != NULL);
-  return info->base_addr + info->plt_addr + (ndx + 1) * 16;
+  dbg_printf("file: %s, base: %lx\n", info->filename, (unsigned long)info->base_addr);
+  return info->base_addr + info->plt_addr + (ndx + 1) * PLT_ENTRY_SZ;
 }
 
 /*
@@ -277,9 +387,7 @@ do_bin_find_symbol(const char *sym, size_t *size, struct elf_info *elf)
 
     name = elf_strptr(elf->elf, elf->symtab_shdr.sh_link, (size_t)esym->st_name);
 
-    assert(name != NULL);
-
-    if (strcmp(name, sym) == 0) {
+    if (name && strcmp(name, sym) == 0) {
       if (size) {
         *size = esym->st_size;
       }
@@ -393,6 +501,13 @@ bin_update_image(const char *trampee, struct tramp_st2_entry *tramp)
     assert(trampee_addr != NULL);
     overwrite_got(trampee_addr, tramp->addr);
   }
+
+  if (strcmp("rb_newobj", trampee) == 0) {
+    dbg_printf("Trying to hook rb_newobj in other libraries...\n");
+    hook_required_objects(tramp->addr);
+    dbg_printf("Done searching other libraries for rb_newobj!\n");
+  }
+
   return 0;
 }
 
@@ -542,31 +657,80 @@ find_die(const char *name, Dwarf_Half type)
 }
 
 /*
- * has_libruby - check if this ruby binary is linked against libruby.so
+ * find_libruby_cb - a callback which attempts to locate libruby in the linkmap
  *
- * This function checks if the curreny binary is linked against libruby. If
- * so, it sets libruby = 1, and fill internal state in the elf_info structure.
+ * This callback is fired from walk_linkmap for each item on the linkmap. This
+ * function searchs for libruby and stores data about it in the object passed
+ * through.
  *
- * Returns 1 if this binary is linked to libruby.so, 0 if not.
+ * This function return CB_EXIT once libruby is found to terminate the link map
+ * walker. If libruby isn't found, this function returns CB_CONTINUE.
  */
-static int
-has_libruby(struct elf_info *lib)
+static linkmap_cb_status
+find_libruby_cb(struct link_map *map, void *data)
+{
+  struct elf_info *lib = data;
+
+  assert(map != NULL);
+  assert(data != NULL);
+
+  if (strstr(map->l_name, "libruby")) {
+    dbg_printf("Found a libruby.so!\n");
+    if (lib) {
+      lib->base_addr = (GElf_Addr)map->l_addr;
+      lib->filename = strdup(map->l_name);
+    }
+    libruby = 1;
+    return CB_EXIT;
+  }
+  return CB_CONTINUE;
+}
+
+/*
+ * walk_linkmap - walk the linkmap firing a callback along the way.
+ *
+ * Given:
+ *  - cb - a callback function
+ *  - data - and any private data to pass through (optional)
+ *
+ * This function will crawl the linkmap and fire the callback on each item
+ * found.
+ *
+ * If the callback returns CB_CONTINUE, this function will move to the next
+ * (if any) item in the link map.
+ *
+ * If the callback returns CB_EXIT, this function will return immediately.
+ */
+static void
+walk_linkmap(linkmap_cb cb, void *data)
 {
   struct link_map *map = _r_debug.r_map;
 
-  libruby = 0;
+  assert(map);
+
   while (map) {
-    if (strstr(map->l_name, "libruby.so")) {
-      if (lib) {
-        lib->base_addr = (GElf_Addr)map->l_addr;
-        lib->filename = strdup(map->l_name);
-      }
-      libruby = 1;
+    dbg_printf("Found a linkmap entry: %s\n", map->l_name);
+    if (cb(map, data) == CB_EXIT)
       break;
-    }
     map = map->l_next;
   }
 
+  return;
+}
+
+/*
+ * has_libruby - check if this ruby binary is linked against libruby.so
+ *
+ * This function checks if the curreny binary is linked against libruby. If
+ * so, it sets libruby = 1, and fill internal state in the elf_info structure.
+ *
+ * Returns 1 if this binary is linked to libruby.so, 0 if not.
+ */
+static int
+has_libruby(struct elf_info *lib)
+{
+  libruby = 0;
+  walk_linkmap(find_libruby_cb, lib);
   return libruby;
 }
 
@@ -627,31 +791,131 @@ bin_type_member_offset(const char *type, const char *member)
  * Given a filename, this function attempts to open the file and start the
  * elf reader.
  *
- * Returns an Elf object.
+ * Returns an elf_info object that must be freed by the caller.
  */
-static Elf *
-open_elf(const char *filename)
+static void
+open_elf(struct elf_info *info)
 {
-  Elf *ret = NULL;
-  int fd = 0;
 
-  assert(filename != NULL);
+  assert(info != NULL);
+
   if (elf_version(EV_CURRENT) == EV_NONE)
-    errx(EX_SOFTWARE, "ELF library initialization failed: %s",
-        elf_errmsg(-1));
+    errx(EX_SOFTWARE, "ELF library initialization failed: %s", elf_errmsg(-1));
 
-  if ((fd = open(filename, O_RDONLY, 0)) < 0)
-    err(EX_NOINPUT, "open \%s\" failed", filename);
+  if ((info->fd = open(info->filename, O_RDONLY, 0)) < 0)
+    err(EX_NOINPUT, "open \%s\" failed", info->filename);
 
-  if ((ret = elf_begin(fd, ELF_C_READ, NULL)) == NULL)
-    errx(EX_SOFTWARE, "elf_begin() failed: %s.",
-        elf_errmsg(-1));
+  if ((info->elf = elf_begin(info->fd, ELF_C_READ, NULL)) == NULL)
+    errx(EX_SOFTWARE, "elf_begin() failed: %s.", elf_errmsg(-1));
 
-  if (elf_kind(ret) != ELF_K_ELF)
-    errx(EX_DATAERR, "%s is not an ELF object.", filename);
+  if (elf_kind(info->elf) != ELF_K_ELF)
+    errx(EX_DATAERR, "%s is not an ELF object.", info->filename);
 
-  assert(ret != NULL);
-  return ret;
+  return;
+}
+
+static char *
+get_debuglink_info(struct elf_info *elf, unsigned long *crc_out)
+{
+  char *basename = (char *) elf->debuglink_data->d_buf;
+  unsigned long offset = strlen(basename) + 1;
+  offset = (offset + 3) & ~3;
+
+  memcpy(crc_out, elf->debuglink_data->d_buf + offset, 4);
+
+  return basename;
+}
+
+static int
+verify_debug_checksum(const char *filename, unsigned long crc)
+{
+  struct stat stat_buf;
+  void *region = NULL;
+  int fd = open(filename, O_RDONLY);
+  unsigned long crc_check = 0;
+
+  if (fd == -1) {
+    dbg_printf("Couldn't open debug file: %s, because: %s\n", filename, strerror(errno));
+    return 1;
+  }
+
+  if (fstat(fd, &stat_buf) == -1) {
+    dbg_printf("Couldn't stat debug file: %s, because: %s\n", filename, strerror(errno));
+    return 1;
+  }
+
+  region = mmap(NULL, stat_buf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
+  if (region == MAP_FAILED) {
+    dbg_printf("mapping a section of size: %zd has failed!\n", stat_buf.st_size);
+    return 1;
+  }
+
+  crc_check = gnu_debuglink_crc32(crc_check, region, stat_buf.st_size);
+  dbg_printf("supposed crc: %lx, computed crc:  %lx\n", crc, crc_check);
+
+  munmap(region, stat_buf.st_size);
+  close(fd);
+
+  return !(crc == crc_check);
+}
+
+static int
+find_debug_syms(struct elf_info *elf)
+{
+  /*
+   * XXX TODO perhaps allow users to specify an env var (or something) pointing
+   * to where the debug symbols live?
+   */
+  unsigned long crc = 0;
+  char *basename = get_debuglink_info(elf, &crc);
+  char *debug_file = NULL, *dir = NULL;
+  char *tmp = strdup(elf->filename);
+
+  assert(basename != NULL);
+  dbg_printf(".gnu_debuglink base file name: %s, crc: %lx\n", basename, crc);
+
+  dir = dirname(tmp);
+  debug_file = malloc(strlen(DEBUGDIR) + strlen(dir) +
+                      strlen("/") + strlen(basename) + 1);
+
+  strncat(debug_file, DEBUGDIR, strlen(DEBUGDIR));
+  strncat(debug_file, dir, strlen(dir));
+  strncat(debug_file, "/", strlen("/"));
+  strncat(debug_file, basename, strlen(basename));
+
+  elf->debug_data = calloc(1, sizeof(*elf->debug_data));
+  elf->debug_data->filename = debug_file;
+
+  dbg_printf("Possible debug symbols in: %s\n", elf->debug_data->filename);
+
+  if (verify_debug_checksum(elf->debug_data->filename, crc)) {
+    dbg_printf("Checksum verification of debug file: %s failed!", elf->debug_data->filename);
+    free(debug_file);
+    free(elf->debug_data);
+    return 1;
+  }
+
+  open_elf(elf->debug_data);
+
+  if (dissect_elf(elf->debug_data, 0) != 0) {
+    /* free debug_data */
+    dbg_printf("Dissection of debug data failed!\n");
+    free(debug_file);
+    free(elf->debug_data);
+    return 1;
+  }
+
+  elf->symtab_data = elf->debug_data->symtab_data;
+  elf->symtab_shdr = elf->debug_data->symtab_shdr;
+
+  /* XXX free stuff */
+  /* LEAK elf_end(elf->elf); */
+
+  elf->elf = elf->debug_data->elf;
+  close(elf->debug_data->fd);
+
+  dbg_printf("Finished dissecting debug data\n");
+  return 0;
 }
 
 /*
@@ -659,32 +923,43 @@ open_elf(const char *filename)
  *
  * Given an elf_info structure, this function will attempt to parse the object
  * and store important state needed to rewrite the object later.
+ *
+ * TODO better error handling
+ *
+ * Returns 1 on hard errors.
+ * Returns 2 on recoverable errors (missing symbol table).
+ * Returns 0 on success.
  */
-static void
-dissect_elf(struct elf_info *info)
+static int
+dissect_elf(struct elf_info *info, int find_debug)
 {
   assert(info != NULL);
 
-  size_t shstrndx = 0;
+  size_t shstrndx = 0, j = 0;
   Elf *elf = info->elf;
   Elf_Scn *scn = NULL;
   GElf_Shdr shdr;
-  size_t j = 0;
+  int ret = 0;
 
   if (elf_getshdrstrndx(elf, &shstrndx) == -1) {
-    errx(EX_SOFTWARE, "getshstrndx() failed: %s.", elf_errmsg(-1));
+    dbg_printf("getshstrndx() failed: %s.", elf_errmsg(-1));
+    ret = 1;
+    goto out;
   }
 
   if (gelf_getehdr(elf, &(info->ehdr)) == NULL) {
-    errx(EX_SOFTWARE, "Couldn't get elf header.");
+    dbg_printf("Couldn't get elf header.");
+    ret = 1;
+    goto out;
   }
 
   /* search each ELF header and store important data for each header... */
   while ((scn = elf_nextscn(elf, scn)) != NULL) {
-    if (gelf_getshdr(scn, &shdr) != &shdr)
-      errx(EX_SOFTWARE, "getshdr() failed: %s.",
-          elf_errmsg(-1));
-
+    if (gelf_getshdr(scn, &shdr) != &shdr) {
+      dbg_printf("getshdr() failed: %s.", elf_errmsg(-1));
+      ret = 1;
+      goto out;
+    }
 
     /*
      * The .dynamic section contains entries that are important to memprof.
@@ -699,8 +974,9 @@ dissect_elf(struct elf_info *info)
       for (j = 0; j < shdr.sh_size / shdr.sh_entsize; ++j) {
         GElf_Dyn dyn;
         if (gelf_getdyn(data, j, &dyn) == NULL) {
-          error(EXIT_FAILURE, 0,
-              "Couldn't get .dynamic data from loaded library.");
+          dbg_printf("Couldn't get .dynamic data from loaded library.");
+          ret = 1;
+          goto out;
         }
 
         if (dyn.d_tag == DT_JMPREL) {
@@ -720,21 +996,26 @@ dissect_elf(struct elf_info *info)
 
       info->dynsym = elf_getdata(scn, NULL);
       info->dynsym_count = shdr.sh_size / shdr.sh_entsize;
-      if (info->dynsym == NULL
-          || elf_getdata(scn, info->dynsym) != NULL)
-        error(EXIT_FAILURE, 0,
-              "Couldn't get .dynsym data ");
+      if (info->dynsym == NULL || elf_getdata(scn, info->dynsym) != NULL) {
+        dbg_printf("Couldn't get .dynsym data ");
+        ret = 1;
+        goto out;
+      }
 
       scn = elf_getscn(elf, shdr.sh_link);
-      if (scn == NULL || gelf_getshdr(scn, &shdr) == NULL)
-        error(EXIT_FAILURE, 0,
-              "Couldn't get section header from");
+      if (scn == NULL || gelf_getshdr(scn, &shdr) == NULL) {
+        dbg_printf("Couldn't get section header.");
+        ret = 1;
+        goto out;
+      }
 
       data = elf_getdata(scn, NULL);
       if (data == NULL || elf_getdata(scn, data) != NULL
-          || shdr.sh_size != data->d_size || data->d_off)
-        error(EXIT_FAILURE, 0,
-              "Couldn't get .dynstr data");
+          || shdr.sh_size != data->d_size || data->d_off) {
+        dbg_printf("Couldn't get .dynstr data");
+        ret = 1;
+        goto out;
+      }
 
       info->dynstr = data->d_buf;
     }
@@ -752,9 +1033,21 @@ dissect_elf(struct elf_info *info)
      * Pull out information (start address) of the .plt section.
      */
     else if (shdr.sh_type == SHT_PROGBITS) {
-	    if (strcmp(elf_strptr(elf, shstrndx, shdr.sh_name), ".plt") == 0) {
-		    info->plt_addr = shdr.sh_addr;
-	    }
+      if (strcmp(elf_strptr(elf, shstrndx, shdr.sh_name), ".plt") == 0) {
+        info->plt_addr = shdr.sh_addr;
+      } else if (strcmp(elf_strptr(elf, shstrndx, shdr.sh_name), ".gnu_debuglink") == 0) {
+        info->debuglink_addr = shdr.sh_addr;
+        info->debuglink_sz = shdr.sh_size;
+        dbg_printf("address: %lx, size: %zd\n", shdr.sh_addr, shdr.sh_size);
+
+       if ((info->debuglink_data = elf_getdata(scn, NULL)) == NULL ||
+           info->debuglink_data->d_size == 0) {
+          dbg_printf(".gnu_debuglink section existed, but wasn't readable.\n");
+          ret = 2;
+          goto out;
+       }
+       dbg_printf("size: %zd\n", shdr.sh_size);
+      }
     }
     /*
      * The symbol table is also needed for bin_find_symbol
@@ -763,42 +1056,52 @@ dissect_elf(struct elf_info *info)
       info->symtab_shdr = shdr;
       if ((info->symtab_data = elf_getdata(scn, info->symtab_data)) == NULL ||
           info->symtab_data->d_size == 0) {
-        errx(EX_DATAERR, "shared lib has a broken symbol table. Is it stripped? "
-            "memprof only works on shared libs that are not stripped!");
+        dbg_printf("shared lib has a broken symbol table. Is it stripped? "
+                   "memprof only works on shared libs that are not stripped!\n");
+        ret = 2;
+        goto out;
       }
     }
   }
 
   /* If this object has no symbol table there's nothing else to do but fail */
   if (!info->symtab_data) {
-    errx(EX_DATAERR, "binary is stripped. memprof only works on binaries that are not stripped!");
+    dbg_printf("binary is stripped. memprof only works on binaries that are not stripped!\n");
+    ret = 1;
   }
 
-
   /*
    * Walk the sections, pull out, and store the .plt section
    */
   for (j = 1; j < info->ehdr.e_shnum; j++) {
     scn =  elf_getscn(elf, j);
-    if (scn == NULL || gelf_getshdr(scn, &shdr) == NULL)
-        error(EXIT_FAILURE, 0,
-              "Couldn't get section header from library.");
+    if (scn == NULL || gelf_getshdr(scn, &shdr) == NULL) {
+      dbg_printf("Couldn't get section header from library.");
+      ret = 1;
+      goto out;
+    }
 
     if (shdr.sh_addr == info->relplt_addr
         && shdr.sh_size == info->plt_size) {
       info->relplt = elf_getdata(scn, NULL);
       info->relplt_count = shdr.sh_size / shdr.sh_entsize;
-      if (info->relplt == NULL
-          || elf_getdata(scn, info->relplt) != NULL)
-        error(EXIT_FAILURE, 0,
-            "Couldn't get .rel*.plt data from");
+      if (info->relplt == NULL || elf_getdata(scn, info->relplt) != NULL) {
+        dbg_printf("Couldn't get .rel*.plt data from");
+        ret = 1;
+        goto out;
+      }
       break;
     }
   }
 
-  return;
+out:
+  if (find_debug && ret == 1) {
+    find_debug_syms(info);
+  }
+  return ret;
 }
 
+
 /*
  * bin_init - initialize the binary parsing/modification layer.
  *
@@ -809,6 +1112,9 @@ bin_init()
 {
   Dwarf_Error dwrf_err;
 
+  ASSERT_ON_COMPILE(sizeof(unsigned long) == sizeof(GElf_Addr));
+  ASSERT_ON_COMPILE(sizeof(unsigned long) == sizeof(Elf64_Addr));
+
   ruby_info = calloc(1, sizeof(*ruby_info));
 
   if (!ruby_info) {
@@ -816,15 +1122,26 @@ bin_init()
   }
 
   if (!has_libruby(ruby_info)) {
-    ruby_info->filename = "/proc/self/exe";
+    dbg_printf("This ruby binary has no libruby\n");
+    char *filename = calloc(1, 255);
+    if (readlink("/proc/self/exe", filename, 255) == -1) {
+      errx(EX_UNAVAILABLE, "Unable to follow /proc/self/exe symlink: %s", strerror(errno));
+    }
+    ruby_info->filename = filename;
     ruby_info->base_addr = 0;
+    dbg_printf("The path to the binary is: %s\n", ruby_info->filename);
   }
 
-  ruby_info->elf = open_elf(ruby_info->filename);
-  dissect_elf(ruby_info);
+  open_elf(ruby_info);
+
+  if (dissect_elf(ruby_info, 1) == 2) {
+    errx(EX_DATAERR, "Error trying to parse elf file: %s\n", ruby_info->filename);
+  }
 
   if (dwarf_elf_init(ruby_info->elf, DW_DLC_READ, NULL, NULL, &dwrf, &dwrf_err) != DW_DLV_OK) {
     errx(EX_DATAERR, "unable to read debugging data from binary. was it compiled with -g? is it unstripped?");
   }
+
+  dbg_printf("bin_init finished\n");
 }
 #endif