manageiq-smartstate 0.8.1 → 0.9.0

data/lib/disk/modules/MSCommon.rb

@@ -1,354 +0,0 @@
-require 'disk/modules/MiqLargeFile'
-require 'miq_unicode'
-require 'binary_struct'
-require 'memory_buffer'
-require 'Scvmm/miq_hyperv_disk'
-
-module MSCommon
-  using ManageIQ::UnicodeString
-
-  # NOTE: All values are stored in network byte order.
-
-  FOOTER = BinaryStruct.new([
-    'a8',   'cookie',           # Always 'conectix'.
-    'N',    'features',         # Should be 2 or 3 (bit 0 is temp disk).
-    'N',    'version',          # Major/Minor file format version.
-    'N',    'data_offset_hi',   # Offset from beginning of file to next data struct (dyn & diff only, 0xffffffff for fixed).
-    'N',    'data_offset_lo',
-    'N',    'time_stamp',       # Create time (sec since Jan 1 2000 12:00 AM in GMT).
-    'a4',   'creator_app',      # Virtual PC = 'vpc ', Virtual Server = 'vs  '.
-    'N',    'creator_ver',      # Major/Minor ver of creator app.
-    'N',    'creator_host',     # Creator host: Windows = 0x5769326b ('Wi2k'); Macintosh = 0x4d616320 ('Mac ').
-    'N',    'original_size_hi', # Original size of disk.
-    'N',    'original_size_lo',
-    'N',    'current_size_hi',  # Current size of the disk.
-    'N',    'current_size_lo',
-    'N',    'disk_geometry',    # CHS (byte sizes 2, 1, 1) values for disk.
-    'N',    'disk_type',        # Disk subtype (Fixed, Dynamic or Differencing).
-    'N',    'checksum',         # One's compliment of sum of struct minus this field.
-    'a16',  'unique_id',        # UUID.
-    'C',    'saved_state',      # If 1, system is in 'saved state'.
-  ])
-
-  HEADER = BinaryStruct.new([
-    'a8',   'cookie',           # Always 'cxsparse'.
-    'Q',    'data_offset',      # Unused, should be 0xffffffff.
-    'N',    'table_offset_hi',  # Byte offset to the Block Allocation Table.
-    'N',    'table_offset_lo',
-    'N',    'header_ver',       # Major/Minor header version.
-    'N',    'max_tbl_ent',      # Max entries in the BAT.
-    'N',    'block_size',       # Size of data section of a block, default 2M (0x00200000).
-    'N',    'checksum',         # One's compliment sum of all fields minus this one.
-    'a16',  'parent_uuid',      # Parent disk UUID (for differencing disk only).
-    'N',    'parent_tstamp',    # MTime of parent disk (sec since Jan 1 2000 12:00 AM in GMT).
-    'N',    'reserved1',        # reserved, should be 0.
-    'a512', 'parent_uname',     # Parent disk filename in UNICODE (UTF-16).
-    'a24',  'parent_loc1',      # Parent locator entries.
-    'a24',  'parent_loc2',
-    'a24',  'parent_loc3',
-    'a24',  'parent_loc4',
-    'a24',  'parent_loc5',
-    'a24',  'parent_loc6',
-    'a24',  'parent_loc7',
-    'a24',  'parent_loc8',
-  ])
-
-  PARENT_LOCATOR = BinaryStruct.new([
-    'a4', 'platform_code',  # Platform specific format used for locator.
-    'N',  'data_space',     # Number of sectors used to store locator.
-    'N',  'data_length',    # Byte length of locator.
-    'N',  'reserved1',      # Must be zero.
-    'N',  'data_offset_hi', # Absolute byte offset of locator.
-    'N',  'data_offset_lo',
-  ])
-
-  BAE_SIZE = 4
-  SECTOR_LENGTH = 512
-  FOOTER_LENGTH = 512
-  HEADER_LOCATION = 512
-  BLOCK_NOT_ALLOCATED = 0xffffffff
-  SUPPORTED_HEADER_VERSION = 0x00010000
-
-  def self.connect_to_hyperv(ostruct)
-    connection  = ostruct.hyperv_connection
-    @network    = ostruct.driveType == "Network"
-    hyperv_disk = MiqHyperVDisk.new(connection[:host],
-                                    connection[:user],
-                                    connection[:password],
-                                    connection[:port],
-                                    @network)
-    hyperv_disk.open(ostruct.fileName)
-    hyperv_disk
-  end
-
-  def self.d_init_common(dInfo, file)
-    @dInfo = dInfo
-    @blockSize = SECTOR_LENGTH
-    @file = file
-
-    # Get file,  footer & header, do footer verification.
-    @footer = getFooter(@file, true)
-    @header = getHeader(@footer, true)
-    verifyFooterCopy(@footer)
-
-    # Verify footer copy.
-
-    # Verify format version number (must be 0x00010000).
-    raise "Incompatible header version: 0x#{'%04x' % @header['header_ver']}" if @header['header_ver'] != SUPPORTED_HEADER_VERSION
-
-    # Calc sectors per block, bytes in block sector bitmap & BAT loc.
-    @secPerBlock = @header['block_size'] / @blockSize
-    @blockSectorBitmapByteCount = @secPerBlock / 8
-    if (bd = @blockSectorBitmapByteCount % 512) != 0
-      @blockSectorBitmapByteCount = @blockSectorBitmapByteCount + 512 - bd
-    end
-    @batBase = getHiLo(@header, "table_offset")
-    process_bae
-  end
-
-  def self.d_read_common(pos, len, parent = nil)
-    # Get starting & ending block, sector & byte offset of read.
-    blockStart, sectorStart, byteOffsetStart = blockPos(pos)
-    blockEnd,   sectorEnd,   byteOffsetEnd   = blockPos(pos + len - 1)
-
-    # Loop on blocks (2M entities of storage).
-    buf = ""
-    (blockStart..blockEnd).each do |blockNum|
-      # Loop on sectors (512 byte entities of storage).
-      secStart = (blockNum == blockStart) ? sectorStart : 0
-      secEnd   = (blockNum == blockEnd) ? sectorEnd : @secPerBlock - 1
-      (secStart..secEnd).each do |secNum|
-        # If STARTING, need to skip to where data is
-        if (blockStart == blockEnd) && (sectorStart == sectorEnd)
-          byteOffset = byteOffsetStart
-          thisLen    = len
-        elsif (blockNum == blockStart) && (secNum == sectorStart)
-          byteOffset = byteOffsetStart
-          thisLen    = @blockSize - byteOffset
-        # If ENDING, need to account for short read
-        elsif (blockNum == blockEnd) && (secNum == sectorEnd)
-          byteOffset = 0
-          thisLen    = len - buf.length
-          raise "Internal Error: Calculated read more than sector: #{thisLen}" if thisLen > @blockSize
-          # Read ENTIRE Sector in all other cases
-        else
-          byteOffset = 0
-          thisLen   = @blockSize
-        end
-
-        # If the allocation status of this sector is 0 return zeros.
-        allocStat = getAllocStatus(blockNum, secNum)
-        if allocStat == false
-          if parent.nil?
-            buf << MemoryBuffer.create(thisLen)
-          else
-            buf << parent.d_read(pos + buf.length, thisLen)
-          end
-        else
-          @file.seek(getAbsSectorLoc(blockNum, secNum) + byteOffset, IO::SEEK_SET)
-          buf << @file.read(thisLen)
-        end
-      end
-    end
-    buf
-  end
-
-  def self.d_write_common(pos, buf, len, parent = nil)
-    # Get starting & ending block, sector & byte offset of read.
-    blockStart, sectorStart, byteOffsetStart = blockPos(pos)
-    blockEnd,   sectorEnd,   byteOffsetEnd   = blockPos(pos + len - 1)
-
-    # Loop on blocks (2M entities of storage).
-    bytesWritten = 0
-    (blockStart..blockEnd).each do |blockNum|
-      # Loop on sectors (512 byte entities of storage).
-      secStart = (blockNum == blockStart) ? sectorStart : 0
-      secEnd   = (blockNum == blockEnd) ? sectorEnd : @secPerBlock - 1
-      (secStart..secEnd).each do |secNum|
-        # If STARTING, need to skip to where data is
-        if (blockStart == blockEnd) && (sectorStart == sectorEnd)
-          byteOffset = byteOffsetStart
-          thisLen    = len
-        elsif (blockNum == blockStart) && (secNum == sectorStart)
-          byteOffset = byteOffsetStart
-          thisLen    = @blockSize - byteOffset
-          # If ENDING, need to account for short read
-        elsif (blockNum == blockEnd) && (secNum == sectorEnd)
-          byteOffset = 0
-          thisLen    = len - bytesWritten
-          raise "Internal Error: Calculated read more than sector: #{thisLen}" if thisLen > @blockSize
-          # Read ENTIRE Sector in all other cases
-        else
-          byteOffset = 0
-          thisLen   = @blockSize
-        end
-
-        # If the allocation status of this sector is 0 then allocate it.
-        allocStat = getAllocStatus(blockNum, secNum)
-        allocSector(blockNum, secNum, pos + bytesWritten, parent) if allocStat == false
-        @file.seek(getAbsSectorLoc(blockNum, secNum) + byteOffset, IO::SEEK_SET)
-        bytesWritten += @file.write(buf[bytesWritten, thisLen], thisLen)
-      end
-    end
-    bytesWritten
-  end
-
-  # Disk size in sectors.
-  def self.d_size_common
-    getHiLo(@footer, "current_size") / @blockSize
-  end
-
-  def self.getHiLo(hash, member)
-    (hash["#{member}_hi"] << 32) + hash["#{member}_lo"]
-  end
-
-  # Needed by diff disk.
-  def self.header
-    @header
-  end
-
-  def self.getFooter(file, skip_check = false)
-    # NOTE: Spec says that if checksum fails use the copy in the header.
-    #       If that fails then the disk is corrupt.
-    file.seek(file.size - FOOTER_LENGTH, IO::SEEK_SET)
-    @footerBuf = file.read(FOOTER_LENGTH)
-    footer = FOOTER.decode(@footerBuf)
-    # TODO: Find out why this checksum test is failing.  For now don't call getFooter without skip_check set to "true"
-    unless skip_check
-      footerCsum = checksum(@footerBuf, 64)
-      raise "Footer checksum doesn't match: got 0x#{'%04x' % footerCsum}, s/b 0x#{'%04x' % @footer['checksum']}" if footerCsum != footer['checksum']
-    end
-    footer
-  end
-
-  private
-
-  def self.getHeader(footer, skip_check = false)
-    hdrLoc = getHiLo(footer, "data_offset")
-    hdrSiz = HEADER.size
-    puts "VHD Header is mislocated: 0x#{'%04x' % hdrLoc} (s/b 0x0200)" if hdrLoc != HEADER_LOCATION && !skip_check
-    @file.seek(hdrLoc, IO::SEEK_SET)
-    buf = @file.read(hdrSiz)
-    header = HEADER.decode(buf)
-    # TODO: Find out why this checksum test is failing.  For now don't call getHeader without skip_check set to "true"
-    unless skip_check
-      headerCsum = checksum(buf, 36)
-      raise "Header checksum doesn't match: got 0x#{'%04x' % headerCsum}, s/b 0x#{'%04x' % @header['checksum']}" if headerCsum != header['checksum']
-    end
-    header
-  end
-
-  def self.verifyFooterCopy(footer)
-    hdrLoc = getHiLo(footer, "data_offset")
-    @file.seek(hdrLoc - FOOTER_LENGTH, IO::SEEK_SET)
-    footer_copy = FOOTER.decode(@file.read(FOOTER_LENGTH))
-    puts "Footer copy does not match header." if footer_copy != @footer
-  end
-
-  def self.blockPos(pos)
-    rawSectorNumber, byteOffset = pos.divmod(@blockSize)
-    blockNumber, secInBlock = rawSectorNumber.divmod(@secPerBlock)
-    return blockNumber, secInBlock, byteOffset
-  end
-
-  def self.process_bae
-    @file.seek(@batBase, IO::SEEK_SET)
-    @bae = []
-    1.step(@header['max_tbl_ent'], 1) do |block_num|
-      @bae << @file.read(BAE_SIZE).unpack('N')[0]
-    end
-  end
-
-  def self.getBAE(blockNumber)
-    @bae[blockNumber]
-  end
-
-  def self.putBAE(blockNum, bae)
-    seekBAE(blockNum)
-    @file.write([bae].pack('N'), BAE_SIZE)
-  end
-
-  def self.seekBAE(blockNum)
-    batOffset = blockNum * BAE_SIZE + @batBase
-    @file.seek(batOffset, IO::SEEK_SET)
-  end
-
-  def self.getAllocStatus(blockNum, sectorNum)
-    sectorMask = seekAllocStatus(blockNum, sectorNum)
-    return false if sectorMask == BLOCK_NOT_ALLOCATED
-    sectorBitmap = @file.read(1).unpack('C')[0]
-    sectorBitmap & sectorMask == sectorMask
-  end
-
-  def self.setAllocStatus(blockNum, sectorNum)
-    sectorMask = seekAllocStatus(blockNum, sectorNum)
-    sectorBitmap = @file.read(1).unpack('C')[0]
-    sectorBitmap |= sectorMask
-    @file.seek(-1, IO::SEEK_CUR)
-    @file.write([sectorBitmap].pack('C'), 1)
-  end
-
-  def self.seekAllocStatus(blockNum, sectorNum)
-    sectorByte, bitOffset = sectorNum.divmod(8)
-    bae = getBAE(blockNum)
-    return bae if bae == BLOCK_NOT_ALLOCATED
-    @file.seek(bae * @blockSize + sectorByte, IO::SEEK_SET)
-    0x80 >> bitOffset
-  end
-
-  def self.getAbsSectorLoc(blockNum, sectorNum)
-    getBAE(blockNum) * @blockSize + sectorNum * @blockSize + @blockSectorBitmapByteCount
-  end
-
-  def self.allocSector(blockNum, sectorNum, pos, parent)
-    allocBlock(blockNum) if getBAE(blockNum) == BLOCK_NOT_ALLOCATED
-    if parent.nil?
-      buf = MemoryBuffer.create(@blockSize)
-    else
-      sector = pos.divmod(@blockSize)[0]
-      buf = parent.d_read(sector, @blockSize)
-    end
-    setAllocStatus(blockNum, sectorNum)
-    @file.seek(getAbsSectorLoc(blockNum, sectorNum), IO::SEEK_SET)
-    @file.write(buf, buf.size)
-  end
-
-  def self.allocBlock(blockNum)
-    # Alloc block.
-    pos = @file.size - FOOTER_LENGTH
-    sector = findFreeSector
-    putBAE(blockNum, sector)
-    # Write sector alloc bitmap.
-    bmp = MemoryBuffer.create(@blockSectorBitmapByteCount)
-    @file.seek(sector * @blockSize, IO::SEEK_SET)
-    @file.write(bmp, bmp.size)
-    # Footer has to move. Total size is 2048 + size of data blocks.
-    pos += @secPerBlock * @blockSize
-    @file.seek(pos, IO::SEEK_SET)
-    @file.write(@footerBuf, @footerBuf.size)
-  end
-
-  def self.findFreeSector
-    # Find a free disk sector with which to start a new block.
-    if @freeSector.nil?
-      seekBAE(0); ents = @header['max_tbl_ent']
-      baes = @file.read(ents * BAE_SIZE).unpack("N#{ents}")
-      baes.delete(BLOCK_NOT_ALLOCATED)
-      raise "Disk full." if baes.size == @header['max_tbl_ent']
-      @freeSector = baes.max
-    end
-    @freeSector += @secPerBlock
-    raise "Disk full." if @freeSector > d_size_common / @blockSize
-    @freeSector
-  end
-
-  def self.checksum(buf, skip_offset)
-    csum = 0
-    0.upto(buf.size - 1) do|i|
-      next if i >= skip_offset && i < skip_offset + 4
-      csum += buf[i].to_i
-    end
-    # GRRRRR - convert to actual 32-bits.
-    [~csum].pack('L').unpack('L')[0]
-  end
-end # module

data/lib/disk/modules/MSVSDiffDisk.rb

@@ -1,85 +0,0 @@
-# encoding: US-ASCII
-
-require 'disk/modules/MSCommon'
-require 'disk/modules/miq_disk_common'
-
-module MSVSDiffDisk
-  def d_init
-    self.diskType = "MSVS Differencing"
-    self.blockSize = MSCommon::SECTOR_LENGTH
-    fileMode = MiqDiskCommon.file_mode(dInfo)
-    if dInfo.hyperv_connection
-      @hyperv_connection = dInfo.hyperv_connection
-      @ms_disk_file      = MSCommon.connect_to_hyperv(dInfo)
-    else
-      @hyperv_connection = nil
-      @ms_disk_file      = MiqLargeFile.open(dInfo.fileName, fileMode) unless dInfo.baseOnly
-    end
-    MSCommon.d_init_common(dInfo, @ms_disk_file) unless dInfo.baseOnly
-
-    # Get parent locators.
-    @locators = []
-    1.upto(8) do|idx|
-      @locators << MSCommon::PARENT_LOCATOR.decode(MSCommon.header["parent_loc#{idx}"])
-      next if @locators[idx - 1]['platform_code'] == "\000\000\000\000"
-      locator = @locators[idx - 1]
-      if locator['platform_code'] == "W2ku"
-        getParentPathWin(locator)
-        getParent(locator)
-      end
-    end
-    raise "No compatible parent locator found" if @parent == nil
-  end
-
-  def getBase
-    @parent || self
-  end
-
-  # /////////////////////////////////////////////////////////////////////////
-  # Implementation.
-
-  def d_read(pos, len)
-    MSCommon.d_read_common(pos, len, @parent)
-  end
-
-  def d_write(pos, buf, len)
-    MSCommon.d_write_common(pos, buf, len, @parent)
-  end
-
-  def d_close
-    @parent.close if @parent
-    @ms_disk_file.close
-  end
-
-  def d_size
-    total = 0
-    total = @parent.d_size if @parent
-    total += @ms_disk_file.size
-    total
-  end
-
-  # /////////////////////////////////////////////////////////////////////////
-  # // Helpers.
-
-  private
-
-  def getParent(locator)
-    if locator.key?('fileName')
-      @parent_ostruct                   = OpenStruct.new
-      @parent_ostruct.fileName          = locator['fileName']
-      @parent_ostruct.driveType         = dInfo.driveType
-      @parent_ostruct.hyperv_connection = @hyperv_connection unless @hyperv_connection.nil?
-      @parent                           = MiqDisk.getDisk(@parent_ostruct)
-    end
-  end
-
-  def getParentPathWin(locator)
-    buf = getPathData(locator)
-    locator['fileName'] = buf.UnicodeToUtf8!
-  end
-
-  def getPathData(locator)
-    @ms_disk_file.seek(MSCommon.getHiLo(locator, "data_offset"), IO::SEEK_SET)
-    @ms_disk_file.read(locator['data_length'])
-  end
-end

data/lib/disk/modules/MSVSDiskProbe.rb

@@ -1,61 +0,0 @@
-# encoding: US-ASCII
-
-require 'Scvmm/miq_hyperv_disk'
-require 'disk/modules/MiqLargeFile'
-require 'disk/modules/MSCommon'
-
-module MSVSDiskProbe
-  MS_MAGIC      = "conectix"
-
-  TYPE_FIXED    = 2
-  TYPE_DYNAMIC  = 3
-  TYPE_DIFF     = 4
-
-  MOD_FIXED     = "MSVSFixedDisk"
-  MOD_DYNAMIC   = "MSVSDynamicDisk"
-  MOD_DIFF      = "MSVSDiffDisk"
-
-  def self.probe(ostruct)
-    return nil unless ostruct.fileName
-    # If file not VHD then not Microsoft.
-    # Allow ".miq" also.
-    ext = File.extname(ostruct.fileName).downcase
-    return nil if ext != ".vhd" && ext != ".avhd" && ext != ".miq"
-
-    if ostruct.hyperv_connection
-      ms_disk_file = connect_to_hyperv(ostruct)
-    else
-      # Get (assumed) footer.
-      ms_disk_file = MiqLargeFile.open(ostruct.fileName, "rb")
-    end
-    footer = MSCommon.getFooter(ms_disk_file, true)
-    ms_disk_file.close
-
-    # Check for MS disk.
-    return nil if footer['cookie'] != MS_MAGIC
-
-    # Return module name to handle type.
-    case footer['disk_type']
-    when TYPE_FIXED
-      return MOD_FIXED
-    when TYPE_DYNAMIC
-      return MOD_DYNAMIC
-    when TYPE_DIFF
-      return MOD_DIFF
-    else
-      raise "Unsupported MS disk: #{footer['disk_type']}"
-    end
-  end
-
-  def self.connect_to_hyperv(ostruct)
-    connection  = ostruct.hyperv_connection
-    network     = ostruct.driveType == "Network"
-    hyperv_disk = MiqHyperVDisk.new(connection[:host],
-                                    connection[:user],
-                                    connection[:password],
-                                    connection[:port],
-                                    network)
-    hyperv_disk.open(ostruct.fileName)
-    hyperv_disk
-  end
-end

data/lib/disk/modules/MSVSDynamicDisk.rb

@@ -1,36 +0,0 @@
-require 'disk/modules/MSCommon'
-require 'disk/modules/miq_disk_common'
-
-module MSVSDynamicDisk
-  def d_init
-    self.diskType = "MSVS Dynamic"
-    self.blockSize = MSCommon::SECTOR_LENGTH
-    fileMode = MiqDiskCommon.file_mode(dInfo)
-    @ms_disk_file = if dInfo.hyperv_connection
-                      MSCommon.connect_to_hyperv(dInfo)
-                    else
-                      MiqLargeFile.open(dInfo.fileName, fileMode)
-                    end
-    MSCommon.d_init_common(dInfo, @ms_disk_file)
-  end
-
-  def getBase
-    self
-  end
-
-  def d_read(pos, len)
-    MSCommon.d_read_common(pos, len)
-  end
-
-  def d_write(pos, buf, len)
-    MSCommon.d_write_common(pos, buf, len)
-  end
-
-  def d_close
-    @ms_disk_file.close
-  end
-
-  def d_size
-    MSCommon.d_size_common
-  end
-end # module

data/lib/disk/modules/MSVSFixedDisk.rb

@@ -1,39 +0,0 @@
-require 'disk/modules/MiqLargeFile'
-require 'disk/modules/miq_disk_common'
-
-module MSVSFixedDisk
-  def d_init
-    @diskType = "MSVSFixed"
-    @blockSize = 512
-
-    fileMode = MiqDiskCommon.file_mode
-
-    if dInfo.hyperv_connection
-      @ms_flat_disk_file = MSCommon.connect_to_hyperv(dInfo)
-    else
-      @ms_flat_disk_file = MiqLargeFile.open(dInfo.fileName, fileMode)
-    end
-  end
-
-  def d_read(pos, len)
-    @ms_flat_disk_file.seek(pos, IO::SEEK_SET)
-    @ms_flat_disk_file.read(len)
-  end
-
-  def getBase
-    self
-  end
-
-  def d_write(pos, buf, len)
-    @ms_flat_disk_file.seek(pos, IO::SEEK_SET)
-    @ms_flat_disk_file.write(buf, len)
-  end
-
-  def d_close
-    @ms_flat_disk_file.close
-  end
-
-  def d_size
-    File.size(dInfo.fileName)
-  end
-end