storage.py

#
# Copyright (C) 2020  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.
#
import os

from decimal import Decimal

from blivet import udev
from blivet.size import Size
from blivet.util import total_memory
from pyanaconda.anaconda_loggers import get_module_logger
from pyanaconda.core.i18n import N_
from pykickstart.constants import AUTOPART_TYPE_PLAIN, AUTOPART_TYPE_BTRFS, AUTOPART_TYPE_LVM, \
    AUTOPART_TYPE_LVM_THINP

log = get_module_logger(__name__)

# Maximum ratio of swap size to disk size (10 %).
MAX_SWAP_DISK_RATIO = Decimal('0.1')

SIZE_POLICY_MAX = -1
SIZE_POLICY_AUTO = 0

DEVICE_TYPE_LVM = 0
DEVICE_TYPE_MD = 1
DEVICE_TYPE_PARTITION = 2
DEVICE_TYPE_BTRFS = 3
DEVICE_TYPE_DISK = 4
DEVICE_TYPE_LVM_THINP = 5

NAMED_DEVICE_TYPES = (
    DEVICE_TYPE_BTRFS,
    DEVICE_TYPE_LVM,
    DEVICE_TYPE_MD,
    DEVICE_TYPE_LVM_THINP
)

CONTAINER_DEVICE_TYPES = (
    DEVICE_TYPE_LVM,
    DEVICE_TYPE_BTRFS,
    DEVICE_TYPE_LVM_THINP
)

SUPPORTED_DEVICE_TYPES = (
    DEVICE_TYPE_PARTITION,
    DEVICE_TYPE_LVM,
    DEVICE_TYPE_LVM_THINP
)

PARTITION_ONLY_FORMAT_TYPES = (
    "macefi",
    "prepboot",
    "biosboot",
    "appleboot"
)

PROTECTED_FORMAT_TYPES = (
    "efi",
    "macefi",
    "prepboot",
    "appleboot"
)

# Used for info about device with
# no more supported type (ie btrfs).
DEVICE_TYPE_UNSUPPORTED = -1

DEVICE_TEXT_MAP = {
    DEVICE_TYPE_UNSUPPORTED: N_("Unsupported"),
    DEVICE_TYPE_LVM: N_("LVM"),
    DEVICE_TYPE_MD: N_("RAID"),
    DEVICE_TYPE_PARTITION: N_("Standard Partition"),
    DEVICE_TYPE_BTRFS: N_("Btrfs"),
    DEVICE_TYPE_LVM_THINP: N_("LVM Thin Provisioning"),
    DEVICE_TYPE_DISK: N_("Disk")
}

AUTOPART_CHOICES = (
    (N_("Standard Partition"), AUTOPART_TYPE_PLAIN),
    (N_("Btrfs"), AUTOPART_TYPE_BTRFS),
    (N_("LVM"), AUTOPART_TYPE_LVM),
    (N_("LVM Thin Provisioning"), AUTOPART_TYPE_LVM_THINP)
)

AUTOPART_DEVICE_TYPES = {
    AUTOPART_TYPE_LVM: DEVICE_TYPE_LVM,
    AUTOPART_TYPE_LVM_THINP: DEVICE_TYPE_LVM_THINP,
    AUTOPART_TYPE_PLAIN: DEVICE_TYPE_PARTITION,
    AUTOPART_TYPE_BTRFS: DEVICE_TYPE_BTRFS
}

MOUNTPOINT_DESCRIPTIONS = {
    "Swap": N_("The 'swap' area on your computer is used by the operating\n"
               "system when running low on memory."),
    "Boot": N_("The 'boot' area on your computer is where files needed\n"
               "to start the operating system are stored."),
    "Root": N_("The 'root' area on your computer is where core system\n"
               "files and applications are stored."),
    "Home": N_("The 'home' area on your computer is where all your personal\n"
               "data is stored."),
    "BIOS Boot": N_("The BIOS boot partition is required to enable booting\n"
                    "from GPT-partitioned disks on BIOS hardware."),
    "PReP Boot": N_("The PReP boot partition is required as part of the\n"
                    "boot loader configuration on some PPC platforms.")
}

# Private cache for the function device_matches.
_udev_device_dict_cache = None


def device_type_from_autopart(autopart_type):
    """Get device type matching the given autopart type."""
    return AUTOPART_DEVICE_TYPES.get(autopart_type, DEVICE_TYPE_LVM)


def get_supported_autopart_choices():
    """Get the supported autopart choices.

    # FIXME: Move this function to the Storage module.
    """
    from blivet.devicefactory import is_supported_device_type
    return [c for c in AUTOPART_CHOICES if is_supported_device_type(AUTOPART_DEVICE_TYPES[c[1]])]


def device_matches(spec, devicetree=None, disks_only=False):
    """Return names of block devices matching the provided specification.

    :param str spec: a device identifier (name, UUID=<uuid>, &c)
    :keyword devicetree: device tree to look up devices in (optional)
    :type devicetree: :class:`blivet.DeviceTree`
    :param bool disks_only: if only disk devices matching the spec should be returned
    :returns: names of matching devices
    :rtype: list of str

    The spec can contain multiple "sub specs" delimited by a |, for example:

    "sd*|hd*|vd*"

    In such case we resolve the specs from left to right and return all
    unique matches, for example:

    ["sda", "sda1", "sda2", "sdb", "sdb1", "vdb"]

    If disks_only is specified we only return
    disk devices matching the spec. For the example above
    the output with disks_only=True would be:

    ["sda", "sdb", "vdb"]

    Also note that parse methods will not have access to a devicetree, while execute
    methods will. The devicetree is superior in that it can resolve md
    array names and in that it reflects scheduled device removals, but for
    normal local disks udev.resolve_devspec should suffice.
    """

    matches = []
    # the device specifications might contain multiple "sub specs" separated by a |
    # - the specs are processed from left to right
    for single_spec in spec.split("|"):
        full_spec = single_spec
        if not full_spec.startswith("/dev/"):
            full_spec = os.path.normpath("/dev/" + full_spec)

        # the regular case
        single_spec_matches = udev.resolve_glob(full_spec)
        for match in single_spec_matches:
            if match not in matches:
                # skip non-disk devices in disk-only mode
                if disks_only and not _is_device_name_disk(match):
                    continue
                matches.append(match)

        dev_name = None
        # Use spec here instead of full_spec to preserve the spec and let the
        # called code decide whether to treat the spec as a path instead of a name.
        if devicetree is None:
            # we run the spec through resolve_devspec() here as unlike resolve_glob()
            # it can also resolve labels and UUIDs
            dev_name = udev.resolve_devspec(single_spec)
            if disks_only and dev_name:
                if not _is_device_name_disk(dev_name):
                    dev_name = None  # not a disk
        else:
            # devicetree can also handle labels and UUIDs
            device = devicetree.resolve_device(single_spec)
            if device:
                dev_name = device.name
                if disks_only and not _is_device_name_disk(dev_name, devicetree=devicetree):
                    dev_name = None  # not a disk

        # The dev_name variable can be None if the spec is not not found or is not valid,
        # but we don't want that ending up in the list.
        if dev_name and dev_name not in matches:
            matches.append(dev_name)

    log.debug("%s matches %s for devicetree=%s and disks_only=%s",
              spec, matches, devicetree, disks_only)

    return matches


def _is_device_name_disk(device_name, devicetree=None, refresh_udev_cache=False):
    """Report if the given device name corresponds to a disk device.

    Check if the device name is a disk device or not. This function uses
    the provided Blivet devicetree for the checking and Blivet udev module
    if no devicetree is provided.

    Please note that the udev based check uses an internal cache that is generated
    when this function is first called in the udev checking mode. This basically
    means that udev devices added later will not be taken into account.
    If this is a problem for your usecase then use the refresh_udev_cache option
    to force a refresh of the udev cache.

    :param str device_name: name of the device to check
    :param devicetree: device tree to look up devices in (optional)
    :type devicetree: :class:`blivet.DeviceTree`
    :param bool refresh_udev_cache: governs if the udev device cache should be refreshed
    :returns: True if the device name corresponds to a disk, False if not
    :rtype: bool
    """
    if devicetree is None:
        global _udev_device_dict_cache
        if device_name:
            if _udev_device_dict_cache is None or refresh_udev_cache:
                # Lazy load the udev dick that contains the {device_name : udev_device,..,}
                # mappings. The operation could be quite costly due to udev_settle() calls,
                # so we cache it in this non-elegant way.
                # An unfortunate side effect of this is that udev devices that show up after
                # this function is called for the first time will not be taken into account.
                _udev_device_dict_cache = dict()

                for d in udev.get_devices():
                    # Add the device name to the cache.
                    _udev_device_dict_cache[udev.device_get_name(d)] = d
                    # If the device is md, add the md name as well.
                    if udev.device_is_md(d) and udev.device_get_md_name(d):
                        _udev_device_dict_cache[udev.device_get_md_name(d)] = d

            udev_device = _udev_device_dict_cache.get(device_name)
            return udev_device and udev.device_is_disk(udev_device)
        else:
            return False
    else:
        device = devicetree.get_device_by_name(device_name)
        return device and device.is_disk


def suggest_swap_size(hibernation=False, disk_space=None):
    """Suggest the size of the swap partition that will be created.

    :param bool hibernation: calculate swap size big enough for hibernation
    :param disk_space: how much disk space is available
    :return: calculated swap size
    """
    mem = total_memory()
    mem = ((mem / 16) + 1) * 16
    log.info("Detected %s of memory", mem)

    sixty_four_gib = Size("64 GiB")

    # the succeeding if-statement implements the following formula for
    # suggested swap size.
    #
    # swap(mem) = 2 * mem, if mem < 2 GiB
    #           = mem,     if 2 GiB <= mem < 8 GiB
    #           = mem / 2, if 8 GIB <= mem < 64 GiB
    #           = 32 GiB,  if mem >= 64 GiB
    if mem < Size("2 GiB"):
        swap = 2 * mem

    elif mem < Size("8 GiB"):
        swap = mem

    elif mem < sixty_four_gib:
        swap = mem / 2

    else:
        swap = Size("32 GiB")

    if hibernation:
        if mem <= sixty_four_gib:
            swap = mem + swap
        else:
            log.info("Ignoring --hibernation option on systems with greater than %s of RAM",
                     sixty_four_gib)

    elif disk_space is not None:
        max_swap = disk_space * MAX_SWAP_DISK_RATIO

        if swap > max_swap:
            log.info("Suggested swap size (%(swap)s) exceeds %(percent)d %% of "
                     "disk space, using %(percent)d %% of disk space (%(size)s) "
                     "instead.", {"percent": MAX_SWAP_DISK_RATIO * 100,
                                  "swap": swap,
                                  "size": max_swap})
            swap = max_swap

    log.info("Swap attempt of %s", swap)
    return swap