Merge remote-tracking branch 'origin/3.3-devel' into 3.3-release

blivet/__init__.py

@@ -74,7 +74,7 @@ def log_bd_message(level, msg):
     blockdev.switch_init_checks(False)
     succ_, avail_plugs = blockdev.try_reinit(require_plugins=_requested_plugins, reload=False, log_func=log_bd_message)
 except GLib.GError as err:
-    raise RuntimeError("Failed to intialize the libblockdev library: %s" % err)
+    raise RuntimeError("Failed to initialize the libblockdev library: %s" % err)
 else:
     avail_plugs = set(avail_plugs)
 

blivet/blivet.py

@@ -46,6 +46,7 @@
 from . import arch
 from . import devicefactory
 from . import __version__
+from . import devicelibs
 from .threads import SynchronizedMeta
 from .static_data import luks_data
 
@@ -77,7 +78,7 @@ def __init__(self):
         self._dump_file = "%s/storage.state" % tempfile.gettempdir()
 
         try:
-            options = "NAME,SIZE,OWNER,GROUP,MODE,FSTYPE,LABEL,UUID,PARTUUID,FSAVAIL,FSUSE%,MOUNTPOINT"
+            options = "NAME,SIZE,OWNER,GROUP,MODE,FSTYPE,LABEL,UUID,PARTUUID,MOUNTPOINT"
             out = capture_output(["lsblk", "--bytes", "-a", "-o", options])
         except Exception:  # pylint: disable=broad-except
             pass
@@ -514,7 +515,7 @@ def new_mdarray(self, *args, **kwargs):
 
         name = kwargs.pop("name", None)
         if name:
-            safe_name = self.safe_device_name(name)
+            safe_name = self.safe_device_name(name, devicefactory.DEVICE_TYPE_MD)
             if safe_name != name:
                 log.warning("using '%s' instead of specified name '%s'",
                             safe_name, name)
@@ -547,7 +548,7 @@ def new_vg(self, *args, **kwargs):
 
         name = kwargs.pop("name", None)
         if name:
-            safe_name = self.safe_device_name(name)
+            safe_name = self.safe_device_name(name, devicefactory.DEVICE_TYPE_LVM)
             if safe_name != name:
                 log.warning("using '%s' instead of specified name '%s'",
                             safe_name, name)
@@ -610,9 +611,9 @@ def new_lv(self, *args, **kwargs):
         name = kwargs.pop("name", None)
         if name:
             # make sure the specified name is sensible
-            safe_vg_name = self.safe_device_name(vg.name)
+            safe_vg_name = self.safe_device_name(vg.name, devicefactory.DEVICE_TYPE_LVM)
             full_name = "%s-%s" % (safe_vg_name, name)
-            safe_name = self.safe_device_name(full_name)
+            safe_name = self.safe_device_name(full_name, devicefactory.DEVICE_TYPE_LVM)
             if safe_name != full_name:
                 new_name = safe_name[len(safe_vg_name) + 1:]
                 log.warning("using '%s' instead of specified name '%s'",
@@ -887,18 +888,31 @@ def resize_device(self, device, new_size):
         for action in actions:
             self.devicetree.actions.add(action)
 
-    def safe_device_name(self, name):
+    def safe_device_name(self, name, device_type=None):
         """ Convert a device name to something safe and return that.
 
             LVM limits lv names to 128 characters. I don't know the limits for
             the other various device types, so I'm going to pick a number so
             that we don't have to have an entire library to determine
             device name limits.
         """
+
+        if device_type in (devicefactory.DEVICE_TYPE_LVM, devicefactory.DEVICE_TYPE_LVM_THINP):
+            allowed = devicelibs.lvm.safe_name_characters
+        elif device_type == devicefactory.DEVICE_TYPE_MD:
+            allowed = devicelibs.mdraid.safe_name_characters
+        elif device_type == devicefactory.DEVICE_TYPE_BTRFS:
+            allowed = devicelibs.btrfs.safe_name_characters
+        else:
+            allowed = "0-9a-zA-Z._-"
+
         max_len = 96    # No, you don't need longer names than this. Really.
         tmp = name.strip()
-        tmp = tmp.replace("/", "_")
-        tmp = re.sub("[^0-9a-zA-Z._-]", "", tmp)
+
+        if "/" not in allowed:
+            tmp = tmp.replace("/", "_")
+
+        tmp = re.sub("[^%s]" % allowed, "", tmp)
 
         # Remove any '-' or '_' prefixes
         tmp = re.sub("^[-_]*", "", tmp)

blivet/devicefactory.py

@@ -319,6 +319,8 @@ def __init__(self, storage, **kwargs):
             :type luks_version: str
             :keyword pbkdf_args: optional arguments for LUKS2 key derivation function
             :type pbkdf_args: :class:`~.formats.luks.LUKS2PBKDFArgs`
+            :keyword luks_sector_size: encryption sector size (use only with LUKS version 2)
+            :type luks_sector_size: int
 
         """
         self.storage = storage  # a Blivet instance
@@ -339,6 +341,7 @@ def __init__(self, storage, **kwargs):
 
         self.luks_version = kwargs.get("luks_version") or crypto.DEFAULT_LUKS_VERSION
         self.pbkdf_args = kwargs.get("pbkdf_args", None)
+        self.luks_sector_size = kwargs.get("luks_sector_size") or 0
 
         # If a device was passed, update the defaults based on it.
         self.device = kwargs.get("device")
@@ -688,6 +691,7 @@ def _create_device(self):
             fmt_args["min_luks_entropy"] = self.min_luks_entropy
             fmt_args["luks_version"] = self.luks_version
             fmt_args["pbkdf_args"] = self.pbkdf_args
+            fmt_args["luks_sector_size"] = self.luks_sector_size
         else:
             fstype = self.fstype
             mountpoint = self.mountpoint
@@ -826,7 +830,8 @@ def _set_encryption(self):
             self.storage.format_device(self.device, get_format("luks",
                                                                min_luks_entropy=self.min_luks_entropy,
                                                                luks_version=self.luks_version,
-                                                               pbkdf_args=self.pbkdf_args))
+                                                               pbkdf_args=self.pbkdf_args,
+                                                               luks_sector_size=self.luks_sector_size))
             luks_device = LUKSDevice("luks-%s" % self.device.name,
                                      fmt=leaf_format,
                                      parents=self.device)
@@ -835,9 +840,14 @@ def _set_encryption(self):
             if parent_container:
                 parent_container.parents.append(self.device)
                 parent_container.parents.remove(orig_device)
-        elif self.encrypted and isinstance(self.device, LUKSDevice) and \
-                self.device.slave.format.luks_version != self.luks_version:
-            self.device.slave.format.luks_version = self.luks_version
+
+        if self.encrypted and isinstance(self.device, LUKSDevice) and \
+                self.raw_device.format.luks_version != self.luks_version:
+            self.raw_device.format.luks_version = self.luks_version
+
+        if self.encrypted and isinstance(self.device, LUKSDevice) and \
+                self.raw_device.format.luks_sector_size != self.luks_sector_size:
+            self.raw_device.format.luks_sector_size = self.luks_sector_size
 
     def _set_name(self):
         if not self.device_name:
@@ -847,7 +857,8 @@ def _set_name(self):
                 swap=(self.fstype == "swap"),
                 mountpoint=self.mountpoint)
 
-        safe_new_name = self.storage.safe_device_name(self.device_name)
+        safe_new_name = self.storage.safe_device_name(self.device_name,
+                                                      get_device_type(self.device))
         if self.device.name != safe_new_name:
             if not safe_new_name:
                 log.error("not renaming '%s' to invalid name '%s'",
@@ -1155,11 +1166,11 @@ def configure(self):
                     container.parents.remove(member)
                 self.storage.destroy_device(member)
                 members.remove(member)
-                self.storage.format_device(member.slave,
+                self.storage.format_device(member.raw_device,
                                            get_format(self.fstype))
-                members.append(member.slave)
+                members.append(member.raw_device)
                 if container:
-                    container.parents.append(member.slave)
+                    container.parents.append(member.raw_device)
 
                 continue
 
@@ -1168,7 +1179,8 @@ def configure(self):
                 self.storage.format_device(member, get_format("luks",
                                                               min_luks_entropy=self.min_luks_entropy,
                                                               luks_version=self.luks_version,
-                                                              pbkdf_args=self.pbkdf_args))
+                                                              pbkdf_args=self.pbkdf_args,
+                                                              luks_sector_size=self.luks_sector_size))
                 luks_member = LUKSDevice("luks-%s" % member.name,
                                          parents=[member],
                                          fmt=get_format(self.fstype))
@@ -1180,9 +1192,10 @@ def configure(self):
 
                 continue
 
-            if member_encrypted and self.encrypted and self.luks_version != member.slave.format.luks_version:
-                member.slave.format.luks_version = self.luks_version
-                continue
+            if member_encrypted and self.encrypted and self.luks_version != member.raw_device.format.luks_version:
+                member.raw_device.format.luks_version = self.luks_version
+            if member_encrypted and self.encrypted and self.luks_sector_size != member.raw_device.format.luks_sector_size:
+                member.raw_device.format.luks_sector_size = self.luks_sector_size
 
         ##
         # Prepare previously allocated member partitions for reallocation.
@@ -1206,6 +1219,7 @@ def configure(self):
                 member_format = "luks"
                 fmt_args["luks_version"] = self.luks_version
                 fmt_args["pbkdf_args"] = self.pbkdf_args
+                fmt_args["luks_sector_size"] = self.luks_sector_size
             else:
                 member_format = self.fstype
 
@@ -1241,7 +1255,7 @@ def configure(self):
 
             if isinstance(member, LUKSDevice):
                 self.storage.destroy_device(member)
-                member = member.slave
+                member = member.raw_device
 
             self.storage.destroy_device(member)
 
@@ -1468,7 +1482,7 @@ def _set_name(self):
                 mountpoint=self.mountpoint)
 
         lvname = "%s-%s" % (self.vg.name, self.device_name)
-        safe_new_name = self.storage.safe_device_name(lvname)
+        safe_new_name = self.storage.safe_device_name(lvname, DEVICE_TYPE_LVM)
         if self.device.name != safe_new_name:
             if safe_new_name in self.storage.names:
                 log.error("not renaming '%s' to in-use name '%s'",

blivet/devicelibs/btrfs.py

@@ -40,5 +40,8 @@
 EXTERNAL_DEPENDENCIES = [availability.BLOCKDEV_BTRFS_PLUGIN]
 
 
+safe_name_characters = "0-9a-zA-Z._@/-"
+
+
 def is_btrfs_name_valid(name):
     return '\x00' not in name

blivet/devicelibs/lvm.py

@@ -63,6 +63,8 @@
 
 LVMETAD_SOCKET_PATH = "/run/lvm/lvmetad.socket"
 
+safe_name_characters = "0-9a-zA-Z._-"
+
 # Start config_args handling code
 #
 # Theoretically we can handle all that can be handled with the LVM --config

blivet/devicelibs/mdraid.py

@@ -31,6 +31,8 @@
 MD_SUPERBLOCK_SIZE = Size("2 MiB")
 MD_CHUNK_SIZE = Size("512 KiB")
 
+safe_name_characters = "0-9a-zA-Z._-"
+
 
 class MDRaidLevels(raid.RAIDLevels):
 

blivet/devices/dm.py

@@ -154,11 +154,6 @@ def _set_name(self, value):
         log_method_call(self, self.name, status=self.status)
         super(DMDevice, self)._set_name(value)
 
-    @property
-    def slave(self):
-        """ This device's backing device. """
-        return self.parents[0]
-
 
 class DMLinearDevice(DMDevice):
     _type = "dm-linear"
@@ -194,8 +189,8 @@ def _setup(self, orig=False):
         """ Open, or set up, a device. """
         log_method_call(self, self.name, orig=orig, status=self.status,
                         controllable=self.controllable)
-        slave_length = self.slave.current_size / LINUX_SECTOR_SIZE
-        blockdev.dm.create_linear(self.name, self.slave.path, slave_length,
+        parent_length = self.parents[0].current_size / LINUX_SECTOR_SIZE
+        blockdev.dm.create_linear(self.name, self.parents[0].path, parent_length,
                                   self.dm_uuid)
 
     def _post_setup(self):

blivet/devices/loop.py

@@ -73,40 +73,40 @@ def _set_name(self, value):
 
     def update_name(self):
         """ Update this device's name. """
-        if not self.slave.status:
+        if not self.parents[0].status:
             # if the backing device is inactive, so are we
             return self.name
 
         if self.name.startswith("loop"):
             # if our name is loopN we must already be active
             return self.name
 
-        name = blockdev.loop.get_loop_name(self.slave.path)
+        name = blockdev.loop.get_loop_name(self.parents[0].path)
         if name.startswith("loop"):
             self.name = name
 
         return self.name
 
     @property
     def status(self):
-        return (self.slave.status and
+        return (self.parents[0].status and
                 self.name.startswith("loop") and
-                blockdev.loop.get_loop_name(self.slave.path) == self.name)
+                blockdev.loop.get_loop_name(self.parents[0].path) == self.name)
 
     @property
     def size(self):
-        return self.slave.size
+        return self.parents[0].size
 
     def _pre_setup(self, orig=False):
-        if not os.path.exists(self.slave.path):
-            raise errors.DeviceError("specified file (%s) does not exist" % self.slave.path)
+        if not os.path.exists(self.parents[0].path):
+            raise errors.DeviceError("specified file (%s) does not exist" % self.parents[0].path)
         return StorageDevice._pre_setup(self, orig=orig)
 
     def _setup(self, orig=False):
         """ Open, or set up, a device. """
         log_method_call(self, self.name, orig=orig, status=self.status,
                         controllable=self.controllable)
-        blockdev.loop.setup(self.slave.path)
+        blockdev.loop.setup(self.parents[0].path)
 
     def _post_setup(self):
         StorageDevice._post_setup(self)
@@ -123,7 +123,3 @@ def _post_teardown(self, recursive=False):
         StorageDevice._post_teardown(self, recursive=recursive)
         self.name = "tmploop%d" % self.id
         self.sysfs_path = ''
-
-    @property
-    def slave(self):
-        return self.parents[0]