manageiq-smartstate 0.1.0

data/lib/fs/xfs/directory_data_header.rb

@@ -0,0 +1,46 @@
+require 'fs/xfs/directory'
+require 'fs/xfs/directory2_data_header'
+require 'fs/xfs/directory3_data_header'
+require 'fs/xfs/superblock'
+
+module XFS
+  DIRECTORY_DATA_FREE = BinaryStruct.new([
+    'S>',  'offset',              # start of freespace
+    'S>',  'length',              # length of freespace
+  ])
+  SIZEOF_DIRECTORY_DATA_FREE    = DIRECTORY_DATA_FREE.size
+
+  class DirectoryDataHeader
+    XFS_DIR2_DATA_FD_COUNT      = 3
+
+    attr_reader :data_header, :header_end, :version_3
+
+    def decode_directory_header(data, header)
+      template     = header.template
+      @data_header = template.decode(data)
+      header.magic_numbers.each { |magic_number| return template.size if @data_header['magic'] == magic_number }
+      raise "XFS::DirectoryDataHeader: Invalid Magic Number #{@data_header['magic']}"
+    end
+
+    def initialize(data, sb)
+      @sb = sb
+      if @sb.version_has_crc?
+        version_header = Directory3DataHeader.new
+      else
+        version_header = Directory2DataHeader.new
+      end
+      @version_3 = version_header.version_3
+      header_size = decode_directory_header(data, version_header)
+      free_offset = header_size
+      @data_free    = []
+      @free_end     = 0
+      (1..XFS_DIR2_DATA_FD_COUNT).each do |i|
+        @free_end     = header_size + SIZEOF_DIRECTORY_DATA_FREE * i
+        @data_free[i] = DIRECTORY_DATA_FREE.decode(data[free_offset..@free_end])
+        free_offset   = @free_end
+      end
+      @header_end = @free_end
+      @header_end += version_header.pad
+    end
+  end # class DirectoryDataHeader
+end   # module XFS

data/lib/fs/xfs/directory_entry.rb

@@ -0,0 +1,106 @@
+require 'binary_struct'
+
+module XFS
+  # ////////////////////////////////////////////////////////////////////////////
+  # // Data definitions.
+  #
+  # Active entry in a data block.
+  # Aligned to 8 bytes.  A variable length name field follows the length.
+  # After the name there is a 2 byte tag field.
+  # For dir3 structures, there is a 1 byte file type field between the name
+  # and the tag.  It is packed hard against the end of the name so any padding
+  # for rounding is between the file type and the tag.
+  DIRECTORY2_DATA_ENTRY = BinaryStruct.new([
+    'Q>',  'inumber',   # inode number
+    'C',   'name_len',  # name length
+  ])
+  SIZEOF_DIRECTORY2_DATA_ENTRY = DIRECTORY2_DATA_ENTRY.size
+
+  DIRECTORY2_DATA_TAG = BinaryStruct.new([
+    'S>',  'tag',       # tag
+  ])
+  SIZEOF_DIRECTORY2_DATA_TAG = DIRECTORY2_DATA_TAG.size
+
+  DIRECTORY2_UNUSED_ENTRY = BinaryStruct.new([
+    'S>',  'freetag',   # 0xFFFF if unused
+    'S>',  'length',    # length of this free entry
+  ])
+  SIZEOF_DIRECTORY2_UNUSED_ENTRY = DIRECTORY2_UNUSED_ENTRY.size
+
+  class DirectoryEntry
+    XFS_DIR2_DATA_FREE_TAG          = 0xffff
+    XFS_DIR2_DATA_ALIGN_LOG         = 3
+    XFS_DIR2_DATA_ALIGN             = 1 << XFS_DIR2_DATA_ALIGN_LOG
+    XFS_DIR2_SPACE_SIZE             = 1 << (32 + XFS_DIR2_DATA_ALIGN_LOG)
+    XFS_DIR2_LEAF_SPACE             = 1
+    XFS_DIR2_LEAF_OFFSET            = XFS_DIR2_LEAF_SPACE * XFS_DIR2_SPACE_SIZE
+
+    # 16 is the smallest directory entry size but hard-coding is not nice
+    SIZEOF_SMALLEST_DIRECTORY_ENTRY = 16
+
+    def symlink?
+      @file_type == Inode::FT_SYM_LNK
+    end
+
+    def directory?
+      @file_type == Inode::FT_DIRECTORY
+    end
+
+    def file?
+      @file_type == Inode::FT_FILE
+    end
+
+    def device?
+      @file_type == Inode::FT_CHAR || @file_type == Inode::FT_BLOCK ||
+        @file_type == Inode::FT_FIFO || @file_type == Inode::FT_SOCKET
+    end
+
+    def round_up(num, base)
+      return num if num % base == 0
+      num + base - (num % base)
+    end
+
+    def dir_data_entsize(n, version_3_header)
+      if version_3_header
+        return round_up(SIZEOF_DIRECTORY2_DATA_ENTRY + n + SIZEOF_DIRECTORY2_DATA_TAG + 1, XFS_DIR2_DATA_ALIGN)
+      end
+      round_up(SIZEOF_DIRECTORY2_DATA_ENTRY + n + SIZEOF_DIRECTORY2_DATA_TAG, XFS_DIR2_DATA_ALIGN)
+    end
+
+    attr_reader :inode, :length, :name, :tag, :name_length
+    attr_accessor :file_type
+
+    def initialize(data, version_3_header)
+      raise "XFS::DirectoryEntry.initialize: Nil directory entry data" if data.nil?
+      size           = SIZEOF_DIRECTORY2_UNUSED_ENTRY
+      start          = @length = @name_length = 0
+      unused_entry   = DIRECTORY2_UNUSED_ENTRY.decode(data[start..size])
+      if unused_entry['freetag'] == XFS_DIR2_DATA_FREE_TAG
+        @length      = unused_entry['length']
+        @name        = ""
+        return
+      end
+      free_size = start
+      size         = SIZEOF_DIRECTORY2_DATA_ENTRY
+      @de          = DIRECTORY2_DATA_ENTRY.decode(data[start..(start + size)])
+      @inode       = @de['inumber']
+      @name_length = @de['name_len']
+      start += size
+      # If there's a name get it.
+      unless @name_length == 0
+        @name     = data[start, @name_length]
+        @tag      = DIRECTORY2_DATA_TAG.decode(data[start])
+        @length   = free_size + dir_data_entsize(@name_length, version_3_header)
+      end
+      raise "XFS::Directory: DirectoryEntry length cannot be 0" if @length == 0
+    end
+
+    def dump
+      out = "\#<#{self.class}:0x#{format('%08x', object_id)}>\n"
+      out += "Inode   : #{inode}\n"
+      out += "Len     : #{length}\n"
+      out += "Name    : #{name}\n"
+      out
+    end
+  end # class
+end # module

data/lib/fs/xfs/inode.rb

@@ -0,0 +1,532 @@
+require 'binary_struct'
+require 'memory_buffer'
+require 'more_core_extensions/all'
+require 'fs/xfs/superblock'
+require 'fs/xfs/bmap_btree_record'
+require 'fs/xfs/bmap_btree_block'
+require 'fs/xfs/bmap_btree_root_node'
+
+module XFS
+  TIMESTAMP = BinaryStruct.new([
+    'I',  'seconds',           # timestamp seconds
+    'I',  'nanoseconds',       # timestamp nanoseconds
+  ])
+
+  INODE = BinaryStruct.new([
+    'S>',  'magic',             # Inode Magic Number
+    'S>',  'file_mode',         # Mode and Type of file
+    'C',   'version',           # Inode Version
+    'C',   'format',            # Format of Data Fork Data
+    'S>',  'old_num_links',     # Old Number of Links to File
+    'I>',  'uid',               # Owner's User Id
+    'I>',  'gid',               # Owner's Group Id
+    'I>',  'num_links',         # Number of Links to File
+    'S>',  'projid_low',        # Lower Part of Owner's Project Id
+    'S>',  'projid_high',       # Higher Part of Owner's Project Id
+    'a6',  'pad',               # Unused, Zeroed Space
+    'S>',  'flush_iterator',    # Incremented on Flush
+    'I>',  'atime_secs',        # time last accessed seconds
+    'I>',  'atime_nsecs',       # time last accessed nanoseconds
+    'I>',  'mtime_secs',        # time last modified seconds
+    'I>',  'mtime_nsecs',       # time last modified nanoseconds
+    'I>',  'ctime_secs',        # time created / inode modified seconds
+    'I>',  'ctime_nsecs',       # time created / inode modified nanoseconds
+    'Q>',  'size',              # number of bytes in file
+    'Q>',  'nblocks',           # Number of direct & btree blocks used
+    'I>',  'extent_size',       # Basic/Minimum extent size for file
+    'I>',  'num_extents',       # Number of extents in data fork
+    'S>',  'attr_num_extents',  # Number of extents in attribute fork
+    'C',   'attr_fork_offset',  # Attribute Fork Offset, <<3 for 64b align
+    'c',   'attr_fork_format',  # Format of Attribute Fork's Data
+    'I>',  'dmig_event_mask',   # DMIG event mask
+    'S>',  'dmig_state_info',   # DMIG state info
+    'S>',  'flags',             # random flags, XFS_DIFLAG_...
+    'I>',  'gen_num',           # generation number
+    'I>',  'next_unlinked',     # agi unlinked list ptr
+  ])
+
+  EXTENDED_INODE = BinaryStruct.new([
+    'S>',  'magic',             # Inode Magic Number
+    'S>',  'file_mode',         # Mode and Type of file
+    'C',   'version',           # Inode Version
+    'C',   'format',            # Format of Data Fork Data
+    'S>',  'old_num_links',     # Old Number of Links to File
+    'I>',  'uid',               # Owner's User Id
+    'I>',  'gid',               # Owner's Group Id
+    'I>',  'num_links',         # Number of Links to File
+    'S>',  'projid_low',        # Lower Part of Owner's Project Id
+    'S>',  'projid_high',       # Higher Part of Owner's Project Id
+    'a6',  'pad',               # Unused, Zeroed Space
+    'S>',  'flush_iterator',    # Incremented on Flush
+    'I>',  'atime_secs',        # time last accessed seconds
+    'I>',  'atime_nsecs',       # time last accessed nanoseconds
+    'I>',  'mtime_secs',        # time last modified seconds
+    'I>',  'mtime_nsecs',       # time last modified nanoseconds
+    'I>',  'ctime_secs',        # time created / inode modified seconds
+    'I>',  'ctime_nsecs',       # time created / inode modified nanoseconds
+    'Q>',  'size',              # number of bytes in file
+    'Q>',  'nblocks',           # Number of direct & btree blocks used
+    'I>',  'extent_size',       # Basic/Minimum extent size for file
+    'I>',  'num_extents',       # Number of extents in data fork
+    'S>',  'attr_num_extents',  # Number of extents in attribute fork
+    'C',   'attr_fork_offset',  # Attribute Fork Offset, <<3 for 64b align
+    'c',   'attr_fork_format',  # Format of Attribute Fork's Data
+    'I>',  'dmig_event_mask',   # DMIG event mask
+    'S>',  'dmig_state_info',   # DMIG state info
+    'S>',  'flags',             # random flags, XFS_DIFLAG_...
+    'I>',  'gen_num',           # generation number
+    'I>',  'next_unlinked',     # agi unlinked list ptr
+    'I>',  'crc',               # CRC of the inode
+    'Q>',  'change_count',      # number of attribute changes
+    'Q>',  'lsn',               # flush sequence
+    'Q>',  'flags2',            # more random flags
+    'a16', 'pad2',              # more padding for future expansion
+    'I>',  'crtime_secs',       # time created seconds
+    'I>',  'crtime_nsecs',      # time created nanoseconds
+    'Q>',  'inode_number',      # inode number
+    'a16', 'uuid',              # UUID of the filesystem
+  ])
+
+  SIZEOF_INODE = INODE.size
+  SIZEOF_EXTENDED_INODE = EXTENDED_INODE.size
+
+  # ////////////////////////////////////////////////////////////////////////////
+  # // Class.
+
+  class Inode
+    MAX_READ              = 4_294_967_296
+    XFS_DINODE_MAGIC             = 0x494e
+
+    # Bits 0 to 8 of file mode.
+    PF_O_EXECUTE  = 0x0001  # owner execute
+    PF_O_WRITE    = 0x0002  # owner write
+    PF_O_READ     = 0x0004  # owner read
+    PF_G_EXECUTE  = 0x0008  # group execute
+    PF_G_WRITE    = 0x0010  # group write
+    PF_G_READ     = 0x0020  # group read
+    PF_U_EXECUTE  = 0x0040  # user execute
+    PF_U_WRITE    = 0x0080  # user write
+    PF_U_READ     = 0x0100  # user read
+
+    # For accessor convenience.
+    MSK_PERM_OWNER = (PF_O_EXECUTE | PF_O_WRITE | PF_O_READ)
+    MSK_PERM_GROUP = (PF_G_EXECUTE | PF_G_WRITE | PF_G_READ)
+    MSK_PERM_USER  = (PF_U_EXECUTE | PF_U_WRITE | PF_U_READ)
+
+    # Bits 12 to 15 of file mode.
+    FM_FIFO       = 0x1000  # fifo device (pipe)
+    FM_CHAR       = 0x2000  # char device
+    FM_DIRECTORY  = 0x4000  # directory
+    FM_BLOCK_DEV  = 0x6000  # block device
+    FM_FILE       = 0x8000  # regular file
+    FM_SYM_LNK    = 0xa000  # symbolic link
+    FM_SOCKET     = 0xc000  # socket device
+
+    # Values our callers may know
+    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
+
+    FILE_MODE_TO_FILE_TYPE_LOOKUP_TABLE = {
+      FM_FIFO      => FT_FIFO,
+      FM_CHAR      => FT_CHAR,
+      FM_DIRECTORY => FT_DIRECTORY,
+      FM_BLOCK_DEV => FT_BLOCK,
+      FM_FILE      => FT_FILE,
+      FM_SYM_LNK   => FT_SYM_LNK,
+      FM_SOCKET    => FT_SOCKET
+    }
+
+    # For accessor convenience.
+    MSK_FILE_MODE = 0xf000
+    MSK_IS_DEV    = (FM_FIFO | FM_CHAR | FM_BLOCK_DEV | FM_SOCKET)
+
+    # For Data Fork Data Format
+    XFS_DINODE_FMT_DEV     = 0  # Device Type
+    XFS_DINODE_FMT_LOCAL   = 1  # Bulk Data
+    XFS_DINODE_FMT_EXTENTS = 2  # xfs_bmbt_rec
+    XFS_DINODE_FMT_BTREE   = 3  # xfs_bmdr_block
+    XFS_DINODE_FMT_UUID    = 4  # uuid
+
+    XFS_DATA_FORK = 0
+    XFS_ATTR_FORK = 1
+
+    def dinode_good_version(version)
+      version >= 1 && version <= 3
+    end
+
+    def dinode_size(version)
+      if version == 3
+        SIZEOF_EXTENDED_INODE
+      else
+        SIZEOF_INODE
+      end
+    end
+
+    def dfork_q
+      @in['attr_fork_offset'] != 0
+    end
+
+    def dfork_boff
+      @in['attr_fork_offset'] << 3
+    end
+
+    def dfork_dsize
+      dfork_q ? dfork_boff : litino
+    end
+
+    def dfork_asize
+      dfork_q ? litino - dfork_boff : 0
+    end
+
+    def dfork_size(which_fork)
+      which_fork == XFS_DATA_FORK ? dfork_dsize : dfork_asize
+    end
+
+    def dfork_dptr
+      start = @offset + dinode_size(@version)
+      @disk_buffer[start..start + @sb.inode_size]
+    end
+
+    def dfork_aptr
+      dfork_dptr + dfork_boff
+    end
+
+    def litino
+      @sb.inode_size - dinode_size(@version)
+    end
+
+    attr_reader :mode, :flags, :length, :disk_buffer, :version, :inode_number, :sb, :data_method, :in
+    attr_accessor :data_fork, :attribute_fork
+
+    def valid_inode?
+      $log.error "XFS::Inode: Bad Magic # inode #{@inode_number}" unless @in['magic'] == XFS_DINODE_MAGIC
+      raise "XFS::Inode: Invalid Magic Number for inode #{@inode_number}"  unless @in['magic'] == XFS_DINODE_MAGIC
+      raise "XFS::Inode: Invalid Inode Version for inode #{@inode_number}" unless dinode_good_version(@in['version'])
+      true
+    end
+
+    def inode_format
+      if @format == XFS_DINODE_FMT_LOCAL
+        data_method    = :local
+      elsif @format == XFS_DINODE_FMT_EXTENTS
+        data_method    = :extents
+      else
+        data_method    = :btree
+      end
+      data_method
+    end
+
+    def initialize(buffer, offset, superblock, inode_number)
+      raise "XFS::Inode: Nil buffer for inode #{inode_number}" if buffer.nil?
+      @sb               = superblock
+      @inode_number     = inode_number
+      @offset           = offset
+      if @sb.inode_size < SIZEOF_EXTENDED_INODE
+        @in             = INODE.decode(buffer[offset..(offset + SIZEOF_INODE)])
+      else
+        @in             = EXTENDED_INODE.decode(buffer[offset..(offset + SIZEOF_EXTENDED_INODE)])
+      end
+      valid_inode? || return
+      rewind
+      @disk_buffer      = buffer
+      @mode             = @in['file_mode']
+      @flags            = @in['flags']
+      @version          = @in['version']
+      @length           = @in['size']
+      @format           = @in['format']
+      @block_offset     = 1
+      @data_method      = inode_format
+    end
+
+    # ////////////////////////////////////////////////////////////////////////////
+    # // Method for data access
+    def rewind
+      @pos = 0
+    end
+
+    def seek(offset, method = IO::SEEK_SET)
+      @pos = case method
+             when IO::SEEK_SET then offset
+             when IO::SEEK_CUR then @pos + offset
+             when IO::SEEK_END then @length - offset
+             end
+      @pos = 0           if @pos < 0
+      @pos = @length if @pos > @length
+      @pos
+    end
+
+    def read(nbytes = @length)
+      raise "XFS::Inode.read: Can't read 4G or more at a time (use a smaller read size)" if nbytes >= MAX_READ
+      return nil if @pos >= @length
+
+      nbytes = @length - @pos if @pos + nbytes > @length
+      return read_short_form(nbytes) if @data_method == :local
+
+      # get data.
+      start_block, start_byte, nblocks = pos_to_block(@pos, nbytes)
+      out = read_blocks(start_block, nblocks)
+      @pos += nbytes
+      out[start_byte, nbytes]
+    end
+
+    def write(buf, _len = buf.length)
+      raise "XFS::Inode.write: Write functionality is not yet supported on XFS."
+    end
+
+    # ////////////////////////////////////////////////////////////////////////////
+    # // Class helpers & accessors.
+
+    def directory?
+      mode_set?(FM_DIRECTORY)
+    end
+
+    def file?
+      mode_set?(FM_FILE)
+    end
+
+    def device?
+      (@mode & MSK_IS_DEV) > 0
+    end
+
+    def symlink?
+      mode_set?(FM_SYM_LNK)
+    end
+
+    def access_time
+      @access_time ||= Time.at(@in['atime_secs'])
+    end
+
+    def create_time
+      @create_time ||= Time.at(@in['ctime_secs'])
+    end
+
+    def modification_time
+      @modification_time ||= Time.at(@in['mtime_secs'])
+    end
+
+    def permissions
+      @permissions ||= @in['file_mode'] & (MSK_PERM_OWNER | MSK_PERM_GROUP | MSK_PERM_USER)
+    end
+
+    def owner_permissions
+      @owner_permissions ||= @in['file_mode'] & MSK_PERM_OWNER
+    end
+
+    def group_permissions
+      @group_permissions ||= @in['file_mode'] & MSK_PERM_GROUP
+    end
+
+    def user_permissions
+      @user_permissions ||= @in['file_mode'] & MSK_PERM_USER
+    end
+
+    # ////////////////////////////////////////////////////////////////////////////
+    # // Utility functions.
+
+    def file_mode_to_file_type
+      FILE_MODE_TO_FILE_TYPE_LOOKUP_TABLE[@mode & MSK_FILE_MODE]
+    end
+
+    def mode_set?(bit)
+      (@mode & bit) == bit
+    end
+
+    def flag_set?(bit)
+      (@flags & bit) == bit
+    end
+
+    def dump
+      out = "\#<#{self.class}:0x#{format('%08x', object_id)}>\n"
+      out += "Inode Number : #{@inode_number}\n"
+      out += "File mode    : 0x#{format('%04x', @in['file_mode'])}\n"
+      out += "UID          : #{@in['uid']}\n"
+      out += "Size         : #{@in['size']}\n"
+      out += "ATime Secs/NSecs: #{@in['atime_secs']}/#{@in['atime_nsecs']}\n"
+      out += "CTime Secs/NSecs: #{@in['ctime_secs']}/#{@in['ctime_nsecs']}\n"
+      out += "MTime Secs/NSecs: #{@in['mtime_secs']}/#{@in['mtime_nsecs']}\n"
+      out += "GID          : #{@in['gid']}\n"
+      out += "Link count   : #{@in['num_links']}\n"
+      out += "Old Link cnt : #{@in['old_num_links']}\n"
+      out += "Block count  : #{@in['nblocks']}\n"
+      out += "Extent size  : #{@in['extent_size']}\n"
+      out += "Num extents  : #{@in['num_extents']}\n"
+      out += "Data Fork Fmt : #{@data_method}\n"
+      out += "Attr Fork Exts: #{@in['attr_num_extents']}\n"
+      out += "Attr Fork Off : #{@in['attr_fork_offset']}\n"
+      out += "Attr Fork Fmt : #{@in['attr_fork_format']}\n"
+      out += "Flags        : #{format('%04x', @in['flags'])}\n"
+      out += "Version      : #{@in['version']}\n"
+      out += "Flush Iter   : #{@in['flush_iterator']}\n"
+      out += "Generation   : #{@in['gen_num']}\n"
+      out
+    end
+
+    private
+
+    def read_short_form(len)
+      unless self.directory? || self.symlink?
+        raise "XFS::Inode.read: Invalid ShortForm Directory for inode #{@inode_number}"
+      end
+      if @pos + len > @sb.inode_size
+        raise "XFS::Inode.read_short_form: Invalid length #{len} for Shortform Inode #{@inode_number}"
+      end
+      fork = dfork_dptr
+      data = fork[@pos..(@pos + len - 1)]
+      @pos += len
+      data
+    end
+
+    # NB: pos is 0-based, while len is 1-based
+    def pos_to_block(pos, len)
+      start_block, start_byte = pos.divmod(@sb.block_size)
+      end_block, _end_byte = (pos + len - 1).divmod(@sb.block_size)
+      nblocks = end_block - start_block + 1
+      return start_block, start_byte, nblocks
+    end
+
+    def read_blocks(startBlock, nblocks = 1)
+      out = MemoryBuffer.create(nblocks * @sb.block_size)
+      dbp_len = data_block_pointers.length
+      raise "XFS::Inode.read_blocks: startBlock=<#{startBlock}> is greater than #{dbp_len}" if startBlock > dbp_len - 1
+      1.upto(nblocks) do |i|
+        block_index = startBlock + i - 1
+        dbp_len = data_block_pointers.length
+        if block_index > dbp_len - 1
+          raise "XFS::Inode.read_blocks: block_index=<#{block_index}> is greater than #{dbp_len}"
+        end
+        block = data_block_pointers[block_index]
+        data  = @sb.get_block(block)
+        out[(i - 1) * @sb.block_size, @sb.block_size] = data
+      end
+      out
+    end
+
+    #
+    # This method is used for both extents and BTree leaf nodes
+    #
+    def bmap_btree_record_to_block_pointers(record, block_pointers_length)
+      block_pointers = []
+      # Fill in the missing blocks with 0-blocks
+      block_pointers << 0 while (block_pointers_length + block_pointers.length) < record.start_offset
+      1.upto(record.block_count) { |i| block_pointers << record.start_block + i - 1 }
+      @block_offset += record.block_count
+      block_pointers
+    end
+
+    def expected_blocks
+      @expected_blocks ||= begin
+        quotient, remainder = @length.divmod(@sb.block_size)
+        quotient + ((remainder > 0) ? 1 : 0)
+      end
+    end
+
+    def block_pointers_via_bmap_btree_block_node(btree_block, data, block_pointers_length)
+      block_pointers = []
+      return block_pointers unless (block_pointers_length + block_pointers.length) < expected_blocks
+      maximum_records = (@sb.block_size - btree_block.header_size) / SIZEOF_BMAP_BTREE_ROOT_NODE_ENTRIES
+      return if maximum_records == 0
+      offset_size  = SIZEOF_BMAP_BTREE_ROOT_NODE_OFFSET
+      block_size   = SIZEOF_BMAP_BTREE_ROOT_NODE_BLOCK
+      1.upto(btree_block.number_records) do |i|
+        start      = maximum_records * offset_size + (i - 1) * block_size
+        block      = (data[start..start + block_size]).unpack('Q>').shift
+        agbno      = @sb.fsb_to_agbno(block)
+        agno       = @sb.fsb_to_agno(block)
+        real_block = sb.agbno_to_real_block(agno, agbno)
+        block_pointers.concat block_pointers_via_bmap_btree_block(real_block,
+                                                                  block_pointers.length + block_pointers_length)
+      end
+      block_pointers
+    end
+
+    def block_pointers_via_bmap_btree_block_leaf(data, block_pointers_length, number_records)
+      block_pointers = []
+      return block_pointers unless (block_pointers_length + block_pointers.length) < expected_blocks
+      1.upto(number_records) do |i|
+        bmap_btree_record = BmapBTreeRecord.new(data[(SIZEOF_BMAP_BTREE_REC * (i - 1))..(SIZEOF_BMAP_BTREE_REC * i)],
+                                                @sb)
+        break if @sb.fsb_to_b(bmap_btree_record.start_offset) >= DirectoryEntry::XFS_DIR2_LEAF_OFFSET
+        if (block_pointers_length + block_pointers.length) < expected_blocks
+          block_pointers.concat bmap_btree_record_to_block_pointers(bmap_btree_record,
+                                                                    block_pointers.length + block_pointers_length)
+        end
+      end
+      block_pointers
+    end
+
+    def block_pointers_via_bmap_btree_block(block_number, block_pointers_length)
+      block_pointers = []
+      if block_pointers_length < expected_blocks
+        data           = @sb.get_block(block_number)
+        btree_block    = BmapBTreeBlock.new(data, @sb)
+        if btree_block.level == 0
+          block_pointers.concat block_pointers_via_bmap_btree_block_leaf(data[btree_block.header_size..-1],
+                                                                         block_pointers.length + block_pointers_length,
+                                                                         btree_block.number_records)
+        else
+          block_pointers.concat block_pointers_via_bmap_btree_block_node(btree_block, data[btree_block.header_size..-1],
+                                                                         block_pointers.length + block_pointers_length)
+        end
+      end
+      block_pointers
+    end
+
+    def block_pointers_via_btree
+      block_pointers = []
+      fork = dfork_dptr
+      root_node = BmapBTreeRootNode.new(fork, self)
+      root_node.blocks.each do |block_number|
+        block_pointers.concat block_pointers_via_bmap_btree_block(block_number, block_pointers.length)
+      end
+      block_pointers
+    end
+
+    def extent_to_block_pointers(extent, bplen)
+      block_pointers = []
+      # Fill in the missing blocks with 0-blocks
+      block_pointers << 0 while (bplen + block_pointers.length) < extent.start_offset
+      1.upto(extent.block_count) { |i| block_pointers << extent.start_block + i - 1 }
+      @block_offset += extent.block_count
+      block_pointers
+    end
+
+    def block_pointers_via_extents
+      block_pointers = []
+      fork = dfork_dptr
+      extent_count = @in['num_extents']
+      return block_pointers if extent_count == 0
+      1.upto(extent_count) do |i|
+        bmap_btree_record = BmapBTreeRecord.new(fork[(SIZEOF_BMAP_BTREE_REC * (i - 1))..(SIZEOF_BMAP_BTREE_REC * i)],
+                                                @sb)
+        #
+        # The following test is to weed out Leaf Metadata Blocks that have no directory content
+        #
+        break if @sb.fsb_to_b(bmap_btree_record.start_offset) >= DirectoryEntry::XFS_DIR2_LEAF_OFFSET
+        block_pointers.concat extent_to_block_pointers(bmap_btree_record, block_pointers.length)
+      end
+      block_pointers
+    end
+
+    def read_block_pointers(block)
+      @sb.get_block(block).unpack('L*')
+    end
+
+    def data_block_pointers
+      if @data_block_pointers.nil?
+        @data_block_pointers = block_pointers_via_extents          if @data_method == :extents
+        @data_block_pointers = block_pointers_via_btree            if @data_method == :btree
+        dbp_len = @data_block_pointers.length
+        if expected_blocks != dbp_len
+          raise "XFS::Inode.block_pointers: Block Pointers <#{dbp_len}> does not match Expected <#{expected_blocks}>"
+        end
+      end
+      @data_block_pointers
+    end
+  end # Class Inode
+end # Module XFS