manageiq-smartstate 0.1.0

data/lib/fs/ext4/inode.rb

@@ -0,0 +1,465 @@
+require 'fs/ext4/directory_entry'
+require 'fs/ext4/extent'
+require 'fs/ext4/extent_header'
+require 'fs/ext4/extent_index'
+
+require 'binary_struct'
+require 'memory_buffer'
+
+module Ext4
+  # ////////////////////////////////////////////////////////////////////////////
+  # // Data definitions.
+
+  INODE = BinaryStruct.new([
+    'S',  'file_mode',    # File mode (type and permission), see PF_ DF_ & FM_ below.
+    'S',  'uid_lo',       # Lower 16-bits of user id.
+    'L',  'size_lo',      # Lower 32-bits of size in bytes.
+    'L',  'atime',        # Last access       time.
+    'L',  'ctime',        # Last change       time.
+    'L',  'mtime',        # Last modification time.
+    'L',  'dtime',        # Time deleted.
+    'S',  'gid_lo',       # Lower 16-bits of group id.
+    'S',  'link_count',   # Link count.
+    'L',  'blocks_lo',    # Lower 32-bits of Block count.
+    'L',  'flags',        # Inode flags, see IF_ below.
+    'L',  'version',      # Version.
+    'a60', 'data',         # 60 bytes deciphered into data (symlink, indirect pointer, or extents)
+    'L',  'gen_num',      # Generation number (NFS).
+    'L',  'file_acl_lo',  # Lower 32-bits of File.
+    'L',  'size_hi',      # Upper 32-bits of size in bytes or directory ACL.
+    'L',  'obso_faddr',   # Obsoleted fragment address.
+    'S',  'blocks_hi',    # Upper 16-bits of Block count.
+    'S',  'file_acl_hi',  # Upper 16-bits of File ACL.
+    'S',  'uid_hi',       # Upper 16-bits of user id.
+    'S',  'gid_hi',       # Upper 16-bits of group id.
+    'L',  'reserved2',    # Unused.
+    'S',  'extra_isize',  #
+    'S',  'pad1',         #
+    'L',  'ctime_extra',  # extra Change             time (nsec << 2 | epoch)
+    'L',  'mtime_extra',  # extra Modification       time (nsec << 2 | epoch)
+    'L',  'atime_extra',  # extra Access             time (nsec << 2 | epoch)
+    'L',  'crtime',       # File Creation time
+    'L',  'crtime_extra', # extra File Creation Time time (nsec << 2 | epoch)
+    'L',  'version_hi',   # Upper 32-bits of version (for 64-bit version)
+  ])
+  SIZEOF_INODE = INODE.size
+
+  SYM_LNK_SIZE          = 60
+  MAX_READ              = 4294967296
+  DEFAULT_BLOCK_SIZE    = 1024
+
+  # ////////////////////////////////////////////////////////////////////////////
+  # // Class.
+
+  class Inode
+    # 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 9 to 11 of file mode.
+    DF_STICKY     = 0x0200
+    DF_SET_GID    = 0x0400
+    DF_SET_UID    = 0x0800
+
+    # 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
+
+    # For accessor convenience.
+    MSK_FILE_MODE = 0xf000
+    MSK_IS_DEV    = (FM_FIFO | FM_CHAR | FM_BLOCK_DEV | FM_SOCKET)
+
+    # Inode flags.
+    IF_SECURE_DEL = 0x00000001  # wipe when deleting
+    IF_KEEP_COPY  = 0x00000002  # never delete
+    IF_COMPRESS   = 0x00000004  # compress content
+    IF_SYNCHRO    = 0x00000008  # don't cache
+    IF_IMMUTABLE  = 0x00000010  # file cannot change
+    IF_APPEND     = 0x00000020  # always append
+    IF_NO_DUMP    = 0x00000040  # don't cat
+    IF_NO_ATIME   = 0x00000080  # don't update atime
+    IF_DIRTY      = 0x00000100
+    IF_COMPR_CL   = 0x00000200  # One or more compressed clusters
+    IF_NOCOMPR    = 0x00000400  # Don't compress
+    IF_ECOMPR     = 0x00000800  # Compression error
+    IF_HASH_INDEX = 0x00001000  # if dir, has hash index
+    IF_AFS_DIR    = 0x00002000  # AFS directory
+    IF_JOURNAL    = 0x00004000  # if using journal, is journal inode
+    IF_NOTAIL     = 0x00008000  # file tail should not be merged
+    IF_DIRSYNC    = 0x00010000  # dirsync behaviour (directories only)
+    IF_TOPDIR     = 0x00020000  # Top of directory hierarchies
+    IF_HUGE_FILE  = 0x00040000  # Set to each huge file
+    IF_EXTENTS    = 0x00080000  # Inode uses extents
+    IF_EA_INODE   = 0x00200000  # Inode used for large EA
+    IF_EOFBLOCKS  = 0x00400000  # Blocks allocated beyond EOF
+    IF_FLAGS = (IF_SECURE_DEL | IF_KEEP_COPY | IF_COMPRESS | IF_SYNCHRO | IF_IMMUTABLE | IF_APPEND | IF_NO_DUMP | IF_NO_ATIME | IF_DIRTY | IF_COMPR_CL | IF_NOCOMPR | IF_ECOMPR | IF_HASH_INDEX | IF_AFS_DIR | IF_JOURNAL | IF_NOTAIL | IF_DIRSYNC | IF_TOPDIR | IF_HUGE_FILE | IF_EXTENTS | IF_EA_INODE | IF_EOFBLOCKS)
+
+    FLAG_STR = {
+      IF_SECURE_DEL => 'IF_SECURE_DEL',
+      IF_KEEP_COPY  => 'IF_KEEP_COPY',
+      IF_COMPRESS   => 'IF_COMPRESS',
+      IF_SYNCHRO    => 'IF_SYNCHRO',
+      IF_IMMUTABLE  => 'IF_IMMUTABLE',
+      IF_APPEND     => 'IF_APPEND',
+      IF_NO_DUMP    => 'IF_NO_DUMP',
+      IF_NO_ATIME   => 'IF_NO_ATIME',
+      IF_DIRTY      => 'IF_DIRTY',
+      IF_COMPR_CL   => 'IF_COMPR_CL',
+      IF_NOCOMPR    => 'IF_NOCOMPR',
+      IF_ECOMPR     => 'IF_ECOMPR',
+      IF_HASH_INDEX => 'IF_HASH_INDEX',
+      IF_AFS_DIR    => 'IF_AFS_DIR',
+      IF_JOURNAL    => 'IF_JOURNAL',
+      IF_NOTAIL     => 'IF_NOTAIL',
+      IF_DIRSYNC    => 'IF_DIRSYNC',
+      IF_TOPDIR     => 'IF_TOPDIR',
+      IF_HUGE_FILE  => 'IF_HUGE_FILE',
+      IF_EXTENTS    => 'IF_EXTENTS',
+      IF_EA_INODE   => 'IF_EA_INODE',
+      IF_EOFBLOCKS  => 'IF_EOFBLOCKS'
+    }
+
+    # Lookup table for File Mode to File Type.
+    @@FM2FT = {
+      Inode::FM_FIFO      => DirectoryEntry::FT_FIFO,
+      Inode::FM_CHAR      => DirectoryEntry::FT_CHAR,
+      Inode::FM_DIRECTORY => DirectoryEntry::FT_DIRECTORY,
+      Inode::FM_BLOCK_DEV => DirectoryEntry::FT_BLOCK,
+      Inode::FM_FILE      => DirectoryEntry::FT_FILE,
+      Inode::FM_SYM_LNK   => DirectoryEntry::FT_SYM_LNK,
+      Inode::FM_SOCKET    => DirectoryEntry::FT_SOCKET
+    }
+
+    attr_reader :mode, :flags, :symlnk, :pos
+
+    def initialize(buf, superblock, inum)
+      raise "Ext4::Inode.initialize: Nil buffer" if buf.nil?
+      @in = INODE.decode(buf)
+
+      @sb    = superblock
+      @inum  = inum
+      @mode  = @in['file_mode']
+      @flags = @in['flags']
+
+      if self.isSymLink? && length < SYM_LNK_SIZE
+        @data_method = nil
+        @symlnk = @in['data']
+      elsif hasExtents?
+        @data_method = :extents
+      else
+        @data_method = :indirect
+      end
+
+      rewind
+    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 "Ext4::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
+
+      # Handle symbolic links.
+      if symlnk
+        out = symlnk[@pos...nbytes]
+        @pos += nbytes
+        return out
+      end
+      nbytes = length - @pos if @pos + nbytes > length
+
+      # get data.
+      start_block, start_byte, end_block, end_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 "Ext4::Inode.write: Write functionality is not yet supported on Ext4."
+    end
+
+    # ////////////////////////////////////////////////////////////////////////////
+    # // Class helpers & accessors.
+
+    def uid
+      @uid ||= (@in['uid_hi'] << 16) | @in['uid_lo']
+    end
+
+    def gid
+      @gid ||= (@in['gid_hi'] << 16) | @in['gid_lo']
+    end
+
+    def nblocks
+      @nblocks ||= (@in['blocks_hi'] << 32) | @in['blocks_lo']
+    end
+
+    def length
+      @length ||= (@in['size_hi'] << 32) | @in['size_lo']
+    end
+
+    def isDir?
+      modeSet?(FM_DIRECTORY)
+    end
+
+    def isFile?
+      modeSet?(FM_FILE)
+    end
+
+    def isDev?
+      (@mode & MSK_IS_DEV) > 0
+    end
+
+    def isSymLink?
+      modeSet?(FM_SYM_LNK)
+    end
+
+    def isHashedDir?
+      isDir? && flagSet?(IF_HASH_INDEX)
+    end
+
+    def hasExtents?
+      flagSet?(IF_EXTENTS)
+    end
+
+    def aTime
+      @atime ||= Time.at(@in['atime'])
+    end
+
+    def cTime
+      @ctime ||= Time.at(@in['ctime'])
+    end
+
+    def mTime
+      @mtime ||= Time.at(@in['mtime'])
+    end
+
+    def dTime
+      @dtime ||= Time.at(@in['dtime'])
+    end
+
+    def permissions
+      @permissions ||= @in['file_mode'] & (MSK_PERM_OWNER | MSK_PERM_GROUP | MSK_PERM_USER)
+    end
+
+    def ownerPermissions
+      @owner_permissions ||= @in['file_mode'] & MSK_PERM_OWNER
+    end
+
+    def groupPermissions
+      @group_permissions ||= @in['file_mode'] & MSK_PERM_GROUP
+    end
+
+    def userPermissions
+      @user_permissions ||= @in['file_mode'] & MSK_PERM_USER
+    end
+
+    # ////////////////////////////////////////////////////////////////////////////
+    # // Utility functions.
+
+    def fileModeToFileType
+      @@FM2FT[@mode & MSK_FILE_MODE]
+    end
+
+    def modeSet?(bit)
+      (@mode & bit) == bit
+    end
+
+    def flagSet?(bit)
+      (@flags & bit) == bit
+    end
+
+    def flags_to_s
+      str_flags = []
+      FLAG_STR.each_key do |flag|
+        str_flags << FLAG_STR[flag] if flagSet?(flag)
+      end
+      str_flags.join(' ')
+    end
+
+    def dump
+      out = "\#<#{self.class}:0x#{'%08x' % object_id}>\n"
+      out += "Inode Number : #{@inum}\n"
+      out += "File mode    : 0x#{'%04x' % @in['file_mode']}\n"
+      out += "UID          : #{uid}\n"
+      out += "Size         : #{length}\n"
+      out += "ATime        : #{aTime}\n"
+      out += "CTime        : #{cTime}\n"
+      out += "MTime        : #{mTime}\n"
+      out += "DTime        : #{dTime}\n"
+      out += "GID          : #{gid}\n"
+      out += "Link count   : #{@in['link_count']}\n"
+      out += "Block count  : #{nblocks}\n"
+      out += "Flags        : #{flags_to_s}\n"
+      extra = @flags - (@flags & IF_FLAGS)
+      out << "  Extra Flags: 0x#{'%08x' % extra}\n" if extra != 0
+      out += "Version      : #{@in['version']}\n"
+      out += "Data         : \n#{@in['data'].hex_dump}"
+      out += "Generation   : 0x#{'%08x' % @in['gen_num']}\n"
+      out += "Ext attrib   : 0x#{'%08x' % @in['ext_attrib']}\n"
+      out += "Frag blk adrs: 0x#{'%08x' % @in['frag_blk']}\n"
+      out += "Frag index   : 0x#{'%02x' % @in['frag_idx']}\n"
+      out += "Frag size    : 0x#{'%02x' % @in['frag_siz']}\n"
+      out
+    end
+
+    private
+
+    # NB: pos is 0-based, while len is 1-based
+    def pos_to_block(pos, len)
+      startBlock, startByte = pos.divmod(@sb.blockSize)
+      endBlock, endByte = (pos + len - 1).divmod(@sb.blockSize)
+      nblocks = endBlock - startBlock + 1
+      return startBlock, startByte, endBlock, endByte, nblocks
+    end
+
+    def read_blocks(startBlock, nblocks = 1)
+      out = MemoryBuffer.create(nblocks * @sb.blockSize)
+      raise "Ext4::Inode.read_blocks: startBlock=<#{startBlock}> is greater than #{data_block_pointers.length}" if startBlock > data_block_pointers.length - 1
+      1.upto(nblocks) do |i|
+        block_index = startBlock + i - 1
+        raise "Ext4::Inode.read_blocks: blockIndex=<#{block_index}> is greater than #{data_block_pointers.length}" if block_index > data_block_pointers.length - 1
+        block = data_block_pointers[block_index]
+        data  = @sb.getBlock(block)
+        out[(i - 1) * @sb.blockSize, @sb.blockSize] = data
+      end
+      out
+    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.block
+      1.upto(extent.length) { |i| block_pointers << extent.start + i - 1 }
+      block_pointers
+    end
+
+    def expected_blocks
+      @expected_blocks ||= begin
+        quotient, remainder = length.divmod(@sb.blockSize)
+        quotient + ((remainder > 0) ? 1 : 0)
+      end
+    end
+
+    def block_pointers_via_extents
+      block_pointers = []
+
+      @extent_header = ExtentHeader.new(@in['data'])
+
+      if @extent_header.depth == 0
+        1.upto(@extent_header.entries) do |i|
+          extent = Extent.new(@in['data'][SIZEOF_EXTENT_HEADER + SIZEOF_EXTENT * (i - 1), SIZEOF_EXTENT])
+          block_pointers.concat extent_to_block_pointers(extent, block_pointers.length)
+        end
+      else
+        1.upto(@extent_header.entries) do |i|
+          extent_index    = ExtentIndex.new(@in['data'][SIZEOF_EXTENT_HEADER + SIZEOF_EXTENT_INDEX * (i - 1), SIZEOF_EXTENT_INDEX])
+          leaf_block      = @sb.getBlock(extent_index.leaf)
+          extent_header   = ExtentHeader.new(leaf_block)
+          1.upto(extent_header.entries) do |j|
+            extent = Extent.new(leaf_block[SIZEOF_EXTENT_HEADER + SIZEOF_EXTENT * (j - 1), SIZEOF_EXTENT])
+            block_pointers.concat extent_to_block_pointers(extent, block_pointers.length)
+          end
+        end
+      end
+
+      block_pointers
+    end
+
+    def read_block_pointers(block)
+      @sb.getBlock(block).unpack('L*')
+    end
+
+    def block_pointers_via_triple_indirect(triple_indirect_block_num, bplen = 0)
+      block_pointers = []
+      if (bplen + block_pointers.length) < expected_blocks
+        read_block_pointers(triple_indirect_block_num).each do |double_indirect_block_num|
+          if (bplen + block_pointers.length) < expected_blocks
+            block_pointers.concat block_pointers_via_double_indirect(double_indirect_block_num, bplen + block_pointers.length)
+          end
+        end
+      end
+      block_pointers
+    end
+
+    def block_pointers_via_double_indirect(double_indirect_block_num, bplen = 0)
+      block_pointers = []
+      if (bplen + block_pointers.length) < expected_blocks
+        read_block_pointers(double_indirect_block_num).each do |single_indirect_block_num|
+          if (bplen + block_pointers.length) < expected_blocks
+            block_pointers.concat block_pointers_via_single_indirect(single_indirect_block_num, bplen + block_pointers.length)
+          end
+        end
+      end
+      block_pointers
+    end
+
+    def block_pointers_via_single_indirect(single_indirect_block_num, bplen = 0)
+      block_pointers = []
+      if (bplen + block_pointers.length) < expected_blocks
+        read_block_pointers(single_indirect_block_num).each do |bp|
+          block_pointers << bp if bplen + block_pointers.length < expected_blocks
+        end
+      end
+      block_pointers
+    end
+
+    def block_pointers_via_indirect
+      block_pointers = []
+
+      # NOTE: Unpack the direct block pointers separately.
+      @in['data'][0, 48].unpack('L12').each { |bp| block_pointers << bp if block_pointers.length < expected_blocks }
+
+      single_indirect_block_num = @in['data'][48, 4].unpack('L').first
+      block_pointers.concat block_pointers_via_single_indirect(single_indirect_block_num, block_pointers.length)
+
+      double_indirect_block_num = @in['data'][52, 4].unpack('L').first
+      block_pointers.concat block_pointers_via_double_indirect(double_indirect_block_num, block_pointers.length)
+
+      triple_indirect_block_num = @in['data'][56, 4].unpack('L').first
+      block_pointers.concat block_pointers_via_triple_indirect(triple_indirect_block_num, block_pointers.length)
+
+      block_pointers
+    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_indirect         if (@data_method == :indirect)
+        raise "Ext4::Inode.block_pointers: Actual Block Pointers <#{@data_block_pointers.length}> does not match Expected <#{expected_blocks}>" if expected_blocks != @data_block_pointers.length
+      end
+      @data_block_pointers
+    end
+  end
+end

data/lib/fs/ext4/posix_acl_entry.rb

@@ -0,0 +1,29 @@
+module Ext4
+  # ////////////////////////////////////////////////////////////////////////////
+  # // Data definitions.
+
+  POSIX_ACL_ENTRY = [
+    'S',  'type',         # Entry type, see ET_ below.
+    'S',  'permissions',  # Permissions, see EP_ below.
+    'L',  'u_g_id',       # User / Group id (not defined for some types).
+  ]
+
+  class PosixAclEntry
+    module EntryType
+      ET_U_INODE      = 0x01  # User, specified in inode.
+      ET_U_ATTRIB     = 0x02  # User, specified in attribute.
+      ET_G_INODE      = 0x04  # Group, specified in inode.
+      ET_G_ATTRUB     = 0x08  # Group, specified in attribute.
+      ET_RIGHTS_MASK  = 0x10  # Effective rights mask.
+      ET_O            = 0x20  # Other, all other users.
+    end
+    include EntryType
+
+    module EntryPermissions
+      EP_EXECUTE  = 0x01  # Execute permission.
+      EP_WRITE    = 0x02  # Write permission.
+      EP_READ     = 0x04  # Read permission.
+    end
+    include EntryPermissions
+  end
+end

data/lib/fs/ext4/posix_acl_header.rb

@@ -0,0 +1,11 @@
+module Ext4
+  # ////////////////////////////////////////////////////////////////////////////
+  # // Data definitions.
+
+  POSIX_ACL_HEADER = [
+    'L',  'version',  # Always 1, or 1 is all that's supported.
+  ]
+
+  class PosixAclHeader
+  end
+end