heapinfo 0.0.5 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 38cb3f9332f88d77ee939beeec7ef2e1563e92fb
-  data.tar.gz: 897f2130e7167fcae28c678df332b4aa0c8be682
+  metadata.gz: bb558249510b9c160a5f0f699d702a17b1189624
+  data.tar.gz: dacc4780724a2254d8137a23d2f920734db9034d
 SHA512:
-  metadata.gz: 3fcb02ec66361586e3f5c00466f266dd1c388b0b27651c3ce030f88ab7d084b080cf7296bd71bbc32dc96a1a41e65f4318d73456c2d6126f6b37a9659e72bcb6
-  data.tar.gz: 7884b477325650a2baf197a303387f580d4cb6de6100691b9e985842b23b8ea863afce4f07b1385a65cf5ce189aff3b70979b00681d39b6863fdde337375d62f
+  metadata.gz: 8fce3e42275b5895a2bec83dbe31d216d1d5a7506905e4d0e527f449c4418f9af00d6f9133d8b1074bb293e7a33ac0557833539562d68dd7a7cfc22d04404885
+  data.tar.gz: 1d036055d53f75e3d9639af6274682b29f5d8f6b275d4644d2619fa29ce4bbed559871ea9caf4b72c66fe81a82dcf4bd0496de239fd88b807df8b50757790ef5

data/README.md

@@ -1,4 +1,5 @@
 [![Build Status](https://travis-ci.org/david942j/heapinfo.svg?branch=master)](https://travis-ci.org/david942j/heapinfo)
+![](http://ruby-gem-downloads-badge.herokuapp.com/heapinfo?type=total)
 [![Code Climate](https://codeclimate.com/github/david942j/heapinfo/badges/gpa.svg)](https://codeclimate.com/github/david942j/heapinfo)
 [![Issue Count](https://codeclimate.com/github/david942j/heapinfo/badges/issue_count.svg)](https://codeclimate.com/github/david942j/heapinfo)
 [![Test Coverage](https://codeclimate.com/github/david942j/heapinfo/badges/coverage.svg)](https://codeclimate.com/github/david942j/heapinfo/coverage)

data/lib/heapinfo.rb

@@ -11,12 +11,13 @@ require 'fileutils'
 module HeapInfo
   # Directory for writing some tmp files when working,
   # make sure /tmp is writable
-  TMP_DIR = '/tmp/.heapinfo'
-  FileUtils.mkdir_p TMP_DIR
+  TMP_DIR = '/tmp/.heapinfo'.freeze
+  FileUtils.mkdir_p(TMP_DIR)
 
-  # Entry point for using HeapInfo.
-  # Show segments info of the process after loaded
-  # @param [String, Fixnum] prog The program name of victim. If a number is given, seem as pid (useful when multi-processes exist)
+  # Entry point for using {HeapInfo}.
+  # Show segments info of the process after loaded.
+  # @param [String, Fixnum] prog
+  #   The program name of victim. If a number is given, seem as pid (useful when multi-processes exist).
   # @param [Hash] options Give library's file name.
   # @option options [String, Regexp] :libc file name of glibc, default is <tt>/libc[^\w]/</tt>
   # @option options [String, Regexp] :ld file name of dynamic linker/loader, default is <tt>/\/ld-.+\.so/</tt>
@@ -34,7 +35,7 @@ module HeapInfo
   #   # => "/lib/x86_64-linux-gnu/libc-2.19.so"
   #   p h.ld.name
   #   # => "/lib/x86_64-linux-gnu/ld-2.19.so"
-  #  
+  #
   # @example
   #   h = heapinfo(27605, libc: 'libc.so.6', ld: 'ld-linux-x86-64.so.2')
   #   # pid 27605 is run by custom loader
@@ -53,9 +54,8 @@ end
 # @return [HeapInfo::Process]
 # @param [Mixed] args see #HeapInfo::heapinfo for more information
 def heapinfo(*args)
-  ::HeapInfo::heapinfo(*args)
+  ::HeapInfo.heapinfo(*args)
 end
- 
 
 require 'heapinfo/helper'
 require 'heapinfo/nil'

data/lib/heapinfo/arena.rb

@@ -11,34 +11,36 @@ module HeapInfo
     attr_reader :unsorted_bin
     # @return [Array<HeapInfo::Smallbin>] Smallbins in an array.
     attr_reader :smallbin
-    # @return [Integer] The <tt>system_mem</tt>
+    # @return [Integer] The +system_mem+ in arena.
     attr_reader :system_mem
     # attr_reader :largebin, :last_remainder
 
-    # Instantiate a <tt>HeapInfo::Arena</tt> object.
+    # Instantiate a {HeapInfo::Arena} object.
     #
     # @param [Integer] base Base address of arena.
     # @param [Integer] size_t Either 8 or 4
     # @param [Proc] dumper For dump more data
     def initialize(base, size_t, dumper)
-      @base, @size_t, @dumper = base, size_t, dumper
+      @base = base
+      @size_t = size_t
+      @dumper = dumper
       reload!
     end
 
     # Refresh all attributes.
-    # Retrive data using <tt>@dumper</tt>, load bins, top chunk etc.
+    # Retrive data using +@dumper+, load bins, top chunk etc.
     # @return [HeapInfo::Arena] self
     def reload!
       top_ptr_offset = @base + 8 + size_t * 10
       top_ptr = Helper.unpack(size_t, @dumper.call(top_ptr_offset, size_t))
       @fastbin = []
-      return self if top_ptr == 0 # arena not init yet
+      return self if top_ptr.zero? # arena not init yet
       @top_chunk = Chunk.new size_t, top_ptr, @dumper
       @last_remainder = Chunk.new size_t, top_ptr_offset + 8, @dumper
       # this offset diff after 2.23
-      @system_mem = 2.times.map do |off|
+      @system_mem = Array.new(2) do |off|
         Helper.unpack(size_t, @dumper.call(top_ptr_offset + 258 * size_t + 16 + off * size_t, size_t))
-      end.find { |val| val >= 0x21000 and (val & 0xfff) == 0 }
+      end.find { |val| val >= 0x21000 && (val & 0xfff).zero? }
       @fastbin = Array.new(7) do |idx|
         f = Fastbin.new(size_t, @base + 8 - size_t * 2 + size_t * idx, @dumper, head: true)
         f.index = idx
@@ -67,7 +69,8 @@ module HeapInfo
       res
     end
 
-  private
+    private
+
     attr_reader :size_t
   end
 
@@ -77,10 +80,10 @@ module HeapInfo
     attr_reader :fd
     # @return [Integer] index
     attr_accessor :index
-    
-    # Instantiate a <tt>HeapInfo::Fastbin</tt> object.
+
+    # Instantiate a {HeapInfo::Fastbin} object.
     #
-    # @param [Mixed] args See <tt>HeapInfo::Chunk</tt> for more information.
+    # @param [Mixed] args See {HeapInfo::Chunk} for more information.
     def initialize(*args)
       super
       @fd = Helper.unpack(size_t, @data[0, @size_t])
@@ -95,7 +98,9 @@ module HeapInfo
     # For pretty inspect.
     # @return [String] Title with color codes.
     def title
-      "%s%s: " % [Helper.color(Helper.class_name(self), sev: :bin),  index.nil? ? nil : "[#{Helper.color("%#x" % idx_to_size)}]"]
+      class_name = Helper.color(Helper.class_name(self), sev: :bin)
+      size_str = index.nil? ? nil : "[#{Helper.color(format('%#x', idx_to_size))}]"
+      "#{class_name}#{size_str}: "
     end
 
     # Pretty inspect.
@@ -104,15 +109,15 @@ module HeapInfo
       title + list.map do |ptr|
         next "(#{ptr})\n" if ptr.is_a? Symbol
         next " => (nil)\n" if ptr.nil?
-        " => %s" % Helper.color("%#x" % ptr)
+        format(' => %s', Helper.color(format('%#x', ptr)))
       end.join
     end
 
-    # @return [Array<Integer, Symbol, NilClass>] single link list of <tt>fd</tt> chain.
+    # @return [Array<Integer, Symbol, NilClass>] single link list of +fd+ chain.
     #   Last element will be:
-    #   - <tt>:loop</tt> if loop detectded
-    #   - <tt>:invalid</tt> invalid address detected
-    #   - <tt>nil</tt> end with zero address (normal case)
+    #   - +:loop+ if loop detectded
+    #   - +:invalid+ invalid address detected
+    #   - +nil+ end with zero address (normal case)
     def list
       dup = {}
       ptr = @fd
@@ -127,19 +132,20 @@ module HeapInfo
       ret << nil
     end
 
-    # @param [Integer] ptr Get the <tt>fd</tt> value of chunk at <tt>ptr</tt>.
-    # @return [Integer] The <tt>fd</tt>.
+    # @param [Integer] ptr Get the +fd+ value of chunk at +ptr+.
+    # @return [Integer] The +fd+.
     def fd_of(ptr)
       addr_of(ptr, 2)
     end
 
-    # @param [Integer] ptr Get the <tt>bk</tt> value of chunk at <tt>ptr</tt>.
-    # @return [Integer] The <tt>bk</tt>.
+    # @param [Integer] ptr Get the +bk+ value of chunk at +ptr+.
+    # @return [Integer] The +bk+.
     def bk_of(ptr)
       addr_of(ptr, 3)
     end
 
-  private
+    private
+
     def addr_of(ptr, offset)
       t = dump(ptr + size_t * offset, size_t)
       return nil if t.nil?
@@ -152,63 +158,60 @@ module HeapInfo
     # @return [Integer]
     attr_reader :bk
 
-    # Instantiate a <tt>HeapInfo::UnsortedBin</tt> object.
+    # Instantiate a {HeapInfo::UnsortedBin} object.
     #
-    # @param [Mixed] args See <tt>HeapInfo::Chunk</tt> for more information.
+    # @param [Mixed] args See {HeapInfo::Chunk} for more information.
     def initialize(*args)
       super
       @bk = Helper.unpack(size_t, @data[@size_t, @size_t])
     end
 
-    # @option [Integer] size At most expand size. For <tt>size = 2</tt>, the expand list would be <tt>bk, bk, bin, fd, fd</tt>.
+    # @param [Integer] size
+    #   At most expand size. For +size = 2+, the expand list would be +bk, bk, bin, fd, fd+.
     # @return [String] unsorted bin layouts wrapper with color codes.
     def inspect(size: 2)
       list = link_list(size)
-      return '' if list.size <= 1 and Helper.class_name(self) != 'UnsortedBin' # bad..
+      return '' if list.size <= 1 && Helper.class_name(self) != 'UnsortedBin' # bad..
       title + pretty_list(list) + "\n"
     end
 
     # Wrapper the double-linked list with color codes.
-    # @param [Array<Integer>] list The list from <tt>#link_list</tt>.
+    # @param [Array<Integer>] list The list from +#link_list+.
     # @return [String] Wrapper with color codes.
     def pretty_list(list)
       center = nil
       list.map.with_index do |c, idx|
-        next center = Helper.color("[self]", sev: :bin) if c == @base
+        next center = Helper.color('[self]', sev: :bin) if c == @base
+        color_c = Helper.color(format('%#x', c))
         fwd = fd_of(c)
-        next "%s(invalid)" % Helper.color("%#x" % c) if fwd.nil? # invalid c
+        next "#{color_c}(invalid)" if fwd.nil? # invalid c
         bck = bk_of(c)
         if center.nil? # bk side
-          next Helper.color("%s%s" % [
-            Helper.color("%#x" % c),
-            fwd == list[idx+1] ? nil : "(%#x)" % fwd,
-          ])
-        else #fd side
-          next Helper.color("%s%s" % [
-            bck == list[idx-1] ? nil : "(%#x)" % bck,
-            Helper.color("%#x" % c),
-          ])
+          Helper.color(format('%s%s', color_c, fwd == list[idx + 1] ? nil : format('(%#x)', fwd)))
+        else # fd side
+          Helper.color(format('%s%s', bck == list[idx - 1] ? nil : format('(%#x)', bck), color_c))
         end
-      end.join(" === ")
+      end.join(' === ')
     end
 
     # Return the double link list with bin in the center.
     #
-    # The list will like <tt>[..., bk of bk, bk of bin, bin, fd of bin, fd of fd, ...]</tt>.
-    # @param [Integer] expand_size At most expand size. For <tt>size = 2</tt>, the expand list would be <tt>bk, bk, bin, fd, fd</tt>.
+    # The list will like +[..., bk of bk, bk of bin, bin, fd of bin, fd of fd, ...]+.
+    # @param [Integer] expand_size
+    #   At most expand size. For +size = 2+, the expand list would be +bk, bk, bin, fd, fd+.
     # @return [Array<Integer>] The linked list.
     def link_list(expand_size)
       list = [@base]
       # fd
-      work = Proc.new do |ptr, nxt, append|
+      work = proc do |ptr, nxt, append|
         sz = 0
         dup = {}
-        while ptr != @base and sz < expand_size
+        while ptr != @base && sz < expand_size
           append.call ptr
           break if ptr.nil? # invalid pointer
           break if dup[ptr] # looped
           dup[ptr] = true
-          ptr = self.send(nxt, ptr)
+          ptr = send(nxt, ptr)
           sz += 1
         end
       end
@@ -220,7 +223,6 @@ module HeapInfo
 
   # Class for record smallbin type chunk.
   class Smallbin < UnsortedBin
-
     # Mapping index of smallbin to chunk size.
     # @return [Integer] size
     def idx_to_size

data/lib/heapinfo/cache.rb

@@ -1,9 +1,8 @@
 require 'digest'
 module HeapInfo
-
   # Self implment file-base cache manager.
   #
-  # Values are recorded in files based on <tt>Marshal</tt>
+  # Values are recorded in files based on <tt>Marshal</tt>.
   module Cache
     # Directory for caching files.
     # e.g. HeapInfo will record main_arena_offset for glibc(s)
@@ -24,8 +23,8 @@ module HeapInfo
     # @return [Boolean] true
     def self.write(key, value)
       filepath = realpath key
-      FileUtils.mkdir_p(File.dirname filepath)
-      IO.binwrite(filepath, Marshal::dump(value))
+      FileUtils.mkdir_p(File.dirname(filepath))
+      IO.binwrite(filepath, Marshal.dump(value))
       true
     end
 
@@ -35,8 +34,8 @@ module HeapInfo
     # @return [Object, NilClass] value that recorded, return <tt>nil</tt> when cache miss.
     def self.read(key)
       filepath = realpath key
-      return unless File.file? filepath
-      Marshal::load IO.binread filepath
+      return unless File.file?(filepath)
+      Marshal.load(IO.binread(filepath))
     rescue
       nil # handle if file content invalid
     end
@@ -44,24 +43,24 @@ module HeapInfo
     # @param [String] key
     # @return [String] Prepend with <tt>CACHE_DIR</tt>
     def self.realpath(key)
-      raise ArgumentError.new('Invalid key(file path)') if key =~ /[^\w\/]/
+      raise ArgumentError, 'Invalid key(file path)' if key =~ %r{[^\w/]}
       File.join(CACHE_DIR, key)
     end
 
-    # @return [Object] Not important.
-    def self.load
+    # @return [void]
+    def self.init
       FileUtils.mkdir_p(CACHE_DIR)
     rescue
       # To prevent ~/ is not writable.
-      self.send :remove_const, :CACHE_DIR
-      self.const_set :CACHE_DIR, File.join(HeapInfo::TMP_DIR, '.cache/heapinfo')
+      send(:remove_const, :CACHE_DIR)
+      const_set(:CACHE_DIR, File.join(HeapInfo::TMP_DIR, '.cache/heapinfo'))
     end
 
     # Clear the cache directory.
-    # @return [Object] Not important.
+    # @return [void]
     def self.clear_all
       FileUtils.rm_rf CACHE_DIR
     end
-    self.load
+    init
   end
 end

data/lib/heapinfo/chunk.rb

@@ -10,24 +10,24 @@ module HeapInfo
     # @return [Integer] Base address of this chunk
     attr_reader :base
 
-    # Instantiate a <tt>HeapInfo::Chunk</tt> object
+    # Instantiate a {HeapInfo::Chunk} object
     #
     # @param [Integer] size_t 4 or 8
     # @param [Integer] base Start address of this chunk
     # @param [Proc] dumper For dump more information of this chunk
-    # @param [Boolean] head For specific if is fake chunk in <tt>arena</tt>. If <tt>head</tt> is <tt>true</tt>, will not load <tt>size</tt> and <tt>prev_size</tt> (since it's meaningless)
+    # @param [Boolean] head
+    #   For specific if is fake chunk in +arena+.
+    #   If +head+ is +true+, will not load +size+ and +prev_size+ (since it's meaningless)
     # @example
-    #   HeapInfo::Chunk.new 8, 0x602000, ->(addr, len) { [0,0x21, 0xda4a].pack("Q*")[addr-0x602000, len] }
+    #   HeapInfo::Chunk.new 8, 0x602000, ->(addr, len) { [0,0x21, 0xda4a].pack('Q*')[addr-0x602000, len] }
     #   # create a chunk with chunk size 0x21
     def initialize(size_t, base, dumper, head: false)
-      raise ArgumentError.new('size_t can be either 4 or 8') unless [4, 8].include? size_t 
-      self.class.send(:define_method, :dump){|*args| dumper.call(*args)}
+      raise ArgumentError, 'size_t can be either 4 or 8' unless [4, 8].include?(size_t)
+      self.class.send(:define_method, :dump) { |*args| dumper.call(*args) }
       @size_t = size_t
       @base = base
       sz = dump(@base, size_t * 2)
-      if head # no need to read size if is bin
-        return @data = dump(@base + size_t * 2, size_t * 4)
-      end
+      return @data = dump(@base + size_t * 2, size_t * 4) if head # no need to read size if is bin
       @prev_size = Helper.unpack(size_t, sz[0, size_t])
       @size = Helper.unpack(size_t, sz[size_t..-1])
       r_size = [size - size_t * 2, size_t * 4].min # don't read too much data
@@ -35,14 +35,14 @@ module HeapInfo
       @data = dump(@base + size_t * 2, r_size)
     end
 
-    # Hook <tt>#to_s</tt> for pretty printing
+    # Hook +#to_s+ for pretty printing
     # @return [String]
     def to_s
-      ret = Helper.color("#<%s:%#x>\n" % [self.class.to_s, @base], sev: :klass) +
-      "flags = [#{flags.map{|f|Helper.color(":#{f}", sev: :sym)}.join(',')}]\n" +
-      "size = #{Helper.color "%#x" % size} (#{bintype})\n"
-      ret += "prev_size = #{Helper.color "%#x" % @prev_size}\n" unless flags.include? :prev_inuse
-      ret += "data = #{Helper.color @data.inspect}#{'...' if @data.length < size - size_t * 2}\n"
+      ret = Helper.color(format("#<%s:%#x>\n", self.class.to_s, @base), sev: :klass)
+      ret += "flags = [#{flags.map { |f| Helper.color(":#{f}", sev: :sym) }.join(',')}]\n"
+      ret += "size = #{Helper.color(format('%#x', size))} (#{bintype})\n"
+      ret += "prev_size = #{Helper.color(format('%#x', @prev_size))}\n" unless flags.include? :prev_inuse
+      ret += "data = #{Helper.color(@data.inspect)}#{'...' if @data.length < size - size_t * 2}\n"
       ret
     end
 
@@ -55,29 +55,29 @@ module HeapInfo
     def flags
       mask = @size - size
       flag = []
-      flag << :non_main_arena unless mask & 4 == 0
-      flag << :mmapped unless mask & 2 == 0
-      flag << :prev_inuse unless mask & 1 == 0
+      flag << :non_main_arena unless (mask & 4).zero?
+      flag << :mmapped unless (mask & 2).zero?
+      flag << :prev_inuse unless (mask & 1).zero?
       flag
     end
 
     # Ask if chunk not belongs to main arena.
     #
-    # @return [Boolean] <tt>true|false</tt> if chunk not belongs to main arena
+    # @return [Boolean] +true|false+ if chunk not belongs to main arena
     def non_main_arena?
       flags.include? :non_main_arena
     end
 
     # Ask if chunk is mmapped.
     #
-    # @return [Boolean] <tt>true|false</tt> if chunk is mmapped
+    # @return [Boolean] +true|false+ if chunk is mmapped
     def mmapped?
       flags.include? :mmapped
     end
 
     # Ask if chunk has set the prev-inuse bit.
     #
-    # @return [Boolean] <tt>true|false</tt> if the <tt>prev_inuse</tt> bit has been set
+    # @return [Boolean] +true|false+ if the +prev_inuse+ bit has been set
     def prev_inuse?
       flags.include? :prev_inuse
     end
@@ -89,7 +89,7 @@ module HeapInfo
     end
 
     # Bin type of this chunk
-    # @return [Symbol] Bin type is simply determined according to <tt>#size</tt>
+    # @return [Symbol] Bin type is simply determined according to +#size+
     # @example
     #   [c.size, c.size_t]
     #   # => [80, 8]
@@ -110,8 +110,8 @@ module HeapInfo
       return :unknown if sz < @size_t * 4
       return :fast if sz <= @size_t * 16
       return :small if sz <= @size_t * 0x7e
-      return :large if sz <= @size_t * 0x3ffe # is this correct? 
-      return :mmap
+      return :large if sz <= @size_t * 0x3ffe # is this correct?
+      :mmap
     end
   end
 end

data/lib/heapinfo/chunks.rb

@@ -1,17 +1,28 @@
 module HeapInfo
   # Self-defined array for collecting chunk(s)
   class Chunks
-    # Instantiate a <tt>HeapInfo::Chunks</tt> object
+    include Enumerable
+    # Instantiate a <tt>HeapInfo::Chunks</tt> object.
     def initialize
       @chunks = []
     end
 
-    def method_missing(method_sym, *arguments, &block) # :nodoc:
-      return super unless @chunks.respond_to? method_sym
-      @chunks.send(method_sym, *arguments, &block)
+    # @return [void]
+    def <<(val)
+      @chunks << val
     end
 
-    # Hook <tt>#to_s</tt> for pretty printing.
+    # @return [Integer]
+    def size
+      @chunks.size
+    end
+
+    # @return [void]
+    def each(&block)
+      @chunks.each(&block)
+    end
+
+    # Hook +#to_s+ for pretty printing.
     # @return [String]
     def to_s
       @chunks.map(&:to_s).join("\n")