From 42042e7fb6177d3cfe5568e358a38278925a2624 Mon Sep 17 00:00:00 2001

From: Vojtech Trefny <vtrefny@redhat.com>

Date: Wed, 26 May 2021 12:27:34 +0200

Subject: [PATCH] Revert "Terminology cleanups"

This reverts following commits:

- 3d46339fe9cf12e9082fcbe4dc5acc9f92617e8d

- 63c9c7165e5cdfa4a47dcf0ed9d717b71e7921f2

- 8956b9af8a785ae25e0e7153d2ef0702ce2f567c

---

 blivet/devicefactory.py               | 24 +++++-----

 blivet/devices/dm.py                  |  9 +++-

 blivet/devices/loop.py                | 20 ++++----

 blivet/devices/luks.py                | 26 +++++-----

 blivet/errors.py                      |  2 +-

 blivet/partitioning.py                | 22 +++++++--

 blivet/populator/helpers/dm.py        |  4 +-

 blivet/populator/helpers/luks.py      |  4 +-

 blivet/populator/helpers/lvm.py       |  2 +-

 blivet/populator/helpers/mdraid.py    | 14 +++---

 blivet/populator/helpers/multipath.py |  8 ++--

 blivet/populator/populator.py         | 69 ++++++++++++++-------------

 blivet/threads.py                     |  3 +-

 blivet/udev.py                        | 34 ++++++-------

 tests/devicefactory_test.py           | 10 ++--

 tests/devices_test/size_test.py       |  6 +--

 tests/populator_test.py               | 34 ++++++-------

 tests/udev_test.py                    | 12 ++---

 tests/vmtests/vmbackedtestcase.py     |  2 +-

 19 files changed, 168 insertions(+), 137 deletions(-)

diff --git a/blivet/devicefactory.py b/blivet/devicefactory.py

index 0f7fdfa1..f56bd9a3 100644

--- a/blivet/devicefactory.py

+++ b/blivet/devicefactory.py

@@ -849,12 +849,12 @@ class DeviceFactory(object):

                 parent_container.parents.remove(orig_device)

         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

+                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_sector_size != self.luks_sector_size:

-            self.raw_device.format.luks_sector_size = self.luks_sector_size

+                self.device.slave.format.luks_sector_size != self.luks_sector_size:

+            self.device.slave.format.luks_sector_size = self.luks_sector_size

     def _set_name(self):

         if not self.device_name:

@@ -1173,11 +1173,11 @@ class PartitionSetFactory(PartitionFactory):

                     container.parents.remove(member)

                 self.storage.destroy_device(member)

                 members.remove(member)

-                self.storage.format_device(member.raw_device,

+                self.storage.format_device(member.slave,

                                            get_format(self.fstype))

-                members.append(member.raw_device)

+                members.append(member.slave)

                 if container:

-                    container.parents.append(member.raw_device)

+                    container.parents.append(member.slave)

                 continue

@@ -1199,10 +1199,10 @@ class PartitionSetFactory(PartitionFactory):

                 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

+            if member_encrypted and self.encrypted and self.luks_version != member.slave.format.luks_version:

+                member.slave.format.luks_version = self.luks_version

+            if member_encrypted and self.encrypted and self.luks_sector_size != member.slave.format.luks_sector_size:

+                member.slave.format.luks_sector_size = self.luks_sector_size

         ##

         # Prepare previously allocated member partitions for reallocation.

@@ -1262,7 +1262,7 @@ class PartitionSetFactory(PartitionFactory):

             if isinstance(member, LUKSDevice):

                 self.storage.destroy_device(member)

-                member = member.raw_device

+                member = member.slave

             self.storage.destroy_device(member)

diff --git a/blivet/devices/dm.py b/blivet/devices/dm.py

index 3529f61c..508a6f89 100644

--- a/blivet/devices/dm.py

+++ b/blivet/devices/dm.py

@@ -154,6 +154,11 @@ class DMDevice(StorageDevice):

         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"

@@ -189,8 +194,8 @@ class DMLinearDevice(DMDevice):

         """ Open, or set up, a device. """

         log_method_call(self, self.name, orig=orig, status=self.status,

                         controllable=self.controllable)

-        parent_length = self.parents[0].current_size / LINUX_SECTOR_SIZE

-        blockdev.dm.create_linear(self.name, self.parents[0].path, parent_length,

+        slave_length = self.slave.current_size / LINUX_SECTOR_SIZE

+        blockdev.dm.create_linear(self.name, self.slave.path, slave_length,

                                   self.dm_uuid)

     def _post_setup(self):

diff --git a/blivet/devices/loop.py b/blivet/devices/loop.py

index 0f4d7775..78f88d7d 100644

--- a/blivet/devices/loop.py

+++ b/blivet/devices/loop.py

@@ -73,7 +73,7 @@ class LoopDevice(StorageDevice):

     def update_name(self):

         """ Update this device's name. """

-        if not self.parents[0].status:

+        if not self.slave.status:

             # if the backing device is inactive, so are we

             return self.name

@@ -81,7 +81,7 @@ class LoopDevice(StorageDevice):

             # if our name is loopN we must already be active

             return self.name

-        name = blockdev.loop.get_loop_name(self.parents[0].path)

+        name = blockdev.loop.get_loop_name(self.slave.path)

         if name.startswith("loop"):

             self.name = name

@@ -89,24 +89,24 @@ class LoopDevice(StorageDevice):

     @property

     def status(self):

-        return (self.parents[0].status and

+        return (self.slave.status and

                 self.name.startswith("loop") and

-                blockdev.loop.get_loop_name(self.parents[0].path) == self.name)

+                blockdev.loop.get_loop_name(self.slave.path) == self.name)

     @property

     def size(self):

-        return self.parents[0].size

+        return self.slave.size

     def _pre_setup(self, orig=False):

-        if not os.path.exists(self.parents[0].path):

-            raise errors.DeviceError("specified file (%s) does not exist" % self.parents[0].path)

+        if not os.path.exists(self.slave.path):

+            raise errors.DeviceError("specified file (%s) does not exist" % self.slave.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.parents[0].path)

+        blockdev.loop.setup(self.slave.path)

     def _post_setup(self):

         StorageDevice._post_setup(self)

@@ -123,3 +123,7 @@ class LoopDevice(StorageDevice):

         StorageDevice._post_teardown(self, recursive=recursive)

         self.name = "tmploop%d" % self.id

         self.sysfs_path = ''

+

+    @property

+    def slave(self):

+        return self.parents[0]

diff --git a/blivet/devices/luks.py b/blivet/devices/luks.py

index 5d6d6c65..555f1acd 100644

--- a/blivet/devices/luks.py

+++ b/blivet/devices/luks.py

@@ -66,13 +66,17 @@ class LUKSDevice(DMCryptDevice):

     @property

     def raw_device(self):

+        return self.slave

+

+    @property

+    def slave(self):

         if self._has_integrity:

             return self.parents[0].parents[0]

         return self.parents[0]

     def _get_size(self):

         if not self.exists:

-            size = self.raw_device.size - crypto.LUKS_METADATA_SIZE

+            size = self.slave.size - crypto.LUKS_METADATA_SIZE

         elif self.resizable and self.target_size != Size(0):

             size = self.target_size

         else:

@@ -80,8 +84,8 @@ class LUKSDevice(DMCryptDevice):

         return size

     def _set_size(self, newsize):

-        if not self.exists and not self.raw_device.exists:

-            self.raw_device.size = newsize + crypto.LUKS_METADATA_SIZE

+        if not self.exists and not self.slave.exists:

+            self.slave.size = newsize + crypto.LUKS_METADATA_SIZE

             # just run the StorageDevice._set_size to make sure we are in the format limits

             super(LUKSDevice, self)._set_size(newsize - crypto.LUKS_METADATA_SIZE)

@@ -108,22 +112,22 @@ class LUKSDevice(DMCryptDevice):

             raise ValueError("size is smaller than the minimum for this device")

         # don't allow larger luks than size (or target size) of backing device

-        if newsize > (self.raw_device.size - crypto.LUKS_METADATA_SIZE):

+        if newsize > (self.slave.size - crypto.LUKS_METADATA_SIZE):

             log.error("requested size %s is larger than size of the backing device %s",

-                      newsize, self.raw_device.size)

+                      newsize, self.slave.size)

             raise ValueError("size is larger than the size of the backing device")

         if self.align_target_size(newsize) != newsize:

             raise ValueError("new size would violate alignment requirements")

     def _get_target_size(self):

-        return self.raw_device.format.target_size

+        return self.slave.format.target_size

     @property

     def max_size(self):

         """ The maximum size this luks device can be. Maximum is based on the

             maximum size of the backing device. """

-        max_luks = self.raw_device.max_size - crypto.LUKS_METADATA_SIZE

+        max_luks = self.slave.max_size - crypto.LUKS_METADATA_SIZE

         max_format = self.format.max_size

         return min(max_luks, max_format) if max_format else max_luks

@@ -131,7 +135,7 @@ class LUKSDevice(DMCryptDevice):

     def resizable(self):

         """ Can this device be resized? """

         return (self._resizable and self.exists and self.format.resizable and

-                self.raw_device.resizable and not self._has_integrity)

+                self.slave.resizable and not self._has_integrity)

     def resize(self):

         # size of LUKSDevice depends on size of the LUKS format on backing

@@ -139,7 +143,7 @@ class LUKSDevice(DMCryptDevice):

         log_method_call(self, self.name, status=self.status)

     def _post_create(self):

-        self.name = self.raw_device.format.map_name

+        self.name = self.slave.format.map_name

         StorageDevice._post_create(self)

     def _post_teardown(self, recursive=False):

@@ -162,10 +166,10 @@ class LUKSDevice(DMCryptDevice):

             self.name = new_name

     def dracut_setup_args(self):

-        return set(["rd.luks.uuid=luks-%s" % self.raw_device.format.uuid])

+        return set(["rd.luks.uuid=luks-%s" % self.slave.format.uuid])

     def populate_ksdata(self, data):

-        self.raw_device.populate_ksdata(data)

+        self.slave.populate_ksdata(data)

         data.encrypted = True

         super(LUKSDevice, self).populate_ksdata(data)

diff --git a/blivet/errors.py b/blivet/errors.py

index fd51283f..f6bf853a 100644

--- a/blivet/errors.py

+++ b/blivet/errors.py

@@ -192,7 +192,7 @@ class DeviceTreeError(StorageError):

     pass

-class NoParentsError(DeviceTreeError):

+class NoSlavesError(DeviceTreeError):

     pass

diff --git a/blivet/partitioning.py b/blivet/partitioning.py

index 53f9cc3f..ca0a55d1 100644

--- a/blivet/partitioning.py

+++ b/blivet/partitioning.py

@@ -32,7 +32,7 @@ import _ped

 from .errors import DeviceError, PartitioningError, AlignmentError

 from .flags import flags

-from .devices import Device, PartitionDevice, device_path_to_name

+from .devices import Device, PartitionDevice, LUKSDevice, device_path_to_name

 from .size import Size

 from .i18n import _

 from .util import stringize, unicodeize, compare

@@ -1632,7 +1632,15 @@ class TotalSizeSet(object):

             :param size: the target combined size

             :type size: :class:`~.size.Size`

         """

-        self.devices = [d.raw_device for d in devices]

+        self.devices = []

+        for device in devices:

+            if isinstance(device, LUKSDevice):

+                partition = device.slave

+            else:

+                partition = device

+

+            self.devices.append(partition)

+

         self.size = size

         self.requests = []

@@ -1670,7 +1678,15 @@ class SameSizeSet(object):

             :keyword max_size: the maximum size for growable devices

             :type max_size: :class:`~.size.Size`

         """

-        self.devices = [d.raw_device for d in devices]

+        self.devices = []

+        for device in devices:

+            if isinstance(device, LUKSDevice):

+                partition = device.slave

+            else:

+                partition = device

+

+            self.devices.append(partition)

+

         self.size = size / len(devices)

         self.grow = grow

         self.max_size = max_size

diff --git a/blivet/populator/helpers/dm.py b/blivet/populator/helpers/dm.py

index 30e99aa1..770736b0 100644

--- a/blivet/populator/helpers/dm.py

+++ b/blivet/populator/helpers/dm.py

@@ -46,13 +46,13 @@ class DMDevicePopulator(DevicePopulator):

         name = udev.device_get_name(self.data)

         log_method_call(self, name=name)

         sysfs_path = udev.device_get_sysfs_path(self.data)

-        parent_devices = self._devicetree._add_parent_devices(self.data)

+        slave_devices = self._devicetree._add_slave_devices(self.data)

         device = self._devicetree.get_device_by_name(name)

         if device is None:

             device = DMDevice(name, dm_uuid=self.data.get('DM_UUID'),

                               sysfs_path=sysfs_path, exists=True,

-                              parents=[parent_devices[0]])

+                              parents=[slave_devices[0]])

             device.protected = True

             device.controllable = False

             self._devicetree._add_device(device)

diff --git a/blivet/populator/helpers/luks.py b/blivet/populator/helpers/luks.py

index 52795a98..51488691 100644

--- a/blivet/populator/helpers/luks.py

+++ b/blivet/populator/helpers/luks.py

@@ -43,7 +43,7 @@ class LUKSDevicePopulator(DevicePopulator):

         return udev.device_is_dm_luks(data)

     def run(self):

-        parents = self._devicetree._add_parent_devices(self.data)

+        parents = self._devicetree._add_slave_devices(self.data)

         device = LUKSDevice(udev.device_get_name(self.data),

                             sysfs_path=udev.device_get_sysfs_path(self.data),

                             parents=parents,

@@ -58,7 +58,7 @@ class IntegrityDevicePopulator(DevicePopulator):

         return udev.device_is_dm_integrity(data)

     def run(self):

-        parents = self._devicetree._add_parent_devices(self.data)

+        parents = self._devicetree._add_slave_devices(self.data)

         device = IntegrityDevice(udev.device_get_name(self.data),

                                  sysfs_path=udev.device_get_sysfs_path(self.data),

                                  parents=parents,

diff --git a/blivet/populator/helpers/lvm.py b/blivet/populator/helpers/lvm.py

index c7adfa4e..b1626306 100644

--- a/blivet/populator/helpers/lvm.py

+++ b/blivet/populator/helpers/lvm.py

@@ -57,7 +57,7 @@ class LVMDevicePopulator(DevicePopulator):

             log.warning("found non-vg device with name %s", vg_name)

             device = None

-        self._devicetree._add_parent_devices(self.data)

+        self._devicetree._add_slave_devices(self.data)

         # LVM provides no means to resolve conflicts caused by duplicated VG

         # names, so we're just being optimistic here. Woo!

diff --git a/blivet/populator/helpers/mdraid.py b/blivet/populator/helpers/mdraid.py

index 3479e3f7..76aebf25 100644

--- a/blivet/populator/helpers/mdraid.py

+++ b/blivet/populator/helpers/mdraid.py

@@ -31,7 +31,7 @@ from ... import udev

 from ...devicelibs import raid

 from ...devices import MDRaidArrayDevice, MDContainerDevice

 from ...devices import device_path_to_name

-from ...errors import DeviceError, NoParentsError

+from ...errors import DeviceError, NoSlavesError

 from ...flags import flags

 from ...storage_log import log_method_call

 from .devicepopulator import DevicePopulator

@@ -52,12 +52,12 @@ class MDDevicePopulator(DevicePopulator):

         log_method_call(self, name=name)

         try:

-            self._devicetree._add_parent_devices(self.data)

-        except NoParentsError:

-            log.error("no parents found for mdarray %s, skipping", name)

+            self._devicetree._add_slave_devices(self.data)

+        except NoSlavesError:

+            log.error("no slaves found for mdarray %s, skipping", name)

             return None

-        # try to get the device again now that we've got all the parents

+        # try to get the device again now that we've got all the slaves

         device = self._devicetree.get_device_by_name(name, incomplete=flags.allow_imperfect_devices)

         if device is None:

@@ -74,8 +74,8 @@ class MDDevicePopulator(DevicePopulator):

             device.name = name

         if device is None:

-            # if we get here, we found all of the parent devices and

-            # something must be wrong -- if all of the parents are in

+            # if we get here, we found all of the slave devices and

+            # something must be wrong -- if all of the slaves are in

             # the tree, this device should be as well

             if name is None:

                 name = udev.device_get_name(self.data)

diff --git a/blivet/populator/helpers/multipath.py b/blivet/populator/helpers/multipath.py

index 96c0a9ad..10c745bf 100644

--- a/blivet/populator/helpers/multipath.py

+++ b/blivet/populator/helpers/multipath.py

@@ -40,13 +40,13 @@ class MultipathDevicePopulator(DevicePopulator):

         name = udev.device_get_name(self.data)

         log_method_call(self, name=name)

-        parent_devices = self._devicetree._add_parent_devices(self.data)

+        slave_devices = self._devicetree._add_slave_devices(self.data)

         device = None

-        if parent_devices:

-            device = MultipathDevice(name, parents=parent_devices,

+        if slave_devices:

+            device = MultipathDevice(name, parents=slave_devices,

                                      sysfs_path=udev.device_get_sysfs_path(self.data),

-                                     wwn=parent_devices[0].wwn)

+                                     wwn=slave_devices[0].wwn)

             self._devicetree._add_device(device)

         return device

diff --git a/blivet/populator/populator.py b/blivet/populator/populator.py

index 75bb1741..d252281d 100644

--- a/blivet/populator/populator.py

+++ b/blivet/populator/populator.py

@@ -31,7 +31,7 @@ gi.require_version("BlockDev", "2.0")

 from gi.repository import BlockDev as blockdev

-from ..errors import DeviceError, DeviceTreeError, NoParentsError

+from ..errors import DeviceError, DeviceTreeError, NoSlavesError

 from ..devices import DMLinearDevice, DMRaidArrayDevice

 from ..devices import FileDevice, LoopDevice

 from ..devices import MDRaidArrayDevice

@@ -92,55 +92,56 @@ class PopulatorMixin(object):

         self._cleanup = False

-    def _add_parent_devices(self, info):

-        """ Add all parents of a device, raising DeviceTreeError on failure.

+    def _add_slave_devices(self, info):

+        """ Add all slaves of a device, raising DeviceTreeError on failure.

             :param :class:`pyudev.Device` info: the device's udev info

-            :raises: :class:`~.errors.DeviceTreeError if no parents are found or

-                     if we fail to add any parent

-            :returns: a list of parent devices

+            :raises: :class:`~.errors.DeviceTreeError if no slaves are found or

+                     if we fail to add any slave

+            :returns: a list of slave devices

             :rtype: list of :class:`~.StorageDevice`

         """

         name = udev.device_get_name(info)

         sysfs_path = udev.device_get_sysfs_path(info)

-        parent_dir = os.path.normpath("%s/slaves" % sysfs_path)

-        parent_names = os.listdir(parent_dir)

-        parent_devices = []

-        if not parent_names:

-            log.error("no parents found for %s", name)

-            raise NoParentsError("no parents found for device %s" % name)

-

-        for parent_name in parent_names:

-            path = os.path.normpath("%s/%s" % (parent_dir, parent_name))

-            parent_info = udev.get_device(os.path.realpath(path))

-

-            if not parent_info:

-                msg = "unable to get udev info for %s" % parent_name

+        slave_dir = os.path.normpath("%s/slaves" % sysfs_path)

+        slave_names = os.listdir(slave_dir)

+        slave_devices = []

+        if not slave_names:

+            log.error("no slaves found for %s", name)

+            raise NoSlavesError("no slaves found for device %s" % name)

+

+        for slave_name in slave_names:

+            path = os.path.normpath("%s/%s" % (slave_dir, slave_name))

+            slave_info = udev.get_device(os.path.realpath(path))

+

+            if not slave_info:

+                msg = "unable to get udev info for %s" % slave_name

                 raise DeviceTreeError(msg)

             # cciss in sysfs is "cciss!cXdYpZ" but we need "cciss/cXdYpZ"

-            parent_name = udev.device_get_name(parent_info).replace("!", "/")

-

-            parent_dev = self.get_device_by_name(parent_name)

-            if not parent_dev and parent_info:

-                # we haven't scanned the parent yet, so do it now

-                self.handle_device(parent_info)

-                parent_dev = self.get_device_by_name(parent_name)

-                if parent_dev is None:

+            slave_name = udev.device_get_name(slave_info).replace("!", "/")

+

+            slave_dev = self.get_device_by_name(slave_name)

+            if not slave_dev and slave_info:

+                # we haven't scanned the slave yet, so do it now

+                self.handle_device(slave_info)

+                slave_dev = self.get_device_by_name(slave_name)

+                if slave_dev is None:

                     if udev.device_is_dm_lvm(info):

-                        if parent_name not in lvs_info.cache:

+                        if slave_name not in lvs_info.cache:

                             # we do not expect hidden lvs to be in the tree

                             continue

-                    # if the current parent is still not in

+                    # if the current slave is still not in

                     # the tree, something has gone wrong

-                    log.error("failure scanning device %s: could not add parent %s", name, parent_name)

-                    msg = "failed to add parent %s of device %s" % (parent_name, name)

+                    log.error("failure scanning device %s: could not add slave %s", name, slave_name)

+                    msg = "failed to add slave %s of device %s" % (slave_name,

+                                                                   name)

                     raise DeviceTreeError(msg)

-            parent_devices.append(parent_dev)

+            slave_devices.append(slave_dev)

-        return parent_devices

+        return slave_devices

     def _add_name(self, name):

         if name not in self.names:

@@ -317,7 +318,7 @@ class PopulatorMixin(object):

                 continue

             # Make sure lvm doesn't get confused by PVs that belong to

-            # incomplete VGs. We will remove the PVs from the reject list when/if

+            # incomplete VGs. We will remove the PVs from the blacklist when/if

             # the time comes to remove the incomplete VG and its PVs.

             for pv in vg.pvs:

                 lvm.lvm_cc_addFilterRejectRegexp(pv.name)

diff --git a/blivet/threads.py b/blivet/threads.py

index 7e6d3105..a70deb69 100644

--- a/blivet/threads.py

+++ b/blivet/threads.py

@@ -63,11 +63,12 @@ class SynchronizedMeta(type):

     """

     def __new__(cls, name, bases, dct):

         new_dct = {}

+        blacklist = dct.get('_unsynchronized_methods', [])

         for n in dct:

             obj = dct[n]

             # Do not decorate class or static methods.

-            if n in dct.get('_unsynchronized_methods', []):

+            if n in blacklist:

                 pass

             elif isinstance(obj, FunctionType):

                 obj = exclusive(obj)

diff --git a/blivet/udev.py b/blivet/udev.py

index a8297f3f..e1b67845 100644

--- a/blivet/udev.py

+++ b/blivet/udev.py

@@ -39,7 +39,7 @@ from gi.repository import BlockDev as blockdev

 global_udev = pyudev.Context()

 log = logging.getLogger("blivet")

-ignored_device_names = []

+device_name_blacklist = []

 """ device name regexes to ignore; this should be empty by default """

@@ -77,7 +77,7 @@ def get_devices(subsystem="block"):

     result = []

     for device in global_udev.list_devices(subsystem=subsystem):

-        if not __is_ignored_blockdev(device.sys_name):

+        if not __is_blacklisted_blockdev(device.sys_name):

             dev = device_to_dict(device)

             result.append(dev)

@@ -176,13 +176,13 @@ def resolve_glob(glob):

     return ret

-def __is_ignored_blockdev(dev_name):

+def __is_blacklisted_blockdev(dev_name):

     """Is this a blockdev we never want for an install?"""

     if dev_name.startswith("ram") or dev_name.startswith("fd"):

         return True

-    if ignored_device_names:

-        if any(re.search(expr, dev_name) for expr in ignored_device_names):

+    if device_name_blacklist:

+        if any(re.search(expr, dev_name) for expr in device_name_blacklist):

             return True

     dev_path = "/sys/class/block/%s" % dev_name

@@ -374,7 +374,7 @@ def device_is_disk(info):

                  device_is_dm_lvm(info) or

                  device_is_dm_crypt(info) or

                  (device_is_md(info) and

-                  (not device_get_md_container(info) and not all(device_is_disk(d) for d in device_get_parents(info))))))

+                  (not device_get_md_container(info) and not all(device_is_disk(d) for d in device_get_slaves(info))))))

 def device_is_partition(info):

@@ -453,18 +453,18 @@ def device_get_devname(info):

     return info.get('DEVNAME')

-def device_get_parents(info):

-    """ Return a list of udev device objects representing this device's parents. """

-    parents_dir = device_get_sysfs_path(info) + "/slaves/"

+def device_get_slaves(info):

+    """ Return a list of udev device objects representing this device's slaves. """

+    slaves_dir = device_get_sysfs_path(info) + "/slaves/"

     names = list()

-    if os.path.isdir(parents_dir):

-        names = os.listdir(parents_dir)

+    if os.path.isdir(slaves_dir):

+        names = os.listdir(slaves_dir)

-    parents = list()

+    slaves = list()

     for name in names:

-        parents.append(get_device(device_node="/dev/" + name))

+        slaves.append(get_device(device_node="/dev/" + name))

-    return parents

+    return slaves

 def device_get_holders(info):

@@ -736,7 +736,7 @@ def device_get_partition_disk(info):

     disk = None

     majorminor = info.get("ID_PART_ENTRY_DISK")

     sysfs_path = device_get_sysfs_path(info)

-    parents_dir = "%s/slaves" % sysfs_path

+    slaves_dir = "%s/slaves" % sysfs_path

     if majorminor:

         major, minor = majorminor.split(":")

         for device in get_devices():

@@ -744,8 +744,8 @@ def device_get_partition_disk(info):

                 disk = device_get_name(device)

                 break

     elif device_is_dm_partition(info):

-        if os.path.isdir(parents_dir):

-            parents = os.listdir(parents_dir)

+        if os.path.isdir(slaves_dir):

+            parents = os.listdir(slaves_dir)

             if len(parents) == 1:

                 disk = resolve_devspec(parents[0].replace('!', '/'))

     else:

diff --git a/tests/devicefactory_test.py b/tests/devicefactory_test.py

index dc0d6408..dfd78a7a 100644

--- a/tests/devicefactory_test.py

+++ b/tests/devicefactory_test.py

@@ -112,9 +112,9 @@ class DeviceFactoryTestCase(unittest.TestCase):

                          kwargs.get("encrypted", False) or

                          kwargs.get("container_encrypted", False))

         if kwargs.get("encrypted", False):

-            self.assertEqual(device.parents[0].format.luks_version,

+            self.assertEqual(device.slave.format.luks_version,

                              kwargs.get("luks_version", crypto.DEFAULT_LUKS_VERSION))

-            self.assertEqual(device.raw_device.format.luks_sector_size,

+            self.assertEqual(device.slave.format.luks_sector_size,

                              kwargs.get("luks_sector_size", 0))

         self.assertTrue(set(device.disks).issubset(kwargs["disks"]))

@@ -354,7 +354,7 @@ class LVMFactoryTestCase(DeviceFactoryTestCase):

         device = args[0]

         if kwargs.get("encrypted"):

-            container = device.parents[0].container

+            container = device.slave.container

         else:

             container = device.container

@@ -373,7 +373,7 @@ class LVMFactoryTestCase(DeviceFactoryTestCase):

             self.assertIsInstance(pv, member_class)

             if pv.encrypted:

-                self.assertEqual(pv.parents[0].format.luks_version,

+                self.assertEqual(pv.slave.format.luks_version,

                                  kwargs.get("luks_version", crypto.DEFAULT_LUKS_VERSION))

     @patch("blivet.formats.lvmpv.LVMPhysicalVolume.formattable", return_value=True)

@@ -589,7 +589,7 @@ class LVMThinPFactoryTestCase(LVMFactoryTestCase):

         device = args[0]

         if kwargs.get("encrypted", False):

-            thinlv = device.parents[0]

+            thinlv = device.slave

         else:

             thinlv = device

diff --git a/tests/devices_test/size_test.py b/tests/devices_test/size_test.py

index d0c0a3f4..a1efa86d 100644

--- a/tests/devices_test/size_test.py

+++ b/tests/devices_test/size_test.py

@@ -107,8 +107,8 @@ class LUKSDeviceSizeTest(StorageDeviceSizeTest):

     def _get_device(self, *args, **kwargs):

         exists = kwargs.get("exists", False)

-        parent = StorageDevice(*args, size=kwargs["size"] + crypto.LUKS_METADATA_SIZE, exists=exists)

-        return LUKSDevice(*args, **kwargs, parents=[parent])

+        slave = StorageDevice(*args, size=kwargs["size"] + crypto.LUKS_METADATA_SIZE, exists=exists)

+        return LUKSDevice(*args, **kwargs, parents=[slave])

     def test_size_getter(self):

         initial_size = Size("10 GiB")

@@ -116,4 +116,4 @@ class LUKSDeviceSizeTest(StorageDeviceSizeTest):

         # for LUKS size depends on the backing device size

         self.assertEqual(dev.size, initial_size)

-        self.assertEqual(dev.raw_device.size, initial_size + crypto.LUKS_METADATA_SIZE)

+        self.assertEqual(dev.slave.size, initial_size + crypto.LUKS_METADATA_SIZE)

diff --git a/tests/populator_test.py b/tests/populator_test.py

index a7748a9d..531ec74b 100644

--- a/tests/populator_test.py

+++ b/tests/populator_test.py

@@ -81,7 +81,7 @@ class DMDevicePopulatorTestCase(PopulatorHelperTestCase):

     @patch.object(DeviceTree, "get_device_by_name")

     @patch.object(DMDevice, "status", return_value=True)

     @patch.object(DMDevice, "update_sysfs_path")

-    @patch.object(DeviceTree, "_add_parent_devices")

+    @patch.object(DeviceTree, "_add_slave_devices")

     @patch("blivet.udev.device_get_name")

     @patch("blivet.udev.device_get_sysfs_path", return_value=sentinel.sysfs_path)

     def test_run(self, *args):

@@ -90,7 +90,7 @@ class DMDevicePopulatorTestCase(PopulatorHelperTestCase):

         devicetree = DeviceTree()

-        # The general case for dm devices is that adding the parent devices

+        # The general case for dm devices is that adding the slave/parent devices

         # will result in the dm device itself being in the tree.

         device = Mock()

         devicetree.get_device_by_name.return_value = device

@@ -99,7 +99,7 @@ class DMDevicePopulatorTestCase(PopulatorHelperTestCase):

         parent = Mock()

         parent.parents = []

-        devicetree._add_parent_devices.return_value = [parent]

+        devicetree._add_slave_devices.return_value = [parent]

         devicetree._add_device(parent)

         devicetree.get_device_by_name.return_value = None

         device_name = "dmdevice"

@@ -228,7 +228,7 @@ class LVMDevicePopulatorTestCase(PopulatorHelperTestCase):

         # could be the first helper class checked.

     @patch.object(DeviceTree, "get_device_by_name")

-    @patch.object(DeviceTree, "_add_parent_devices")

+    @patch.object(DeviceTree, "_add_slave_devices")

     @patch("blivet.udev.device_get_name")

     @patch("blivet.udev.device_get_lv_vg_name")

     def test_run(self, *args):

@@ -240,7 +240,7 @@ class LVMDevicePopulatorTestCase(PopulatorHelperTestCase):

         devicetree = DeviceTree()

         data = Mock()

-        # Add parent devices and then look up the device.

+        # Add slave/parent devices and then look up the device.

         device_get_name.return_value = sentinel.lv_name

         devicetree.get_device_by_name.return_value = None

@@ -260,7 +260,7 @@ class LVMDevicePopulatorTestCase(PopulatorHelperTestCase):

              call(sentinel.vg_name),

              call(sentinel.lv_name)])

-        # Add parent devices, but the device is still not in the tree

+        # Add slave/parent devices, but the device is still not in the tree

         get_device_by_name.side_effect = None

         get_device_by_name.return_value = None

         self.assertEqual(helper.run(), None)

@@ -625,7 +625,7 @@ class MDDevicePopulatorTestCase(PopulatorHelperTestCase):

         # could be the first helper class checked.

     @patch.object(DeviceTree, "get_device_by_name")

-    @patch.object(DeviceTree, "_add_parent_devices")

+    @patch.object(DeviceTree, "_add_slave_devices")

     @patch("blivet.udev.device_get_name")

     @patch("blivet.udev.device_get_md_uuid")

     @patch("blivet.udev.device_get_md_name")

@@ -636,7 +636,7 @@ class MDDevicePopulatorTestCase(PopulatorHelperTestCase):

         devicetree = DeviceTree()

-        # base case: _add_parent_devices gets the array into the tree

+        # base case: _add_slave_devices gets the array into the tree

         data = Mock()

         device = Mock()

         device.parents = []

@@ -699,12 +699,12 @@ class MultipathDevicePopulatorTestCase(PopulatorHelperTestCase):

         # could be the first helper class checked.

     @patch("blivet.udev.device_get_sysfs_path")

-    @patch.object(DeviceTree, "_add_parent_devices")

+    @patch.object(DeviceTree, "_add_slave_devices")

     @patch("blivet.udev.device_get_name")

     def test_run(self, *args):

         """Test multipath device populator."""

         device_get_name = args[0]

-        add_parent_devices = args[1]

+        add_slave_devices = args[1]

         devicetree = DeviceTree()

         # set up some fake udev data to verify handling of specific entries

@@ -719,13 +719,13 @@ class MultipathDevicePopulatorTestCase(PopulatorHelperTestCase):

         device_name = "mpathtest"

         device_get_name.return_value = device_name

-        parent_1 = Mock(tags=set(), wwn=wwn[2:])

-        parent_1.parents = []

-        parent_2 = Mock(tags=set(), wwn=wwn[2:])

-        parent_2.parents = []

-        devicetree._add_device(parent_1)

-        devicetree._add_device(parent_2)

-        add_parent_devices.return_value = [parent_1, parent_2]

+        slave_1 = Mock(tags=set(), wwn=wwn[2:])

+        slave_1.parents = []

+        slave_2 = Mock(tags=set(), wwn=wwn[2:])

+        slave_2.parents = []

+        devicetree._add_device(slave_1)

+        devicetree._add_device(slave_2)

+        add_slave_devices.return_value = [slave_1, slave_2]

         helper = self.helper_class(devicetree, data)

diff --git a/tests/udev_test.py b/tests/udev_test.py

index f9b10620..d30a647b 100644

--- a/tests/udev_test.py

+++ b/tests/udev_test.py

@@ -45,11 +45,11 @@ class UdevTest(unittest.TestCase):

     @mock.patch('blivet.udev.device_is_dm_crypt', return_value=False)

     @mock.patch('blivet.udev.device_is_md')

     @mock.patch('blivet.udev.device_get_md_container')

-    @mock.patch('blivet.udev.device_get_parents')

+    @mock.patch('blivet.udev.device_get_slaves')

     def test_udev_device_is_disk_md(self, *args):

         import blivet.udev

         info = dict(DEVTYPE='disk', SYS_PATH=mock.sentinel.md_path)

-        (device_get_parents, device_get_md_container, device_is_md) = args[:3]  # pylint: disable=unbalanced-tuple-unpacking

+        (device_get_slaves, device_get_md_container, device_is_md) = args[:3]  # pylint: disable=unbalanced-tuple-unpacking

         disk_parents = [dict(DEVTYPE="disk", SYS_PATH='/fake/path/2'),

                         dict(DEVTYPE="disk", SYS_PATH='/fake/path/3')]

@@ -64,20 +64,20 @@ class UdevTest(unittest.TestCase):

         # Intel FW RAID (MD RAID w/ container layer)

         # device_get_container will return some mock value which will evaluate to True

         device_get_md_container.return_value = mock.sentinel.md_container

-        device_get_parents.side_effect = lambda info: list()

+        device_get_slaves.side_effect = lambda info: list()

         self.assertTrue(blivet.udev.device_is_disk(info))

         # Normal MD RAID

-        device_get_parents.side_effect = lambda info: partition_parents if info['SYS_PATH'] == mock.sentinel.md_path else list()

+        device_get_slaves.side_effect = lambda info: partition_parents if info['SYS_PATH'] == mock.sentinel.md_path else list()

         device_get_md_container.return_value = None