manageiq-smartstate 0.1.0

data/lib/fs/ext3/superblock.rb

@@ -0,0 +1,406 @@
+# encoding: US-ASCII
+
+require 'fs/ext3/group_descriptor_table'
+require 'fs/ext3/inode'
+
+require 'binary_struct'
+require 'util/miq-uuid'
+require 'stringio'
+require 'memory_buffer'
+
+require 'rufus/lru'
+
+module Ext3
+  # ////////////////////////////////////////////////////////////////////////////
+  # // Data definitions. Linux 2.6.2 from Fedora Core 6.
+
+  SUPERBLOCK = BinaryStruct.new([
+    'L',  'num_inodes',         # Number of inodes in file system.
+    'L',  'num_blocks',         # Number of blocks in file system.
+    'L',  'reserved_blocks',    # Number of reserved blocks to prevent file system from filling up.
+    'L',  'unallocated_blocks', # Number of unallocated blocks.
+    'L',  'unallocated_inodes', # Number of unallocated inodes.
+    'L',  'block_group_zero',   # Block where block group 0 starts.
+    'L',  'block_size',         # Block size (saved as num bits to shift 1024 left).
+    'L',  'fragment_size',      # Fragment size (saved as num bits to shift 1024 left).
+    'L',  'blocks_in_group',    # Number of blocks in each block group.
+    'L',  'fragments_in_group', # Number of fragments in each block group.
+    'L',  'inodes_in_group',    # Number of inodes in each block group.
+    'L',  'last_mount_time',    # Time FS was last mounted.
+    'L',  'last_write_time',    # Time FS was last written to.
+    'S',  'mount_count',        # Current mount count.
+    'S',  'max_mount_count',    # Maximum mount count.
+    'S',  'signature',          # Always 0xef53
+    'S',  'fs_state',           # File System State: see FSS_ below.
+    'S',  'err_method',         # Error Handling Method: see EHM_ below.
+    'S',  'ver_minor',          # Minor version number.
+    'L',  'last_check_time',    # Last consistency check time.
+    'L',  'forced_check_int',   # Forced check interval.
+    'L',  'creator_os',         # Creator OS: see CO_ below.
+    'L',  'ver_major',          # Major version: see MV_ below.
+    'S',  'uid_res_blocks',     # UID that can use reserved blocks.
+    'S',  'gid_res_blocks',     # GID that can uss reserved blocks.
+    # Begin dynamic version fields
+    'L',  'first_inode',        # First non-reserved inode in file system.
+    'S',  'inode_size',         # Size of each inode.
+    'S',  'block_group',        # Block group that this superblock is part of (if backup copy).
+    'L',  'compat_flags',       # Compatible feature flags (see CFF_ below).
+    'L',  'incompat_flags',     # Incompatible feature flags (see ICF_ below).
+    'L',  'ro_flags',           # Read Only feature flags (see ROF_ below).
+    'a16',  'fs_id',            # File system ID (UUID or GUID).
+    'a16',  'vol_name',         # Volume name.
+    'a64',  'last_mnt_path',    # Path where last mounted.
+    'L',  'algo_use_bmp',       # Algorithm usage bitmap.
+    # Performance hints
+    'C',  'file_prealloc_blks', # Blocks to preallocate for files.
+    'C',  'dir_prealloc_blks',  # Blocks to preallocate for directories.
+    'S',  'unused1',            # Unused.
+    # Journal support
+    'a16',  'jrnl_id',          # Joural ID (UUID or GUID).
+    'L',  'jrnl_inode',         # Journal inode.
+    'L',  'jrnl_device',        # Journal device.
+    'L',  'orphan_head',        # Head of orphan inode list.
+    'a16',  'hash_seed',        # HTREE hash seed. This is actually L4 (__u32 s_hash_seed[4])
+    'C',  'hash_ver',           # Default hash version.
+    'C',  'unused2',
+    'S',  'unused3',
+    'L',  'mount_opts',         # Default mount options.
+    'L',  'first_meta_blk_grp', # First metablock block group.
+    'a360', 'reserved'          # Unused.
+  ])
+
+  SUPERBLOCK_SIG = 0xef53
+  SUPERBLOCK_OFFSET = 1024
+  SUPERBLOCK_SIZE = 1024
+  GDE_SIZE = 32
+  INODE_SIZE = 128              # Default inode size.
+
+  # Simpler structure for just validating the presence of a superblock
+  SUPERBLOCK_VALIDATE = BinaryStruct.new([
+    'x56', nil,
+    'S',  'signature',          # Always 0xef53
+    'S',  'fs_state',           # File System State: see FSS_ below.
+    'S',  'err_method',         # Error Handling Method: see EHM_ below.
+  ])
+  SUPERBLOCK_VALIDATE_SIZE = SUPERBLOCK_VALIDATE.size
+
+  # ////////////////////////////////////////////////////////////////////////////
+  # // Class.
+
+  class Superblock
+    # Default cache sizes.
+    DEF_BLOCK_CACHE_SIZE = 50
+    DEF_INODE_CACHE_SIZE = 50
+
+    # File System State.
+    FSS_CLEAN       = 0x0001  # File system is clean.
+    FSS_ERR         = 0x0002  # File system has errors.
+    FSS_ORPHAN_REC  = 0x0004  # Orphan inodes are being recovered.
+    # NOTE: Recovered NOT by this software but by the 'NIX kernel.
+    # IOW start the VM to repair it.
+    FSS_END         = FSS_CLEAN | FSS_ERR | FSS_ORPHAN_REC
+
+    # Error Handling Method.
+    EHM_CONTINUE    = 1 # No action.
+    EHM_RO_REMOUNT  = 2 # Remount file system as read only.
+    EHM_PANIC       = 3 # Don't mount? halt? - don't know what this means.
+
+    # Creator OS.
+    CO_LINUX    = 0 # NOTE: FS creation tools allow setting this value.
+    CO_GNU_HURD = 1 # These values are supposedly defined.
+    CO_MASIX    = 2
+    CO_FREE_BSD = 3
+    CO_LITES    = 4
+
+    # Major Version.
+    MV_ORIGINAL = 0 # NOTE: If version is not dynamic, then values from
+    MV_DYNAMIC  = 1 # first_inode on may not be accurate.
+
+    # Compatible Feature Flags.
+    CFF_PREALLOC_DIR_BLKS = 0x0001  # Preallocate directory blocks to reduce fragmentation.
+    CFF_AFS_SERVER_INODES = 0x0002  # AFS server inodes exist in system.
+    CFF_JOURNAL           = 0x0004  # File system has journal (Ext3).
+    CFF_EXTENDED_ATTRIBS  = 0x0008  # Inodes have extended attributes.
+    CFF_BIG_PART          = 0x0010  # File system can resize itself for larger partitions.
+    CFF_HASH_INDEX        = 0x0020  # Directories use hash index (another modified b-tree).
+    CFF_FLAGS             = (CFF_PREALLOC_DIR_BLKS | CFF_AFS_SERVER_INODES | CFF_JOURNAL | CFF_EXTENDED_ATTRIBS | CFF_BIG_PART | CFF_HASH_INDEX)
+
+    # Incompatible Feature flags.
+    ICF_COMPRESSION       = 0x0001  # Not supported on Linux?
+    ICF_FILE_TYPE         = 0x0002  # Directory entries contain file type field.
+    ICF_RECOVER_FS        = 0x0004  # File system needs recovery.
+    ICF_JOURNAL           = 0x0008  # File system uses journal device.
+    ICF_META_BG           = 0x0010  #
+    ICF_EXTENTS           = 0x0040  # File system uses extents (ext4)
+    ICF_64BIT             = 0x0080  # File system uses 64-bit
+    ICF_MMP               = 0x0100  #
+    ICF_FLEX_BG           = 0x0200  #
+    ICF_EA_INODE          = 0x0400  # EA in inode
+    ICF_DIRDATA           = 0x1000  # data in dirent
+    ICF_FLAGS             = (ICF_COMPRESSION | ICF_FILE_TYPE | ICF_RECOVER_FS | ICF_JOURNAL | ICF_META_BG | ICF_EXTENTS | ICF_64BIT | ICF_MMP | ICF_FLEX_BG | ICF_EA_INODE | ICF_DIRDATA)
+
+    # ReadOnly Feature flags.
+    ROF_SPARSE            = 0x0001  # Sparse superblocks & group descriptor tables.
+    ROF_LARGE_FILES       = 0x0002  # File system contains large files (over 4G).
+    ROF_BTREES            = 0x0004  # Directories use B-Trees (not implemented?).
+    ROF_FLAGS             = (ROF_SPARSE | ROF_LARGE_FILES | ROF_BTREES)
+
+    # /////////////////////////////////////////////////////////////////////////
+    # // initialize
+    attr_reader :numGroups, :fsId, :stream, :numBlocks, :numInodes, :fsId, :volName
+    attr_reader :sectorSize, :blockSize
+
+    @@track_inodes = false
+
+    def self.isSuperblock?(buf)
+      sb = SUPERBLOCK_VALIDATE.decode(buf)
+      sb['signature'] == SUPERBLOCK_SIG &&
+        sb['fs_state'] <= FSS_END &&
+        sb['err_method'] <= EHM_PANIC
+    end
+
+    def initialize(stream)
+      raise "Ext3::Superblock.initialize: Nil stream" if stream.nil?
+      @stream = stream
+
+      # Seek, read & decode the superblock structure
+      @stream.seek(SUPERBLOCK_OFFSET)
+      @sb = SUPERBLOCK.decode(@stream.read(SUPERBLOCK_SIZE))
+
+      # Grab some quick facts & make sure there's nothing wrong. Tight qualification.
+      raise "Ext3::Superblock.initialize: Invalid signature=[#{@sb['signature']}]" if @sb['signature'] != SUPERBLOCK_SIG
+      state = @sb['fs_state']
+      raise "Ext3::Superblock.initialize: Invalid file system state" if state > FSS_END
+      if state != FSS_CLEAN
+        $log.warn("Ext3 file system has errors")        if $log && gotBit?(state, FSS_ERR)
+        $log.warn("Ext3 orphan inodes being recovered") if $log && gotBit?(state, FSS_ORPHAN_REC)
+      end
+      raise "Ext3::Superblock.initialize: Invalid error handling method=[#{@sb['err_method']}]" if @sb['err_method'] > EHM_PANIC
+      raise "Ext3::Superblock.initialize: Filesystem has extents (ext4)"  if gotBit?(@sb['incompat_flags'], ICF_EXTENTS)
+
+      @blockSize = 1024 << @sb['block_size']
+
+      @block_cache = LruHash.new(DEF_BLOCK_CACHE_SIZE)
+      @inode_cache = LruHash.new(DEF_INODE_CACHE_SIZE)
+
+      # expose for testing.
+      @numBlocks = @sb['num_blocks']
+      @numInodes = @sb['num_inodes']
+
+      # Inode file size members can't be trusted, so use sector count instead.
+      # MiqDisk exposes blockSize, which for our purposes is sectorSize.
+      @sectorSize = @stream.blockSize
+
+      # Preprocess some members.
+      @sb['vol_name'].delete!("\000")
+      @sb['last_mnt_path'].delete!("\000")
+      @numGroups, @lastGroupBlocks = @sb['num_blocks'].divmod(@sb['blocks_in_group'])
+      @numGroups += 1 if @lastGroupBlocks > 0
+      @fsId = UUIDTools::UUID.parse_raw(@sb['fs_id'])
+      @volName = @sb['vol_name']
+      @jrnlId = UUIDTools::UUID.parse_raw(@sb['jrnl_id'])
+    end
+
+    # ////////////////////////////////////////////////////////////////////////////
+    # // Class helpers & accessors.
+
+    def gdt
+      @gdt ||= GroupDescriptorTable.new(self)
+    end
+
+    def isDynamic?
+      @sb['ver_major'] == MV_DYNAMIC
+    end
+
+    def isNewDirEnt?
+      gotBit?(@sb['incompat_flags'], ICF_FILE_TYPE)
+    end
+
+    def fragmentSize
+      1024 << @sb['fragment_size']
+    end
+
+    def blocksPerGroup
+      @sb['blocks_in_group']
+    end
+
+    def fragmentsPerGroup
+      @sb['fragments_in_group']
+    end
+
+    def inodesPerGroup
+      @sb['inodes_in_group']
+    end
+
+    def inodeSize
+      isDynamic? ? @sb['inode_size'] : INODE_SIZE
+    end
+
+    def freeBytes
+      @sb['unallocated_blocks'] * @blockSize
+    end
+
+    def blockNumToGroupNum(block)
+      raise "Ext3::Superblock.blockNumToGroupNum: block is nil" if block.nil?
+      group = (block - @sb['block_group_zero']) / @sb['blocks_in_group']
+      offset = block.modulo(@sb['blocks_in_group'])
+      return group, offset
+    end
+
+    def firstGroupBlockNum(group)
+      group * @sb['blocks_in_group'] + @sb['block_group_zero']
+    end
+
+    def inodeNumToGroupNum(inode)
+      (inode - 1).divmod(inodesPerGroup)
+    end
+
+    def blockToAddress(block)
+      address  = block * @blockSize
+      address += (SUPERBLOCK_SIZE + GDE_SIZE * @numGroups)  if address == SUPERBLOCK_OFFSET
+      address
+    end
+
+    def isValidInode?(inode)
+      group, offset = inodeNumToGroupNum(inode)
+      gde = gdt[group]
+      gde.inodeAllocBmp[offset]
+    end
+
+    def isValidBlock?(block)
+      group, offset = blockNumToGroupNum(block)
+      gde = gdt[group]
+      gde.blockAllocBmp[offset]
+    end
+
+    # Ignore allocation is for testing only.
+    def getInode(inode, _ignore_alloc = false)
+      unless @inode_cache.key?(inode)
+        group, offset = inodeNumToGroupNum(inode)
+        gde = gdt[group]
+        # raise "Inode #{inode} is not allocated" if (not gde.inodeAllocBmp[offset] and not ignore_alloc)
+        @stream.seek(blockToAddress(gde.inodeTable) + offset * inodeSize)
+        @inode_cache[inode] = Inode.new(@stream.read(inodeSize))
+        $log.info "Inode num: #{inode}\n#{@inode_cache[inode].dump}\n\n" if $log && @@track_inodes
+      end
+
+      @inode_cache[inode]
+    end
+
+    # Ignore allocation is for testing only.
+    def getBlock(block, _ignore_alloc = false)
+      raise "Ext3::Superblock.getBlock: block is nil" if block.nil?
+
+      unless @block_cache.key?(block)
+        if block == 0
+          @block_cache[block] = MemoryBuffer.create(@blockSize)
+        else
+          group, offset = blockNumToGroupNum(block)
+          gde = gdt[group]
+          # raise "Block #{block} is not allocated" if (not gde.blockAllocBmp[offset] and not ignore_alloc)
+
+          address = blockToAddress(block)  # This function will read the block into our cache
+
+          @stream.seek(address)
+          @block_cache[block] = @stream.read(@blockSize)
+        end
+      end
+      @block_cache[block]
+    end
+
+    def getFeatureStrings
+      out = "Compatible Feature Flags:\n"
+      cff = @sb['compat_flags']
+      out << "  CFF_PREALLOC_DIR_BLKS\n"  if gotBit?(cff, CFF_PREALLOC_DIR_BLKS)
+      out << "  CFF_AFS_SERVER_INODE\n"   if gotBit?(cff, CFF_AFS_SERVER_INODES)
+      out << "  CFF_JOURNAL\n"            if gotBit?(cff, CFF_JOURNAL)
+      out << "  CFF_EXTENDED_ATTRIBS\n"   if gotBit?(cff, CFF_EXTENDED_ATTRIBS)
+      out << "  CFF_BIG_PART\n"           if gotBit?(cff, CFF_BIG_PART)
+      out << "  CFF_HASH_INDEX\n"         if gotBit?(cff, CFF_HASH_INDEX)
+      extra = cff - (cff & CFF_FLAGS)
+      out << "  Extra Flags: 0x%08X\n" % extra if extra != 0
+      out << "Incompatible Feature Flags:\n"
+      icf = @sb['incompat_flags']
+      out << "  ICF_COMPRESSION\n"        if gotBit?(icf, ICF_COMPRESSION)
+      out << "  ICF_FILE_TYPE\n"          if gotBit?(icf, ICF_FILE_TYPE)
+      out << "  ICF_RECOVER_FS\n"         if gotBit?(icf, ICF_RECOVER_FS)
+      out << "  ICF_JOURNAL\n"            if gotBit?(icf, ICF_JOURNAL)
+      out << "  ICF_META_BG\n"            if gotBit?(icf, ICF_META_BG)
+      out << "  ICF_EXTENTS\n"            if gotBit?(icf, ICF_EXTENTS)
+      out << "  ICF_64BIT\n"              if gotBit?(icf, ICF_64BIT)
+      out << "  ICF_MMP\n"                if gotBit?(icf, ICF_MMP)
+      out << "  ICF_FLEX_BG\n"            if gotBit?(icf, ICF_FLEX_BG)
+      out << "  ICF_EA_INODE\n"           if gotBit?(icf, ICF_EA_INODE)
+      out << "  ICF_DIRDATA\n"            if gotBit?(icf, ICF_DIRDATA)
+      extra = icf - (icf & ICF_FLAGS)
+      out << "  Extra Flags: 0x%08X\n" % extra if extra != 0
+      out << "Read Only Feature Flags:\n"
+      rof = @sb['ro_flags']
+      out << "  ROF_SPARSE\n"             if gotBit?(rof, ROF_SPARSE)
+      out << "  ROF_LARGE_FILES\n"        if gotBit?(rof, ROF_LARGE_FILES)
+      out << "  ROF_BTREES\n"             if gotBit?(rof, ROF_BTREES)
+      extra = rof - (rof & ROF_FLAGS)
+      out << "  Extra Flags: 0x%08X\n" % extra if extra != 0
+      out
+    end
+
+    # ////////////////////////////////////////////////////////////////////////////
+    # // Utility functions.
+
+    def gotBit?(field, bit)
+      field & bit == bit
+    end
+
+    # Dump object.
+    def dump
+      out = "\#<#{self.class}:0x#{'%08x' % object_id}>\n"
+      out << "Number of inodes      : #{@sb['num_inodes']}\n"
+      out << "Number of blocks      : #{@sb['num_blocks']}\n"
+      out << "Reserved blocks       : #{@sb['reserved_blocks']}\n"
+      out << "Unallocated blocks    : #{@sb['unallocated_blocks']}\n"
+      out << "Unallocated inodes    : #{@sb['unallocated_inodes']}\n"
+      out << "Block group 0         : #{@sb['block_group_zero']}\n"
+      out << "Block size            : #{@sb['block_size']} (#{@blockSize} bytes)\n"
+      out << "Fragment size         : #{@sb['fragment_size']} (#{fragmentSize} bytes)\n"
+      out << "Blocks per group      : #{@sb['blocks_in_group']} (#{blocksPerGroup} blocks per group)\n"
+      out << "Fragments per group   : #{@sb['fragments_in_group']} (#{fragmentsPerGroup} fragments per group)\n"
+      out << "Inodes per group      : #{@sb['inodes_in_group']} (#{inodesPerGroup} inodes per group)\n"
+      out << "Last mount time       : #{Time.at(@sb['last_mount_time'])}\n"
+      out << "Last write time       : #{Time.at(@sb['last_write_time'])}\n"
+      out << "Current mount count   : #{@sb['mount_count']}\n"
+      out << "Maximum mount count   : #{@sb['max_mount_count']}\n"
+      out << "Signature             : #{@sb['signature']}\n"
+      out << "File system state     : #{@sb['fs_state']}\n"
+      out << "Error hndling methd   : #{@sb['err_method']}\n"
+      out << "Minor version         : #{@sb['ver_minor']}\n"
+      out << "Last consistency check: #{Time.at(@sb['last_check_time'])}\n"
+      out << "Forced check interval : #{@sb['forced_check_int']} sec\n"
+      out << "Creator OS            : #{@sb['creator_os']}\n"
+      out << "Major version         : #{@sb['ver_major']}\n"
+      out << "UID can use res blocks: #{@sb['uid_res_blocks']}\n"
+      out << "GID can use res blocks: #{@sb['gid_res_blocks']}\n"
+      if isDynamic?
+        out << "First non-res inode   : #{@sb['first_inode']}\n"
+        out << "Size of inode         : #{@sb['inode_size']}\n"
+        out << "Block group of this SB: #{@sb['block_group']}\n"
+        out << "Compatible features   : 0x#{'%08x' % @sb['compat_flags']}\n"
+        out << "Incompatible features : 0x#{'%08x' % @sb['incompat_flags']}\n"
+        out << "Read Only features    : 0x#{'%08x' % @sb['ro_flags']}\n"
+        out << "File system id        : #{@fsId}\n"
+        out << "Volume name           : #{@sb['vol_name']}\n"
+        out << "Last mount path       : #{@sb['last_mnt_path']}\n"
+        out << "Algorithm usage bitmap: 0x#{'%08x' % @sb['algo_use_bmp']}\n"
+        out << "Blocks prealloc files : #{@sb['file_prealloc_blks']}\n"
+        out << "Blocks prealloc dirs  : #{@sb['dir_prealloc_blks']}\n"
+        out << "Journal id            : #{@jrnlId}\n"
+        out << "Journal inode         : #{@sb['jrnl_inode']}\n"
+        out << "Journal device        : #{@sb['jrnl_device']}\n"
+        out << "Orphan inode head     : #{@sb['orphan_head']}\n"
+      end
+      out << "Number of groups      : #{numGroups}\n"
+      out << "Free bytes            : #{freeBytes}\n"
+      out << getFeatureStrings
+      out
+    end
+  end
+end # moule Ext3

data/lib/fs/ext3/test/tc_Ext3BlockPointersPath.rb

@@ -0,0 +1,74 @@
+require 'minitest/unit'
+require 'enumerator'
+
+require 'fs/ext3/block_pointers_path'
+include  Ext3
+
+class TestBlockPointersPath < MiniTest::Unit::TestCase
+  NUM_INDIRECTS = 15
+  MAX_BLOCK = 3626
+
+  EXPECTED = [
+    0,    [0,  nil, nil, nil], :direct,
+
+    11,   [11, nil, nil, nil], :direct,
+    12,   [12,   0, nil, nil], :single_indirect,
+    13,   [12,   1, nil, nil], :single_indirect,
+
+    26,   [12,  14, nil, nil], :single_indirect,
+    27,   [13,   0,   0, nil], :double_indirect,
+    28,   [13,   0,   1, nil], :double_indirect,
+
+    41,   [13,   0,  14, nil], :double_indirect,
+    42,   [13,   1,   0, nil], :double_indirect,
+
+    251,  [13,  14,  14, nil], :double_indirect,
+    252,  [14,   0,   0,   0], :triple_indirect,
+    253,  [14,   0,   0,   1], :triple_indirect,
+
+    266,  [14,   0,   0,  14], :triple_indirect,
+    267,  [14,   0,   1,   0], :triple_indirect,
+
+    476,  [14,   0,  14,  14], :triple_indirect,
+    477,  [14,   1,   0,   0], :triple_indirect,
+
+    MAX_BLOCK, [14,  14,  14,  14], :triple_indirect
+  ]
+
+  def test_block_set
+    path = BlockPointersPath.new(NUM_INDIRECTS)
+
+    assert_raise(ArgumentError) { path.block = -1 }
+    assert_raise(ArgumentError) { path.block = MAX_BLOCK + 1 }
+
+    EXPECTED.each_slice(3) do |block, path_a, type|
+      path.block = block
+      assert_equal block, path.block
+      assert_equal path_a, path.to_a
+      assert_equal type, path.index_type
+    end
+  end
+
+  def test_succ!
+    path = BlockPointersPath.new(NUM_INDIRECTS)
+
+    EXPECTED.each_slice(3) do |block, path_a, type|
+      path.succ! until path.block == block
+      assert_equal block, path.block
+      assert_equal path_a, path.to_a
+      assert_equal type, path.index_type
+      break if block == MAX_BLOCK
+    end
+
+    assert_raise(RangeError) { path.succ! }
+  end
+
+  def test_path_to_block
+    path = BlockPointersPath.new(NUM_INDIRECTS)
+
+    EXPECTED.each_slice(3) do |block, _path_a, _type|
+      path.block = block
+      assert_equal block, path.send(:path_to_block)
+    end
+  end
+end

data/lib/fs/ext4/alloc_bitmap.rb

@@ -0,0 +1,38 @@
+module Ext4
+  class AllocBitmap
+    def initialize(data)
+      raise "Ext4::AllocBitmap.initialize: Nil data" if data.nil?
+      @data = data
+    end
+
+    def isAllocated?(number)
+      getStatus(number)
+    end
+
+    def [](number)
+      getStatus(number)
+    end
+
+    def dump
+      @data.hex_dump
+    end
+
+    private
+
+    def getStatus(number)
+      byte, mask = index(number)
+      @data[byte] & mask == mask
+    end
+
+    def index(number)
+      byte, bit = number.divmod(8)
+      if byte > @data.size - 1
+        msg = "AllocBitmap#index: "
+        msg += "byte index #{byte} is out of range for data[0:#{@data.size - 1}]"
+        raise msg
+      end
+      mask = 128 >> bit
+      return byte, mask
+    end
+  end # class
+end # module

data/lib/fs/ext4/directory.rb

@@ -0,0 +1,87 @@
+require 'fs/ext4/directory_entry'
+require 'fs/ext4/hash_tree_header'
+require 'fs/ext4/hash_tree_entry'
+
+module Ext4
+  class Directory
+    ROOT_DIRECTORY = 2
+
+    attr_reader :inodeNum
+
+    def initialize(sb, inodeNum = ROOT_DIRECTORY)
+      log_prefix = "Ext4::Directory.initialize"
+      raise "#{log_prefix}: Nil superblock"   if sb.nil?
+      raise "#{log_prefix}: Nil inode number" if inodeNum.nil?
+      @sb       = sb
+      @inodeNum = inodeNum
+      @inodeObj = sb.getInode(inodeNum)
+      raise "#{log_prefix}: INODE=#{inodeNum} is NOT a DIRECTORY" unless @inodeObj.isDir?
+      @data     = @inodeObj.read
+    end
+
+    def globNames
+      @ent_names ||= globEntries.keys.compact.sort
+    end
+
+    def findEntry(name, type = nil)
+      return nil unless globEntries.key?(name)
+
+      globEntries[name].each do |ent|
+        unless @sb.isNewDirEnt?
+          inode        = @sb.getInode(ent.inode)
+          ent.fileType = inode.fileModeToFileType
+        end
+
+        return ent if (ent.fileType == type) || type.nil?
+      end
+      nil
+    end
+
+    private
+
+    def globEntries
+      @ents_by_name ||= globEntriesByLinkedList
+    end
+
+    def globEntriesByLinkedList
+      ents_by_name = {}
+      return ents_by_name if @data.nil?
+      newEnt = @sb.isNewDirEnt?
+      p = 0
+      loop do
+        break if p > @data.length - 4
+        break if @data[p, 4].nil?
+        de = DirectoryEntry.new(@data[p..-1], newEnt)
+        raise "Ext4::Directory.globEntriesByLinkedList: DirectoryEntry length cannot be 0" if de.len == 0
+        ents_by_name[de.name] ||= []
+        ents_by_name[de.name] << de
+        p += de.len
+      end
+      ents_by_name
+    end
+
+    #
+    # If the inode has the IF_HASH_INDEX bit set,
+    # then the first directory block is to be interpreted as the root of an HTree index.
+    def globEntriesByHashTree
+      ents_by_name = {}
+      offset = 0
+      # Chomp fake '.' and '..' directories first
+      2.times do
+        de = DirectoryEntry.new(@data[offset..-1], @sb.isNewDirEnt?)
+        ents_by_name[de.name] ||= []
+        ents_by_name[de.name] << de
+        offset += 12
+      end
+
+      $log.info("Ext4::Directory.globEntriesByHashTree (inode=#{@inodeNum}) >>\n#{@data[0, 256].hex_dump}")
+      header = HashTreeHeader.new(@data[offset..-1])
+      $log.info("Ext4::Directory.globEntriesByHashTree --\n#{header.dump}")
+      $log.info("Ext4::Directory.globEntriesByHashTree (inode=#{@inodeNum}) <<#{ents_by_name.inspect}")
+      offset += header.length
+      root = HashTreeEntry.new(@data[offset..-1], true)
+      $log.info("Ext4::Directory.globEntriesByHashTree --\n#{root.dump}")
+      ents_by_name
+    end
+  end # class
+end # module

data/lib/fs/ext4/directory_entry.rb

@@ -0,0 +1,77 @@
+require 'binary_struct'
+
+module Ext4
+  # ////////////////////////////////////////////////////////////////////////////
+  # // Data definitions.
+
+  DIR_ENTRY_ORIGINAL = BinaryStruct.new([
+    'L',  'inode_val',  # Inode address of metadata.
+    'S',  'entry_len',  # Length of entry.
+    'S',  'name_len',   # Length of name.
+  ])
+  # Here follows the name in ASCII.
+  SIZEOF_DIR_ENTRY_ORIGINAL = DIR_ENTRY_ORIGINAL.size
+
+  DIR_ENTRY_NEW = BinaryStruct.new([
+    'L',  'inode_val',  # Inode address of metadata.
+    'S',  'entry_len',  # Length of entry.
+    'C',  'name_len',   # Length of name.
+    'C',  'file_type',  # Type of file (see FT_ below).
+  ])
+  # Here follows the name in ASCII.
+  SIZEOF_DIR_ENTRY_NEW = DIR_ENTRY_NEW.size
+
+  class DirectoryEntry
+    FT_UNKNOWN    = 0
+    FT_FILE       = 1
+    FT_DIRECTORY  = 2
+    FT_CHAR       = 3
+    FT_BLOCK      = 4
+    FT_FIFO       = 5
+    FT_SOCKET     = 6
+    FT_SYM_LNK    = 7
+
+    attr_reader :inode, :len, :name
+    attr_accessor :fileType
+
+    def initialize(data, new_entry = true)
+      raise "Ext4::DirectoryEntry.initialize: Nil directory entry data" if data.nil?
+      @isNew    = new_entry
+      siz       = @isNew ? SIZEOF_DIR_ENTRY_NEW : SIZEOF_DIR_ENTRY_ORIGINAL
+      @de       = @isNew ? DIR_ENTRY_NEW.decode(data[0..siz]) : DIR_ENTRY_ORIGINAL.decode(data[0..siz])
+      # If there's a name get it.
+      @name     = data[siz, @de['name_len']] if @de['name_len'] != 0
+      @inode    = @de['inode_val']
+      @len      = @de['entry_len']
+      @fileType = @de['file_type'] if @isNew
+    end
+
+    def isDir?
+      @fileType == FT_DIRECTORY
+    end
+
+    def isSymLink?
+      @fileType == FT_SYM_LNK
+    end
+
+    def fileTypeString
+      return "UNKNOWN"   if @fileType == FT_UNKNOWN
+      return "FILE"      if @fileType == FT_FILE
+      return "DIRECTORY" if @fileType == FT_DIRECTORY
+      return "CHAR"      if @fileType == FT_CHAR
+      return "BLOCK"     if @fileType == FT_BLOCK
+      return "FIFO"      if @fileType == FT_FIFO
+      return "SOCKET"    if @fileType == FT_SOCKET
+      return "SYMLINK"   if @fileType == FT_SYM_LNK
+    end
+
+    def dump
+      out = "\#<#{self.class}:0x#{'%08x' % object_id}>\n"
+      out += "Inode   : #{inode}\n"
+      out += "Len     : #{len}\n"
+      out += "Name len: 0x#{'%04x' % @de['name_len']}\n"
+      out += "Type    : #{fileTypeString}\n" if @isNew
+      out += "Name    : #{name}\n"
+    end
+  end # class
+end # module