Merge ~raharper/curtin:fix/mpath-partition-wiping into curtin:master

[Ryan Harper]

multipath: handle removal of multipath partitions correctly

Curtin could handle multipath-partition removal if it was given
the device-mapper device (dm-x) however, if it was fed the
underying scsi device (e.g. sda2) this would fail when curtin
would try to clear the partition requesting exclusive access
which it could not obtain due to the device-mapper device.

This branch implements a kernel scsi device lookup to map
sdXN -> dm-N mapping which resolves the issue by allowing
curtin to wipe the dm-X device even if it has been
provided the sdXN device.

Additional Changes
 - Enable dirty_disk mode on multipath test to reproduce
   failure

LP: #1857042

5514b58... by Ryan Harper on 2020-01-22

Handle multipath not installed in dirty_disk setup.

[Server Team CI bot (server-team-bot)]

FAILED: Continuous integration, rev:0bf2887ad5957495c63b08c4e8a4001003e82702
https://jenkins.ubuntu.com/server/job/curtin-ci/3812/
Executed test runs:
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-arm64/3812/
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-ppc64el/3812/
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-s390x/3812/
    FAILURE: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=torkoal/3812/

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/server/job/curtin-ci/3812//rebuild

review: Needs Fixing (continuous-integration)

[Server Team CI bot (server-team-bot)]

PASSED: Continuous integration, rev:5514b585ae48ffd9b7ee44082c6960367c91ed32
https://jenkins.ubuntu.com/server/job/curtin-ci/3813/
Executed test runs:
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-arm64/3813/
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-ppc64el/3813/
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-s390x/3813/
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=torkoal/3813/

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/server/job/curtin-ci/3813//rebuild

review: Approve (continuous-integration)

[Dan Watkins (oddbloke)]

A few inline comments/questions. Thanks!

cddfb4d... by Ryan Harper on 2020-01-23

Update comment and remove unneeded variable initialization.

79dd492... by Ryan Harper on 2020-01-23

Refactor logic to drop unneeded mpath_is_member call

10b2611... by Ryan Harper on 2020-01-23

multipath: move up no device found check

79748dd... by Ryan Harper on 2020-01-23

Handle dmsetup names with spaces

[Ryan Harper (raharper)]

Working on fixes, thanks for the review, update coming in just a bit

36cdc45... by Ryan Harper on 2020-01-23

Add an additional path to make test more clear.

9f40323... by Ryan Harper on 2020-01-23

Use assertIsNone

[Server Team CI bot (server-team-bot)]

FAILED: Continuous integration, rev:9f403230ba2c53c267acc3f53eed8e8d30e3d14e
https://jenkins.ubuntu.com/server/job/curtin-ci/3815/
Executed test runs:
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-arm64/3815/
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-ppc64el/3815/
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-s390x/3815/
    FAILURE: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=torkoal/3815/

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/server/job/curtin-ci/3815//rebuild

review: Needs Fixing (continuous-integration)

[Server Team CI bot (server-team-bot)]

FAILED: Continuous integration, rev:9f403230ba2c53c267acc3f53eed8e8d30e3d14e
https://jenkins.ubuntu.com/server/job/curtin-ci/3816/
Executed test runs:
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-arm64/3816/
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-ppc64el/3816/
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-s390x/3816/
    FAILURE: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=torkoal/3816/

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/server/job/curtin-ci/3816//rebuild

review: Needs Fixing (continuous-integration)

1acb477... by Ryan Harper on 2020-01-24

multipath: add docstrings to unittests

Also, update the negative case for dmsetup ls output.

4b17684... by Ryan Harper on 2020-01-24

multipath: update docstrings and add supported check

Bionic and older systems do not have multipath installed by
default so curtin will check if multipath tools are present
and only issues multipath commands if they are needed. This
fixes the bionic basic test on this branch.

dd507cc... by Ryan Harper on 2020-01-24

Add footer to multipath.py

[Server Team CI bot (server-team-bot)]

PASSED: Continuous integration, rev:dd507cc6916f4c4366773f867251044b19130031
https://jenkins.ubuntu.com/server/job/curtin-ci/3817/
Executed test runs:
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-arm64/3817/
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-ppc64el/3817/
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-s390x/3817/
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=torkoal/3817/

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/server/job/curtin-ci/3817//rebuild

review: Approve (continuous-integration)

6a07152... by Ryan Harper on 2020-01-24

multipath: try harder when removing multipath devices, add verbosity

[Server Team CI bot (server-team-bot)]

PASSED: Continuous integration, rev:6a07152bfbed01ea2589320128d431de543e5baa
https://jenkins.ubuntu.com/server/job/curtin-ci/3819/
Executed test runs:
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-arm64/3819/
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-ppc64el/3819/
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-s390x/3819/
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=torkoal/3819/

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/server/job/curtin-ci/3819//rebuild

review: Approve (continuous-integration)

[Dan Watkins (oddbloke)]

LGTM, thanks!

review: Approve

diff --git a/curtin/block/clear_holders.py b/curtin/block/clear_holders.py
index 10e7dc5..08aa70a 100644
--- a/curtin/block/clear_holders.py
+++ b/curtin/block/clear_holders.py
@@ -285,7 +285,25 @@ def wipe_superblock(device):
             else:
                 bcache._stop_device(stop_path)
 
-    _wipe_superblock(blockdev)
+    # the blockdev (e.g. /dev/sda2) may be a multipath partition which can
+    # only be wiped via its device mapper device (e.g. /dev/dm-4)
+    # check for this and determine the correct device mapper value to use.
+    mp_dev = None
+    mp_support = multipath.multipath_supported()
+    if mp_support:
+        parent, partnum = block.get_blockdev_for_partition(blockdev)
+        parent_mpath_id = multipath.find_mpath_id_by_path(parent)
+        if parent_mpath_id is not None:
+            # construct multipath dmsetup id
+            # <mpathid>-part%d -> /dev/dm-1
+            mp_id, mp_dev = multipath.find_mpath_id_by_parent(parent_mpath_id,
+                                                              partnum=partnum)
+            # if we don't find a mapping then the mp partition has already been
+            # wiped/removed
+            if mp_dev:
+                _wipe_superblock(mp_dev)
+    else:
+        _wipe_superblock(blockdev)
 
     # if we had partitions, make sure they've been removed
     if partitions:
@@ -308,16 +326,19 @@ def wipe_superblock(device):
                       device, attempt + 1, len(retries), wait)
             time.sleep(wait)
 
-    # multipath partitions are separate block devices (disks)
-    if multipath.is_mpath_partition(blockdev):
-        multipath.remove_partition(blockdev)
-    # multipath devices must be hidden to utilize a single member (path)
-    elif multipath.is_mpath_device(blockdev):
-        mp_id = multipath.find_mpath_id(blockdev)
-        if mp_id:
-            multipath.remove_map(mp_id)
-        else:
-            raise RuntimeError('Failed to find multipath id for %s' % blockdev)
+    if mp_support:
+        # multipath partitions are separate block devices (disks)
+        if mp_dev or multipath.is_mpath_partition(blockdev):
+            multipath.remove_partition(mp_dev if mp_dev else blockdev)
+        # multipath devices must be hidden to utilize a single member (path)
+        elif multipath.is_mpath_device(blockdev):
+            mp_id = multipath.find_mpath_id(blockdev)
+            multipath.remove_partition(blockdev)
+            if mp_id:
+                multipath.remove_map(mp_id)
+            else:
+                raise RuntimeError(
+                    'Failed to find multipath id for %s' % blockdev)
 
 
 def _wipe_superblock(blockdev, exclusive=True, strict=True):
diff --git a/curtin/block/multipath.py b/curtin/block/multipath.py
index d1e8441..8ce0509 100644
--- a/curtin/block/multipath.py
+++ b/curtin/block/multipath.py
@@ -11,6 +11,7 @@ SHOW_MAPS_FMT = "name=%n multipath='%w' sysfs='%d' paths='%N'"
 
 
 def _extract_mpath_data(cmd, show_verb):
+    """ Parse output from specifed command output via load_shell_content."""
     data, _err = util.subp(cmd, capture=True)
     result = []
     for line in data.splitlines():
@@ -23,16 +24,34 @@ def _extract_mpath_data(cmd, show_verb):
 
 
 def show_paths():
+    """ Query multipathd for paths output and return a dict of the values."""
     cmd = ['multipathd', 'show', 'paths', 'raw', 'format', SHOW_PATHS_FMT]
     return _extract_mpath_data(cmd, 'paths')
 
 
 def show_maps():
+    """ Query multipathd for maps output and return a dict of the values."""
     cmd = ['multipathd', 'show', 'maps', 'raw', 'format', SHOW_MAPS_FMT]
     return _extract_mpath_data(cmd, 'maps')
 
 
+def dmname_to_blkdev_mapping():
+    """ Use dmsetup ls output to build a dict of DM_NAME, /dev/dm-x values."""
+    data, _err = util.subp(['dmsetup', 'ls', '-o', 'blkdevname'], capture=True)
+    mapping = {}
+    if data and data.strip() != "No devices found":
+        LOG.debug('multipath: dmsetup ls output:\n%s', data)
+        for line in data.splitlines():
+            if line:
+                dm_name, blkdev = line.split('\t')
+                # (dm-1) -> /dev/dm-1
+                mapping[dm_name] = '/dev/' + blkdev.strip('()')
+
+    return mapping
+
+
 def is_mpath_device(devpath):
+    """ Check if devpath is a multipath device, returns boolean. """
     info = udev.udevadm_info(devpath)
     if info.get('DM_UUID', '').startswith('mpath-'):
         return True
@@ -41,6 +60,7 @@ def is_mpath_device(devpath):
 
 
 def is_mpath_member(devpath):
+    """ Check if a device is a multipath member (a path), returns boolean. """
     try:
         util.subp(['multipath', '-c', devpath], capture=True)
         return True
@@ -49,6 +69,7 @@ def is_mpath_member(devpath):
 
 
 def is_mpath_partition(devpath):
+    """ Check if a device is a multipath partition, returns boolean. """
     if devpath.startswith('/dev/dm-'):
         if 'DM_PART' in udev.udevadm_info(devpath):
             LOG.debug("%s is multipath device partition", devpath)
@@ -58,6 +79,7 @@ def is_mpath_partition(devpath):
 
 
 def mpath_partition_to_mpath_id(devpath):
+    """ Return the mpath id of a multipath partition. """
     info = udev.udevadm_info(devpath)
     if 'DM_MPATH' in info:
         return info['DM_MPATH']
@@ -66,9 +88,10 @@ def mpath_partition_to_mpath_id(devpath):
 
 
 def remove_partition(devpath, retries=10):
+    """ Remove a multipath partition mapping. """
     LOG.debug('multipath: removing multipath partition: %s', devpath)
     for _ in range(0, retries):
-        util.subp(['dmsetup', 'remove', devpath], rcs=[0, 1])
+        util.subp(['dmsetup', 'remove', '--force', '--retry', devpath])
         udev.udevadm_settle()
         if not os.path.exists(devpath):
             return
@@ -77,10 +100,11 @@ def remove_partition(devpath, retries=10):
 
 
 def remove_map(map_id, retries=10):
+    """ Remove a multipath device mapping. """
     LOG.debug('multipath: removing multipath map: %s', map_id)
     devpath = '/dev/mapper/%s' % map_id
     for _ in range(0, retries):
-        util.subp(['multipath', '-f', map_id], rcs=[0, 1])
+        util.subp(['multipath', '-v3', '-R3', '-f', map_id], rcs=[0, 1])
         udev.udevadm_settle()
         if not os.path.exists(devpath):
             return
@@ -89,6 +113,7 @@ def remove_map(map_id, retries=10):
 
 
 def find_mpath_members(multipath_id, paths=None):
+    """ Return a list of device path for each member of aspecified mpath_id."""
     if not paths:
         paths = show_paths()
 
@@ -98,6 +123,7 @@ def find_mpath_members(multipath_id, paths=None):
 
 
 def find_mpath_id(devpath, maps=None):
+    """ Return the mpath_id associated with a specified device path. """
     if not maps:
         maps = show_maps()
 
@@ -109,3 +135,49 @@ def find_mpath_id(devpath, maps=None):
             return mpmap['multipath']
 
     return None
+
+
+def find_mpath_id_by_path(devpath, paths=None):
+    """ Return the mpath_id associated with a specified device path. """
+    if not paths:
+        paths = show_paths()
+
+    for path in paths:
+        if devpath == '/dev/' + path['device']:
+            return path['multipath']
+
+    return None
+
+
+def find_mpath_id_by_parent(multipath_id, partnum=None):
+    """ Return the mpath_id associated with a specified device path. """
+    devmap = dmname_to_blkdev_mapping()
+    LOG.debug('multipath: dm_name blk map: %s', devmap)
+    dm_name = multipath_id
+    if partnum:
+        dm_name += "-part%d" % int(partnum)
+
+    return (dm_name, devmap.get(dm_name))
+
+
+def multipath_supported():
+    """Return a boolean indicating if multipath is supported."""
+    try:
+        multipath_assert_supported()
+        return True
+    except RuntimeError:
+        return False
+
+
+def multipath_assert_supported():
+    """ Determine if the runtime system supports multipath.
+    returns: True if system supports multipath
+    raises: RuntimeError: if system does not support multipath
+    """
+    missing_progs = [p for p in ('multipath', 'multipathd')
+                     if not util.which(p)]
+    if missing_progs:
+        raise RuntimeError(
+            "Missing multipath utils: %s" % ','.join(missing_progs))
+
+# vi: ts=4 expandtab syntax=python
diff --git a/examples/tests/dirty_disks_config.yaml b/examples/tests/dirty_disks_config.yaml
index 9fd68ab..2f86f9e 100644
--- a/examples/tests/dirty_disks_config.yaml
+++ b/examples/tests/dirty_disks_config.yaml
@@ -22,6 +22,13 @@ bucket:
     done
     swapon --show
     exit 0
+  - &multipath_on |
+      #!/bin/sh
+      if command -v multipath; then
+          multipath -ll
+          multipath -r
+          multipath -ll
+      fi
   - &zpool_export |
       #!/bin/sh
       # disable any rpools to trigger disks with zfs_member label but inactive
@@ -80,6 +87,7 @@ early_commands:
               WORKING_DIR=/tmp/my.bdir/work.d,
               curtin, --showtrace, -v, block-meta, --umount, custom]
   02-enable_swaps: [sh, -c, *swapon]
+  02-multipath_on: [sh, -c, *multipath_on]
   03-disable_rpool: [sh, -c, *zpool_export]
   04-lvm_stop: [sh, -c, *lvm_stop]
   05-mdadm_stop: [sh, -c, *mdadm_stop]
diff --git a/tests/unittests/test_block_multipath.py b/tests/unittests/test_block_multipath.py
index 0964349..b0a8e32 100644
--- a/tests/unittests/test_block_multipath.py
+++ b/tests/unittests/test_block_multipath.py
@@ -4,6 +4,14 @@ from curtin.block import multipath
 from .helpers import CiTestCase, raise_pexec_error
 
 
+# dmsetup uses tabs as separators
+DMSETUP_LS_BLKDEV_OUTPUT = '''\
+mpatha	(dm-0)
+mpatha-part1	(dm-1)
+1gb zero	(dm-2)
+'''
+
+
 class TestMultipath(CiTestCase):
 
     def setUp(self):
@@ -14,6 +22,7 @@ class TestMultipath(CiTestCase):
         self.m_subp.return_value = ("", "")
 
     def test_show_paths(self):
+        """verify show_paths extracts mulitpath path data correctly."""
         self.m_subp.return_value = ("foo=bar wark=2", "")
         expected = ['multipathd', 'show', 'paths', 'raw', 'format',
                     multipath.SHOW_PATHS_FMT]
@@ -22,6 +31,7 @@ class TestMultipath(CiTestCase):
         self.m_subp.assert_called_with(expected, capture=True)
 
     def test_show_maps(self):
+        """verify show_maps extracts mulitpath map data correctly."""
         self.m_subp.return_value = ("foo=bar wark=2", "")
         expected = ['multipathd', 'show', 'maps', 'raw', 'format',
                     multipath.SHOW_MAPS_FMT]
@@ -30,29 +40,36 @@ class TestMultipath(CiTestCase):
         self.m_subp.assert_called_with(expected, capture=True)
 
     def test_is_mpath_device_true(self):
+        """is_mpath_device returns true if dev DM_UUID starts with mpath-"""
         self.m_udev.udevadm_info.return_value = {'DM_UUID': 'mpath-mpatha-foo'}
         self.assertTrue(multipath.is_mpath_device(self.random_string()))
 
     def test_is_mpath_device_false(self):
+        """is_mpath_device returns false when DM_UUID doesnt start w/ mpath-"""
         self.m_udev.udevadm_info.return_value = {'DM_UUID': 'lvm-vg-foo-lv1'}
         self.assertFalse(multipath.is_mpath_device(self.random_string()))
 
     def test_is_mpath_member_true(self):
+        """is_mpath_device returns false when DM_UUID doesnt start w/ mpath-"""
         self.assertTrue(multipath.is_mpath_member(self.random_string()))
 
     def test_is_mpath_member_false(self):
+        """is_mpath_member returns false if 'multipath -c <dev>' exits err."""
         self.m_subp.side_effect = raise_pexec_error
         self.assertFalse(multipath.is_mpath_member(self.random_string()))
 
     def test_is_mpath_partition_true(self):
+        """is_mpath_member returns true if 'multipath -c <dev>' exits 0."""
         dm_device = "/dev/dm-" + self.random_string()
         self.m_udev.udevadm_info.return_value = {'DM_PART': '1'}
         self.assertTrue(multipath.is_mpath_partition(dm_device))
 
     def test_is_mpath_partition_false(self):
+        """is_mpath_member returns false if DM_PART is not present for dev."""
         self.assertFalse(multipath.is_mpath_partition(self.random_string()))
 
     def test_mpath_partition_to_mpath_id(self):
+        """mpath_part_to_mpath_id extracts MD_MPATH value from mp partition."""
         dev = self.random_string()
         mpath_id = self.random_string()
         self.m_udev.udevadm_info.return_value = {'DM_MPATH': mpath_id}
@@ -60,18 +77,20 @@ class TestMultipath(CiTestCase):
                          multipath.mpath_partition_to_mpath_id(dev))
 
     def test_mpath_partition_to_mpath_id_none(self):
+        """mpath_part_to_mpath_id returns none if DM_MPATH missing."""
         dev = self.random_string()
         self.m_udev.udevadm_info.return_value = {}
-        self.assertEqual(None,
-                         multipath.mpath_partition_to_mpath_id(dev))
+        self.assertIsNone(multipath.mpath_partition_to_mpath_id(dev))
 
     @mock.patch('curtin.block.multipath.os.path.exists')
     @mock.patch('curtin.block.multipath.util.wait_for_removal')
     def test_remove_partition(self, m_wait, m_exists):
+        """multipath.remove_partition runs dmsetup skips wait if dev gone."""
         devpath = self.random_string()
         m_exists.side_effect = iter([True, True, False])
         multipath.remove_partition(devpath)
-        expected = mock.call(['dmsetup', 'remove', devpath], rcs=[0, 1])
+        expected = mock.call(
+            ['dmsetup', 'remove', '--force', '--retry', devpath])
         self.m_subp.assert_has_calls([expected] * 3)
         m_wait.assert_not_called()
         self.assertEqual(3, self.m_udev.udevadm_settle.call_count)
@@ -79,10 +98,12 @@ class TestMultipath(CiTestCase):
     @mock.patch('curtin.block.multipath.os.path.exists')
     @mock.patch('curtin.block.multipath.util.wait_for_removal')
     def test_remove_partition_waits(self, m_wait, m_exists):
+        """multipath.remove_partition runs dmsetup waits if dev still there."""
         devpath = self.random_string()
         m_exists.side_effect = iter([True, True, True])
         multipath.remove_partition(devpath, retries=3)
-        expected = mock.call(['dmsetup', 'remove', devpath], rcs=[0, 1])
+        expected = mock.call(
+            ['dmsetup', 'remove', '--force', '--retry', devpath])
         self.m_subp.assert_has_calls([expected] * 3)
         self.assertEqual(3, self.m_udev.udevadm_settle.call_count)
         self.assertEqual(1, m_wait.call_count)
@@ -90,11 +111,13 @@ class TestMultipath(CiTestCase):
     @mock.patch('curtin.block.multipath.os.path.exists')
     @mock.patch('curtin.block.multipath.util.wait_for_removal')
     def test_remove_map(self, m_wait, m_exists):
+        """multipath.remove_map runs multipath -f skips wait if map gone."""
         map_id = self.random_string()
         devpath = '/dev/mapper/%s' % map_id
         m_exists.side_effect = iter([True, True, False])
         multipath.remove_map(devpath)
-        expected = mock.call(['multipath', '-f', devpath], rcs=[0, 1])
+        expected = mock.call(
+            ['multipath', '-v3', '-R3', '-f', devpath], rcs=[0, 1])
         self.m_subp.assert_has_calls([expected] * 3)
         m_wait.assert_not_called()
         self.assertEqual(3, self.m_udev.udevadm_settle.call_count)
@@ -102,16 +125,19 @@ class TestMultipath(CiTestCase):
     @mock.patch('curtin.block.multipath.os.path.exists')
     @mock.patch('curtin.block.multipath.util.wait_for_removal')
     def test_remove_map_wait(self, m_wait, m_exists):
+        """multipath.remove_map runs multipath -f  wait if map remains."""
         map_id = self.random_string()
         devpath = '/dev/mapper/%s' % map_id
         m_exists.side_effect = iter([True, True, True])
         multipath.remove_map(devpath, retries=3)
-        expected = mock.call(['multipath', '-f', devpath], rcs=[0, 1])
+        expected = mock.call(
+            ['multipath', '-v3', '-R3', '-f', devpath], rcs=[0, 1])
         self.m_subp.assert_has_calls([expected] * 3)
         self.assertEqual(3, self.m_udev.udevadm_settle.call_count)
         self.assertEqual(1, m_wait.call_count)
 
     def test_find_mpath_members(self):
+        """find_mpath_members enumerates kernel block devs of a mpath_id."""
         mp_id = 'mpatha'
         paths = ['device=bar multipath=mpatha',
                  'device=wark multipath=mpatha']
@@ -120,6 +146,7 @@ class TestMultipath(CiTestCase):
                          sorted(multipath.find_mpath_members(mp_id)))
 
     def test_find_mpath_members_empty(self):
+        """find_mpath_members returns empty list if mpath_id not found."""
         mp_id = self.random_string()
         paths = ['device=bar multipath=mpatha',
                  'device=wark multipath=mpatha']
@@ -127,6 +154,7 @@ class TestMultipath(CiTestCase):
         self.assertEqual([], multipath.find_mpath_members(mp_id))
 
     def test_find_mpath_id(self):
+        """find_mpath_id returns mpath_id if device is part of mpath group."""
         mp_id = 'mpatha'
         maps = ['sysfs=bar multipath=mpatha',
                 'sysfs=wark multipath=mpatha']
@@ -134,16 +162,69 @@ class TestMultipath(CiTestCase):
         self.assertEqual(mp_id, multipath.find_mpath_id('/dev/bar'))
 
     def test_find_mpath_id_name(self):
+        """find_mpath_id_name returns the name if present in maps on match."""
         maps = ['sysfs=bar multipath=mpatha name=friendly',
                 'sysfs=wark multipath=mpatha']
         self.m_subp.return_value = ("\n".join(maps), "")
         self.assertEqual('friendly', multipath.find_mpath_id('/dev/bar'))
 
     def test_find_mpath_id_none(self):
+        """find_mpath_id_name returns none when device is not part of maps."""
         maps = ['sysfs=bar multipath=mpatha',
                 'sysfs=wark multipath=mpatha']
         self.m_subp.return_value = ("\n".join(maps), "")
         self.assertEqual(None, multipath.find_mpath_id('/dev/foo'))
 
+    def test_dmname_to_blkdev_mapping(self):
+        """dmname_to_blkdev_mapping returns dmname to blkdevice dictionary."""
+        self.m_subp.return_value = (DMSETUP_LS_BLKDEV_OUTPUT, "")
+        expected_mapping = {
+            'mpatha': '/dev/dm-0',
+            'mpatha-part1': '/dev/dm-1',
+            '1gb zero': '/dev/dm-2',
+        }
+        self.assertEqual(expected_mapping,
+                         multipath.dmname_to_blkdev_mapping())
+
+    def test_dmname_to_blkdev_mapping_empty(self):
+        """dmname_to_blkdev_mapping returns empty dict when dmsetup is empty.
+        """
+        self.m_subp.return_value = ("No devices found", "")
+        expected_mapping = {}
+        self.assertEqual(expected_mapping,
+                         multipath.dmname_to_blkdev_mapping())
+
+    @mock.patch('curtin.block.multipath.dmname_to_blkdev_mapping')
+    def test_find_mpath_id_by_parent(self, m_dmmap):
+        """find_mpath_id_by_parent returns device mapper blk for given DM_NAME.
+        """
+        m_dmmap.return_value = {
+            'mpatha': '/dev/dm-0', 'mpatha-part1': '/dev/dm-1'}
+        mpath_id = 'mpatha'
+        expected_result = ('mpatha-part1', '/dev/dm-1')
+        self.assertEqual(
+            expected_result,
+            multipath.find_mpath_id_by_parent(mpath_id, partnum=1))
+
+    def test_find_mpath_id_by_path(self):
+        """find_mpath_id_by_path returns the mp_id if specified device is
+           member.
+        """
+        mp_id = 'mpatha'
+        paths = ['device=bar multipath=mpatha',
+                 'device=wark multipath=mpathb']
+        self.m_subp.return_value = ("\n".join(paths), "")
+        self.assertEqual(mp_id, multipath.find_mpath_id_by_path('/dev/bar'))
+
+    def test_find_mpath_id_by_path_returns_none_not_found(self):
+        """find_mpath_id_by_path returns None if specified device is not a
+           member.
+        """
+        mp_id = 'mpatha'
+        paths = ['device=bar multipath=%s' % mp_id,
+                 'device=wark multipath=%s' % mp_id]
+        self.m_subp.return_value = ("\n".join(paths), "")
+        self.assertIsNone(multipath.find_mpath_id_by_path('/dev/xxx'))
+
 
 # vi: ts=4 expandtab syntax=python
diff --git a/tests/unittests/test_clear_holders.py b/tests/unittests/test_clear_holders.py
index b454ae4..0a8f2da 100644
--- a/tests/unittests/test_clear_holders.py
+++ b/tests/unittests/test_clear_holders.py
@@ -305,17 +305,22 @@ class TestClearHolders(CiTestCase):
         self.assertTrue(mock_log.debug.called)
         self.assertTrue(mock_log.critical.called)
 
+    @mock.patch('curtin.block.multipath.find_mpath_id_by_path')
     @mock.patch('curtin.block.clear_holders.is_swap_device')
     @mock.patch('curtin.block.clear_holders.os.path.exists')
     @mock.patch('curtin.block.clear_holders.LOG')
     @mock.patch('curtin.block.clear_holders.block')
     def test_clear_holders_wipe_superblock(self, mock_block, mock_log,
-                                           mock_os_path, mock_swap):
+                                           mock_os_path, mock_swap,
+                                           mock_mp_bp):
         """test clear_holders.wipe_superblock handles errors right"""
         mock_swap.return_value = False
         mock_os_path.return_value = False
         mock_block.sysfs_to_devpath.return_value = self.test_blockdev
         mock_block.is_extended_partition.return_value = True
+        mock_block.get_blockdev_for_partition.return_value = (
+            self.test_blockdev, None)
+        mock_mp_bp.return_value = None
         clear_holders.wipe_superblock(self.test_syspath)
         self.assertFalse(mock_block.wipe_volume.called)
         mock_block.is_extended_partition.return_value = False
@@ -325,16 +330,21 @@ class TestClearHolders(CiTestCase):
         mock_block.wipe_volume.assert_called_with(
             self.test_blockdev, exclusive=True, mode='superblock', strict=True)
 
+    @mock.patch('curtin.block.multipath.find_mpath_id_by_path')
     @mock.patch('curtin.block.clear_holders.is_swap_device')
     @mock.patch('curtin.block.clear_holders.zfs')
     @mock.patch('curtin.block.clear_holders.LOG')
     @mock.patch('curtin.block.clear_holders.block')
     def test_clear_holders_wipe_superblock_zfs(self, mock_block, mock_log,
-                                               mock_zfs, mock_swap):
+                                               mock_zfs, mock_swap,
+                                               mock_mp_bp):
         """test clear_holders.wipe_superblock handles zfs member"""
         mock_swap.return_value = False
         mock_block.sysfs_to_devpath.return_value = self.test_blockdev
         mock_block.is_extended_partition.return_value = True
+        mock_block.get_blockdev_for_partition.return_value = (
+            self.test_blockdev, None)
+        mock_mp_bp.return_value = None
         clear_holders.wipe_superblock(self.test_syspath)
         self.assertFalse(mock_block.wipe_volume.called)
         mock_block.is_extended_partition.return_value = False
@@ -348,16 +358,21 @@ class TestClearHolders(CiTestCase):
         mock_block.wipe_volume.assert_called_with(
             self.test_blockdev, exclusive=True, mode='superblock', strict=True)
 
+    @mock.patch('curtin.block.multipath.find_mpath_id_by_path')
     @mock.patch('curtin.block.clear_holders.is_swap_device')
     @mock.patch('curtin.block.clear_holders.zfs')
     @mock.patch('curtin.block.clear_holders.LOG')
     @mock.patch('curtin.block.clear_holders.block')
     def test_clear_holders_wipe_superblock_no_zfs(self, mock_block, mock_log,
-                                                  mock_zfs, mock_swap):
+                                                  mock_zfs, mock_swap,
+                                                  mock_mp_bp):
         """test clear_holders.wipe_superblock checks zfs supported"""
         mock_swap.return_value = False
         mock_block.sysfs_to_devpath.return_value = self.test_blockdev
         mock_block.is_extended_partition.return_value = True
+        mock_block.get_blockdev_for_partition.return_value = (
+            self.test_blockdev, None)
+        mock_mp_bp.return_value = None
         clear_holders.wipe_superblock(self.test_syspath)
         self.assertFalse(mock_block.wipe_volume.called)
         mock_block.is_extended_partition.return_value = False
@@ -372,13 +387,14 @@ class TestClearHolders(CiTestCase):
         mock_block.wipe_volume.assert_called_with(
             self.test_blockdev, exclusive=True, mode='superblock', strict=True)
 
+    @mock.patch('curtin.block.multipath.find_mpath_id_by_path')
     @mock.patch('curtin.block.clear_holders.is_swap_device')
     @mock.patch('curtin.block.clear_holders.zfs')
     @mock.patch('curtin.block.clear_holders.LOG')
     @mock.patch('curtin.block.clear_holders.block')
     def test_clear_holders_wipe_superblock_zfs_no_utils(self, mock_block,
                                                         mock_log, mock_zfs,
-                                                        mock_swap):
+                                                        mock_swap, mock_mp_bp):
         """test clear_holders.wipe_superblock handles missing zpool cmd"""
         mock_swap.return_value = False
         mock_block.sysfs_to_devpath.return_value = self.test_blockdev
@@ -386,6 +402,9 @@ class TestClearHolders(CiTestCase):
         clear_holders.wipe_superblock(self.test_syspath)
         self.assertFalse(mock_block.wipe_volume.called)
         mock_block.is_extended_partition.return_value = False
+        mock_block.get_blockdev_for_partition.return_value = (
+            self.test_blockdev, None)
+        mock_mp_bp.return_value = None
         mock_block.is_zfs_member.return_value = True
         mock_zfs.zfs_supported.return_value = True
         mock_zfs.device_to_poolname.return_value = 'fake_pool'
@@ -400,17 +419,21 @@ class TestClearHolders(CiTestCase):
         mock_block.wipe_volume.assert_called_with(
             self.test_blockdev, exclusive=True, mode='superblock', strict=True)
 
+    @mock.patch('curtin.block.multipath.find_mpath_id_by_path')
     @mock.patch('curtin.block.clear_holders.is_swap_device')
     @mock.patch('curtin.block.clear_holders.time')
     @mock.patch('curtin.block.clear_holders.LOG')
     @mock.patch('curtin.block.clear_holders.block')
     def test_clear_holders_wipe_superblock_rereads_pt(self, mock_block,
                                                       mock_log, m_time,
-                                                      mock_swap):
+                                                      mock_swap, mock_mp_bp):
         """test clear_holders.wipe_superblock re-reads partition table"""
         mock_swap.return_value = False
         mock_block.sysfs_to_devpath.return_value = self.test_blockdev
         mock_block.is_extended_partition.return_value = False
+        mock_block.get_blockdev_for_partition.return_value = (
+            self.test_blockdev, None)
+        mock_mp_bp.return_value = None
         mock_block.is_zfs_member.return_value = False
         mock_block.get_sysfs_partitions.side_effect = iter([
             ['p1', 'p2'],  # has partitions before wipe
@@ -426,17 +449,22 @@ class TestClearHolders(CiTestCase):
         mock_block.rescan_block_devices.assert_has_calls(
             [mock.call(devices=[self.test_blockdev])] * 2)
 
+    @mock.patch('curtin.block.multipath.find_mpath_id_by_path')
     @mock.patch('curtin.block.clear_holders.is_swap_device')
     @mock.patch('curtin.block.clear_holders.time')
     @mock.patch('curtin.block.clear_holders.LOG')
     @mock.patch('curtin.block.clear_holders.block')
     def test_clear_holders_wipe_superblock_rereads_pt_oserr(self, mock_block,
                                                             mock_log, m_time,
-                                                            mock_swap):
+                                                            mock_swap,
+                                                            mock_mp_bp):
         """test clear_holders.wipe_superblock re-reads ptable handles oserr"""
         mock_swap.return_value = False
         mock_block.sysfs_to_devpath.return_value = self.test_blockdev
         mock_block.is_extended_partition.return_value = False
+        mock_block.get_blockdev_for_partition.return_value = (
+            self.test_blockdev, None)
+        mock_mp_bp.return_value = None
         mock_block.is_zfs_member.return_value = False
         mock_block.get_sysfs_partitions.side_effect = iter([
             ['p1', 'p2'],  # has partitions before wipe
diff --git a/tests/vmtests/test_multipath.py b/tests/vmtests/test_multipath.py
index 339441e..c807a9b 100644
--- a/tests/vmtests/test_multipath.py
+++ b/tests/vmtests/test_multipath.py
@@ -11,6 +11,7 @@ import textwrap
 
 class TestMultipathBasicAbs(VMBaseClass):
     conf_file = "examples/tests/multipath.yaml"
+    dirty_disks = True
     test_type = 'storage'
     multipath = True
     disk_driver = 'scsi-hd'