manageiq-smartstate 0.1.0

data/lib/fs/xfs/allocation_group.rb

@@ -0,0 +1,160 @@
+require 'binary_struct'
+require 'util/miq-uuid'
+require 'stringio'
+require 'memory_buffer'
+require 'fs/xfs/superblock'
+
+require 'rufus/lru'
+
+module XFS
+  # ////////////////////////////////////////////////////////////////////////////
+
+  AG_FREESPACE = BinaryStruct.new([
+    #  Common allocation group header information
+    'I>',  'magic_num',          # magic number of the filesystem
+    'I>',  'version_num',        # header version
+    'I>',  'seq_no',             # sequence # starting from 0
+    'I>',  'length',             # size in blocks of a.g.
+    #  Freespace Information
+    #
+    'I>2', 'root_blocks',        # Root Blocks
+    'I>',  'spare0',             # spare field
+    'I>2', 'btree_levels',       # btree levels
+    'I>',  'spare1',             # spare field
+    'I>',  'fl_first',           # first freelist block's index
+    'I>',  'fl_last',            # last freelist block's index
+    'I>',  'fl_count',           # count of blocks in freelist
+    'I>',  'free_blocks',        # total free blocks
+    'L>',  'longest',            # longest free space
+    'L>',  'btree_blocks',       # # of blocks held in alloc group free btrees
+    'a16', 'uuid',               # Filesystem uuid
+    #
+    # Reserve some contiguous space for future logged fields before we add
+    # the unlogged fields.  This makes the range logging via flags and
+    # structure offsets much simpler.
+    #
+    'Q>16', 'spare64',           # underlying disk sector size in bytes
+    #
+    # Unlogged fields, written during buffer writeback.
+    #
+    'Q>',  'last_write_seq',     # last write sequence
+    'I>',  'crc',                # CRC of alloc group free space sector
+    'I>',  'spare2',             # name for the filesystem
+  ])
+
+  AG_INODEINFO = BinaryStruct.new([
+    #  Common allocation group header information
+    'I>',  'magic_num',          # magic number of the filesystem
+    'I>',  'version_num',        # header version
+    'I>',  'seq_no',             # sequence # starting from 0
+    'I>',  'length',             # size in blocks of a.g.
+    #
+    #  Inode information
+    #  Inodes are mapped by interpretting the inode number, so no
+    #  mapping data is needed here.
+    #
+    'I>',  'count',              # count of allocated inodes
+    'I>',  'root',               # root of inode btree
+    'I>',  'level',              # levels in inode btree
+    'I>',  'free_count',         # number of free inodes
+    'I>',  'new_inode',          # new inode just allocated
+    'I>',  'dir_inode',          # last directory inode chunk
+    #
+    # Hash table of inodes which have been unlinked but are
+    # still being referenced.
+    #
+    'I>64', 'unlinked_hash',     # the hash
+    'a16', 'uuid',               # Filesystem uuid
+    'I>',  'crc',                # CRC of alloc group inode info sector
+    'I>',  'pad32',              #
+    'Q>',  'last_write_seq',     # last write sequence
+    'I>',  'free_root',          # root of the free inode btree
+    'I>',  'free_level',         # levels in free inode btree
+  ])
+
+  #
+  # The third AG block contains the AG FreeList, an array
+  # of block pointers to blocks owned by the allocation btree code.
+  #
+  AG_FREELIST = BinaryStruct.new([
+    'I>',  'magic_num',          # magic number of the filesystem
+    'I>',  'seq_no',             # sequence # starting from 0
+    'a16', 'uuid',               # Filesystem uuid
+    'Q>',  'last_write_seq',     # last write sequence
+    'I>',  'crc',                # CRC of alloc group inode info sector
+    'I>',  'bno',                # actually XFS_AGFL_SIZE
+  ])
+  AG_FL_STRUCT_SIZE = AG_FREELIST.size
+
+  # ////////////////////////////////////////////////////////////////////////////
+  # // Class.
+
+  class AllocationGroup
+    AG_FREESPACE_SIZE = 512
+    AG_INODEINFO_SIZE = 512
+    AG_FREELIST_SIZE  = 512
+
+    XFS_AGF_MAGIC                          = 0x58414746
+    XFS_AGI_MAGIC                          = 0x58414749
+    XFS_AGFL_MAGIC                         = 0x5841464c
+
+    # /////////////////////////////////////////////////////////////////////////
+    # // initialize
+    attr_reader :stream, :agf, :agi, :agfl, :allocation_group_block
+
+    def initialize(stream, _agno, sb)
+      raise "XFS::AllocationGroup.initialize: Nil stream" if stream.nil?
+      #
+      # The stream should be pointing at the Allocation Group to be built on the disk.
+      #
+      @stream = stream
+
+      @agf                    = AG_FREESPACE.decode(@stream.read(AG_FREESPACE_SIZE))
+      @stream.seek(AG_FREESPACE_SIZE, IO::SEEK_CUR)
+      @agi                    = AG_INODEINFO.decode(@stream.read(AG_INODEINFO_SIZE))
+      @stream.seek(AG_INODEINFO_SIZE, IO::SEEK_CUR)
+      @agfl                   = AG_FREELIST.decode(@stream.read(AG_FREELIST_SIZE))
+      @stream.seek(-(AG_FREESPACE_SIZE + AG_INODEINFO_SIZE + AG_FREELIST_SIZE))
+      @allocation_group_block = @stream.read(sb['block_size'])
+
+      # Grab some quick facts & make sure there's nothing wrong. Tight qualification.
+      if @agf['magic_num'] != XFS_AGF_MAGIC
+        raise "XFS::AllocationGroup.initialize: Invalid AGF magic number=[#{@agf['magic_num']}]"
+      elsif @agi['magic_num'] != XFS_AGI_MAGIC
+        raise "XFS::AllocationGroup.initialize: Invalid AGI magic number=[#{@agi['magic_num']}]"
+      elsif @agfl['magic_num'] != XFS_AGFL_MAGIC
+        raise "XFS::AllocationGroup.initialize: Invalid AGFL magic number=[#{@agfl['magic_num']}]"
+      end
+    end
+
+    # ////////////////////////////////////////////////////////////////////////////
+    # // Class helpers & accessors.
+
+    # Dump object.
+    def dump
+      out = "\#<#{self.class}:0x#{format('%08x', object_id)}>\n"
+      out << "AGI Magic number        : #{@agf['magic_num']}\n"
+      out << "Version number          : #{@agf['version_num']})\n"
+      out << "Sequence Number         : #{@agf['seq_no']}\n"
+      out << "Length                  : #{@agf['length']}\n"
+      out << "Root Blocks             : #{@agf['root_blocks']}\n"
+      out << "Btree Levels            : #{@agf['btree_levels']}\n"
+      out << "1st Freelist Blk Index  : #{@agf['fl_first']}\n"
+      out << "Last Freelist Blk Index : #{@agf['fl_last']}\n"
+      out << "# Blocks in Freelist    : #{@agf['fl_count']}\n"
+      out << "# of Free Blocks        : #{@agf['free_blocks']}\n"
+      out << "Longest Free Space      : #{@agf['longest']}\n"
+      out << "# Blks in AG Free Btree : #{@agf['btree_blocks']}\n"
+      out << "Filesystem UUID         : #{@agf['uuid']}\n"
+      out << "Allocated Inodes        : #{@agi['count']}\n"
+      out << "Root of Inode BTree     : #{@agi['root']}\n"
+      out << "Levels in Inode BTree   : #{@agi['level']}\n"
+      out << "Number of Free Inodes   : #{@agi['free_count']}\n"
+      out << "Newest Inode Allocated  : #{@agi['new_inode']}\n"
+      out << "Last Dir Inode Chunk    : #{@agi['dir_inode']}\n"
+      out << "Root of Free Ino Btree  : #{@agi['free_root']}\n"
+      out << "Levels in Free Ino Btree : #{@agi['free_level']}\n"
+      out
+    end
+  end # class AllocationGroup
+end # module XFS

data/lib/fs/xfs/bmap_btree_block.rb

@@ -0,0 +1,125 @@
+require 'binary_struct'
+require 'util/miq-uuid'
+require 'stringio'
+
+require 'rufus/lru'
+
+module XFS
+  # ////////////////////////////////////////////////////////////////////////////
+
+  BTREE_BLOCK_SHORT_NOCRC = BinaryStruct.new([
+    #  Common BTree Block header information
+    'I>',  'magic_num',          # magic number of the btree block type
+    'S>',  'level',              # level number.  0 is a leaf
+    'S>',  'num_recs',           # current # of data records
+    #
+    #  Short Section
+    #
+    'I>',  'left_sibling',       #
+    'I>',  'right_sibling',      #
+  ])
+  SIZEOF_BTREE_BLOCK_SHORT_NOCRC = BTREE_BLOCK_SHORT_NOCRC.size
+
+  BTREE_BLOCK_SHORT = BinaryStruct.new([
+    #  Common BTree Block header information
+    'I>',  'magic_num',          # magic number of the btree block type
+    'S>',  'level',              # level number.  0 is a leaf
+    'S>',  'num_recs',           # current # of data records
+    #
+    #  Short Section
+    #
+    'I>',  'left_sibling',       #
+    'I>',  'right_sibling',      #
+    'Q>',  'block_num',          #
+    'Q>',  'lsn',                #
+    'a16', 'uuid',               #
+    'I>',  'owner',              #
+    'I>',  'crc',                #
+  ])
+  SIZEOF_BTREE_BLOCK_SHORT = BTREE_BLOCK_SHORT.size
+
+  BTREE_BLOCK_LONG_NOCRC = BinaryStruct.new([
+    #  Common BTree Block header information
+    'I>',  'magic_num',          # magic number of the btree block type
+    'S>',  'level',              # level number.  0 is a leaf
+    'S>',  'num_recs',           # current # of data records
+    #
+    #  Long Section
+    #
+    'Q>',  'left_sibling',       #
+    'Q>',  'right_sibling',      #
+  ])
+  SIZEOF_BTREE_BLOCK_LONG_NOCRC = BTREE_BLOCK_LONG_NOCRC.size
+
+  BTREE_BLOCK_LONG = BinaryStruct.new([
+    #  Common BTree Block header information
+    'I>',  'magic_num',          # magic number of the btree block type
+    'S>',  'level',              # level number.  0 is a leaf
+    'S>',  'num_recs',           # current # of data records
+    #
+    #  Long Section
+    #
+    'Q>',  'left_sibling',       #
+    'Q>',  'right_sibling',      #
+    'Q>',  'block_num',          #
+    'Q>',  'lsn',                #
+    'a16', 'uuid',               #
+    'Q>',  'owner',              #
+    'I>',  'crc',                #
+    'I>',  'pad',                #
+  ])
+  SIZEOF_BTREE_BLOCK_LONG = BTREE_BLOCK_LONG.size
+
+  # ////////////////////////////////////////////////////////////////////////////
+  # // Class.
+
+  class BmapBTreeBlock
+    XFS_BTREE_LONG_PTRS = 1
+    XFS_BMAP_MAGIC      = 0x424d4150
+    XFS_BMAP_CRC_MAGIC  = 0x424d4133
+    # // initialize
+    attr_reader :level, :number_records, :header_size, :buffer, :left_sibling, :right_sibling
+
+    def initialize(buffer, sb)
+      @sb = sb
+      if defined? XFS_BTREE_LONG_PTRS
+        if @sb.version_has_crc?
+          @btree_block = BTREE_BLOCK_LONG.decode(buffer)
+        else
+          @btree_block = BTREE_BLOCK_LONG_NOCRC.decode(buffer)
+        end
+      else
+        if sb.version_has_crc?
+          @btree_block = BTREE_BLOCK_SHORT.decode(buffer)
+        else
+          @btree_block = BTREE_BLOCK_SHORT_NOCRC.decode(buffer)
+        end
+      end
+      @header_size   = btree_block_length
+      @number_records = @btree_block['num_recs']
+      @level         = @btree_block['level']
+      raise "Invalid BTreeBlock" unless (@btree_block['magic_num'] == XFS_BMAP_MAGIC) ||
+                                        (@btree_block['magic_num'] == XFS_BMAP_CRC_MAGIC)
+      @left_sibling  = @btree_block['left_sibling']
+      @right_sibling = @btree_block['right_sibling']
+      @buffer        = buffer
+    end
+
+    def btree_block_length
+      if defined? XFS_BTREE_LONG_PTRS
+        if @sb.version_has_crc?
+          len = SIZEOF_BTREE_BLOCK_LONG
+        else
+          len = SIZEOF_BTREE_BLOCK_LONG_NOCRC
+        end
+      else
+        if @sb.version_has_crc?
+          len = SIZEOF_BTREE_BLOCK_SHORT
+        else
+          len = SIZEOF_BTREE_BLOCK_SHORT_NOCRC
+        end
+      end
+      len
+    end
+  end # class BTreeBlock
+end # module XFS

data/lib/fs/xfs/bmap_btree_record.rb

@@ -0,0 +1,80 @@
+module XFS
+  BMAP_BTREE_REC = BinaryStruct.new([
+    'Q>',          'l0',
+    'Q>',          'l1',
+  ])
+
+  SIZEOF_BMAP_BTREE_REC   = 16
+
+  class BmapBTreeRecord
+    BMBT_EXNTFLAG_BITLEN    = 1
+    BMBT_STARTOFF_BITLEN    = 54
+    BMBT_STARTBLOCK_BITLEN  = 52
+    BMBT_BLOCKCOUNT_BITLEN  = 21
+
+    XFS_EXT_NORM            = 0
+    XFS_EXT_UNWRITTEN       = 1
+    attr_accessor   :key_ptr, :start_offset, :start_block, :big_start_block, :block_count, :flag
+
+    def xfs_mask64lo(shift)
+      (1 << shift) - 1
+    end
+
+    def bmbt_get_state(doubleword)
+      flag = doubleword >> (64 - BMBT_EXNTFLAG_BITLEN)
+      return XFS_EXT_UNWRITTEN if flag > 0
+      XFS_EXT_NORM
+    end
+
+    def bmbt_get_block_count(doubleword)
+      doubleword & xfs_mask64lo(21)
+    end
+
+    def bmbt_get_start_offset(doubleword)
+      (doubleword & xfs_mask64lo(64 - BMBT_EXNTFLAG_BITLEN)) >> 9
+    end
+
+    def bmbt_get_start_block(doubleword)
+      doubleword >> 21
+    end
+
+    def bmbt_get_big_start_block(word0, word1)
+      ((word0 & xfs_mask64lo(9) << 43)) | (word1 >> 21)
+    end
+
+    def initialize(data, sb)
+      raise "XFS::BmapBTreeRec: Nil buffer" if data.nil?
+      @record          = BMAP_BTREE_REC.decode(data)
+      @start_offset    = bmbt_get_start_offset(@record['l0'])
+      start_block     = bmbt_get_start_block(@record['l1'])
+      big_start_block = bmbt_get_big_start_block(@record['l0'], @record['l1'])
+      @block_count     = bmbt_get_block_count(@record['l1'])
+      @flag            = bmbt_get_state(@record['l0'])
+      agno             = sb.fsb_to_agno(start_block)
+      agbno            = sb.fsb_to_agbno(start_block)
+      @start_block     = sb.agbno_to_real_block(agno, agbno)
+      agno             = sb.fsb_to_agno(big_start_block)
+      agbno            = sb.fsb_to_agbno(big_start_block)
+      @big_start_block = sb.agbno_to_real_block(agno, agbno)
+    end
+
+    def set_record(cursor, level, key_number, block)
+      super
+      if level == 0
+        record       = btree_rec_addr(cursor, key_number, block)
+        @start_inode = record.start_inode
+      end
+      @key_pointer = btree_key_address(cursor, key_number, block)
+    end
+
+    def dump
+      out = "\#<#{self.class}:0x#{format('%08x', object_id)}>\n"
+      out += "Offset       : #{@start_offset}\n"
+      out += "Start Block  : #{@start_block}\n"
+      out += "Big Start Blk: #{@big_start_block}\n"
+      out += "Block Count  : #{@block_count}\n"
+      out += "Flag         : #{@flag}\n"
+      out
+    end
+  end
+end

data/lib/fs/xfs/bmap_btree_root_node.rb

@@ -0,0 +1,72 @@
+require 'fs/xfs/inode'
+
+module XFS
+  BMAP_BTREE_ROOT_NODE_HEADER = BinaryStruct.new([
+    'S>',          'level',           # B+Tree Level
+    'S>',          'entry_count',     # Number of Key and Pointer Array Elements
+  ])
+
+  SIZEOF_BMAP_BTREE_ROOT_NODE_HEADER  = BMAP_BTREE_ROOT_NODE_HEADER.size
+
+  #
+  # Note that the following 3 entries are used simply to compute the maximum
+  # number of records possible in the on-disk inode.
+  #
+  BMAP_BTREE_ROOT_NODE_ENTRIES = BinaryStruct.new([
+    'Q>',          'starting_offset', # starting offset of the block
+    'Q>',          'block_number',    # block number of the entry
+  ])
+  SIZEOF_BMAP_BTREE_ROOT_NODE_ENTRIES   = BMAP_BTREE_ROOT_NODE_ENTRIES.size
+
+  BMAP_BTREE_ROOT_NODE_OFFSET = BinaryStruct.new([
+    'Q>',          'starting_offset',  # starting offset of the block
+  ])
+  SIZEOF_BMAP_BTREE_ROOT_NODE_OFFSET   = BMAP_BTREE_ROOT_NODE_OFFSET.size
+
+  BMAP_BTREE_ROOT_NODE_BLOCK = BinaryStruct.new([
+    'Q>',          'block_number',     # block number of the entry
+  ])
+  SIZEOF_BMAP_BTREE_ROOT_NODE_BLOCK    = BMAP_BTREE_ROOT_NODE_BLOCK.size
+
+  #
+  # Handle the BTree Root Node in the Disk Inode
+  #
+  class BmapBTreeRootNode
+    attr_accessor   :level, :entry_count, :blocks
+
+    def initialize(data, inode)
+      raise "XFS::BmapBTreeRootNode: Nil buffer" if data.nil?
+      @inode         = inode
+      @header        = BMAP_BTREE_ROOT_NODE_HEADER.decode(data[0..inode.length])
+      @level         = @header['level']
+      @entry_count   = @header['entry_count']
+      raise "XFS::BmapBTreeRootNode: Invalid Root Node Level" if @level.nil? || @level == 0
+      header_size    = SIZEOF_BMAP_BTREE_ROOT_NODE_HEADER
+      return if @entry_count == 0
+      #
+      # The Root Node contains an array of starting offsets followed by
+      # an array of block numbers.  While only the required number of entries
+      # are initialized, there is space left for the maximum number of entries
+      # that may fit in the disk inode data fork (eliminating any space taken
+      # up by extended attributes).
+      # We only care about the block numbers.  The offsets of individual data blocks are
+      # also kept in the BmapBTreeRecord
+      #
+      fork_size       = @inode.dfork_size(Inode::XFS_DATA_FORK)
+      maximum_records = (fork_size - header_size) / SIZEOF_BMAP_BTREE_ROOT_NODE_ENTRIES
+      return if maximum_records == 0
+      @blocks         = []
+      offset_size     = SIZEOF_BMAP_BTREE_ROOT_NODE_OFFSET
+      block_size      = SIZEOF_BMAP_BTREE_ROOT_NODE_BLOCK
+      size            = SIZEOF_BMAP_BTREE_ROOT_NODE_HEADER
+      1.upto(@entry_count) do |i|
+        start             = size + maximum_records * offset_size + (i - 1) * block_size
+        block             = (data[start..start + block_size]).unpack('Q>').shift
+        agbno             = inode.sb.fsb_to_agbno(block)
+        agno              = inode.sb.fsb_to_agno(block)
+        real_block        = inode.sb.agbno_to_real_block(agno, agbno)
+        @blocks.concat([real_block])
+      end
+    end
+  end
+end

data/lib/fs/xfs/directory.rb

@@ -0,0 +1,133 @@
+require 'fs/xfs/inode'
+require 'fs/xfs/directory_entry'
+require 'fs/xfs/directory_block_tail'
+require 'fs/xfs/directory_data_header'
+require 'fs/xfs/short_form_header'
+require 'fs/xfs/short_form_directory_entry'
+
+module XFS
+  DIRECTORY_LEAF_ENTRY = BinaryStruct.new([
+    'I>', 'hashval',               # hash value of name
+    'I>', 'address',               # address of data entry
+  ])
+  SIZEOF_DIRECTORY_LEAF_ENTRY = DIRECTORY_LEAF_ENTRY.size
+
+  class Directory
+    DOT                     = 1
+    DOTDOT                  = 2
+    ROOT_DIRECTORY          = 128
+
+    attr_reader :inode_number, :inode_object
+
+    def initialize(sb, inode_number = ROOT_DIRECTORY)
+      raise "XFS::Directory: Nil superblock"   if sb.nil?
+      @sb           = sb
+      @inode_number = inode_number
+      @inode_object = sb.get_inode(inode_number)
+      raise "XFS::Directory: INODE=#{inode_number} is NOT a DIRECTORY" unless @inode_object.directory?
+      @data         = @inode_object.read
+    end
+
+    def glob_names
+      @ent_names ||= glob_entries.keys.compact.sort
+    end
+
+    def find_entry(name, type = nil)
+      return nil unless glob_entries.key?(name)
+
+      glob_entries[name].each do |entry|
+        @inode_object    = @sb.get_inode(entry.inode)
+        entry.file_type = @inode_object.file_mode_to_file_type
+        return entry if (entry.file_type == type) || type.nil?
+      end
+      nil
+    end
+
+    private
+
+    def glob_entries
+      @entries_by_name ||= glob_entries_by_linked_list
+    end
+
+    def add_entry_by_name(entries_by_name, directory_entry)
+      return entries_by_name unless directory_entry.name_length > 0
+      entries_by_name[directory_entry.name] ||= []
+      entries_by_name[directory_entry.name] << directory_entry
+      entries_by_name
+    end
+
+    def glob_short_form_entries_by_linked_list
+      entries_by_name = {}
+      header              = ShortFormHeader.new(@data)
+      data_pointer        = header.size
+      small_inode         = header.small_inode
+      #
+      # Fill In Dot and DotDot Entries Which don't exist in ShortForm Dir.
+      #
+      directory_entry = ShortFormDirectoryEntry.new(nil, small_inode, @sb, DOT, @inode_object.inode_number)
+      entries_by_name = add_entry_by_name(entries_by_name, directory_entry)
+      directory_entry = ShortFormDirectoryEntry.new(nil, small_inode, @sb, DOTDOT, header.parent_inode)
+      entries_by_name = add_entry_by_name(entries_by_name, directory_entry)
+      loop do
+        break if data_pointer > @data.length - 4 || @data[data_pointer, data_pointer + 4].nil?
+        directory_entry = ShortFormDirectoryEntry.new(@data[data_pointer..@inode_object.length], small_inode, @sb)
+        entries_by_name = add_entry_by_name(entries_by_name, directory_entry)
+        data_pointer += directory_entry.length
+      end
+      entries_by_name
+    end
+
+    def glob_single_extent_entries_by_linked_list
+      entries_by_name           = {}
+      header                    = DirectoryDataHeader.new(@data, @sb)
+      data_pointer              = header.header_end
+      tail                      = DirectoryBlockTail.new(@data[@sb.block_size - SIZEOF_DIRECTORY_BLOCK_TAIL..-1])
+      total_leaves_size         = tail.count * SIZEOF_DIRECTORY_LEAF_ENTRY
+      last_directory_space      = @sb.block_size - DirectoryEntry::SIZEOF_SMALLEST_DIRECTORY_ENTRY -
+                                  SIZEOF_DIRECTORY_BLOCK_TAIL - total_leaves_size
+      loop do
+        break if data_pointer > @data.length - 4 || @data[data_pointer, 4].nil? || data_pointer > last_directory_space
+        directory_entry = DirectoryEntry.new(@data[data_pointer..-1], header.version_3)
+        entries_by_name = add_entry_by_name(entries_by_name, directory_entry)
+        data_pointer += directory_entry.length
+      end
+      entries_by_name
+    end
+
+    def glob_extent_or_btree_entries_by_linked_list
+      entries_by_name           = {}
+      data_pointer              = 0
+      block_number              = 1
+      last_directory_space      = @sb.block_size - DirectoryEntry::SIZEOF_SMALLEST_DIRECTORY_ENTRY
+      if @inode_object.data_method == :extents
+        return glob_single_extent_entries_by_linked_list if @inode_object.in['num_extents'] == 1
+      end
+      loop do
+        header                = DirectoryDataHeader.new(@data[data_pointer..@sb.block_size * block_number], @sb)
+        block_pointer         = header.header_end
+        data_pointer += header.header_end
+        loop do
+          break if block_pointer > last_directory_space
+          directory_entry = DirectoryEntry.new(@data[data_pointer..@sb.block_size * block_number], header.version_3)
+          entries_by_name = add_entry_by_name(entries_by_name, directory_entry)
+          block_pointer += directory_entry.length
+          data_pointer += directory_entry.length
+        end
+        block_number += 1
+        data_pointer = @sb.block_size * (block_number - 1)
+        break if data_pointer > @data.length - 4 || @data[data_pointer, 4].nil?
+      end
+      entries_by_name
+    end
+
+    def glob_entries_by_linked_list
+      return {} if @data.nil?
+      if @inode_object.data_method == :extents || @inode_object.data_method == :btree
+        return glob_extent_or_btree_entries_by_linked_list
+      elsif @inode_object.data_method == :local
+        return glob_short_form_entries_by_linked_list
+      end
+      {}
+    end
+  end # class
+end # module

data/lib/fs/xfs/directory2_data_header.rb

@@ -0,0 +1,27 @@
+require 'fs/xfs/directory'
+require 'fs/xfs/superblock'
+
+module XFS
+  #
+  # xfs_dir2_data_hdr consists of the magic number
+  # followed by 3 copies of the xfs_dir2_data_free structure
+  #
+  DIRECTORY2_DATA_HEADER = BinaryStruct.new([
+    'I>', 'magic',               # magic number
+  ])
+  SIZEOF_DIRECTORY2_DATA_HEADER = DIRECTORY2_DATA_HEADER.size
+
+  class Directory2DataHeader
+    XFS_DIR2_BLOCK_MAGIC        = 0x58443242 # XD2B: single block dirs
+    XFS_DIR2_DATA_MAGIC         = 0x58443244 # XD2D: multiblock dirs
+
+    attr_reader :template, :magic_numbers, :pad, :version_3
+
+    def initialize
+      @template      = DIRECTORY2_DATA_HEADER
+      @magic_numbers = [XFS_DIR2_BLOCK_MAGIC, XFS_DIR2_DATA_MAGIC]
+      @pad           = 0
+      @version_3     = false
+    end
+  end # class Directory3DataHeader
+end   # module XFS

data/lib/fs/xfs/directory3_data_header.rb

@@ -0,0 +1,34 @@
+require 'fs/xfs/directory'
+require 'fs/xfs/superblock'
+
+module XFS
+  DIRECTORY3_DATA_HEADER = BinaryStruct.new([
+    'I>',  'magic',               # magic number
+    'I>',  'crc',                 # CRC of block
+    'Q>',  'block_number',        # first block of the buffer
+    'Q>',  'last_write_sequence', # sequence number of last write
+    'a16', 'uuid',                # filesystem we belong to
+    'Q>',  'owner',               # inode that owns the block
+  ])
+  SIZEOF_DIRECTORY3_DATA_HEADER = DIRECTORY3_DATA_HEADER.size
+
+  DIRECTORY3_DATA_PAD = BinaryStruct.new([
+    'I>',  'padding',             # padding
+  ])
+  SIZEOF_DIRECTORY3_DATA_PAD = DIRECTORY3_DATA_PAD.size
+
+  class Directory3DataHeader
+    XFS_DIR3_BLOCK_MAGIC        = 0x58444233 # XDB3: single block dirs
+    XFS_DIR3_DATA_MAGIC         = 0x58444433 # XDD3: multiblock dirs
+
+    attr_reader :template, :magic_numbers, :pad, :version_3
+
+    def initialize
+      @template      = DIRECTORY3_DATA_HEADER
+      @magic_numbers = [XFS_DIR3_BLOCK_MAGIC, XFS_DIR3_DATA_MAGIC]
+      @pad           = SIZEOF_DIRECTORY3_DATA_PAD
+      @version_3     = true
+      super
+    end
+  end # class Directory3DataHeader
+end   # module XFS

data/lib/fs/xfs/directory_block_tail.rb

@@ -0,0 +1,22 @@
+module XFS
+  #
+  # xfs_dir2_data_hdr consists of the magic number
+  # followed by 3 copies of the xfs_dir2_data_free structure
+  #
+  DIRECTORY_BLOCK_TAIL = BinaryStruct.new([
+    'I>', 'count',               # total number of leaf entries
+    'I>', 'stale',               # total number of free entries
+  ])
+  SIZEOF_DIRECTORY_BLOCK_TAIL = DIRECTORY_BLOCK_TAIL.size
+
+  class DirectoryBlockTail
+    attr_reader :count, :stale, :size
+
+    def initialize(data)
+      tail = DIRECTORY_BLOCK_TAIL.decode(data)
+      @count = tail['count']
+      @stale = tail['stale']
+      @size  = SIZEOF_DIRECTORY_BLOCK_TAIL
+    end
+  end # class DirectoryBlockTail
+end   # module XFS