lib/VolumeManager/MiqLdm.rb
# encoding: US-ASCII
# Windows dynamic disks
#
require 'ostruct'
require 'binary_struct'
require 'uuidtools'
class BinaryStruct
def self.stepDecode(data, format)
type = format[0, 1]
raise "unrecognized format: #{type}" if SIZES.key?(type) == false
raise "unsupported format: #{type}" if SIZES[type].nil?
count = (format.size > 1) ? format[1, format.size - 1].to_i : 1
raise "unsupported count: #{count}" if count.kind_of?(Numeric) == false
size = (count * SIZES[type])
data.slice!(0, size).unpack(format)[0]
end
end
module LdmScanner
LDM_SECTOR_SIZE = 512
LDM_PARTITION_TYPE = 66
PRIVHEAD_OFFSET = 6 * LDM_SECTOR_SIZE
#
# On disk, all numbers are in big-endian format.
#
PRIVHEAD = [
'a8', 'signature', # 8
'N', 'unknown_1', # 4
'n', 'ver_major', # 2
'n', 'ver_minor', # 2
'Q', 'timestamp', # 8
'Q', 'unknown_2', # 8 number ?
'Q', 'unknown_3', # 8 size ?
'Q', 'unknown_4', # 8 size ?
'a64', 'disk_id', # 64 zero padded
'a64', 'host_id', # 64 zero padded
'a64', 'diskgroup_id', # 64 zero padded
'a32', 'diskgroup_name', # 32 zero padded
'a2', 'unknown_5', # 2
'a9', 'unknown_6', # 9 zeros
'N', 'logical_disk_start_H', # 8
'N', 'logical_disk_start_L', # "
'N', 'logical_disk_size_H', # 8
'N', 'logical_disk_size_L', # "
'N', 'db_start_H', # 8
'N', 'db_start_L', # "
'N', 'db_size_H', # 8
'N', 'db_size_L', # "
'N', 'num_tocs_H', # 8
'N', 'num_tocs_L', # "
'N', 'toc_size_H', # 8
'N', 'toc_size_L', # "
'N', 'num_configs', # 4
'N', 'num_logs', # 4
'N', 'config_size_H', # 8
'N', 'config_size_L', # "
'N', 'log_size_H', # 8
'N', 'log_size_L', # "
'N', 'disk_signature', # 4
'C16', 'disk_set_guid', # 16
'C16', 'disk_set_guid2', # 16
"C#{512 - 391}", 'padding' # Pad to 512 bytes (sector size)
]
TBLOCK_BLOCK = [1, 2, 2045, 2046]
TOCBLOCK = [
'a8', 'signature',
'N', 'sequence1',
'a4', 'unknown1',
'N', 'sequence2',
'a16', 'unknown2',
'a10', 'bitmap1_name',
'N', 'bitmap1_start_H',
'N', 'bitmap1_start_L',
'N', 'bitmap1_size_H',
'N', 'bitmap1_size_L',
'N', 'bitmap1_flags_H',
'N', 'bitmap1_flags_L',
'a10', 'bitmap2_name',
'N', 'bitmap2_start_H',
'N', 'bitmap2_start_L',
'N', 'bitmap2_size_H',
'N', 'bitmap2_size_L',
'N', 'bitmap2_flags_H',
'N', 'bitmap2_flags_L',
"C#{512 - 104}", 'padding'
]
VMDB = [
'a4', 'signature',
'N', 'sequence',
'N', 'vblk_size',
'N', 'vblk_offset',
'n', 'unknown1',
'n', 'ver_major',
'n', 'ver_minor',
'a31', 'dg_name',
'a64', 'dg_guid',
'N', 'committed_seq_H',
'N', 'committed_seq_L',
'N', 'pending_seq_H',
'N', 'pending_seq_L',
'a56', 'unknown2',
'N', 'timestamp',
"C#{512 - 193}", 'padding'
]
VBLK = [
'a4', 'signature',
'N', 'vmdb_seq',
'N', 'grpnum',
'n', 'record',
'n', 'nrecords',
'n', 'update_status',
'C', 'flags',
'C', 'rec_type',
'N', 'data_length',
"a#{128 - 24}", 'padding'
]
#
# VBLOCK types.
#
VBT_NONE = 0x00
VBT_COMPONENT = 0x32
VBT_PARTITION = 0x33
VBT_DISKV1 = 0x34
VBT_DISKGROUPV1 = 0x35
VBT_DISKV2 = 0x44
VBT_DISKGROUPV2 = 0x45
VBT_VOLUME = 0x51
VBLK_TYPES = {
VBT_NONE => "NONE",
VBT_COMPONENT => "Component",
VBT_PARTITION => "Partition",
VBT_DISKV1 => "Disk v1",
VBT_DISKGROUPV1 => "Disk Group v1",
VBT_DISKV2 => "Disk v2",
VBT_DISKGROUPV2 => "Disk Group v2",
VBT_VOLUME => "Volume"
}
def self.scan(d)
return nil if d.partType != LDM_PARTITION_TYPE
d.seek(PRIVHEAD_OFFSET)
ph = readStruct(d, PRIVHEAD)
# LdmScanner.dumpPrivhead(ph)
return nil if ph.signature != "PRIVHEAD"
ph.disk_id.delete!("\000")
ph.diskgroup_id.delete!("\000")
ph.diskgroup_name.delete!("\000")
ph.host_id.delete!("\000")
ph.lvm_type = "LDM"
ph.pv_uuid = ph.disk_id
ph.diskObj = d
tb = nil
TBLOCK_BLOCK.each do |tbo|
tblock_offset = (ph.db_start + tbo) * LDM_SECTOR_SIZE
d.seek(tblock_offset)
tb = readStruct(d, TOCBLOCK)
# LdmScanner.dumpTocblock(tb)
break if tb.signature == "TOCBLOCK"
end
unless tb
$log.warn "LdmScanner: could not find valid TOCBLOCK on LDM disk" if $log
return nil
end
vmdb_offset = (ph.db_start + tb.bitmap1_start) * LDM_SECTOR_SIZE
d.seek(vmdb_offset)
vmdb = readStruct(d, VMDB)
ph.vblkHash = {}
ph.volumes = []
ph.diskVb = nil
(0...vmdb.sequence).each { |_i| readVBLK(d, ph) }
ph.vblkHash.each_value do |v|
ph.vblkHash[v.parent_id].children << v if v.parent_id
v.disk = ph.vblkHash[v.disk_id] if v.disk_id
end
(ph)
end
def self.readStruct(d, struct)
h = BinaryStruct.decode(d.read(BinaryStruct.sizeof(struct)), struct)
h.keys.delete_if { |k| !(/.*_H/ =~ k) }.each do |k|
(nk = k.dup)[/_H$/] = ""
lk = nk + "_L"
h[nk] = (h[k] << 32) | h[lk]
end
OpenStruct.new(h)
end # def self.readStruct
def self.getChunk(data)
len = data.slice!(0, 1).unpack("C")[0]
data.slice!(0, len)
end
def self.getNum(data)
n = 0
getChunk(data).each_byte { |b| n = (n << 8) | b }
(n)
end
def self.getNBO8(data)
h, l = data.slice!(0, 8).unpack("N2")
((h << 32) | l)
end
def self.readVBLK(disk, ph)
vblk = LdmScanner.readStruct(disk, LdmScanner::VBLK)
return if vblk.data_length == 0
buf = vblk.padding
vblk.vobject_id = getNum(buf)
vblk.name = getChunk(buf)
case vblk.rec_type
when VBT_NONE # NONE
when VBT_COMPONENT # Component
vblk.children = []
vblk.volume_state = getChunk(buf)
vblk.component_type = BinaryStruct.stepDecode(buf, "C")
BinaryStruct.stepDecode(buf, "C4")
vblk.num_children = getNum(buf)
BinaryStruct.stepDecode(buf, "C16")
vblk.parent_id = getNum(buf)
BinaryStruct.stepDecode(buf, "C")
if vblk.flags != 0
vblk.stripe_size = getNum(buf)
vblk.num_col = getNum(buf)
end
when VBT_PARTITION # Partition
BinaryStruct.stepDecode(buf, "C12")
vblk.start = getNBO8(buf)
vblk.volume_offset = getNBO8(buf)
vblk.size = getNum(buf)
vblk.parent_id = getNum(buf)
vblk.disk_id = getNum(buf)
vblk.comp_part_idx = getNum(buf) if vblk.flags == 0x08
when VBT_DISKV1 # Disk v1
vblk.disk_guid = getChunk(buf)
vblk.alt_name = getChunk(buf)
ph.diskVb = vblk if ph.disk_id == vblk.disk_guid
when VBT_DISKGROUPV1 # Disk Group v1
vblk.dg_guid = getChunk(buf)
when VBT_DISKV2 # Disk v2
vblk.disk_guid1 = UUIDTools::UUID.parse_raw(BinaryStruct.stepDecode(buf, "a16")).to_s
vblk.disk_guid2 = UUIDTools::UUID.parse_raw(BinaryStruct.stepDecode(buf, "a16")).to_s
ph.diskVb = vblk if ph.disk_id == vblk.disk_guid1
when VBT_DISKGROUPV2 # Disk Group v2
vblk.dg_guid = UUIDTools::UUID.parse_raw(BinaryStruct.stepDecode(buf, "a16")).to_s
vblk.ds_guid = UUIDTools::UUID.parse_raw(BinaryStruct.stepDecode(buf, "a16")).to_s
when VBT_VOLUME # Volume
vblk.children = []
vblk.volume_type = getChunk(buf)
BinaryStruct.stepDecode(buf, "C")
vblk.volume_state = BinaryStruct.stepDecode(buf, "a14").delete("\000")
vblk.volume_typeN = BinaryStruct.stepDecode(buf, "C")
BinaryStruct.stepDecode(buf, "C")
vblk.volume_number = BinaryStruct.stepDecode(buf, "C")
BinaryStruct.stepDecode(buf, "C3")
vblk.vol_flags = BinaryStruct.stepDecode(buf, "C")
vblk.num_children = getNum(buf)
BinaryStruct.stepDecode(buf, "C16")
vblk.size = getNum(buf)
BinaryStruct.stepDecode(buf, "C4")
vblk.partition_type = BinaryStruct.stepDecode(buf, "C")
vblk.volume_id = UUIDTools::UUID.parse_raw(BinaryStruct.stepDecode(buf, "a16")).to_s
vblk.id1 = getChunk(buf) if (vblk.flags & 0x08) != 0x0
vblk.id2 = getChunk(buf) if (vblk.flags & 0x20) != 0x0
vblk.csize = getNum(buf) if (vblk.flags & 0x80) != 0x0
vblk.drive_hint = getChunk(buf) if (vblk.flags & 0x02) != 0x0
if vblk.volume_state == "ACTIVE"
if vblk.volume_type == "gen"
ph.volumes << vblk
else
$log.warn "LdmScanner: unsupported volume type - #{vblk.volume_type}" if $log
end
end
end
vblk.delete_field("padding") if vblk.padding
ph.vblkHash[vblk.vobject_id] = vblk
(vblk)
end
def self.dumpPrivhead(ph)
puts
puts "PRIVHEAD:"
puts "\tsignature: #{ph.signature}"
puts "\tver_major: #{ph.ver_major}"
puts "\tver_minor: #{ph.ver_minor}"
puts "\tdisk_id: #{ph.disk_id}"
puts "\thost_id: #{ph.host_id}"
puts "\tdiskgroup_id: #{ph.diskgroup_id}"
puts "\tdiskgroup_name: #{ph.diskgroup_name}"
puts "\tlogical_disk_start: #{ph.logical_disk_start}"
puts "\tlogical_disk_size: #{ph.logical_disk_size}"
puts "\tdb_start: #{ph.db_start}"
puts "\tdb_size: #{ph.db_size}"
puts "\tnum_tocs: #{ph.num_tocs}"
puts "\ttoc_size: #{ph.toc_size}"
puts "\tnum_configs: #{ph.num_configs}"
puts "\tconfig_size: #{ph.config_size}"
puts "\tnum_logs: #{ph.num_logs}"
puts "\tlog_size: #{ph.log_size}"
puts "\tdisk_signature: #{ph.disk_signature}"
puts "\tdisk_set_guid: #{ph.disk_set_guid}"
puts "\tdisk_set_guid2: #{ph.disk_set_guid2}"
end
def self.dumpTocblock(tb)
puts
puts "TOCBLOCK:"
puts "\tsignature: #{tb.signature}"
puts "\tsequence1: #{tb.sequence1}"
puts "\tsequence2: #{tb.sequence2}"
puts "\tbitmap1_name: #{tb.bitmap1_name}"
puts "\tbitmap1_start: #{tb.bitmap1_start}"
puts "\tbitmap2_name: #{tb.bitmap2_name}"
puts "\tbitmap2_start: #{tb.bitmap2_start}"
end
def self.dumpVmdb(vmdb)
puts
puts "VMDB:"
puts "\tsignature: #{vmdb.signature}"
puts "\tsequence: #{vmdb.sequence}"
puts "\tvblk_size: #{vmdb.vblk_size}"
puts "\tvblk_offset: #{vmdb.vblk_offset}"
puts "\tver_major: #{vmdb.ver_major}"
puts "\tver_minor: #{vmdb.ver_minor}"
puts "\tdg_name: #{vmdb.dg_name}"
puts "\tdg_guid: #{vmdb.dg_guid}"
puts "\tcommitted_seq: #{vmdb.committed_seq}"
puts "\tpending_seq: #{vmdb.pending_seq}"
end
def self.dumpVblk_old(vb)
return if vb.data_length == 0
puts
puts "VBLK:"
puts "\tsignature: #{vb.signature}"
puts "\tvmdb_seq: #{vb.vmdb_seq}"
puts "\tgrpnum: #{vb.grpnum}"
puts "\trecord: #{vb.record}"
puts "\tnrecords: #{vb.nrecords}"
puts "\tupdate_status: #{vb.update_status}"
printf("\trec_type: 0x%x\t%s\n", vb.rec_type & 0xff, VBLK_TYPES[vb.rec_type & 0xff])
puts "\tdata_length: #{vb.data_length}"
puts "\tpadding.length: #{vb.padding.length}"
end
def self.dumpVblk(vb, indent = "")
return if vb.data_length == 0
puts
puts "#{indent}VBLK: #{VBLK_TYPES[vb.rec_type]}"
vb.marshal_dump.each { |k, v| printf("#{indent}\t%-15s: #{v}\n", k) unless v.kind_of?(Array) || v.kind_of?(OpenStruct) }
end
end # module LdmScanner
class LdmMdParser
attr_reader :vgName
def initialize(privhead, pvHdrs)
@pvHdrs = pvHdrs # PV headers hashed by UUID
@privhead = privhead
@vgName = privhead.diskgroup_name
end
def parse
getVgObj
end
private
def getVgObj
vgObj = VolumeGroup.new(@privhead.diskgroup_id, @vgName, 1)
vgObj.lvmType = "LDM"
@pvHdrs.each_value do |pvh|
next if pvh.diskgroup_name != @vgName
vgObj.physicalVolumes[pvh.diskVb.name] = getPvObj(vgObj, pvh) if pvh.diskVb
end
@privhead.volumes.each do |v|
vgObj.logicalVolumes[v.name] = getLvObj(vgObj, v)
end
(vgObj)
end
def getPvObj(vgObj, pvh)
pvObj = PhysicalVolume.new(pvh.disk_id, pvh.diskVb.name, nil, pvh.logical_disk_size, pvh.logical_disk_start, pvh.logical_disk_size)
pvObj.vgObj = vgObj
pvObj.diskObj = pvh.diskObj
pvObj.diskObj.pvObj = pvObj
(pvObj)
end
def getLvObj(vgObj, vol)
comp = vol.children.first
lvObj = LogicalVolume.new(vol.volume_id, vol.name, comp.num_children)
lvObj.vgObj = vgObj
lvObj.driveHint = vol.drive_hint
comp.children.each { |part| lvObj.segments << getSegObj(part) }
lvObj.segments.sort! { |x, y| x.startExtent <=> y.startExtent }
(lvObj)
end
def getSegObj(part)
segObj = LvSegment.new(part.volume_offset, part.size, nil, 1)
segObj.stripes << part.disk.name
segObj.stripes << part.start
(segObj)
end
end # class LdmMdParser
if __FILE__ == $0
SD = File.dirname(__FILE__)
$: << File.join(SD, "../disk")
require 'rubygems'
require 'ostruct'
require 'MiqDisk'
require 'logger'
$log = Logger.new(STDERR)
$log.level = Logger::DEBUG
# DISK = "/Volumes/WDpassport/Virtual Machines/cn071vcce130/cn071vcce130_3.vmdk"
# DISK = "/Volumes/WDpassport/Virtual Machines/cn071vcce130/cn071vcce130.vmdk"
DISK = "/Volumes/WDpassport/Virtual Machines/MIQAppliance-win2008x86/Win2008x86.vmdk"
puts "VMDB size = #{BinaryStruct.sizeof(LdmScanner::VBLK)}"
diskInfo = OpenStruct.new
diskInfo.fileName = DISK
disk = MiqDisk.getDisk(diskInfo)
unless disk
puts "Failed to open disk"
exit(1)
end
# parts = disk.getPartitions
puts "Disk type: #{disk.diskType}"
puts "Disk partition type: #{disk.partType}"
puts "Disk block size: #{disk.blockSize}"
puts "Disk start LBA: #{disk.lbaStart}"
puts "Disk end LBA: #{disk.lbaEnd}"
puts "Disk start byte: #{disk.startByteAddr}"
puts "Disk end byte: #{disk.endByteAddr}"
# disk.seek(LdmScanner::PRIVHEAD_OFFSET)
# ph = LdmScanner.readStruct(disk, LdmScanner::PRIVHEAD)
# if ph.signature != "PRIVHEAD"
# puts "#{DISK} is not an LDM disk"
# exit
# end
# LdmScanner.dumpPrivhead(ph)
#
# tblock_offset = (ph.db_start + LdmScanner::TBLOCK_BLOCK) * LdmScanner::LDM_SECTOR_SIZE
# disk.seek(tblock_offset)
# tb = LdmScanner.readStruct(disk, LdmScanner::TOCBLOCK)
# LdmScanner.dumpTocblock(tb)
#
# vmdb_offset = (ph.db_start + tb.bitmap1_start) * LdmScanner::LDM_SECTOR_SIZE
# disk.seek(vmdb_offset)
# vmdb = LdmScanner.readStruct(disk, LdmScanner::VMDB)
# LdmScanner.dumpVmdb(vmdb)
#
# # puts
# # puts "=============================================="
# #
# (0...vmdb.sequence).each do |i|
# next unless (vblk = LdmScanner.readVBLK(disk))
# LdmScanner.dumpVblk(vblk)
# end
#
# LdmScanner.vblkHash.each_value do |v|
# LdmScanner.vblkHash[v.parent_id].children << v if v.parent_id
# v.disk = LdmScanner.vblkHash[v.disk_id] if v.disk_id
# end
puts
puts "=============================================="
unless (ph = LdmScanner.scan(disk))
puts "#{disk.dInfo.fileName} is not an LDM disk"
disk.close
exit
end
if ph.volumes.empty?
puts "#{disk.dInfo.fileName} has no volumes"
disk.close
exit
end
ph.volumes.each do |v|
LdmScanner.dumpVblk(v)
v.children.each do |c|
LdmScanner.dumpVblk(c, "\t")
c.children.each do |p|
LdmScanner.dumpVblk(p, "\t\t")
LdmScanner.dumpVblk(p.disk, "\t\t\t") if p.disk
end
end
end
disk.close
end