manageiq-smartstate 0.1.0

data/lib/fs/ext4/ex_attrib_header.rb

@@ -0,0 +1,14 @@
+module Ext4
+  # ////////////////////////////////////////////////////////////////////////////
+  # // Data definitions.
+
+  EX_ATTRIB_HEADER = [
+    'L',  'signature',  # Always 0xea020000
+    'L',  'ref_count',
+    'L',  'num_blks',
+    'L',  'hash',
+  ]
+
+  class ExAttribHeader
+  end
+end

data/lib/fs/ext4/ex_attrib_name.rb

@@ -0,0 +1,23 @@
+module Ext4
+  # ////////////////////////////////////////////////////////////////////////////
+  # // Data definitions.
+
+  EX_ATTRIB_NAME = [
+    'C',  'name_len',       # Length of name
+    'C',  'type',           # Type of attribute, see AT_ below.
+    'S',  'offset_to_val',  # Offset to value.
+    'L',  'blk_loc',        # Block location of value (not used).
+    'L',  'size_of_val',    # Size in bytes of value.
+    'L',  'hash_of_val',    # Hash of value.
+  ]
+  # Here follows the value name in ASCII.
+
+  class ExAttribName
+    AT_USER           = 1 # User space attribute.
+    AT_POSIX_ACL      = 2 # POSIX ACL.
+    AT_POSIX_ACL_DEF  = 3 # POSIX ACL default (directories only).
+    AT_TRUSTED        = 4 # Trusted space attribute.
+    AT_LUSTRE         = 5 # Not currently used.
+    AT_SECURITY       = 6 # Security space attribute.
+  end
+end

data/lib/fs/ext4/extent.rb

@@ -0,0 +1,35 @@
+require 'binary_struct'
+
+module Ext4
+  # ////////////////////////////////////////////////////////////////////////////
+  # // Data definitions.
+
+  EXTENT = BinaryStruct.new([
+    'L',  'block',      # first logical block extent covers
+    'S',  'length',     # number of blocks covered by extent
+    'S',  'start_hi',   # high 16 bits of physical block
+    'L',  'start_lo',   # low  32 bits of physical block
+  ])
+  SIZEOF_EXTENT = EXTENT.size
+
+  class Extent
+    attr_reader :block, :length, :start
+
+    def initialize(buf)
+      raise "Ext4::Extent.initialize: Nil buffer" if buf.nil?
+      @extent = EXTENT.decode(buf)
+
+      @block      = @extent['block']
+      @length     = @extent['length']
+      @start      = (@extent['start_hi'] << 32) | @extent['start_lo']
+    end
+
+    def dump
+      out = "\#<#{self.class}:0x#{'%08x' % object_id}>\n"
+      out += "Block        : #{@block}\n"
+      out += "Length       : #{@length}\n"
+      out += "Start        : #{@start}\n"
+      out
+    end
+  end
+end

data/lib/fs/ext4/extent_header.rb

@@ -0,0 +1,40 @@
+require 'binary_struct'
+
+module Ext4
+  # ////////////////////////////////////////////////////////////////////////////
+  # // Data definitions.
+
+  EXTENT_HEADER = BinaryStruct.new([
+    'S',  'magic',      # Signature.
+    'S',  'entries',    # Number of Valid Entries
+    'S',  'max',        # Capacity of Store in Entries
+    'S',  'depth',      # Has tree real underlying blocks?
+    'L',  'generation', # Generation of the tree.
+  ])
+  SIZEOF_EXTENT_HEADER = EXTENT_HEADER.size
+
+  class ExtentHeader
+    attr_reader :magic, :entries, :max, :depth, :generation
+
+    def initialize(buf)
+      raise "Ext4::ExtentHeader.initialize: Nil buffer" if buf.nil?
+      @eh = EXTENT_HEADER.decode(buf)
+
+      @magic      = @eh['magic']
+      @entries    = @eh['entries']
+      @max        = @eh['max']
+      @depth      = @eh['depth']
+      @generation = @eh['generation']
+    end
+
+    def dump
+      out = "\#<#{self.class}:0x#{'%08x' % object_id}>\n"
+      out += "Magic        : #{@magic}\n"
+      out += "Entries      : #{@entries}\n"
+      out += "Max          : #{@max}\n"
+      out += "Depth        : #{@depth}\n"
+      out += "Generation   : #{@generation}\n"
+      out
+    end
+  end
+end

data/lib/fs/ext4/extent_index.rb

@@ -0,0 +1,33 @@
+require 'binary_struct'
+
+module Ext4
+  # ////////////////////////////////////////////////////////////////////////////
+  # // Data definitions.
+
+  EXTENT_INDEX = BinaryStruct.new([
+    'L',  'block',      # index covers logical blocks from 'block'
+    'L',  'leaf_lo',    # low  32 bits of physical block of the next level. leaf or next index could be there
+    'S',  'leaf_hi',    # high 16 bits of physical block
+    'S',  'unused',     #
+  ])
+  SIZEOF_EXTENT_INDEX = EXTENT_INDEX.size
+
+  class ExtentIndex
+    attr_reader :block, :leaf
+
+    def initialize(buf)
+      raise "Ext4::ExtentIndex.initialize: Nil buffer" if buf.nil?
+      @ei = EXTENT_INDEX.decode(buf)
+
+      @block      = @ei['block']
+      @leaf       = (@ei['leaf_hi'] << 32) | @ei['leaf_lo']
+    end
+
+    def dump
+      out = "\#<#{self.class}:0x#{'%08x' % object_id}>\n"
+      out += "Block        : #{@block}\n"
+      out += "Leaf         : #{@leaf}\n"
+      out
+    end
+  end
+end

data/lib/fs/ext4/group_descriptor_entry.rb

@@ -0,0 +1,69 @@
+require 'binary_struct'
+
+module Ext4
+  # ////////////////////////////////////////////////////////////////////////////
+  # // Data definitions.
+
+  GDE = BinaryStruct.new([
+    'L',  'blk_bmp',        # Starting block address of block bitmap.
+    'L',  'inode_bmp',      # Starting block address of inode bitmap.
+    'L',  'inode_table',    # Starting block address of inode table.
+    'S',  'unalloc_blks',   # Number of unallocated blocks in group.
+    'S',  'unalloc_inodes', # Number of unallocated inodes in group.
+    'S',  'num_dirs',       # Number of directories in group.
+    'a14',  'unused1',      # Unused.
+  ])
+
+  #SIZEOF_GDE = GDE.size
+  # if sb.isEnabled64Bit?, the size of GDE will be 64 with extra information. 
+  # Because the current GDE structure has all the information we need, we'll
+  # continue to use it unless we have to expand it to 64.
+
+  # ////////////////////////////////////////////////////////////////////////////
+  # // Class.
+
+  class GroupDescriptorEntry
+    attr_accessor :blockAllocBmp, :inodeAllocBmp
+
+    def initialize(buf)
+      raise "Ext4::GroupDescriptorEntry.initialize: Nil buffer" if buf.nil?
+
+      # Decode the group descriptor table entry.
+      @gde = GDE.decode(buf)
+    end
+
+    # ////////////////////////////////////////////////////////////////////////////
+    # // Class helpers & accessors.
+
+    def blockBmp
+      @gde['blk_bmp']
+    end
+
+    def inodeBmp
+      @gde['inode_bmp']
+    end
+
+    def inodeTable
+      @gde['inode_table']
+    end
+
+    def numDirs
+      @gde['num_dirs']
+    end
+
+    # ////////////////////////////////////////////////////////////////////////////
+    # // Utility functions.
+
+    # Dump object.
+    def dump
+      out = "\#<#{self.class}:0x#{'%08x' % object_id}>\n"
+      out += "Block bitmap      : 0x#{'%08x' % @gde['blk_bmp']}\n"
+      out += "Inode bitmap      : 0x#{'%08x' % @gde['inode_bmp']}\n"
+      out += "Inode table       : 0x#{'%08x' % @gde['inode_table']}\n"
+      out += "Unallocated blocks: 0x#{'%04x' % @gde['unalloc_blks']}\n"
+      out += "Unallocated inodes: 0x#{'%04x' % @gde['unalloc_inodes']}\n"
+      out += "Num directories   : 0x#{'%04x' % @gde['num_dirs']}\n"
+      out
+    end
+  end
+end

data/lib/fs/ext4/group_descriptor_table.rb

@@ -0,0 +1,54 @@
+require 'fs/ext4/group_descriptor_entry'
+require 'fs/ext4/alloc_bitmap'
+
+module Ext4
+  class GroupDescriptorTable
+    def initialize(sb)
+      raise "Ext4::GroupDescriptorTable.initialize: Nil Superblock" if sb.nil?
+
+      # Read all the group descriptor entries.
+      @gdt = []
+      $log.info "Ext4::GroupDescriptorTable.initialize: group_desc_size=#{sb.groupDescriptorSize}" if $log
+      sb.stream.seek(sb.blockToAddress(sb.blockSize == 1024 ? 2 : 1))
+      buf = sb.stream.read(sb.groupDescriptorSize * sb.numGroups)
+      offset = 0
+      sb.numGroups.times do
+        gde = GroupDescriptorEntry.new(buf[offset, sb.groupDescriptorSize])
+
+        # Construct allocation bitmaps for blocks & inodes.
+        gde.blockAllocBmp = getAllocBitmap(sb, gde.blockBmp, sb.blockSize)
+        gde.inodeAllocBmp = getAllocBitmap(sb, gde.inodeBmp, sb.inodesPerGroup / 8)
+
+        @gdt << gde
+        offset += sb.groupDescriptorSize 
+      end
+    end
+
+    def each
+      @gdt.each { |gde| yield(gde) }
+    end
+
+    def [](group)
+      @gdt[group]
+    end
+
+    def dump(dump_bitmaps = false)
+      out = "\#<#{self.class}:0x#{'%08x' % object_id}>\n"
+      @gdt.each do |gde|
+        out += gde.dump
+        if dump_bitmaps
+          out += "Block allocation\n#{gde.blockAllocBmp.dump}"
+          out += "Inode allocation\n#{gde.inodeAllocBmp.dump}"
+        end
+      end
+      out
+    end
+
+    private
+
+    def getAllocBitmap(sb, block, size)
+      sb.stream.seek(sb.blockToAddress(block))
+      AllocBitmap.new(sb.stream.read(size))
+    end
+  end # class
+end # module

data/lib/fs/ext4/hash_tree_entry.rb

@@ -0,0 +1,58 @@
+require 'binary_struct'
+
+module Ext4
+  # ////////////////////////////////////////////////////////////////////////////
+  # // Data definitions.
+
+  HASH_TREE_ENTRY_FIRST = BinaryStruct.new([
+    'S',  'max_descriptors',  # Maximum number of node descriptors.
+    'S',  'cur_descriptors',  # Current number of node descriptors.
+    'L',  'first_node',       # Block address of first node.
+  ])
+  SIZEOF_HASH_TREE_ENTRY_FIRST = HASH_TREE_ENTRY_FIRST.size
+
+  HASH_TREE_ENTRY_NEXT = BinaryStruct.new([
+    'L',  'min_hash',   # Minimum hash value in node.
+    'L',  'next_node',  # Block address of next node.
+  ])
+  SIZEOF_HASH_TREE_ENTRY_NEXT = HASH_TREE_ENTRY_NEXT.size
+
+  SIZEOF_HASH_TREE_ENTRY = SIZEOF_HASH_TREE_ENTRY_NEXT
+
+  class HashTreeEntry
+    attr_reader :first, :max_descriptors, :cur_descriptors, :node, :min_hash
+
+    def initialize(buf, first = false)
+      raise "Ext4::HashTreeEntry.initialize: Nil buffer" if buf.nil?
+
+      @first = first
+
+      if first
+        @hte             = HASH_TREE_ENTRY_FIRST.decode(buf)
+        @max_descriptors = @hte['max_descriptors']
+        @cur_descriptors = @hte['cur_descriptors']
+        @node            = @hte['first_node']
+      else
+        @hte             = HASH_TREE_ENTRY_NEXT.decode(buf)
+        @min_hash        = @hte['min_hash']
+        @node            = @hte['next_node']
+      end
+    end
+
+    def dump
+      out = "\#<#{self.class}:0x#{'%08x' % object_id}>\n"
+      if @first
+        out += "First Node?     : true\n"
+        out += "Max Descriptors : #{@max_descriptors}\n"
+        out += "Cur Descriptors : #{@cur_descriptors}\n"
+        out += "First Node      : #{@node}\n"
+      else
+        out += "First Node?     : false\n"
+        out += "Min Hash        : #{@min_hash}\n"
+        out += "Next Node       : #{@node}\n"
+      end
+
+      out
+    end
+  end
+end

data/lib/fs/ext4/hash_tree_header.rb

@@ -0,0 +1,35 @@
+require 'binary_struct'
+
+module Ext4
+  # ////////////////////////////////////////////////////////////////////////////
+  # // Data definitions.
+
+  HASH_TREE_HEADER = BinaryStruct.new([
+    'L',  'unused1',    # Unused.
+    'C',  'hash_ver',   # Hash version.
+    'C',  'length',     # Length of this structure.
+    'C',  'leaf_level', # Levels of leaves.
+    'C',  'unused2',    # Unused.
+  ])
+  SIZEOF_HASH_TREE_HEADER = HASH_TREE_HEADER.size
+
+  class HashTreeHeader
+    attr_reader :hash_version, :length, :leaf_level
+
+    def initialize(buf)
+      raise "Ext4::HashTreeHeader.initialize: Nil buffer" if buf.nil?
+      @hth = HASH_TREE_HEADER.decode(buf)
+
+      @hash_version = @hth['hash_ver']
+      @length       = @hth['length']
+      @leaf_level   = @hth['leaf_level']
+    end
+
+    def dump
+      out = "\#<#{self.class}:0x#{'%08x' % object_id}>\n"
+      out += "Hash Version : #{@hash_version}\n"
+      out += "Length       : #{@length}\n"
+      out += "Leaf Level   : #{@leaf_level}\n"
+    end
+  end
+end