manageiq-smartstate 0.1.0

data/lib/fs/xfs/inode_map.rb

@@ -0,0 +1,100 @@
+require 'fs/xfs/inode'
+
+module XFS
+  # ////////////////////////////////////////////////////////////////////////////
+  # // Class.
+
+  class InodeMap
+    attr_reader :inode_blkno, :inode_length, :inode_boffset
+
+    def valid_inode_size?(sb)
+      if (@inode_blkno + @inode_length) > sb.fsb_to_bb(sb.block_count)
+        $log.error "XFS::InodeMap - Inode #{@inode_blkno} too large for filesystem" if $log
+        raise "XFS::InodeMap - Inode #{@inode_blkno} too large for filesystem"
+      end
+      true
+    end
+
+    def valid_inode_number?(inode, sb)
+      if (@agno >= sb.sb['ag_count']) ||
+         (@agbno >= sb.sb['ag_blocks']) ||
+         sb.agino_to_ino(@agno, @agino) != inode
+        $log.error "XFS::InodeMap - Bad Inode number #{inode} for agno #{@agno} agcount #{sb.sb['ag_count']}, agbno #{@agbno}, agblocks #{sb.sb['ag_blocks']}, agino #{@agino}, agino_to_ino #{sb.agino_to_ino(@agno, @agino)}" if $log
+        raise "XFS::InodeMap - Bad Inode number #{inode}"
+      end
+      true
+    end
+
+    def initialize(inode, sb)
+      #
+      # Split up the inode number into its parts
+      #
+      @inode_number   = inode
+      @agno           = sb.ino_to_agno(inode)
+      @agino          = sb.ino_to_agino(inode)
+      @agbno          = sb.agino_to_agbno(@agino)
+
+      valid_inode_number?(inode, sb) || return
+      #
+      # If the inode cluster size is the same as the blocksize or
+      # smaller we get to the block by simple arithmetic
+      #
+      blocks_per_cluster = sb.icluster_size_fsb
+      @inode_length = sb.fsb_to_bb(blocks_per_cluster)
+      if blocks_per_cluster == 1
+        offset = sb.ino_to_offset(inode)
+        @inode_blkno  = sb.agbno_to_real_block(@agno, @agbno)
+        @inode_boffset = offset << sb['inode_size_log']
+        return
+      elsif sb.inode_align_mask
+        #
+        # If the inode chunks are aligned then use simple math to
+        # find the location.  Otherwise we have to do a btree
+        # lookup to find the location.
+        #
+        offset_agbno = @agbno & (sb.inode_align_mask - 1)
+        chunk_agbno  = @agbno - offset_agbno
+      else
+        start_ino    = imap_lookup(@agno, @agino)
+        chunk_agbno  = sb.agino_to_agbno(start_ino)
+        offset_agbno = @agbno - chunk_agbno
+      end
+
+      @cluster_agbno = chunk_agbno + (offset_agbno / blocks_per_cluster) * blocks_per_cluster
+      offset = (@agbno - @cluster_agbno) * sb.sb['inodes_per_blk'] + sb.ino_to_offset(inode)
+      @inode_blkno  = sb.agbno_to_real_block(@agno, @cluster_agbno)
+      @inode_boffset = offset << sb.sb['inode_size_log']
+      valid_inode_size?(sb) || return
+    end # initialize
+
+    def imap_lookup(agno, agino)
+      ag = get_ag(agno)
+      cursor = InodeBtreeCursor.new(@sb, ag.agi, agno, XFS_BTNUM_INO)
+      cursor.block_ptr = ag.agblock
+      error = inobt_lookup(cursor, agino, XFS_LOOKUP_LE)
+      raise "XFS::Superblock.imap_lookup: #{error}" if error
+      inode_rec = inode_btree_record(cursor)
+      if inode_rec.nil?
+        raise "XFS::Superblock.imap_lookup: Error #{cursor.error} getting InodeBtreeRecord for inode #{agino}"
+      end
+      if inode_rec.start_ino > agino ||
+         inode_rec.start_ino + @ialloc_inos <= agino
+        raise "XFS::Superblock.imap_lookup: InodeBtreeRecord does not contain required inode #{agino}"
+      end
+      inode_rec.start_ino
+    end # imap_lookup
+
+    def dump
+      out = "\#<#{self.class}:0x#{format('%08x', object_id)}>\n"
+      out += "Inode Number : #{@inode_number}\n"
+      out += "Alloc Grp Num: #{@agno}\n"
+      out += "AG Ino       : #{@agino}\n"
+      out += "AG Block Num : #{@agbno}\n"
+      out += "Inode Length : #{@inode_length}\n"
+      out += "Inode Blkno  : #{@inode_blkno}\n"
+      out += "InoBlk Offset: #{@inode_boffset}\n"
+      out += "Cluster AGBNO: #{@cluster_agbno}\n"
+      out
+    end
+  end # Class InodeMap
+end # Module XFS

data/lib/fs/xfs/short_form_directory_entry.rb

@@ -0,0 +1,91 @@
+require 'binary_struct'
+require 'fs/xfs/inode'
+
+module XFS
+  # ////////////////////////////////////////////////////////////////////////////
+  # // Data definitions.
+  #
+  # Short Form Directory Entry in a Short Form Inode.
+  #
+  SHORT_FORM_DIRECTORY_ENTRY = BinaryStruct.new([
+    'C',   'name_length',  # name length
+    'C',   'offset_byte0',
+    'C',   'offset_byte1',
+  ])
+  SIZEOF_SHORT_FORM_DIRECTORY_ENTRY = SHORT_FORM_DIRECTORY_ENTRY.size
+
+  SHORT_FORM_SHORT_INO = BinaryStruct.new([
+    'I>',  'inode_num', # 4 byte inode number
+  ])
+  SIZEOF_SHORT_FORM_SHORT_INO = SHORT_FORM_SHORT_INO.size
+
+  SHORT_FORM_LONG_INO = BinaryStruct.new([
+    'Q>',  'inode_num', # 8 byte inode number
+  ])
+  SIZEOF_SHORT_FORM_LONG_INO = SHORT_FORM_LONG_INO.size
+
+  class ShortFormDirectoryEntry
+    attr_reader :length, :name, :name_length, :short_inode
+    attr_accessor :file_type, :inode
+
+    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 dot_entry(dots, inode_number)
+      @length      = 0
+      @name_length = dots
+      @name        = "."
+      @name        = ".." if dots == 2
+      @inode       = inode_number
+      # Inode Numbers will be filled in by the caller
+    end
+
+    def initialize(data, short_inode, sb, dots = nil, inode_number = nil)
+      #
+      # If dots is 1 or 2 we need to construct the
+      # "." and ".." directory entries.
+      #
+      return dot_entry(dots, inode_number) if dots
+      raise "XFS::ShortFormDirectoryEntry.initialize: Nil directory entry data" if data.nil?
+      siz              = SIZEOF_SHORT_FORM_DIRECTORY_ENTRY
+      @directory_entry = SHORT_FORM_DIRECTORY_ENTRY.decode(data[0..siz])
+      @name_length     = @directory_entry['name_length']
+      unless @name_length == 0
+        @name = data[siz, @name_length]
+        @name_length += 1 if sb.version_has_crc?
+        start = siz + @name_length
+        if short_inode
+          ino_size = SIZEOF_SHORT_FORM_SHORT_INO
+          inode    = SHORT_FORM_SHORT_INO.decode(data[start..(start + ino_size)])
+        else
+          ino_size = SIZEOF_SHORT_FORM_LONG_INO
+          inode    = SHORT_FORM_LONG_INO.decode(data[start..(start + ino_size)])
+        end
+        @length    = start + ino_size
+        @inode     = inode['inode_num']
+      end
+    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/short_form_header.rb

@@ -0,0 +1,44 @@
+module XFS
+  #
+  # Directory Entry when stored internal to an inode.
+  # Small directories are packed as tightly as possible so as to fit into the
+  # literal area of the inode.  These "shortform" directories consist of a
+  # single header followed by zero or more dir entries.  Due to the different
+  # inode number storage size and the variable length name field in the dir
+  # entry all these structures are variable length, and the accessors in
+  # this file should be used to iterate over them.
+  #
+  DIRECTORY_SHORTERFORM_HEADER = BinaryStruct.new([
+    'C',  'entry_count',         # count of entries
+    'C',  'i8byte_count',        # count of 8-byte inode #s
+    'I>', 'parent_ino_4byte',    # parent dir inode # stored as 4 8-bit values
+  ])
+  SIZEOF_DIRECTORY_SHORTERFORM_HEADER = DIRECTORY_SHORTERFORM_HEADER.size
+
+  DIRECTORY_SHORTFORM_HEADER = BinaryStruct.new([
+    'C',  'entry_count',         # count of entries
+    'C',  'i8byte_count',        # count of 8-byte inode #s
+    'Q>', 'parent_ino_8byte',    # parent dir inode # stored as 8 8-bit values
+  ])
+  SIZEOF_DIRECTORY_SHORTFORM_HEADER = DIRECTORY_SHORTFORM_HEADER.size
+
+  class ShortFormHeader
+    attr_reader :short_form_header, :entry_count, :parent_inode, :size, :small_inode
+
+    def initialize(data)
+      @short_form_header = DIRECTORY_SHORTERFORM_HEADER.decode(data)
+      @entry_count       = @short_form_header['entry_count']
+      i8byte_count       = @short_form_header['i8byte_count']
+      @parent_inode      = @short_form_header['parent_ino_4byte']
+      @size              = SIZEOF_DIRECTORY_SHORTERFORM_HEADER
+      @small_inode       = true
+      if @entry_count == 0
+        @entry_count       = i8byte_count
+        @short_form_header = DIRECTORY_SHORTFORM_HEADER.decode(data)
+        @parent_inode      = @short_form_header['parent_ino_8byte']
+        @size              = SIZEOF_DIRECTORY_SHORTFORM_HEADER
+        @small_inode       = nil
+      end
+    end
+  end # class ShortFormHeader
+end   # module XFS