# # Copyright (C) 2009-2017 Red Hat, Inc. # # This copyrighted material is made available to anyone wishing to use, # modify, copy, or redistribute it subject to the terms and conditions of # the GNU General Public License v.2, or (at your option) any later version. # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY expressed or implied, including the implied warranties of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General # Public License for more details. You should have received a copy of the # GNU General Public License along with this program; if not, write to the # Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA # 02110-1301, USA. Any Red Hat trademarks that are incorporated in the # source code or documentation are not subject to the GNU General Public # License and may only be used or replicated with the express permission of # Red Hat, Inc. # # Red Hat Author(s): David Lehman # import os from blivet.blivet import Blivet from blivet.flags import flags as blivet_flags from blivet.devices import BTRFSSubVolumeDevice from blivet.formats import get_format from blivet.formats.disklabel import DiskLabel from blivet.size import Size from blivet.devicelibs.crypto import DEFAULT_LUKS_VERSION from pyanaconda.modules.storage.bootloader import BootLoaderFactory from pyanaconda.core.configuration.anaconda import conf from pyanaconda.core.constants import DRACUT_REPO_DIR, LIVE_MOUNT_POINT from pyanaconda.core.path import set_system_root from pyanaconda.core.product import get_product_short_name from pyanaconda.modules.storage.devicetree.fsset import FSSet from pyanaconda.modules.storage.devicetree.utils import download_escrow_certificate, \ find_backing_device, find_stage2_device from pyanaconda.modules.storage.devicetree.root import find_existing_installations from pyanaconda.modules.common.constants.services import NETWORK import logging log = logging.getLogger("anaconda.storage") __all__ = ["create_storage"] def create_storage(): """Create the storage object. :return: an instance of the Blivet's storage object """ return InstallerStorage() class InstallerStorage(Blivet): """ Top-level class for managing installer-related storage configuration. """ def __init__(self): super().__init__() self.roots = [] self.protected_devices = [] self._escrow_certificates = {} self._bootloader = None self.fsset = FSSet(self.devicetree) self._short_product_name = get_product_short_name() self._default_luks_version = DEFAULT_LUKS_VERSION # Set the default filesystem type. self.set_default_fstype(conf.storage.file_system_type or self.default_fstype) # Set the default LUKS version. self.set_default_luks_version(conf.storage.luks_version or self.default_luks_version) # Enable GPT discoverable partitions blivet_flags.gpt_discoverable_partitions = conf.storage.gpt_discoverable_partitions @property def bootloader(self): if self._bootloader is None: self._bootloader = BootLoaderFactory.create_boot_loader() return self._bootloader @property def boot_device(self): root_device = self.mountpoints.get("/") dev = self.mountpoints.get("/boot", root_device) return dev @property def default_boot_fstype(self): """The default filesystem type for the boot partition.""" if self.default_fstype in self.bootloader.stage2_format_types: return self.default_fstype return self.bootloader.stage2_format_types[0] @property def default_luks_version(self): """The default LUKS version.""" return self._default_luks_version def set_default_luks_version(self, version): """Set the default LUKS version. :param version: a string with LUKS version :raises: ValueError on invalid input """ log.debug("trying to set new default luks version to '%s'", version) self._check_valid_luks_version(version) self._default_luks_version = version def _check_valid_luks_version(self, version): get_format("luks", luks_version=version) def get_fstype(self, mountpoint=None): """ Return the default filesystem type based on mountpoint. """ fstype = super().get_fstype(mountpoint=mountpoint) if mountpoint == "/boot": fstype = self.default_boot_fstype return fstype def get_escrow_certificate(self, url): """Get the escrow certificate. :param url: an URL of the certificate :return: a content of the certificate """ if not url: return None certificate = self._escrow_certificates.get(url, None) if not certificate: certificate = download_escrow_certificate(url) self._escrow_certificates[url] = certificate return certificate @property def mountpoints(self): return self.fsset.mountpoints @property def root_device(self): return self.fsset.root_device def get_file_system_free_space(self, mount_points=("/", "/usr")): """Get total file system free space on the given mount points. Calculates total free space in / and /usr, by default. :param mount_points: a list of mount points :return: a total size """ free = Size(0) btrfs_volumes = [] for mount_point in mount_points: device = self.mountpoints.get(mount_point) if not device: continue # don't count the size of btrfs volumes repeatedly when multiple # subvolumes are present if isinstance(device, BTRFSSubVolumeDevice): if device.volume in btrfs_volumes: continue else: btrfs_volumes.append(device.volume) if device.format.exists: free += device.format.free else: free += device.format.free_space_estimate(device.size) return free def get_disk_free_space(self, disks=None): """Get total free space on the given disks. Calculates free space available for use. :param disks: a list of disks or None :return: a total size """ # Use all disks in the device tree by default. if disks is None: disks = self.disks # Get a list of disks with supported disk labels. disks = self._skip_unsupported_disk_labels(disks) # Get the dictionary of free spaces for each disk. snapshot = self.get_free_space(disks) # Calculate the total free space. return sum((disk_free for disk_free, fs_free in snapshot.values()), Size(0)) def get_disk_reclaimable_space(self, disks=None): """Get total reclaimable space on the given disks. Calculates free space unavailable but reclaimable from existing partitions. :param disks: a list of disks or None :return: a total size """ # Use all disks in the device tree by default. if disks is None: disks = self.disks # Get a list of disks with supported disk labels. disks = self._skip_unsupported_disk_labels(disks) # Get the dictionary of free spaces for each disk. snapshot = self.get_free_space(disks) # Calculate the total reclaimable free space. return sum((fs_free for disk_free, fs_free in snapshot.values()), Size(0)) def _skip_unsupported_disk_labels(self, disks): """Get a list of disks with supported disk labels. Skip initialized disks with disk labels that are not supported on this platform. :param disks: a list of disks :return: a list of disks with supported disk labels """ label_types = set(DiskLabel.get_platform_label_types()) def is_supported(disk): if disk.format.type is None: return True return disk.format.type == "disklabel" \ and disk.format.label_type in label_types return list(filter(is_supported, disks)) def reset(self, cleanup_only=False): """ Reset storage configuration to reflect actual system state. This will cancel any queued actions and rescan from scratch but not clobber user-obtained information like passphrases, iscsi config, &c :keyword cleanup_only: prepare the tree only to deactivate devices :type cleanup_only: bool See :meth:`devicetree.Devicetree.populate` for more information about the cleanup_only keyword argument. """ # set up the disk images if conf.target.is_image: self.setup_disk_images() # save passphrases for luks devices so we don't have to reprompt for device in self.devices: if device.format.type == "luks" and device.format.exists: self.save_passphrase(device) super().reset(cleanup_only=cleanup_only) # Protect devices from teardown. self._mark_protected_devices() self.devicetree.teardown_all() self.fsset = FSSet(self.devicetree) # Clear out attributes that refer to devices that are no longer in the tree. self.bootloader.reset() self.roots = [] self.roots = find_existing_installations(self.devicetree) self.dump_state("initial") def _mark_protected_devices(self): """Mark protected devices. If a device is protected, mark it as such now. Once the tree has been populated, devices' protected attribute is how we will identify protected devices. """ protected = [] protected_with_ancestors = [] # Resolve the protected device specs to devices. for spec in self.protected_devices: dev = self.devicetree.resolve_device(spec) if dev is not None: log.debug("Protected device spec %s resolved to %s.", spec, dev.name) protected.append(dev) # Find the stage2 backing device and its parents. stage2_device = find_stage2_device(self.devicetree) if stage2_device: log.debug("Resolved stage2 device to %s.", stage2_device.name) protected.append(stage2_device) # Find the live backing device and its parents. live_device = find_backing_device(self.devicetree, LIVE_MOUNT_POINT) if live_device: log.debug("Resolved live device to %s.", live_device.name) protected_with_ancestors.append(live_device) # Find the backing device of a stage2 source and its parents. source_device = find_backing_device(self.devicetree, DRACUT_REPO_DIR) if source_device: log.debug("Resolved a stage2 source device to %s.", source_device.name) protected.append(source_device) # For image installation setup_disk_images method marks all local # storage disks as ignored so they are protected from teardown. # Here we protect also cdrom devices from tearing down that, in case of # cdroms, involves unmounting which is undesirable (see bug #1671713). protected_with_ancestors.extend(dev for dev in self.devicetree.devices if dev.type == "cdrom") # Protect also all devices with an iso9660 file system. It will protect # NVDIMM devices that can be used only as an installation source anyway # (see the bug #1856264). protected_with_ancestors.extend(dev for dev in self.devicetree.devices if dev.format.type == "iso9660") # Mark the collected devices as protected. for dev in protected: self._mark_protected_device(dev) for dev in protected_with_ancestors: self._mark_protected_device(dev, include_ancestors=True) def protect_devices(self, protected_names): """Protect given devices. :param protected_names: a list of device names """ protected = set(protected_names) unprotected = set(self.protected_devices) # Mark unprotected devices. # Skip devices that should stay protected. for spec in unprotected - protected: device = self.devicetree.resolve_device(spec) self._mark_unprotected_device(device) # Mark protected devices. # Skip devices that are already protected. for spec in protected - unprotected: device = self.devicetree.resolve_device(spec) self._mark_protected_device(device) # Update the list. self.protected_devices = protected_names def _mark_protected_device(self, device, include_ancestors=False): """Mark a device and its ancestors as protected.""" if not device: return device.protected = True log.debug("Marking device %s as protected.", device.name) if include_ancestors: for d in device.ancestors: log.debug("Marking ancestor %s of device %s as protected.", d.name, device.name) d.protected = True def _mark_unprotected_device(self, device, include_ancestors=False): """Mark a device and its ancestors as unprotected.""" if not device: return device.protected = False log.debug("Marking device %s as unprotected.", device.name) if include_ancestors: for d in device.ancestors: log.debug("Marking ancestor %s of device %s as unprotected.", d.name, device.name) d.protected = False @property def usable_disks(self): """Disks that can be used for the installation. :return: a list of disks """ # Get all devices. devices = self.devicetree.devices # Add the hidden devices. if conf.target.is_image: devices += [ d for d in self.devicetree._hidden if d.name in self.devicetree.disk_images ] else: devices += self.devicetree._hidden # Filter out the usable disks. disks = [] for d in devices: if d.is_disk and not d.format.hidden and not d.protected: # Unformatted DASDs are detected with a size of 0, but they should # still show up as valid disks if this function is called, since we # can still use them; anaconda will know how to handle them, so they # don't need to be ignored anymore. if d.type == "dasd": disks.append(d) elif d.size > 0 and d.media_present: disks.append(d) # Remove duplicate names from the list. return sorted(set(disks), key=lambda d: d.name) def select_disks(self, selected_names): """Select disks that should be used for the installation. Hide usable disks that are not selected. :param selected_names: a list of disk names """ for disk in self.usable_disks: if disk.name not in selected_names: if disk in self.devices: self.devicetree.hide(disk) else: if disk not in self.devices: self.devicetree.unhide(disk) def _get_hostname(self): """Return a hostname.""" ignored_hostnames = {None, "", 'localhost', 'localhost.localdomain', 'localhost-live'} network_proxy = NETWORK.get_proxy() hostname = network_proxy.Hostname if hostname in ignored_hostnames: hostname = network_proxy.GetCurrentHostname() if hostname in ignored_hostnames: hostname = None return hostname def _get_container_name_template(self, prefix=None): """Return a template for suggest_container_name method.""" prefix = prefix or "" # make sure prefix is a string instead of None # try to create a device name incorporating the hostname hostname = self._get_hostname() if hostname: template = "%s_%s" % (prefix, hostname.split('.')[0].lower()) template = self.safe_device_name(template) else: template = prefix if conf.target.is_image: template = "%s_image" % template return template def turn_on_swap(self): self.fsset.turn_on_swap(root_path=conf.target.system_root) def mount_filesystems(self): root_path = conf.target.physical_root # Mount the root and the filesystems. self.fsset.mount_filesystems(root_path=root_path) # Set up the sysroot. set_system_root(root_path) def umount_filesystems(self, swapoff=True): # Unmount the root and the filesystems. self.fsset.umount_filesystems(swapoff=swapoff) # Unmount the sysroot. set_system_root(None) def parse_fstab(self, chroot=None): self.fsset.parse_fstab(chroot=chroot) def make_mtab(self, chroot=None): path = "/etc/mtab" target = "/proc/self/mounts" chroot = chroot or conf.target.system_root path = os.path.normpath("%s/%s" % (chroot, path)) if os.path.islink(path): # return early if the mtab symlink is already how we like it current_target = os.path.normpath(os.path.dirname(path) + "/" + os.readlink(path)) if current_target == target: return if os.path.exists(path): os.unlink(path) os.symlink(target, path) def add_fstab_swap(self, device): """ Add swap device to the list of swaps that should appear in the fstab. :param device: swap device that should be added to the list :type device: blivet.devices.StorageDevice instance holding a swap format """ self.fsset.add_fstab_swap(device) def set_fstab_swaps(self, devices): """ Set swap devices that should appear in the fstab. :param devices: iterable providing devices that should appear in the fstab :type devices: iterable providing blivet.devices.StorageDevice instances holding a swap format """ self.fsset.set_fstab_swaps(devices) def copy(self): """Create a copy of the storage model.""" log.debug("Creating a copy of the storage model.") # Create a copy of the Blivet object. new = super().copy() # Create proper copies of the collected installation roots. new.roots = [root.copy(storage=new) for root in new.roots] log.debug("Finished a copy of the storage model.") return new