yast / yast-bootloader / 153

pending completion

Build # 153

Build Type

Pull #202

travis-ci

Committed by

jreidinger

Commit Message

<a href="https://github.com/yast/yast-bootloader/commit/<a class=hub.com/yast/yast-bootloader/commit/b9ac4220faf0702262472105b71babf45b8a2ab9">b9ac4220f<a href="https://github.com/yast/yast-bootloader/commit/b9ac4220faf0702262472105b71babf45b8a2ab9">&quot;&gt;Revert &amp;quot;make clear rule when use // and when %r&quot;

This reverts commit </a><a class="double-link" href="https://github.com/yast/yast-bootloader/commit/<a class="double-link" href="https://github.com/yast/yast-bootloader/commit/eab1953a5de25f66672d2c31a33f2984714acf3d">eab1953a5</a>">eab1953a5</a><a href="https://github.com/yast/yast-bootloader/commit/b9ac4220faf0702262472105b71babf45b8a2ab9">.

Conflicts:
	.rubocop.yml
	test/boot_record_backup_test.rb
	test/mbr_update_test.rb

Pull Request Pull Request #202: Rubocop

Run Details

225 of 225 new or added lines in 25 files covered. (100.0%)

1575 of 2449 relevant lines covered (64.31%)

2.56 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

41.94

/src/modules/BootStorage.rb

# encoding: utf-8

# File:
#      modules/BootStorage.ycp
#
# Module:
#      Bootloader installation and configuration
#
# Summary:
#      Module includes specific functions for handling storage data.
#      The idea is handling all storage data necessary for bootloader
#      in one module.
#
# Authors:
#      Jozef Uhliarik <juhliarik@suse.cz>
#
#
#
#
require "yast"
require "bootloader/device_map"
require "bootloader/udev_mapping"

module Yast
  class BootStorageClass < Module
    include Yast::Logger

    attr_accessor :device_map

    def main
      textdomain "bootloader"

      Yast.import "Storage"
      Yast.import "StorageDevices"
      Yast.import "Arch"
      Yast.import "Mode"

      # Saved change time from target map - only for checkCallingDiskInfo()
      @disk_change_time_checkCallingDiskInfo = nil

      # Storage locked
      @storage_initialized = false

      # device mapping between real devices and multipath
      @multipath_mapping = {}

      # mountpoints for perl-Bootloader
      @mountpoints = {}

      # list of all partitions for perl-Bootloader
      @partinfo = []

      # information about MD arrays for perl-Bootloader
      @md_info = {}

      # device mapping between Linux and firmware
      @device_map = ::Bootloader::DeviceMap.new

      # string sepresenting device name of /boot partition
      # same as RootPartitionDevice if no separate /boot partition
      @BootPartitionDevice = ""

      # string representing device name of / partition
      @RootPartitionDevice = ""

      # string representing device name of extended partition
      @ExtendedPartitionDevice = ""

      # FATE#305008: Failover boot configurations for md arrays with redundancy
      # list <string> includes physical disks used for md raid

      @md_physical_disks = []
    end

    # bnc #447591, 438243, 448110 multipath wrong device map
    # Function maps real devices to multipath e.g.
    # "/dev/sda/" : "/dev/mapper/SATA_ST3120813AS_3LS0CD7M"
    #
    # @return [Hash{String => String}] mapping real disk to multipath

    # FIXME: grub only

    def mapRealDevicesToMultipath
      ret = {}
      tm = Storage.GetTargetMap
      tm.each do |disk, disk_info|
        next unless disk_info["type"] != :CT_DMMULTIPATH

        devices = disk_info["devices"] || []
        devices.each { |d| ret[d] = disk }
      end

      ret
    end

    # Check if function was called or storage change
    # partitionig of disk. It is usefull fo using cached data
    # about disk. Data is send to perl-Bootloader and it includes
    # info about partitions, multi path and md-raid
    #
    # @return false if it is posible use cached data

    def checkCallingDiskInfo
      # fix for problem with unintialized storage library in AutoYaST mode
      # bnc #464090
      if Mode.config && !@storage_initialized
        @storage_initialized = true
        log.info "Init storage library in yast2-bootloader"
        Storage.InitLibstorage(true)
      end
      if @disk_change_time_checkCallingDiskInfo != Storage.GetTargetChangeTime ||
          @partinfo.empty?
        # save last change time from storage
        @disk_change_time_checkCallingDiskInfo = Storage.GetTargetChangeTime
        log.info "disk was changed by storage or partinfo is empty"
        log.info "generate partinfo, md_info, mountpoints and multipath_mapping"
        return true
      else
        log.info "Skip genarating partinfo, md_info, mountpoints and multipath_mapping"
        return false
      end
    end

    # Function init data for perl-Bootloader about disk
    # It means fullfil md_info, multipath_mapping, partinfo
    # and mountpoints

    def InitDiskInfo
      return unless checkCallingDiskInfo

      # delete variables for perl-Bootloader
      @md_info = {}

      tm = Storage.GetTargetMap

      @multipath_mapping = mapRealDevicesToMultipath
      @mountpoints = Builtins.mapmap(Storage.GetMountPoints) do |k, v|
        # detect all raid1 md devices and mark them in md_info
        device = v[0]
        @md_info[device] = [] if v[3] == "raid1"
        { k => device }
      end
      # filter out temporary mount points from installation

      tmpdir = SCR.Read(path(".target.tmpdir"))
      @mountpoints = Builtins.filter(@mountpoints) do |k, v|
        v.is_a?(::String) && !k.start_with?(tmpdir)
      end

      log.info "Detected mountpoints: #{@mountpoints}"

      @partinfo = tm.reduce([]) do |res, i|
        disk, info = i
        next res if [:CT_LVM, :CT_EVMS].include?(info["type"])
        partitions = info["partitions"]
        parts = partitions.map do |p|
          raid = p["used_by_type"] == :UB_MD ? p["used_by_device"] : nil
          device = p["device"] || ""
          # We only pass along RAID1 devices as all other causes
          # severe breakage in the bootloader stack
          @md_info[raid] << device if raid && @md_info.include?(raid)

          nr = (p["nr"] || 0).to_s
          region = p.fetch("region", [])
          [
            device,
            disk,
            nr,
            p["fsid"].to_i.to_s,
            p["fstype"] || "unknown",
            p["type"] || "nil",
            (region[0] || 0).to_s,
            (region[1] || 0).to_s,
            ::Bootloader::UdevMapping.to_mountby_device(device)
          ]
        end
        res.concat(parts)
      end
    end

    # Get the order of disks according to BIOS mapping
    # @return a list of all disks in the order BIOS sees them
    def DisksOrder
      @device_map.propose if @device_map.empty?

      @device_map.disks_order
    end

    # Returns list of partitions and disks. Requests current partitioning from
    # yast2-storage and creates list of partition and disks usable for grub stage1
    def possible_locations_for_stage1
      devices = Storage.GetTargetMap

      all_disks = devices.keys
      # Devices which is not in device map cannot be used to boot
      all_disks.select! { |d| device_map.contain_disk?(d) }

      disks_for_stage1 = all_disks.select do |d|
        [:CT_DISK, :CR_DMRAID].include?(devices[d]["type"])
      end

      partitions = []

      devices.each do |k, v|
        next unless all_disks.include?(k)

        partitions.concat(v["partitions"] || [])
      end

      partitions.delete_if do |p|
        p["delete"]
      end

      partitions.select! do |p|
        [:primary, :extended, :logical, :sw_raid].include?(p["type"]) &&
          (p["used_fs"] || p["detected_fs"]) != :xfs &&
          ["Linux native", "Extended", "Linux RAID", "MD RAID", "DM RAID"].include?(p["fstype"])
      end

      res = partitions.map { |p| p["device"] || "" }
      res.concat(disks_for_stage1)
      res.delete_if(&:empty?)

      res
    end

    # Get extended partition for given partition or disk
    def extended_partition_for(device)
      disk_partition = Yast::Storage.GetDiskPartition(device)
      return nil unless disk_partition["disk"]

      target_map = Yast::Storage.GetTargetMap
      disk_map = target_map[disk_partition["disk"]] || {}
      partitions = disk_map["partitions"] || []
      ext_part = partitions.find { |p| p["type"] == :extended }
      return nil unless ext_part

      ext_part["device"]
    end

    # FATE#305008: Failover boot configurations for md arrays with redundancy
    # Check if devices has same partition number and if they are from different disks
    #
    # @param list <string> list of devices
    # @return [Boolean] true on success
    def checkDifferentDisks(devices)
      disks = []
      no_partition = ""
      devices.each do |dev|
        p_dev = Storage.GetDiskPartition(dev)
        disk = p_dev["disk"]
        if disks.include?(disk)
          log.info "Same disk for md array -> disable synchronize md arrays"
          return false
        else
          disks <<  disk
        end
        # add disk from partition to md_physical_disks
        @md_physical_disks << disk unless @md_physical_disks.include?(disk)

        no_p = p_dev["nr"].to_s
        if no_p == ""
          log.error "Wrong number of partition: #{dev} from Storage::GetDiskPartition: #{p_dev}"
          return false
        end
        if no_partition == ""
          no_partition = no_p
        elsif no_partition != no_p
          log.info "Different number of partitions -> disable synchronize md arrays"
          return false
        end
      end

      true
    end

    # FATE#305008: Failover boot configurations for md arrays with redundancy
    # Check if device are build from 2 partitions with same number but from different disks
    #
    # @param [Hash{String => map}] tm taregte map from storage
    # @param [String] device (md device)
    # @return true if device is from 2 partisions with same number and different disks
    def checkMDDevices(tm, device)
      ret = false
      tm_dm = tm["/dev/md"] || {}

      # find partitions in target map
      (tm_dm["partitions"] || []).each do |p|
        next unless p["device"] == device

        if p["raid_type"] == "raid1"
          p_devices = p["devices"] || []
          if p_devices.size == 2 # TODO: why only 2? it do not make sense
            ret = checkDifferentDisks(p_devices)
          else
            log.info "Device: #{device} doesn't contain 2 partitions: #{p_devices}"
          end
        else
          log.info "Device: #{device} is not on raid1: #{p["raid_type"]}"
        end
      end

      log.info "device: #{device} is based on md_physical_disks: #{@md_physical_disks}"\
        "is #{ ret ? "valid" : "invalid" } for enable redundancy"

      ret
    end

    def can_boot_from_partition
      tm = Storage.GetTargetMap
      partition = @BootPartitionDevice || @RootPartitionDevice

      part = Storage.GetPartition(tm, partition)

      if !part
        log.error "cannot find partition #{partition}"
        return false
      end

      fs = part["used_fs"]
      log.info "FS for boot partition #{fs}"

      # cannot install stage one to xfs as it doesn't have reserved space (bnc#884255)
      fs != :xfs
    end

    # FATE#305008: Failover boot configurations for md arrays with redundancy
    # Function check partitions and set redundancy available if
    # partitioning of disk allows it.
    # It means if md array is based on 2 partitions with same number but 2 different disks
    # E.g. /dev/md0 is from /dev/sda1 and /dev/sb1 and /dev/md0 is "/"
    # There is possible only boot from MBR (GRUB not generic boot code)
    #
    # @return [Array] Array of devices that can be used to redundancy boot

    def devices_for_redundant_boot
      tm = Storage.GetTargetMap

      if !tm["/dev/md"]
        log.info "Doesn't include md raid"
        return []
      end

      boot_devices = [@BootPartitionDevice]
      if @BootPartitionDevice != @RootPartitionDevice
        boot_devices << @RootPartitionDevice
      end
      boot_devices << @ExtendedPartitionDevice
      boot_devices.delete_if { |d| d.nil? || d.empty? }

      log.info "Devices for analyse of redundacy md array: #{boot_devices}"

      boot_devices.each do |dev|
        ret = checkMDDevices(tm, dev)
        if !ret
          log.info "Skip enable redundancy of md arrays"
          return []
        end
      end

      @md_physical_disks
    end

    # Converts the md device to the list of devices building it
    # @param [String] md_device string md device
    # @return a map of devices from device name to BIOS ID or empty hash if
    #   not detected) building the md device
    def Md2Partitions(md_device)
      ret = {}
      tm = Storage.GetTargetMap
      tm.each_pair do |_disk, descr|
        bios_id = (descr["bios_id"] || 256).to_i # maximum + 1 (means: no bios_id found)
        partitions = descr["partitions"] || []
        partitions.each do |partition|
          if partition["used_by_device"] == md_device
            ret[partition["device"]] = bios_id
          end
        end
      end
      log.info "Partitions building #{md_device}: #{ret}"

      ret
    end

    # returns disk names where partition lives
    def real_disks_for_partition(partition)
      # FIXME: handle somehow if disk are in logical raid
      partitions = Md2Partitions(partition).keys
      partitions = [partition] if partitions.empty?
      res = partitions.map do |part|
        Storage.GetDiskPartition(part)["disk"]
      end
      res.uniq!
      # handle LVM disks
      tm = Storage.GetTargetMap
      res = res.each_with_object([]) do |disk, ret|
        disk_meta = tm[disk]
        next unless disk_meta

        if disk_meta["lvm2"]
          devices = (disk_meta["devices"] || []) + (disk_meta["devices_add"] || [])
          disks = devices.map { |d| real_disks_for_partition(d) }
          ret.concat(disks.flatten)
        else
          ret << disk
        end
      end

      res.uniq
    end

    # Sets properly boot, root and mbr disk.
    # @return true if proposal need to be reconfigured
    def detect_disks
      mp = Storage.GetMountPoints

      mountdata_boot = mp["/boot"] || mp["/"]
      mountdata_root = mp["/"]

      log.info "mountPoints #{mp}"
      log.info "mountdata_boot #{mountdata_boot}"

      @RootPartitionDevice = mountdata_root.first || ""
      raise "No mountpoint for / !!" if @RootPartitionDevice.empty?

      # if /boot changed, re-configure location
      @BootPartitionDevice = mountdata_boot.first

      # get extended partition device (if exists)
      @ExtendedPartitionDevice = extended_partition_for(@BootPartitionDevice)

      if BootCommon.mbrDisk == "" || BootCommon.mbrDisk.nil?
        # mbr detection.
        BootCommon.mbrDisk = BootCommon.FindMBRDisk
      end

      # if no bootloader devices have been set up, or any of the set up
      # bootloader devices have become unavailable, then re-propose the
      # bootloader location.
      bldevs = BootCommon.GetBootloaderDevices

      return true if bldevs.empty?

      all_boot_partitions = possible_locations_for_stage1
      bldevs.any? do |dev|
        !all_boot_partitions.include?(dev)
      end
    end

    publish :variable => :multipath_mapping, :type => "map <string, string>"
    publish :variable => :mountpoints, :type => "map <string, any>"
    publish :variable => :partinfo, :type => "list <list>"
    publish :variable => :md_info, :type => "map <string, list <string>>"
    publish :variable => :BootPartitionDevice, :type => "string"
    publish :variable => :RootPartitionDevice, :type => "string"
    publish :variable => :ExtendedPartitionDevice, :type => "string"
    publish :function => :InitDiskInfo, :type => "void ()"
    publish :function => :DisksOrder, :type => "list <string> ()"
    publish :function => :Md2Partitions, :type => "map <string, integer> (string)"
  end

  BootStorage = BootStorageClass.new
  BootStorage.main
end

1	# encoding: utf-8
2
3	# File:
4	# modules/BootStorage.ycp
5	#
6	# Module:
7	# Bootloader installation and configuration
8	#
9	# Summary:
10	# Module includes specific functions for handling storage data.
11	# The idea is handling all storage data necessary for bootloader
12	# in one module.
13	#
14	# Authors:
15	# Jozef Uhliarik <juhliarik@suse.cz>
16	#
17	#
18	#
19	#
20	require "yast"	1✔
21	require "bootloader/device_map"	1✔
22	require "bootloader/udev_mapping"	1✔
23
24	module Yast	1✔
25	class BootStorageClass < Module	1✔
26	include Yast::Logger	1✔
27
28	attr_accessor :device_map	1✔
29
30	def main	1✔
31	textdomain "bootloader"	1✔
32
33	Yast.import "Storage"	1✔
34	Yast.import "StorageDevices"	1✔
35	Yast.import "Arch"	1✔
36	Yast.import "Mode"	1✔
37
38	# Saved change time from target map - only for checkCallingDiskInfo()
39	@disk_change_time_checkCallingDiskInfo = nil	1✔
40
41	# Storage locked
42	@storage_initialized = false	1✔
43
44	# device mapping between real devices and multipath
45	@multipath_mapping = {}	1✔
46
47	# mountpoints for perl-Bootloader
48	@mountpoints = {}	1✔
49
50	# list of all partitions for perl-Bootloader
51	@partinfo = []	1✔
52
53	# information about MD arrays for perl-Bootloader
54	@md_info = {}	1✔
55
56	# device mapping between Linux and firmware
57	@device_map = ::Bootloader::DeviceMap.new	1✔
58
59	# string sepresenting device name of /boot partition
60	# same as RootPartitionDevice if no separate /boot partition
61	@BootPartitionDevice = ""	1✔
62
63	# string representing device name of / partition
64	@RootPartitionDevice = ""	1✔
65
66	# string representing device name of extended partition
67	@ExtendedPartitionDevice = ""	1✔
68
69	# FATE#305008: Failover boot configurations for md arrays with redundancy
70	# list <string> includes physical disks used for md raid
71
72	@md_physical_disks = []	1✔
73	end
74
75	# bnc #447591, 438243, 448110 multipath wrong device map
76	# Function maps real devices to multipath e.g.
77	# "/dev/sda/" : "/dev/mapper/SATA_ST3120813AS_3LS0CD7M"
78	#
79	# @return [Hash{String => String}] mapping real disk to multipath
80
81	# FIXME: grub only
82
83	def mapRealDevicesToMultipath	1✔
84	ret = {}	×
85	tm = Storage.GetTargetMap	×
86	tm.each do \|disk, disk_info\|	×
87	next unless disk_info["type"] != :CT_DMMULTIPATH	×
88
89	devices = disk_info["devices"] \|\| []	×
90	devices.each { \|d\| ret[d] = disk }	×
91	end
92
93	ret	×
94	end
95
96	# Check if function was called or storage change
97	# partitionig of disk. It is usefull fo using cached data
98	# about disk. Data is send to perl-Bootloader and it includes
99	# info about partitions, multi path and md-raid
100	#
101	# @return false if it is posible use cached data
102
103	def checkCallingDiskInfo	1✔
104	# fix for problem with unintialized storage library in AutoYaST mode
105	# bnc #464090
106	if Mode.config && !@storage_initialized	×
107	@storage_initialized = true	×
108	log.info "Init storage library in yast2-bootloader"	×
109	Storage.InitLibstorage(true)	×
110	end
111	if @disk_change_time_checkCallingDiskInfo != Storage.GetTargetChangeTime \|\|
112	@partinfo.empty?	×
113	# save last change time from storage
114	@disk_change_time_checkCallingDiskInfo = Storage.GetTargetChangeTime	×
115	log.info "disk was changed by storage or partinfo is empty"	×
116	log.info "generate partinfo, md_info, mountpoints and multipath_mapping"	×
117	return true	×
118	else
119	log.info "Skip genarating partinfo, md_info, mountpoints and multipath_mapping"	×
120	return false	×
121	end
122	end
123
124	# Function init data for perl-Bootloader about disk
125	# It means fullfil md_info, multipath_mapping, partinfo
126	# and mountpoints
127
128	def InitDiskInfo	1✔
129	return unless checkCallingDiskInfo	×
130
131	# delete variables for perl-Bootloader
132	@md_info = {}	×
133
134	tm = Storage.GetTargetMap	×
135
136	@multipath_mapping = mapRealDevicesToMultipath	×
137	@mountpoints = Builtins.mapmap(Storage.GetMountPoints) do \|k, v\|	×
138	# detect all raid1 md devices and mark them in md_info
139	device = v[0]	×
140	@md_info[device] = [] if v[3] == "raid1"	×
141	{ k => device }	×
142	end
143	# filter out temporary mount points from installation
144
145	tmpdir = SCR.Read(path(".target.tmpdir"))	×
146	@mountpoints = Builtins.filter(@mountpoints) do \|k, v\|	×
147	v.is_a?(::String) && !k.start_with?(tmpdir)	×
148	end
149
150	log.info "Detected mountpoints: #{@mountpoints}"	×
151
152	@partinfo = tm.reduce([]) do \|res, i\|	×
153	disk, info = i	×
154	next res if [:CT_LVM, :CT_EVMS].include?(info["type"])	×
155	partitions = info["partitions"]	×
156	parts = partitions.map do \|p\|	×
157	raid = p["used_by_type"] == :UB_MD ? p["used_by_device"] : nil	×
158	device = p["device"] \|\| ""	×
159	# We only pass along RAID1 devices as all other causes
160	# severe breakage in the bootloader stack
161	@md_info[raid] << device if raid && @md_info.include?(raid)	×
162
163	nr = (p["nr"] \|\| 0).to_s	×
164	region = p.fetch("region", [])	×
165	[
166	device,	×
167	disk,
168	nr,
169	p["fsid"].to_i.to_s,
170	p["fstype"] \|\| "unknown",
171	p["type"] \|\| "nil",
172	(region[0] \|\| 0).to_s,	×
173	(region[1] \|\| 0).to_s,	×
174	::Bootloader::UdevMapping.to_mountby_device(device)
175	]
176	end
177	res.concat(parts)	×
178	end
179	end
180
181	# Get the order of disks according to BIOS mapping
182	# @return a list of all disks in the order BIOS sees them
183	def DisksOrder	1✔
184	@device_map.propose if @device_map.empty?	×
185
186	@device_map.disks_order	×
187	end
188
189	# Returns list of partitions and disks. Requests current partitioning from
190	# yast2-storage and creates list of partition and disks usable for grub stage1
191	def possible_locations_for_stage1	1✔
192	devices = Storage.GetTargetMap	5✔
193
194	all_disks = devices.keys	5✔
195	# Devices which is not in device map cannot be used to boot
196	all_disks.select! { \|d\| device_map.contain_disk?(d) }	35✔
197
198	disks_for_stage1 = all_disks.select do \|d\|	5✔
199	[:CT_DISK, :CR_DMRAID].include?(devices[d]["type"])	17✔
200	end
201
202	partitions = []	5✔
203
204	devices.each do \|k, v\|	5✔
205	next unless all_disks.include?(k)	30✔
206
207	partitions.concat(v["partitions"] \|\| [])	17✔
208	end
209
210	partitions.delete_if do \|p\|	5✔
211	p["delete"]	51✔
212	end
213
214	partitions.select! do \|p\|	5✔
215	[:primary, :extended, :logical, :sw_raid].include?(p["type"]) &&
216	(p["used_fs"] \|\| p["detected_fs"]) != :xfs &&	50✔
217	["Linux native", "Extended", "Linux RAID", "MD RAID", "DM RAID"].include?(p["fstype"])
218	end
219
220	res = partitions.map { \|p\| p["device"] \|\| "" }	55✔
221	res.concat(disks_for_stage1)	5✔
222	res.delete_if(&:empty?)	5✔
223
224	res	5✔
225	end
226
227	# Get extended partition for given partition or disk
228	def extended_partition_for(device)	1✔
229	disk_partition = Yast::Storage.GetDiskPartition(device)	×
230	return nil unless disk_partition["disk"]	×
231
232	target_map = Yast::Storage.GetTargetMap	×
233	disk_map = target_map[disk_partition["disk"]] \|\| {}	×
234	partitions = disk_map["partitions"] \|\| []	×
235	ext_part = partitions.find { \|p\| p["type"] == :extended }	×
236	return nil unless ext_part	×
237
238	ext_part["device"]	×
239	end
240
241	# FATE#305008: Failover boot configurations for md arrays with redundancy
242	# Check if devices has same partition number and if they are from different disks
243	#
244	# @param list <string> list of devices
245	# @return [Boolean] true on success
246	def checkDifferentDisks(devices)	1✔
247	disks = []	×
248	no_partition = ""	×
249	devices.each do \|dev\|	×
250	p_dev = Storage.GetDiskPartition(dev)	×
251	disk = p_dev["disk"]	×
252	if disks.include?(disk)	×
253	log.info "Same disk for md array -> disable synchronize md arrays"	×
254	return false	×
255	else
256	disks << disk	×
257	end
258	# add disk from partition to md_physical_disks
259	@md_physical_disks << disk unless @md_physical_disks.include?(disk)	×
260
261	no_p = p_dev["nr"].to_s	×
262	if no_p == ""	×
263	log.error "Wrong number of partition: #{dev} from Storage::GetDiskPartition: #{p_dev}"	×
264	return false	×
265	end
266	if no_partition == ""	×
267	no_partition = no_p	×
268	elsif no_partition != no_p
269	log.info "Different number of partitions -> disable synchronize md arrays"	×
270	return false	×
271	end
272	end
273
274	true	×
275	end
276
277	# FATE#305008: Failover boot configurations for md arrays with redundancy
278	# Check if device are build from 2 partitions with same number but from different disks
279	#
280	# @param [Hash{String => map}] tm taregte map from storage
281	# @param [String] device (md device)
282	# @return true if device is from 2 partisions with same number and different disks
283	def checkMDDevices(tm, device)	1✔
284	ret = false	×
285	tm_dm = tm["/dev/md"] \|\| {}	×
286
287	# find partitions in target map
288	(tm_dm["partitions"] \|\| []).each do \|p\|	×
289	next unless p["device"] == device	×
290
291	if p["raid_type"] == "raid1"	×
292	p_devices = p["devices"] \|\| []	×
293	if p_devices.size == 2 # TODO: why only 2? it do not make sense	×
294	ret = checkDifferentDisks(p_devices)	×
295	else
296	log.info "Device: #{device} doesn't contain 2 partitions: #{p_devices}"	×
297	end
298	else
299	log.info "Device: #{device} is not on raid1: #{p["raid_type"]}"	×
300	end
301	end
302
303	log.info "device: #{device} is based on md_physical_disks: #{@md_physical_disks}"\	×
304	"is #{ ret ? "valid" : "invalid" } for enable redundancy"
305
306	ret	×
307	end
308
309	def can_boot_from_partition	1✔
310	tm = Storage.GetTargetMap	×
311	partition = @BootPartitionDevice \|\| @RootPartitionDevice	×
312
313	part = Storage.GetPartition(tm, partition)	×
314
315	if !part	×
316	log.error "cannot find partition #{partition}"	×
317	return false	×
318	end
319
320	fs = part["used_fs"]	×
321	log.info "FS for boot partition #{fs}"	×
322
323	# cannot install stage one to xfs as it doesn't have reserved space (bnc#884255)
324	fs != :xfs	×
325	end
326
327	# FATE#305008: Failover boot configurations for md arrays with redundancy
328	# Function check partitions and set redundancy available if
329	# partitioning of disk allows it.
330	# It means if md array is based on 2 partitions with same number but 2 different disks
331	# E.g. /dev/md0 is from /dev/sda1 and /dev/sb1 and /dev/md0 is "/"
332	# There is possible only boot from MBR (GRUB not generic boot code)
333	#
334	# @return [Array] Array of devices that can be used to redundancy boot
335
336	def devices_for_redundant_boot	1✔
337	tm = Storage.GetTargetMap	×
338
339	if !tm["/dev/md"]	×
340	log.info "Doesn't include md raid"	×
341	return []	×
342	end
343
344	boot_devices = [@BootPartitionDevice]	×
345	if @BootPartitionDevice != @RootPartitionDevice	×
346	boot_devices << @RootPartitionDevice	×
347	end
348	boot_devices << @ExtendedPartitionDevice	×
349	boot_devices.delete_if { \|d\| d.nil? \|\| d.empty? }	×
350
351	log.info "Devices for analyse of redundacy md array: #{boot_devices}"	×
352
353	boot_devices.each do \|dev\|	×
354	ret = checkMDDevices(tm, dev)	×
355	if !ret	×
356	log.info "Skip enable redundancy of md arrays"	×
357	return []	×
358	end
359	end
360
361	@md_physical_disks	×
362	end
363
364	# Converts the md device to the list of devices building it
365	# @param [String] md_device string md device
366	# @return a map of devices from device name to BIOS ID or empty hash if
367	# not detected) building the md device
368	def Md2Partitions(md_device)	1✔
369	ret = {}	16✔
370	tm = Storage.GetTargetMap	16✔
371	tm.each_pair do \|_disk, descr\|	16✔
372	bios_id = (descr["bios_id"] \|\| 256).to_i # maximum + 1 (means: no bios_id found)	80✔
373	partitions = descr["partitions"] \|\| []	80✔
374	partitions.each do \|partition\|	80✔
375	if partition["used_by_device"] == md_device	188✔
376	ret[partition["device"]] = bios_id	24✔
377	end
378	end
379	end
380	log.info "Partitions building #{md_device}: #{ret}"	16✔
381
382	ret	16✔
383	end
384
385	# returns disk names where partition lives
386	def real_disks_for_partition(partition)	1✔
387	# FIXME: handle somehow if disk are in logical raid
388	partitions = Md2Partitions(partition).keys	13✔
389	partitions = [partition] if partitions.empty?	13✔
390	res = partitions.map do \|part\|	13✔
391	Storage.GetDiskPartition(part)["disk"]	22✔
392	end
393	res.uniq!	13✔
394	# handle LVM disks
395	tm = Storage.GetTargetMap	13✔
396	res = res.each_with_object([]) do \|disk, ret\|	13✔
397	disk_meta = tm[disk]	16✔
398	next unless disk_meta	16✔
399
400	if disk_meta["lvm2"]	15✔
401	devices = (disk_meta["devices"] \|\| []) + (disk_meta["devices_add"] \|\| [])	2✔
402	disks = devices.map { \|d\| real_disks_for_partition(d) }	4✔
403	ret.concat(disks.flatten)	2✔
404	else
405	ret << disk	13✔
406	end
407	end
408
409	res.uniq	13✔
410	end
411
412	# Sets properly boot, root and mbr disk.
413	# @return true if proposal need to be reconfigured
414	def detect_disks	1✔
415	mp = Storage.GetMountPoints	×
416
417	mountdata_boot = mp["/boot"] \|\| mp["/"]	×
418	mountdata_root = mp["/"]	×
419
420	log.info "mountPoints #{mp}"	×
421	log.info "mountdata_boot #{mountdata_boot}"	×
422
423	@RootPartitionDevice = mountdata_root.first \|\| ""	×
424	raise "No mountpoint for / !!" if @RootPartitionDevice.empty?	×
425
426	# if /boot changed, re-configure location
427	@BootPartitionDevice = mountdata_boot.first	×
428
429	# get extended partition device (if exists)
430	@ExtendedPartitionDevice = extended_partition_for(@BootPartitionDevice)	×
431
432	if BootCommon.mbrDisk == "" \|\| BootCommon.mbrDisk.nil?	×
433	# mbr detection.
434	BootCommon.mbrDisk = BootCommon.FindMBRDisk	×
435	end
436
437	# if no bootloader devices have been set up, or any of the set up
438	# bootloader devices have become unavailable, then re-propose the
439	# bootloader location.
440	bldevs = BootCommon.GetBootloaderDevices	×
441
442	return true if bldevs.empty?	×
443
444	all_boot_partitions = possible_locations_for_stage1	×
445	bldevs.any? do \|dev\|	×
446	!all_boot_partitions.include?(dev)	×
447	end
448	end
449
450	publish :variable => :multipath_mapping, :type => "map <string, string>"	1✔
451	publish :variable => :mountpoints, :type => "map <string, any>"	1✔
452	publish :variable => :partinfo, :type => "list <list>"	1✔
453	publish :variable => :md_info, :type => "map <string, list <string>>"	1✔
454	publish :variable => :BootPartitionDevice, :type => "string"	1✔
455	publish :variable => :RootPartitionDevice, :type => "string"	1✔
456	publish :variable => :ExtendedPartitionDevice, :type => "string"	1✔
457	publish :function => :InitDiskInfo, :type => "void ()"	1✔
458	publish :function => :DisksOrder, :type => "list <string> ()"	1✔
459	publish :function => :Md2Partitions, :type => "map <string, integer> (string)"	1✔
460	end
461
462	BootStorage = BootStorageClass.new	1✔
463	BootStorage.main	1✔
464	end

yast / yast-bootloader / 153

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous