heapinfo 0.0.5 → 0.1.0

data/lib/heapinfo/dumper.rb

@@ -4,18 +4,19 @@ module HeapInfo
     # Default dump length
     DUMP_BYTES = 8
 
-    # Instantiate a <tt>HeapInfo::Dumper</tt> object
+    # Instantiate a {HeapInfo::Dumper} object
     #
     # @param [HeapInfo::ProcessInfo] info process info object.
-    # @param [String] mem_filename The filename that can be access for dump. Should be <tt>/proc/[pid]/mem</tt>.
+    # @param [String] mem_filename The filename that can be access for dump. Should be +/proc/[pid]/mem+.
     def initialize(info, mem_filename)
-      @info, @filename = info, mem_filename
+      @info = info
+      @filename = mem_filename
       need_permission unless dumpable?
     end
 
-    # A helper for <tt>HeapInfo::Process</tt> to dump memory.
-    # @param [Mixed] args The use input commands, see examples of <tt>HeapInfo::Process#dump</tt>.
-    # @return [String, NilClass] Dump results. If error happend, <tt>nil</tt> is returned.
+    # A helper for {HeapInfo::Process} to dump memory.
+    # @param [Mixed] args The use input commands, see examples of {HeapInfo::Process#dump}.
+    # @return [String, NilClass] Dump results. If error happend, +nil+ is returned.
     # @example
     #   p dump(:elf, 4)
     #   # => "\x7fELF"
@@ -29,47 +30,51 @@ module HeapInfo
       mem
     rescue => e
       raise e if e.is_a? ArgumentError
-      nil 
+      nil
     end
 
     # Return the dump result as chunks.
-    # see <tt>HeapInfo::Chunks</tt> and <tt>HeapInfo::Chunk</tt> for more information.
+    # see {HeapInfo::Chunks} and {HeapInfo::Chunk} for more information.
     #
-    # Note: Same as <tt>dump</tt>, need permission of attaching another process.
+    # Note: Same as {#dump}, need permission of attaching another process.
     # @return [HeapInfo::Chunks] An array of chunk(s).
-    # @param [Mixed] args Same as arguments of <tt>#dump</tt>
+    # @param [Mixed] args Same as arguments of {#dump}.
     def dump_chunks(*args)
       base = base_of(*args)
       dump(*args).to_chunks(bits: @info.bits, base: base)
     end
 
-    # Show dump results like in gdb's command <tt>x</tt>.
+    # Show dump results like in gdb's command +x+.
     #
-    # Details are in <tt>HeapInfo:Process#x</tt>
+    # Details are in {HeapInfo:Process#x}.
     # @param [Integer] count The number of result need to dump.
-    # @param [Mixed] commands Same format as <tt>#dump(*args)</tt>.
-    # @param [IO] io <tt>IO</tt> that use for printing.
-    # @return [NilClass] The return value of <tt>io.puts</tt>.
+    # @param [Mixed] commands Same format as +#dump(*args)+.
+    # @param [IO] io +IO+ that use for printing.
+    # @return [NilClass] The return value of +io.puts+.
     # @example
     #   x 3, 0x400000
     #   # 0x400000:       0x00010102464c457f      0x0000000000000000
     #   # 0x400010:       0x00000001003e0002
     def x(count, *commands, io: $stdout)
-      commands = commands + [count * size_t]
+      commands += [count * size_t]
       base = base_of(*commands)
-      res = dump(*commands).unpack(size_t == 4 ? "L*" : "Q*")
-      str = res.group_by.with_index{|_, i| i / (16 / size_t) }.map do |round, values|
-        "%#x:\t" % (base + round * 16) + values.map{|v| Helper.color "0x%0#{size_t * 2}x" % v}.join("\t")
+      res = dump(*commands).unpack(size_t == 4 ? 'L*' : 'Q*')
+      str = res.group_by.with_index { |_, i| i / (16 / size_t) }.map do |round, values|
+        format("%#x:\t", (base + round * 16)) +
+          values.map { |v| Helper.color(format("0x%0#{size_t * 2}x", v)) }.join("\t")
       end.join("\n")
       io.puts str
     end
 
     # Search a specific value/string/regexp in memory.
-    # <tt>#find</tt> only return the first matched address.
-    # @param [Integer, String, Regexp] pattern The desired search pattern, can be value(<tt>Integer</tt>), string, or regular expression.
-    # @param [Integer, String, Symbol] from Start address for searching, can be segment(<tt>Symbol</tt>) or segments with offset. See examples for more information.
+    # +#find+ only return the first matched address.
+    # @param [Integer, String, Regexp] pattern
+    #   The desired search pattern, can be value(+Integer+), string, or regular expression.
+    # @param [Integer, String, Symbol] from
+    #   Start address for searching, can be segment(+Symbol+)
+    #   or segments with offset. See examples for more information.
     # @param [Integer] length The length limit for searching.
-    # @return [Integer, NilClass] The first matched address, <tt>nil</tt> is returned when no such pattern found.
+    # @return [Integer, NilClass] The first matched address, +nil+ is returned when no such pattern found.
     # @example
     #   find(/E.F/, :elf)
     #   # => 4194305
@@ -81,17 +86,17 @@ module HeapInfo
       from = base_of(from)
       length = 1 << 40 if length.is_a? Symbol
       case pattern
-      when Integer; find_integer(pattern, from, length)
-      when String; find_string(pattern, from, length)
-      when Regexp; find_regexp(pattern, from, length)
-      else; nil
+      when Integer then find_integer(pattern, from, length)
+      when String then find_string(pattern, from, length)
+      when Regexp then find_regexp(pattern, from, length)
       end
     end
 
-
-    # Parse the dump command into <tt>[base, offset, length]</tt>
+    # Parse the dump command into +[base, offset, length]+
     # @param [Array] args The command, see examples for more information
-    # @return [Array<Symbol, Integer>] <tt>[base, offset, length]</tt>, while <tt>base</tt> can be a [Symbol] or an [Integer]. <tt>length</tt> has default value equal to <tt>8</tt>.
+    # @return [Array<Symbol, Integer>]
+    #   +[base, offset, length]+, while +base+ can be a +Symbol+ or an +Integer+.
+    #   +length+ has default value equals to +8+.
     # @example
     #   HeapInfo::Dumper.parse_cmd([:heap, 32, 10])
     #   # [:heap, 32, 10]
@@ -111,12 +116,12 @@ module HeapInfo
       [base, offset, len]
     end
 
-    # Helper for <tt>#parse_cmd</tt>.
+    # Helper for +#parse_cmd+.
     #
-    # Split commands to exactly three parts: <tt>[base, offset, length]</tt>
-    # <tt>length</tt> is <tt>nil</tt> if not present.
+    # Split commands to exactly three parts: +[base, offset, length]+.
+    # +length+ is +nil+ if not present.
     # @param [Array] args
-    # @return [Array<String>] <tt>[base, offset, length]</tt> in string expression.
+    # @return [Array<String>] +[base, offset, length]+ in string expression.
     # @example
     #   HeapInfo::Dumper.split_cmd([:heap, 32, 10])
     #   # ['heap', '32', '10']
@@ -138,9 +143,14 @@ module HeapInfo
       args[0, 3]
     end
 
-  private
+    private
+
     def need_permission
-      puts Helper.color(%q(Could not attach to process. Check the setting of /proc/sys/kernel/yama/ptrace_scope, or try again as the root user.  For more details, see /etc/sysctl.d/10-ptrace.conf), sev: :fatal)
+      msg = 'Could not attach to process. ' \
+            'Check the setting of /proc/sys/kernel/yama/ptrace_scope, ' \
+            'or try again as the root user. ' \
+            'For more details, see /etc/sysctl.d/10-ptrace.conf'
+      puts Helper.color(msg, sev: :fatal)
     end
 
     # use /proc/[pid]/mem for memory dump, must sure have permission
@@ -161,10 +171,10 @@ module HeapInfo
 
     def base_len_of(*args)
       base, offset, len = Dumper.parse_cmd(args)
-      if HeapInfo::ProcessInfo::EXPORT.include?(base) and (segment = @info.send(base)).is_a? Segment
+      if HeapInfo::ProcessInfo::EXPORT.include?(base) && (segment = @info.send(base)).is_a?(Segment)
         base = segment.base
-      elsif not base.is_a? Integer
-        raise ArgumentError.new("Invalid base: #{base}") # invalid usage
+      elsif !base.is_a?(Integer)
+        raise ArgumentError, "Invalid base: #{base}" # invalid usage
       end
       [base + offset, len]
     end
@@ -174,15 +184,15 @@ module HeapInfo
     end
 
     def find_integer(value, from, length)
-      find_string([value].pack(size_t == 4 ? "L*" : "Q*"), from, length)
+      find_string([value].pack(size_t == 4 ? 'L*' : 'Q*'), from, length)
     end
 
-    def find_string(string, from ,length)
-      batch_dumper(from, length) {|str| str.index string}
+    def find_string(string, from, length)
+      batch_dumper(from, length) { |str| str.index(string) }
     end
 
-    def find_regexp(pattern, from ,length)
-      batch_dumper(from, length) {|str| str =~ pattern}
+    def find_regexp(pattern, from, length)
+      batch_dumper(from, length) { |str| str =~ pattern }
     end
 
     def batch_dumper(from, remain_size)
@@ -199,6 +209,7 @@ module HeapInfo
       return if idx.nil?
       from + idx
     end
+
     def size_t
       @info.bits / 8
     end

data/lib/heapinfo/ext/string.rb

@@ -9,7 +9,7 @@ module HeapInfo
         # @return [HeapInfo::Chunk]
         def to_chunk(bits: 64, base: 0)
           size_t = bits / 8
-          dumper = ->(addr, len) { self[addr-base, len] }
+          dumper = ->(addr, len) { self[addr - base, len] }
           Chunk.new(size_t, base, dumper)
         end
 
@@ -21,7 +21,7 @@ module HeapInfo
           size_t = bits / 8
           chunks = Chunks.new
           cur = 0
-          while cur + size_t * 2 <= self.length
+          while cur + size_t * 2 <= length
             now_chunk = self[cur, size_t * 2].to_chunk
             sz = now_chunk.size
             chunks << self[cur, sz + 1].to_chunk(bits: bits, base: base + cur) # +1 for dump prev_inuse

data/lib/heapinfo/glibc/error.rb

@@ -1,11 +1,12 @@
 module HeapInfo
+  # Define errors.
   module Glibc
     # @abstract Exceptions raised by HeapInfo inherit from Error
     class Error < StandardError; end
     # Exception raised in malloc.c(malloc, free, etc.) methods.
     class MallocError < Error; end
     def malloc_assert(condition)
-      raise MallocError.new(yield) unless condition
+      raise MallocError, yield unless condition
     end
   end
 end

data/lib/heapinfo/glibc/free.rb

@@ -1,25 +1,29 @@
 # Implment glibc's free-related functions
 # [Reference](https://code.woboq.org/userspace/glibc/malloc/malloc.c.html)
 module HeapInfo
+  # Implement free-related functions.
   module Glibc
     # Implmentation of <tt>void __libc_free(void *mem)</tt>.
-    # [glibc-2.23](https://github.com/david942j/heapinfo/blob/master/examples/libcdb/libc-2.23/malloc.c#L2934) or [Online Source](https://code.woboq.org/userspace/glibc/malloc/malloc.c.html#__libc_free)
+    # [glibc-2.23](https://github.com/david942j/heapinfo/blob/master/examples/libcdb/libc-2.23/malloc.c#L2934) or
+    # [Online Source](https://code.woboq.org/userspace/glibc/malloc/malloc.c.html#__libc_free)
     # @param [Integer] mem Memory address to be free.
     def libc_free(mem)
       # TODO: free_hook
       mem = ulong mem
-      return if mem == 0 # free(0) has no effect
+      return if mem.zero? # free(0) has no effect
       ptr = mem2chunk(mem)
       return munmap_chunk(ptr) if chunk_is_mmapped(ptr)
       av = arena_for_chunk(ptr)
       int_free(av, ptr)
     end
-    alias :free :libc_free
+    alias free libc_free
+
+    private
 
-  private
     # Implmentation of <tt>void _int_free (mstate av, mchunkptr p, [int have_lock])</tt>.
-    # [glibc-2.23](https://github.com/david942j/heapinfo/blob/master/examples/libcdb/libc-2.23/malloc.c#L2934) or [Online Source](https://code.woboq.org/userspace/glibc/malloc/malloc.c.html#__libc_free)
-    # 
+    # [glibc-2.23](https://github.com/david942j/heapinfo/blob/master/examples/libcdb/libc-2.23/malloc.c#L2934) or
+    # [Online Source](https://code.woboq.org/userspace/glibc/malloc/malloc.c.html#__libc_free)
+    #
     # The original method in C is too long, split to multiple methods to match ruby convention.
     # @param [HeapInfo::Arena] av
     # @param [Integer] ptr Use <tt>ptr</tt> instead of <tt>p</tt> to prevent confusing with ruby native method.
@@ -42,17 +46,19 @@ module HeapInfo
       invalid_next_size(:fast, av, ptr, size)
       idx = fastbin_index(size)
       old = av.fastbin[idx].fd
-      malloc_assert( old != ptr ) { "double free or corruption (fasttop)\ntop of fastbin[0x%x]: 0x%x=0x%x" % [size & -8, ptr, ptr]   }
+      malloc_assert(old != ptr) do
+        format("double free or corruption (fasttop)\ntop of fastbin[0x%x]: 0x%x=0x%x", size & -8, ptr, ptr)
+      end
       true
     end
 
-    def int_free_small(av, ptr, size)
+    def int_free_small(av, ptr, size) # rubocop:disable UnusedMethodArgument
       # TODO: unfinished
       true
     end
 
-    def munmap_chunk(ptr)
-      # TODO: check page alignment and... page exists? 
+    def munmap_chunk(ptr) # rubocop:disable UnusedMethodArgument
+      # TODO: check page alignment and... page exists?
       true
     end
 
@@ -61,21 +67,28 @@ module HeapInfo
     def invalid_pointer(ptr, size)
       errmsg = "free(): invalid pointer\n"
       # unsigned compare
-      malloc_assert(ptr <= ulong(-size)) { errmsg + "ptr(0x%x) > -size(0x%x)" % [ptr, ulong(-size)] }
-      malloc_assert(ptr % (size_t * 2) == 0) { errmsg + "ptr(0x%x) %% %d != 0" % [ptr, size_t * 2] }
+      malloc_assert(ptr <= ulong(-size)) { errmsg + format('ptr(0x%x) > -size(0x%x)', ptr, ulong(-size)) }
+      malloc_assert((ptr % (size_t * 2)).zero?) { errmsg + format('ptr(0x%x) %% %d != 0', ptr, size_t * 2) }
     end
 
     def invalid_size(size)
       errmsg = "free(): invalid size\n"
-      malloc_assert(size >= min_chunk_size) { errmsg + "size(0x%x) < min_chunk_size(0x%x)" % [size, min_chunk_size] }
-      malloc_assert(aligned_ok size) { errmsg + "alignment error: size(0x%x) %% 0x%x != 0" % [size, size_t * 2] }
+      malloc_assert(size >= min_chunk_size) do
+        errmsg + format('size(0x%x) < min_chunk_size(0x%x)', size, min_chunk_size)
+      end
+      malloc_assert(aligned_ok(size)) { errmsg + format('alignment error: size(0x%x) %% 0x%x != 0', size, size_t * 2) }
     end
 
     def invalid_next_size(type, av, ptr, size)
       errmsg = "free(): invalid next size (#{type})\n"
       nxt_chk = dumper.call(ptr + size, size_t * 2).to_chunk(base: ptr + size)
-      malloc_assert(nxt_chk.size > 2 * size_t) { errmsg + "next chunk(0x%x) has size(#{nxt_chk.size}) <=  2 * #{size_t}" % nxt_chk.base }
-      malloc_assert(nxt_chk.size < av.system_mem) { errmsg + "next chunk(0x%x) has size(0x%x) >= av.system_mem(0x%x)" % [nxt_chk.base, nxt_chk.size, av.system_mem] }
+      malloc_assert(nxt_chk.size > 2 * size_t) do
+        errmsg + format("next chunk(0x%x) has size(#{nxt_chk.size}) <=  2 * #{size_t}", nxt_chk.base)
+      end
+      malloc_assert(nxt_chk.size < av.system_mem) do
+        errmsg + format('next chunk(0x%x) has size(0x%x) >= av.system_mem(0x%x)',
+                        nxt_chk.base, nxt_chk.size, av.system_mem)
+      end
     end
   end
 end

data/lib/heapinfo/glibc/glibc.rb

@@ -1,11 +1,15 @@
 module HeapInfo
+  # To define heap-related functions in glibc.
   module Glibc
     attr_accessor :size_t
-  private
+
+    private
+
     attr_accessor :main_arena
     attr_accessor :dumper
   end
 end
+
 require 'heapinfo/glibc/error.rb'
 require 'heapinfo/glibc/helper.rb'
 require 'heapinfo/glibc/free.rb'

data/lib/heapinfo/glibc/helper.rb

@@ -1,6 +1,8 @@
 module HeapInfo
+  # Define some useful functions here.
   module Glibc
-  private
+    private
+
     def mem2chunk(mem)
       ulong(mem - 2 * size_t)
     end
@@ -11,9 +13,10 @@ module HeapInfo
       dumper.call(ptr, size_t * 2).to_chunk.mmapped?
     end
 
-    def get_max_fast
+    def max_fast
       size_t * 16
     end
+    alias get_max_fast max_fast
 
     # The minimal chunk size.
     # Not the real implmentation, maybe wrong some day?
@@ -25,19 +28,19 @@ module HeapInfo
     # Not the real implmentation, maybe wrong some day?
     # @return [Boolean]
     def aligned_ok(size)
-      size & (2 * size_t - 1) == 0
+      (size & (2 * size_t - 1)).zero?
     end
 
     # @return [Integer]
     def ulong(n)
-      n % 2 ** (size_t * 8)
+      n % 2**(size_t * 8)
     end
 
     # @return [HeapInfo::Arena]
     def arena_for_chunk(ptr)
       # not support arena other than initial main_arena
-      return if dumper.call(ptr, size_t * 2).to_chunk.non_main_arena? 
-      main_arena 
+      return if dumper.call(ptr, size_t * 2).to_chunk.non_main_arena?
+      main_arena
     end
 
     # @return [Integer]

data/lib/heapinfo/helper.rb

@@ -7,15 +7,15 @@ module HeapInfo
     def self.pidof(prog)
       # plz, don't cmd injection your self :p
       pid = `pidof #{prog}`.strip.to_i
-      return nil if pid == 0 # process not exists yet
-      throw "pidof #{prog} fail" unless pid.between?(2, 65535)
+      return nil if pid.zero? # process not exists yet
+      throw "pidof #{prog} fail" unless pid.between?(2, 65_535)
       pid
-      #TODO: handle when multi processes exists
+      # TODO: handle when multi processes exists
     end
 
     # Create read <tt>/proc/[pid]/*</tt> methods
     %w(exe maps).each do |method|
-      self.define_singleton_method("#{method}_of".to_sym) do |pid|
+      define_singleton_method("#{method}_of".to_sym) do |pid|
         begin
           IO.binread("/proc/#{pid}/#{method}")
         rescue
@@ -23,7 +23,7 @@ module HeapInfo
         end
       end
     end
-    
+
     # Parse the contents of <tt>/proc/[pid]/maps</tt>.
     #
     # @param [String] content The file content of <tt>/proc/[pid]/maps</tt>
@@ -35,15 +35,15 @@ module HeapInfo
     #     7f2788315000-7f2788316000 r--p 00022000 ca:01 402319                     /lib/x86_64-linux-gnu/ld-2.19.so
     #     EOS
     #   )
-    #   # [[0x400000, 0x40b000, 'r-xp', '/bin/cat'], 
-    #   # [0xbc4000, 0xbe5000, 'rw-p', '[heap]'], 
+    #   # [[0x400000, 0x40b000, 'r-xp', '/bin/cat'],
+    #   # [0xbc4000, 0xbe5000, 'rw-p', '[heap]'],
     #   # [0x7f2788315000, 0x7f2788316000, 'r--p', '/lib/x86_64-linux-gnu/ld-2.19.so']]
     def self.parse_maps(content)
       lines = content.split("\n")
       lines.map do |line|
-        s = line.scan(/^([0-9a-f]+)-([0-9a-f]+)\s([rwxp-]{4})[^\/|\[]*([\/|\[].+)$/)[0]
+        s = line.scan(%r{^([0-9a-f]+)-([0-9a-f]+)\s([rwxp-]{4})[^/|\[]*([/|\[].+)$})[0]
         next nil if s.nil?
-        s[0],s[1] = s[0,2].map{|h|h.to_i(16)}
+        s[0], s[1] = s[0, 2].map { |h| h.to_i(16) }
         s
       end.compact
     end
@@ -57,23 +57,19 @@ module HeapInfo
       bin: "\e[38;5;120m", # light green
       klass: "\e[38;5;155m", # pry like
       sym: "\e[38;5;229m", # pry like
-    }
-    # Wrapper color codes for for pretty inspect
+    }.freeze
+    # Wrapper color codes for pretty inspect.
     # @param [String] s Contents for wrapper
-    # @param [Symbol?] sev Specific which kind of color want to use, valid symbols are defined in <tt>#COLOR_CODE</tt>.
-    # If this argument is not present, will detect according to the content of <tt>s</tt>
-    # @return [String] wrapper with color codes. 
+    # @param [Symbol?] sev Specific which kind of color want to use, valid symbols are defined in +#COLOR_CODE+.
+    # If this argument is not present, will detect according to the content of +s+.
+    # @return [String] wrapper with color codes.
     def self.color(s, sev: nil)
       s = s.to_s
-      color = ''
       cc = COLOR_CODE
-      if cc.keys.include?(sev)
-        color = cc[sev]
-      elsif s =~ /^(0x)?[0-9a-f]+$/ # integers
-        color = cc[:integer]
-      else #normal string
-        color = cc[:normal_s]
-      end
+      color = if cc.key?(sev) then cc[sev]
+              elsif s =~ /^(0x)?[0-9a-f]+$/ then cc[:integer] # integers
+              else cc[:normal_s] # normal string
+              end
       "#{color}#{s.sub(cc[:esc_m], color)}#{cc[:esc_m]}"
     end
 
@@ -114,9 +110,9 @@ module HeapInfo
       obj.class.name.split('::').last || obj.class.name
     end
 
-    # For checking a string is actually an integer
-    # @param [String] str String to be checked
-    # @return [Boolean] If <tt>str</tt> can be converted into integer
+    # For checking a string is actually an integer.
+    # @param [String] str String to be checked.
+    # @return [Boolean] If +str+ can be converted into integer.
     # @example
     #   Helper.integer? '1234'
     #   # => true
@@ -125,7 +121,7 @@ module HeapInfo
     #   Helper.integer? '0xheapoverflow'
     #   # => false
     def self.integer?(str)
-      !!Integer(str)
+      true if Integer(str)
     rescue ArgumentError, TypeError
       false
     end