manageiq-smartstate 0.1.0

data/lib/VolumeManager/LVM/thin/constants.rb

@@ -0,0 +1,86 @@
+module Lvm2Thin
+  SECTOR_SIZE = 512
+
+  THIN_MAGIC = 27022010
+
+  SPACE_MAP_ROOT_SIZE = 128
+
+  MAX_METADATA_BITMAPS = 255
+
+  SUPERBLOCK = BinaryStruct.new([
+   'L',                       'csum',
+   'L',                       'flags_',
+   'Q',                       'block',
+   'A16',                     'uuid',
+   'Q',                       'magic',
+   'L',                       'version',
+   'L',                       'time',
+
+   'Q',                       'trans_id',
+   'Q',                       'metadata_snap',
+
+   "A#{SPACE_MAP_ROOT_SIZE}", 'data_space_map_root',
+   "A#{SPACE_MAP_ROOT_SIZE}", 'metadata_space_map_root',
+
+   'Q',                       'data_mapping_root',
+
+   'Q',                       'device_details_root',
+
+   'L',                       'data_block_size',     # in 512-byte sectors
+
+   'L',                       'metadata_block_size', # in 512-byte sectors
+   'Q',                       'metadata_nr_blocks',
+
+   'L',                       'compat_flags',
+   'L',                       'compat_ro_flags',
+   'L',                       'incompat_flags'
+  ])
+
+  SPACE_MAP = BinaryStruct.new([
+    'Q',                      'nr_blocks',
+    'Q',                      'nr_allocated',
+    'Q',                      'bitmap_root',
+    'Q',                      'ref_count_root'
+  ])
+
+  DISK_NODE = BinaryStruct.new([
+    'L',                      'csum',
+    'L',                      'flags',
+    'Q',                      'blocknr',
+
+    'L',                      'nr_entries',
+    'L',                      'max_entries',
+    'L',                      'value_size',
+    'L',                      'padding'
+    #'Q',                      'keys'
+  ])
+
+  INDEX_ENTRY = BinaryStruct.new([
+    'Q',                      'blocknr',
+    'L',                      'nr_free',
+    'L',                      'none_free_before'
+  ])
+
+  METADATA_INDEX = BinaryStruct.new([
+    'L',                      'csum',
+    'L',                      'padding',
+    'Q',                      'blocknr'
+  ])
+
+  BITMAP_HEADER = BinaryStruct.new([
+    'L',                      'csum',
+    'L',                      'notused',
+    'Q',                      'blocknr'
+  ])
+
+  DEVICE_DETAILS = BinaryStruct.new([
+    'Q',                      'mapped_blocks',
+    'Q',                      'transaction_id',
+    'L',                      'creation_time',
+    'L',                      'snapshotted_time'
+  ])
+
+  MAPPING_DETAILS = BinaryStruct.new([
+    'Q',                       'value'
+  ])
+end # module Lvm2Thin

data/lib/VolumeManager/LVM/thin/data_map.rb

@@ -0,0 +1,44 @@
+module Lvm2Thin
+  class DataMap < BTree
+    TIME_MASK = (1 << 24) - 1
+
+    def initialize(superblock, root_address)
+      super superblock, root_address, MAPPING_DETAILS
+    end
+
+    alias :device_blocks :keys
+
+    def entries
+      @dmentries ||= begin
+        super.collect do |entry|
+          value = entry['value']
+          internal? ? DataMap.new(@superblock, @superblock.md_block_address(value)) :
+                      [extract_data_block(value), extract_time(value)]
+        end
+      end
+    end
+
+    def data_block(device_block)
+      device_blocks.reverse.each do |map_device_block|
+        if map_device_block <= device_block
+          entry = entry_for(map_device_block)
+          return entry.data_block(device_block) if entry.is_a?(DataMap)
+          raise RuntimeError, "LVM2Thin cannot find device block: #{device_block} (closest: #{map_device_block})" unless map_device_block == device_block
+          return entry.first
+        end
+      end
+
+      raise RuntimeError, "LVM2Thin could not find data block for #{device_block}"
+    end
+
+    private
+
+    def extract_data_block(value)
+      value >> 24
+    end
+
+    def extract_time(value)
+      value & TIME_MASK
+    end
+  end
+end # module Lvm2Thin

data/lib/VolumeManager/LVM/thin/mapping_tree.rb

@@ -0,0 +1,19 @@
+module Lvm2Thin
+  class MappingTree < BTree
+    def initialize(superblock, root_address)
+      super superblock, root_address, MAPPING_DETAILS
+    end
+
+    def entries
+      @mtentries ||= begin
+        super.collect do |entry|
+          DataMap.new @superblock, @superblock.md_block_address(entry['value'])
+        end
+      end
+    end
+
+    def map_for(device_id)
+      entry_for(device_id)
+    end
+  end
+end # module Lvm2Thin

data/lib/VolumeManager/LVM/thin/space_maps.rb

@@ -0,0 +1,58 @@
+module Lvm2Thin
+  class DataSpaceMap
+    attr_accessor :struct
+
+    def initialize(superblock, struct)
+      @superblock = superblock
+      @struct = struct
+    end
+
+    def btree_root_address
+      @btree_root_address ||= @superblock.md_block_address(struct['bitmap_root'])
+    end
+
+    def btree
+      @btree ||= BTree.new @superblock, btree_root_address, INDEX_ENTRY
+    end
+  end
+
+  class MetadataSpaceMap
+    def metadata_root_address
+      @metadata_root_address ||= @superblock.md_block_address(struct['bitmap_root'])
+    end
+
+    def root
+      @metadata_root ||= begin
+        @superblock.seek metadata_root_address
+        @superblock.read_struct METADATA_INDEX
+      end
+    end
+
+    def indices
+      @metadata_indices ||= (struct['nr_blocks'].to_f / @superblock.entries_per_block).ceil
+    end
+
+    def index_entries
+      @index_entries ||=
+        0.upto(indices-1).collect do |i|
+          address = metadata_root_address + METADATA_INDEX.size + i * INDEX_ENTRY.size
+          @superblock.seek address
+          @superblock.read_struct INDEX_ENTRY
+        end
+    end
+
+    def bitmaps
+      @bitmaps ||= index_entries.collect do |index_entry|
+        @superblock.seek @superblock.md_block_address(index_entry['blocknr'])
+        @superblock.read_struct BITMAP_HEADER
+      end
+    end
+
+    attr_accessor :struct
+
+    def initialize(superblock, struct)
+      @superblock = superblock
+      @struct     = struct
+    end
+  end
+end # module Lvm2Thin

data/lib/VolumeManager/LVM/thin/superblock.rb

@@ -0,0 +1,136 @@
+module Lvm2Thin
+  class SuperBlock
+    attr_accessor :metadata_volume
+
+    attr_accessor :struct
+
+    def self.get(metadata_volume)
+      @superblock ||= begin
+        superblock = SuperBlock.new
+        superblock.metadata_volume = metadata_volume
+        superblock.seek 0
+        superblock.struct = superblock.read_struct SUPERBLOCK
+        raise "unknown lvm2 thin metadata magic number" if superblock.struct.magic != THIN_MAGIC
+        superblock
+      end
+    end
+
+    ### superblock properties:
+
+    def md_block_size
+      @md_block_size ||= struct['metadata_block_size'] * 512 # = 4096
+    end
+
+    def md_block_address(blk_addr)
+      blk_addr * md_block_size
+    end
+
+    def entries_per_block
+      @entries_per_block ||= (md_block_size - BITMAP_HEADER.size) * 4
+    end
+
+    def data_block_size
+      @data_block_size ||= struct['data_block_size'] * 512
+    end
+
+    def data_block_address(blk_addr)
+      blk_addr * data_block_size
+    end
+
+    ### lvm thin structures:
+
+    def data_space_map
+      @data_space_map ||= begin
+        seek SUPERBLOCK.offset('data_space_map_root')
+        DataSpaceMap.new self, read_struct(SPACE_MAP)
+      end
+    end
+
+    def metadata_space_map
+      @metadata_space_map ||= begin
+        seek SUPERBLOCK.offset('metadata_space_map_root')
+        MetadataSpaceMap.new self, read_struct(SPACE_MAP)
+      end
+    end
+
+    def data_mapping_address
+      @data_mapping_address ||= md_block_address(struct['data_mapping_root'])
+    end
+
+    def data_mapping
+      @data_mapping ||= MappingTree.new self, data_mapping_address
+    end
+
+    def device_details_address
+      @device_details_address ||= md_block_address(struct['device_details_root'])
+    end
+
+    def device_details
+      @device_details ||= BTree.new self, device_details_address, DEVICE_DETAILS
+    end
+
+    ### address resolution / mapping:
+
+    def device_block(device_address)
+      (device_address / data_block_size).to_i
+    end
+
+    def device_block_offset(device_address)
+      device_address % data_block_size
+    end
+
+    # return array of tuples containing data volume addresses and lengths to
+    # read from them to read the specified device offset & length
+    def device_to_data(device_id, pos, len)
+      dev_blk = device_block(pos)
+      dev_off = device_block_offset(pos)
+
+      total_len = 0
+      data_blks = []
+
+      num_data_blks = (len / data_block_size).to_i + 1
+      0.upto(num_data_blks - 1) do |i|
+        data_blk = data_mapping.map_for(device_id).data_block(dev_blk + i)
+
+        blk_start = data_blk * data_block_size
+        blk_len   = 0
+
+        if i == 0
+          blk_start += dev_off
+          blk_len    = data_block_size - dev_off - 1
+
+        elsif i == num_data_blks - 1
+          blk_len = len - total_len
+
+        else
+          blk_len    = data_block_size
+        end
+
+        total_len += blk_len
+        data_blks << [blk_start, blk_len]
+      end
+
+      data_blks
+    end
+
+    ### metadata volume disk helpers:
+
+    def seek(pos)
+      @metadata_volume.disk.seek pos
+    end
+
+    def read(n)
+      @metadata_volume.disk.read n
+    end
+
+    def read_struct(struct)
+      OpenStruct.new(struct.decode(@metadata_volume.disk.read(struct.size)))
+    end
+
+    def read_structs(struct, num)
+      Array.new(num) do
+        read_struct struct
+      end
+    end
+  end # class SuperBlock
+end # module Lvm2Thin

data/lib/VolumeManager/LVM/thin.rb

@@ -0,0 +1,6 @@
+require 'VolumeManager/LVM/thin/constants'
+require 'VolumeManager/LVM/thin/btree'
+require 'VolumeManager/LVM/thin/data_map'
+require 'VolumeManager/LVM/thin/mapping_tree'
+require 'VolumeManager/LVM/thin/space_maps'
+require 'VolumeManager/LVM/thin/superblock'

data/lib/VolumeManager/LVM/volume_group.rb

@@ -0,0 +1,97 @@
+#
+# One object of this class for each volume group.
+#
+class VolumeGroup
+  attr_accessor :vgId, :vgName, :extentSize, :seqNo, :status, :physicalVolumes, :logicalVolumes, :lvmType
+
+  def initialize(vgId = nil, vgName = nil, extentSize = nil, seqNo = nil)
+    @vgId = vgId                        # the UUID of this volme group
+    @vgName = vgName                    # the name of this volume group
+    @extentSize = extentSize.to_i       # the size of all physical and logical extents (in sectors)
+    @seqNo = seqNo
+
+    @lvmType = nil
+    @status = []
+    @physicalVolumes = {}         # PhysicalVolume objects, hashed by name
+    @logicalVolumes = {}          # LogicalVolume objects, hashed by name
+  end
+
+  def thin_pool_volumes
+    @thin_pool_volumes ||= logicalVolumes.values.select { |lv| lv.thin_pool? }
+  end
+
+  def thin_volumes
+    @thin_volumes ||= logicalVolumes.values.select { |lv| lv.thin? }
+  end
+
+  def getLvs
+    lvList  = []
+    skipLvs = []
+    @logicalVolumes.each_value do |lvObj|
+      # remove logical volumes w/ 'thin-pool' segments as they are handled internally
+      if lvObj.thin_pool?
+        skipLvs << lvObj.lvName unless skipLvs.include?(lvObj.lvName)
+        metadata_volume_names = lvObj.thin_pool_segments.collect { |tps| tps.metadata }
+        data_volume_names     = lvObj.thin_pool_segments.collect { |tps| tps.pool     }
+        (metadata_volume_names + data_volume_names).each do |vol|
+          skipLvs <<  vol unless skipLvs.include?(vol)
+        end
+      end
+    end
+
+    @logicalVolumes.each_value do |lvObj|
+      if skipLvs.include?(lvObj.lvName)
+        $log.debug "Ignoring thin volume: #{lvObj.lvName}"
+        next
+      end
+
+      begin
+        lvList << lvObj.disk
+      rescue => err
+        $log.warn "Failed to load MiqDisk for <#{lvObj.disk.dInfo.fileName}>.  Message:<#{err}> #{err.backtrace}"
+      end
+    end
+    lvList
+  end # def getLvs
+
+  def dump
+    $log.info "#{@vgName}:"
+    $log.info "\tID: #{@vgId}"
+    $log.info "\tseqno: #{@seqNo}"
+    $log.info "\textent_size: #{@extentSize}"
+    $log.info "\tstatus:"
+    vg.status.each { |s| $log.info "\t\t#{s}" }
+
+    $log.info "\n\tPhysical Volumes:"
+    vg.physicalVolumes.each do |pvName, pv|
+      $log.info "\t\t#{pvName}:"
+      $log.info "\t\t\tID: #{pv.pvId}"
+      $log.info "\t\t\tdevice: #{pv.device}"
+      $log.info "\t\t\tdev_size: #{pv.deviceSize}"
+      $log.info "\t\t\tpe_start: #{pv.peStart}"
+      $log.info "\t\t\tpe_count: #{pv.peCount}"
+      $log.info "\t\t\tstatus:"
+      pv.status.each { |s| $log.info "\t\t\t\t#{s}" }
+    end
+
+    $log.info "\n\tLogical Volumes:"
+    @logicalVolumes.each do |lvName, lv|
+      $log.info "\t\t#{lvName}:"
+      $log.info "\t\t\tID: #{lv.lvId}"
+      $log.info "\t\t\tstatus:"
+      lv.status.each { |s| $log.info "\t\t\t\t#{s}" }
+      $log.info "\n\t\t\tSegments, count = #{lv.segmentCount}:"
+      i = 0
+      lv.segments.each do |s|
+        $log.info "\t\t\t\tsegment - #{i}:"
+        $log.info "\t\t\t\t\tstart_extent: #{s.startExtent}"
+        $log.info "\t\t\t\t\textent_count: #{s.extentCount}"
+        $log.info "\t\t\t\t\ttype: #{s.type}"
+        $log.info "\t\t\t\t\tstripe_count: #{s.stripeCount}"
+        $log.info "\n\t\t\t\t\tstripes:"
+        s.stripes.each { |si| $log.info "\t\t\t\t\t\t#{si}" }
+        i += 1
+      end
+    end
+  end # def dump
+end # class VolumeGroup

data/lib/VolumeManager/LVM.rb

@@ -0,0 +1,8 @@
+require 'VolumeManager/LVM/scanner'
+require 'VolumeManager/LVM/parser'
+require 'VolumeManager/LVM/thin'
+require 'VolumeManager/LVM/volume_group'
+require 'VolumeManager/LVM/physical_volume'
+require 'VolumeManager/LVM/logical_volume'
+require 'VolumeManager/LVM/lv_segment'
+require 'VolumeManager/LVM/lvm2disk'