manageiq-smartstate 0.8.1 → 0.9.0

data/lib/disk/modules/VhdxDisk.rb

@@ -1,629 +0,0 @@
-# encoding: US-ASCII
-
-require 'miq_unicode'
-require 'binary_struct'
-require 'disk/MiqDisk'
-require 'memory_buffer'
-require 'disk/modules/MiqLargeFile'
-require 'disk/modules/vhdx_bat_entry'
-
-module VhdxDisk
-  using ManageIQ::UnicodeString
-
-  # NOTE: All values are stored in network byte order.
-
-  VHDX_FILE_IDENTIFIER = BinaryStruct.new([
-    'Q<',   'signature',        # Always 'vhdxfile'.
-    'A256', 'creator',          # Parser that created the vhdx.
-  ])
-  SIZEOF_VHDX_FILE_IDENTIFIER        = VHDX_FILE_IDENTIFIER.size
-  VHDX_FILE_IDENTIFIER_SIGNATURE     = 0x656C696678646876
-
-  VHDX_HEADER                        = BinaryStruct.new([
-    'I<',    'signature',       # Always 'head'.
-    'I<',    'checksum',        # cfc-32c hash over entire 4 KB structure
-    'Q<',    'sequence_number', #
-    'A16',  'file_write_guid',  # Identifies the file's contents
-    'A16',  'data_write_guid',  # Identifies the user visible data
-    'A16',  'log_guid',         # Determines validity of log entries
-    'S<',    'log_version',     # The version of the log format.
-    'S<',    'version',         # The version of the VHDX format.
-    'I<',    'log_length',      # Length of the log
-    'I<',    'log_offset',      # Byte offset of the log
-    'A4016', 'reserved',        # reserved
-  ])
-  SIZEOF_VHDX_HEADER                 = VHDX_HEADER.size
-  VHDX_HEADER_OFFSET                 = 64 * 1024
-  VHDX_HEADER_SIGNATURE              = 0x64616568
-  VHDX_HEADER2_OFFSET                = 2 * 64 * 1024
-
-  VHDX_REGION_TABLE_HEADER           = BinaryStruct.new([
-    'I<',  'signature',         # Always 'regi'.
-    'I<',  'checksum',          # cfc-32c hash over entire 4 KB structure
-    'I<',  'entry_count',       # Number of Region Table entries
-    'I<',  'reserved',          # reserved
-  ])
-  SIZEOF_VHDX_REGION_TABLE_HEADER    = VHDX_REGION_TABLE_HEADER.size
-  VHDX_REGION_TABLE_HEADER_OFFSET    = 64 * 1024
-  VHDX_REGION_TABLE_HEADER_SIGNATURE = 0x69676572
-
-  VHDX_REGION_TABLE_ENTRY            = BinaryStruct.new([
-    'A16',  'guid',             # GUID must be unique within the table
-    'Q<',   'file_offset',      # offset of the Region Table entry (1MB multiples)
-    'I<',   'length',           # Byte length of the object (1MB multiples)
-    'I<',   'required',         # 1st bit is required, 31 remaining bits reserved
-  ])
-  SIZEOF_VHDX_REGION_TABLE_ENTRY     = VHDX_REGION_TABLE_ENTRY.size
-  REGION_TABLE_BAT_GUID              = 0x2DC27766F62342009D64115E9BFD4A08
-  REGION_TABLE_METADATA_GUID         = 0x8B7CA20647904B9AB8FE575F050F886E
-
-  VHDX_BAT_STATE_ENTRY               = BinaryStruct.new([
-    'B8',    'state',             # least significant three bits only
-    'B8',    'reserved',
-    'B48',   'file_offset_mb'     # the offset within the file in units of 1 MB
-  ])
-  VHDX_BAT_ENTRY = BinaryStruct.new([
-    'Q<',    'file_offset_mb',    # most significant 44 bits only
-  ])
-  SIZEOF_VHDX_BAT_ENTRY              = VHDX_BAT_ENTRY.size
-  BAT_OFFSET_MASK                    = 0x00000FFFFFFFFFFF
-  BAT_OFFSET_SHIFT                   = 20
-  BAT_OFFSET_UNITS                   = 1024 * 1024 # units for fill_offset_mb field
-
-  PAYLOAD_BLOCK_NOT_PRESENT          = 0
-  PAYLOAD_BLOCK_UNDEFINED            = 1
-  PAYLOAD_BLOCK_ZERO                 = 2
-  PAYLOAD_BLOCK_UNMAPPED             = 3
-  PAYLOAD_BLOCK_FULLY_PRESENT        = 6
-  PAYLOAD_BLOCK_PARTIALLY_PRESENT    = 7
-
-  SB_BLOCK_NOT_PRESENT               = 0
-  SB_BLOCK_PRESENT                   = 6
-  SECTOR_BITMAP_BLOCKSIZE            = 1024 * 1024
-
-  VHDX_METADATA_TABLE_HEADER         = BinaryStruct.new([
-    'Q<',   'signature',        # Always 'metadata'
-    'S<',   'reserved',         #
-    'S<',   'entry_count',      # number of entries in the table
-    'I5',   'reserved2',        #
-  ])
-  SIZEOF_VHDX_METADATA_TABLE_HEADER    = VHDX_METADATA_TABLE_HEADER.size
-  VHDX_METADATA_TABLE_HEADER_SIGNATURE = 0x617461646174656D
-
-  VHDX_METADATA_TABLE_ENTRY            = BinaryStruct.new([
-    'A16', 'item_id',           # item_id and isuser pair must be unique within the table
-    'I<',   'offset',           # offset relative to beginning of the metadata region >= 64KB
-    'I<',   'length',           # < = 1MB
-    'b32',  'bit_fields',
-    # 'B1', 'is_user',          # system or user metadata
-    # 'B1', 'is_virtual_disk',  # file or virtual disk metadata
-    # 'B1', 'is_required',      #
-    # 'B29', 'reserved',
-    'I<',   'reserved2'
-  ])
-  SIZEOF_VHDX_METADATA_TABLE_ENTRY   = VHDX_METADATA_TABLE_ENTRY.size
-
-  FILE_PARAMETERS_GUID               = 0xCAA16737FA364D43B3B633F0AA44E76B
-  VIRTUAL_DISK_SIZE_GUID             = 0x2FA54224CD1B4876B2115DBED83BF4B8
-  PAGE_83_DATA_GUID                  = 0xBECA12ABB2E6452393EFC309E000C746
-  LOGICAL_SECTOR_SIZE_GUID           = 0x8141BF1DA96F4709BA47F233A8FAAB5F
-  PHYSICAL_SECTOR_SIZE_GUID          = 0xCDA348C7445D44719CC9E9885251C556
-  PARENT_LOCATOR_GUID                = 0xA8D35F2DB30B454DABF7D3D84834AB0C
-
-  METADATA_OPS                       = {
-    FILE_PARAMETERS_GUID      => :file_parameters,
-    VIRTUAL_DISK_SIZE_GUID    => :virtual_disk_size,
-    PAGE_83_DATA_GUID         => :page_83_data,
-    LOGICAL_SECTOR_SIZE_GUID  => :logical_sector_size,
-    PHYSICAL_SECTOR_SIZE_GUID => :physical_sector_size,
-    PARENT_LOCATOR_GUID       => :parent_locator_header
-  }
-
-  ALLOCATION_STATUS = {
-    PAYLOAD_BLOCK_NOT_PRESENT       => PAYLOAD_BLOCK_NOT_PRESENT,
-    PAYLOAD_BLOCK_UNDEFINED         => nil,
-    PAYLOAD_BLOCK_ZERO              => nil,
-    PAYLOAD_BLOCK_UNMAPPED          => nil,
-    PAYLOAD_BLOCK_FULLY_PRESENT     => PAYLOAD_BLOCK_FULLY_PRESENT,
-    PAYLOAD_BLOCK_PARTIALLY_PRESENT => PAYLOAD_BLOCK_PARTIALLY_PRESENT
-  }
-
-  VHDX_FILE_PARAMETERS = BinaryStruct.new([
-    'I<',  'block_size', # size of payload block in bytes between 1MB & 256MB
-    'b32', 'bit_fields',
-    # 'B1',  'leave_blocks_allocated',
-    # 'B1',  'has_parent',
-    # 'B30', 'reserved',
-  ])
-  SIZEOF_VHDX_FILE_PARAMETERS        = VHDX_FILE_PARAMETERS.size
-
-  VHDX_VIRTUAL_DISK_SIZE             = BinaryStruct.new([
-    'Q<', 'virtual_disk_size' # size in bytes.  must be a multiple of logical sector size
-  ])
-  SIZEOF_VHDX_VIRTUAL_DISK_SIZE = VHDX_VIRTUAL_DISK_SIZE.size
-
-  VHDX_LOGICAL_SECTOR_SIZE = BinaryStruct.new([
-    'I<', 'logical_sector_size' # size in bytes.  must be 512 or 4096
-  ])
-  SIZEOF_VHDX_LOGICAL_SECTOR_SIZE = VHDX_LOGICAL_SECTOR_SIZE.size
-
-  VHDX_PHYSICAL_SECTOR_SIZE = BinaryStruct.new([
-    'I<', 'physical_sector_size' # size in bytes.  must be 512 or 4096
-  ])
-  SIZEOF_VHDX_PHYSICAL_SECTOR_SIZE   = VHDX_PHYSICAL_SECTOR_SIZE.size
-
-  VHDX_PAGE_83_DATA                  = BinaryStruct.new([
-    'A16', 'page_83_data' # unique guid
-  ])
-  SIZEOF_VHDX_PAGE_83_DATA           = VHDX_PAGE_83_DATA.size
-
-  VHDX_PARENT_LOCATOR_HEADER         = BinaryStruct.new([
-    'A16', 'locator_type',      # guid with type of the parent virtual disk
-    'S<',   'reserved',
-    'S<',   'key_value_count',  # number of key-value pairs for the parent locator
-  ])
-  SIZEOF_VHDX_PARENT_LOCATOR_HEADER  = VHDX_PARENT_LOCATOR_HEADER.size
-  VHDX_PARENT_LOCATOR_TYPE_GUID      = 0xB04AEFB7D19E4A81B78925B8E9445913
-
-  VHDX_PARENT_LOCATOR_ENTRY          = BinaryStruct.new([
-    'I<',   'key_offset',       # offset within the metadata item of key
-    'I<',   'value_offset',     # offset within the metadata item of value
-    'S<',   'key_length',       # length of the entry's key
-    'S<',   'value_length',     # length of the entry's value
-  ])
-  SIZEOF_VHDX_PARENT_LOCATOR_ENTRY = VHDX_PARENT_LOCATOR_ENTRY.size
-
-  attr_reader :file_identifier_signature, :vhdx_header_signature, :dInfo
-  def d_init
-    @diskType             = "Vhdx"
-    @blockSize            = 0
-    @virtual_disk_size    = 0
-    @logical_sector_size  = 0
-    @physical_sector_size = 0
-    @payload_block_size   = 0
-    @has_parent           = nil
-    @parent_locator       = nil
-    @file_name            = dInfo.fileName
-    @scvmm                = dInfo.scvmm
-    @hyperv_connection    = nil
-    @vhdx_file            = connection_to_file(dInfo)
-    @converter            = Encoding::Converter.new("UTF-16LE", "UTF-8")
-    header_section
-  end
-
-  def connection_to_file(dInfo)
-    if dInfo.mountMode.nil? || dInfo.mountMode == "r"
-      dInfo.mountMode     = "r"
-      file_mode           = "r"
-    elsif dInfo.mountMode == "rw"
-      file_mode           = "r+"
-    else
-      raise "Unrecognized mountMode: #{dInfo.mountMode}"
-    end
-    if dInfo.hyperv_connection
-      @vhdx_file = connect_to_hyperv(dInfo)
-    else
-      @vhdx_file = MiqLargeFile.open(@file_name, file_mode)
-    end
-    @vhdx_file
-  end
-
-  def d_read(pos, len)
-    raise "VhdxDisk.d_read Invalid len #{len} #{@has_parent ? "Checkpoint Disk" : "Parent Disk"}\n #{caller}" if len < 0
-    $log.debug "VhdxDisk.d_read(#{pos}, #{len})"
-    buf = ""
-    return buf if len == 0
-    block_start, sector_start, byte_offset_start = block_pos(pos)
-    block_end,   sector_end,   _byte_offset_end  = block_pos(pos + len - 1)
-    byte_offset = 0
-    this_len    = @blockSize
-    (block_start..block_end).each do |block_number|
-      real_sector_start = (block_number == block_start) ? sector_start : 0
-      real_sector_end   = (block_number == block_end) ? sector_end : @sectors_per_block - 1
-      allocation_status = get_allocation_status(block_number)
-      bat_offset        = bat_offset(block_number)
-      (real_sector_start..real_sector_end).each do |sector_number|
-        if (block_start == block_end) && (sector_start == sector_end)
-          byte_offset = byte_offset_start
-          this_len    = len
-        elsif (block_number == block_start) && (sector_number == sector_start)
-          byte_offset = byte_offset_start
-          this_len    = @blockSize - byte_offset
-        elsif (block_number == block_end) && (sector_number == sector_end)
-          byte_offset = 0
-          this_len    = len - buf.length
-          raise "Internal Error: Calculated read more than sector: #{this_len}" if this_len > @blockSize
-        else
-          byte_offset = 0
-          this_len    = @blockSize
-        end
-        if allocation_status.nil? || allocation_status == PAYLOAD_BLOCK_NOT_PRESENT
-          buf << read_unallocated_buf(pos, this_len, buf, allocation_status == PAYLOAD_BLOCK_NOT_PRESENT)
-        else
-          if allocation_status == PAYLOAD_BLOCK_PARTIALLY_PRESENT
-            sector_status = get_sector_allocation_status(block_number, sector_number)
-            $log.debug "PAYLOAD_BLOCK_PARTIALLY_PRESENT & sector_status #{sector_status} for sector #{sector_number}"
-            if sector_status == false
-              buf << read_unallocated_buf(pos, this_len, buf, true)
-              next
-            end
-          end
-          byte_offset += sector_number * @logical_sector_size
-          @vhdx_file.seek(bat_offset + byte_offset, IO::SEEK_SET)
-          buf << @vhdx_file.read(this_len)
-        end
-      end
-    end
-    buf
-  end
-
-  def d_write(pos, buf, len)
-    @vhdx_file.seek(pos, IO::SEEK_SET)
-    @vhdx_file.write(buf, len)
-  end
-
-  def d_close
-    @vhdx_file.close
-  end
-
-  # Disk size in sectors.
-  def d_size
-    @virtual_disk_size / @logical_sector_size
-  end
-
-  def getBase
-    self
-  end
-
-  private
-
-  def read_unallocated_buf(pos, len, buf, status)
-    if status == true && @has_parent == true
-      return @parent.d_read(pos + buf.length, len)
-    else
-      return MemoryBuffer.create(len)
-    end
-  end
-
-  def header_section
-    @file_identifier       = file_identifier
-    @vhdx_header           = header(1)
-    unless valid_header_signature?
-      $log.info "Invalid VHDX Header Signature #{@vhdx_header_signature}"
-      @vhdx_header = header(2)
-    end
-    raise "Invalid VHDX Header Signature #{@vhdx_header_signature}" unless valid_header_signature?
-    @region_table_header = region_table(1)
-    unless valid_region_table_header?
-      $log.info "Invalid Region Table Header Signature #{@region_table_header_signature}"
-      @region_table_header = header(2)
-    end
-    raise "Invalid Region Table Header Signature #{@region_table_header_signature}" unless valid_region_table_header?
-  end
-
-  def file_identifier
-    @vhdx_file.seek(0, IO::SEEK_SET)
-    file_identifier            = VHDX_FILE_IDENTIFIER.decode(@vhdx_file.read(SIZEOF_VHDX_FILE_IDENTIFIER))
-    @file_identifier_signature = file_identifier['signature']
-    raise "Invalid VHDX File Identifier Signature #{@file_identifier_signature}" unless valid_file_identifier_signature?
-    file_identifier
-  end
-
-  def valid_file_identifier_signature?
-    @file_identifier_signature == VHDX_FILE_IDENTIFIER_SIGNATURE
-  end
-
-  def header(header_number)
-    @vhdx_file.seek(header_number * VHDX_HEADER_OFFSET, IO::SEEK_SET)
-    vhdx_header            = VHDX_HEADER.decode(@vhdx_file.read(SIZEOF_VHDX_HEADER))
-    @vhdx_header_signature = vhdx_header['signature']
-    vhdx_header
-  end
-
-  def valid_header_signature?
-    @vhdx_header_signature == VHDX_HEADER_SIGNATURE
-  end
-
-  def region_table(table_number)
-    table_offset = 2 * VHDX_HEADER_OFFSET + table_number * VHDX_REGION_TABLE_HEADER_OFFSET
-    header       = region_table_header(table_offset)
-    return if header.nil?
-    (1..header['entry_count']).each do |count|
-      process_region_table_entry(table_offset, count)
-    end
-    process_metadata_table_header
-    process_bat
-  end
-
-  def region_table_header(table_offset)
-    @vhdx_file.seek(table_offset, IO::SEEK_SET)
-    region_table_header = VHDX_REGION_TABLE_HEADER.decode(@vhdx_file.read(SIZEOF_VHDX_REGION_TABLE_HEADER))
-    @region_table_header_signature = region_table_header['signature']
-    unless valid_region_table_header?
-      $log.info "Invalid Region Table Header #{@region_table_header_signature}"
-      return nil
-    end
-    unless region_table_header['entry_count'] > 0
-      $log.warn "Invalid Region Table Entry Count #{region_table_header['entry_count']}"
-      return nil
-    end
-    region_table_header
-  end
-
-  def valid_region_table_header?
-    @region_table_header_signature == VHDX_REGION_TABLE_HEADER_SIGNATURE
-  end
-
-  def process_region_table_entry(table_offset, count)
-    table_entry        = region_table_entry(table_offset, count)
-    region_table_guid  = table_entry['guid']
-    file_offset        = table_entry['file_offset']
-    length             = table_entry['length']
-    if guid_match?(region_table_guid, REGION_TABLE_BAT_GUID)
-      @bat_offset      = file_offset
-      @bat_length      = length
-    elsif guid_match?(region_table_guid, REGION_TABLE_METADATA_GUID)
-      @metadata_offset = file_offset
-      @metadata_length = length
-    else
-      raise "Invalid Region Table GUID Type #{region_table_guid}"
-    end
-  end
-
-  def region_table_entry(table_offset, count)
-    offset_to_entry = table_offset + SIZEOF_VHDX_REGION_TABLE_HEADER + (count - 1) * SIZEOF_VHDX_REGION_TABLE_ENTRY
-    @vhdx_file.seek(offset_to_entry, IO::SEEK_SET)
-    VHDX_REGION_TABLE_ENTRY.decode(@vhdx_file.read(SIZEOF_VHDX_REGION_TABLE_ENTRY))
-  end
-
-  def process_bat
-    @vhdx_file.seek(@bat_offset, IO::SEEK_SET)
-    @bat = []
-    1.step(@total_bat_entries, 1) do |block_num|
-      encoded_bat_entry    = @vhdx_file.read(SIZEOF_VHDX_BAT_ENTRY)
-
-      next_bat_state_entry = VHDX_BAT_STATE_ENTRY.decode(encoded_bat_entry)
-      state                = next_bat_state_entry['state'][5..7].to_i(2) # 3 least significant bits
-
-      next_bat_entry       = VHDX_BAT_ENTRY.decode(encoded_bat_entry)
-      file_offset_mb       = (next_bat_entry['file_offset_mb'] >> BAT_OFFSET_SHIFT) & BAT_OFFSET_MASK
-
-      entry = VhdxBatEntry.new(block_num, state, file_offset_mb)
-      @bat << entry
-    end
-  end
-
-  def compute_bat_offset(offset_bits)
-    (offset_bits & BAT_OFFSET_MASK) >> BAT_OFFSET_SHIFT
-  end
-
-  def process_metadata_table_header
-    @vhdx_file.seek(@metadata_offset, IO::SEEK_SET)
-    metadata_table_header = VHDX_METADATA_TABLE_HEADER.decode(@vhdx_file.read(SIZEOF_VHDX_METADATA_TABLE_HEADER))
-    signature             = metadata_table_header['signature']
-    count                 = metadata_table_header['entry_count']
-    raise "Invalid Metadata Header Signature #{signature}" unless signature == VHDX_METADATA_TABLE_HEADER_SIGNATURE
-    raise "Invalid Metadata Header Entry Count #{count}" unless count > 0
-    (1..count).each do |i|
-      process_metadata_table_entry(i)
-    end
-    raise "Invalid or Missing Metadata Table Entries" unless valid_metadata_table?
-    post_process_metadata
-  end
-
-  def post_process_metadata
-    @chunk_ratio                = (2**23 * @logical_sector_size) / @payload_block_size
-    @data_blocks_count          = (@virtual_disk_size.to_f / @payload_block_size).ceil
-    @sector_bitmap_blocks_count = (@data_blocks_count.to_f / @chunk_ratio).ceil
-    @sectors_per_block          = @payload_block_size / @logical_sector_size
-    @total_bat_entries          = if @has_parent
-                                    @sector_bitmap_blocks_count * (@chunk_ratio + 1)
-                                  else
-                                    @data_blocks_count + ((@data_blocks_count - 1) / @chunk_ratio).floor
-                                  end
-  end
-
-  def process_metadata_table_entry(entry_number)
-    entry_offset = @metadata_offset + SIZEOF_VHDX_METADATA_TABLE_HEADER +
-                   (entry_number - 1) * SIZEOF_VHDX_METADATA_TABLE_ENTRY
-    @vhdx_file.seek(entry_offset, IO::SEEK_SET)
-    metadata_table_entry = VHDX_METADATA_TABLE_ENTRY.decode(@vhdx_file.read(SIZEOF_VHDX_METADATA_TABLE_ENTRY))
-    guid             = metadata_table_entry['item_id']
-    offset           = @metadata_offset + metadata_table_entry['offset']
-    length           = metadata_table_entry['length']
-    bits             = metadata_table_entry['bit_fields']
-    @is_user         = bits[0].to_i(2)
-    @is_virtual_disk = bits[1].to_i(2)
-    @is_required     = bits[2].to_i(2)
-    if length == 0
-      raise "Invalid Metadata Table Entry - Length Zero and Offset is #{offset}" if offset != 0
-      $log.debug "Metadata Table Entry Present but Empty"
-      return
-    end
-    @vhdx_file.seek(offset, IO::SEEK_SET)
-    guid_found = nil
-    METADATA_OPS.each do |meta_guid, op|
-      next unless guid_match?(guid, meta_guid)
-      method(op).call(offset)
-      guid_found = guid
-      break
-    end
-    raise "Invalid Metadata Table Entry GUID #{guid}" unless guid_found
-  end
-
-  def file_parameters(_offset)
-    file_parameters_entry   = VHDX_FILE_PARAMETERS.decode(@vhdx_file.read(SIZEOF_VHDX_FILE_PARAMETERS))
-    @payload_block_size     = file_parameters_entry['block_size']
-    bits                    = file_parameters_entry['bit_fields']
-    @leave_blocks_allocated = bits[0].to_i(2) == 1
-    @has_parent             = bits[1].to_i(2) == 1
-    $log.debug "Payload Block Size #{@payload_block_size} Leave Blocks Allocated #{@leave_blocks_allocated}"
-    $log.debug "Has Parent #{@has_parent}"
-  end
-
-  def virtual_disk_size(_offset)
-    virtual_disk_metadata = VHDX_VIRTUAL_DISK_SIZE.decode(@vhdx_file.read(SIZEOF_VHDX_VIRTUAL_DISK_SIZE))
-    @virtual_disk_size    = virtual_disk_metadata['virtual_disk_size']
-    $log.debug "Virtual Disk Size #{@virtual_disk_size}"
-  end
-
-  def page_83_data(_offset)
-    page_83_metadata = VHDX_PAGE_83_DATA.decode(@vhdx_file.read(SIZEOF_VHDX_PAGE_83_DATA))
-    @page_83_data    = page_83_metadata['page_83_data']
-    $log.debug "Page 83 Data #{@page_83_data}"
-  end
-
-  def logical_sector_size(_offset)
-    logical_sector_metadata = VHDX_LOGICAL_SECTOR_SIZE.decode(@vhdx_file.read(SIZEOF_VHDX_LOGICAL_SECTOR_SIZE))
-    @logical_sector_size    = logical_sector_metadata['logical_sector_size']
-    @blockSize              = @logical_sector_size
-    $log.debug "Logical Sector Size (blockSize) #{@logical_sector_size}"
-  end
-
-  def physical_sector_size(_offset)
-    physical_sector_metadata = VHDX_PHYSICAL_SECTOR_SIZE.decode(@vhdx_file.read(SIZEOF_VHDX_PHYSICAL_SECTOR_SIZE))
-    @physical_sector_size    = physical_sector_metadata['physical_sector_size']
-    $log.debug "Physical Sector Size #{@physical_sector_size}"
-  end
-
-  def parent_locator_header(offset)
-    raise "Inconsistent filesystem - \'Has_Parent\' Flag unset but Parent Locator Info Present" if @has_parent == false
-    @parent_locator         = VHDX_PARENT_LOCATOR_HEADER.decode(@vhdx_file.read(SIZEOF_VHDX_PARENT_LOCATOR_HEADER))
-    @parent_locator_entries = {}
-    key_value_count         = @parent_locator['key_value_count']
-    guid                    = @parent_locator['locator_type']
-    raise "Invalid Parent Locator Type Guid #{guid}" unless guid_match?(guid, VHDX_PARENT_LOCATOR_TYPE_GUID)
-    return if key_value_count == 0
-    (1..key_value_count).each do |i|
-      @vhdx_file.seek(offset + SIZEOF_VHDX_PARENT_LOCATOR_HEADER +
-                     (i - 1) * SIZEOF_VHDX_PARENT_LOCATOR_ENTRY, IO::SEEK_SET)
-      process_parent_locator_entry(offset)
-    end
-    keys = @parent_locator_entries.keys
-    $log.warn "Missing \"parent_linkage\" Parent Locator Entry" if keys.index("parent_linkage").nil?
-    parent_locators_to_path(keys)
-  end
-
-  def parent_locators_to_path(keys)
-    if keys.index("absolute_win32_path")
-      parent_path = strip_path_prefix(@parent_locator_entries["absolute_win32_path"])
-    elsif keys.index("relative_path")
-      parent_path = File.dirname(@file_name) + '/' + @parent_locator_entries["relative_path"]
-    elsif keys.index("volume_path")
-      # TODO: Test Volume Path Parent Locator
-      parent_path = strip_path_prefix(@parent_locator_entries["volume_path"])
-    else
-      raise "Missing Parent Locator entries \"relative_path\", \"volume_path\", and \"absolute_win32_path\""
-    end
-    @parent = parent_disk(parent_path)
-  end
-
-  def parent_disk(path)
-    @parent_ostruct                   = OpenStruct.new
-    @parent_ostruct.fileName          = path
-    @parent_ostruct.scvmm             = @scvmm
-    @parent_ostruct.driveType         = @scvmm.get_drivetype(path)
-    @parent_ostruct.hyperv_connection = @hyperv_connection if @hyperv_connection
-    parent                            = MiqDisk.getDisk(@parent_ostruct)
-    raise "Unable to access parent disk #{path}" if parent.nil?
-    $log.debug "Got #{path} as Parent disk of #{@file_name}"
-    parent
-  end
-
-  def strip_path_prefix(path)
-    path[0, 4] == "\\\\?\\" ? path[4..-1] : path
-  end
-
-  def process_parent_locator_entry(offset)
-    entry = VHDX_PARENT_LOCATOR_ENTRY.decode(@vhdx_file.read(SIZEOF_VHDX_PARENT_LOCATOR_ENTRY))
-    @vhdx_file.seek(offset + entry['key_offset'], IO::SEEK_SET)
-    key = @converter.convert(@vhdx_file.read(entry['key_length'])).gsub(/\"/, '')
-    @vhdx_file.seek(offset + entry['value_offset'], IO::SEEK_SET)
-    value = @converter.convert(@vhdx_file.read(entry['value_length'])).gsub(/\"/, '')
-    @parent_locator_entries[key] = value
-  end
-
-  def valid_metadata_table?
-    if @virtual_disk_size > 0 && @payload_block_size > 0 && @logical_sector_size > 0 && @physical_sector_size > 0
-      return true
-    end
-    $log.warn "Disk Size #{@virtual_disk_size}"
-    $log.warn "Block Size #{@blockSize}"
-    $log.warn "Logical Sector Size #{@logical_sector_size}"
-    $log.warn "Physical Sector Size #{physical_sector_size}"
-    false
-  end
-
-  def guid_match?(input, guid)
-    new_guid = ""
-    input.unpack("I<S<S<C8").each do |x|
-      if x < 16
-        new_guid += "0#{x.to_s(16)}"
-      else
-        new_guid += x.to_s(16)
-      end
-    end
-    new_guid == guid.to_s(16)
-  end
-
-  def block_pos(pos)
-    raw_sector, byte_offset       = pos.divmod(@blockSize)
-    block_number, sector_in_block = raw_sector.divmod(@sectors_per_block)
-    return block_number, sector_in_block, byte_offset
-  end
-
-  def get_allocation_status(block_number)
-    allocation_status = bat_status(block_number)
-    if allocation_status == PAYLOAD_BLOCK_PARTIALLY_PRESENT
-      raise "Invalid status PAYLOAD_BLOCK_PARTIALLY_PRESENT for BAT block number #{block_number}" unless @has_parent
-    end
-    ALLOCATION_STATUS[allocation_status]
-  end
-
-  def get_sector_allocation_status(block_number, sector_number)
-    sector_bitmap_status = bitmap_status(block_number)
-    raise "Invalid Sector Bitmap Status #{sector_bitmap_status}" unless sector_bitmap_status == SB_BLOCK_PRESENT
-    sector_bitmap_offset    = bitmap_offset(block_number)
-    sector_byte, bit_offset = sector_number.divmod(8)
-    @vhdx_file.seek(sector_bitmap_offset + sector_byte, IO::SEEK_SET)
-    sector_mask   = 0x80 >> bit_offset
-    sector_bitmap = @vhdx_file.read(1).unpack("C")[0]
-    sector_bitmap & sector_mask == sector_mask
-  end
-
-  def bat_status(block_number)
-    @bat[bat_entry_number(block_number)].state
-  end
-
-  def bat_offset(block_number)
-    @bat[bat_entry_number(block_number)].offset * BAT_OFFSET_UNITS
-  end
-
-  def bat_entry_number(block_number)
-    block_number + block_number / @chunk_ratio
-  end
-
-  def bitmap_status(block_number)
-    @bat[bitmap_entry_number(block_number)].state
-  end
-
-  def bitmap_offset(block_number)
-    @bat[bitmap_entry_number(block_number)].offset * BAT_OFFSET_UNITS
-  end
-
-  def bitmap_entry_number(block_number)
-    (block_number / @chunk_ratio) * (@chunk_ratio + 1) + @chunk_ratio
-  end
-
-  def connect_to_hyperv(disk_info)
-    connection  = @hyperv_connection = disk_info.hyperv_connection
-    @network    = disk_info.driveType == "Network"
-    hyperv_disk = MiqHyperVDisk.new(connection[:host],
-                                    connection[:user],
-                                    connection[:password],
-                                    connection[:port],
-                                    @network)
-    hyperv_disk.open(@file_name)
-    hyperv_disk
-  end
-end

data/lib/disk/modules/VhdxDiskProbe.rb

@@ -1,46 +0,0 @@
-# encoding: US-ASCII
-
-require 'Scvmm/miq_hyperv_disk'
-
-VHDX_DISK      = "VhdxDisk"
-VHDX_SIGNATURE = "vhdxfile"
-
-module VhdxDiskProbe
-  def self.probe(ostruct)
-    return nil unless ostruct.fileName
-    # If file not VHD then not Microsoft.
-    # Allow ".miq" also.
-    extended = false
-    ext = File.extname(ostruct.fileName).downcase
-    extended = true if ext == ".vhdx" || ext == ".avhdx"
-    return nil unless extended
-
-    if ostruct.hyperv_connection
-      vhdx_disk_file = connect_to_hyperv(ostruct)
-    else
-      vhdx_disk_file = File.new(ostruct.fileName, "rb")
-    end
-    rv = do_probe(vhdx_disk_file)
-    vhdx_disk_file.close
-    rv
-  end
-
-  def self.do_probe(io)
-    io.seek(0)
-    magic = io.read(8)
-    return VHDX_DISK if magic == VHDX_SIGNATURE
-    nil
-  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