Merge ~raharper/curtin:ubuntu/bionic/sru-20180518 into curtin:ubuntu/bionic

[Ryan Harper]

curtin (18.1-17-gae48e86f-0ubuntu1~18.04.1) bionic; urgency=medium

  * New upstream snapshot. (LP: #1772044)
    - tests: replace usage of mock.assert_called
    - tools: jenkins-runner show curtin version in output.
    - zfs: implement a supported check to handle i386
    - Support mount entries not tied to a device, including bind and tmpfs.
    - block/clear_holders/mdadm: refactor handling of layered device wiping
    - clear_holders: only export zpools that have been imported
    - vmtests: allow env control of apt, system_upgrade, package upgrade
    - util.get_efibootmgr: filter bootorder by found entries
    - vmtests: adjust lvm_iscsi dnames to match configuration
    - vmtest: always boot with BOOTIF and ip=:::::BOOTIF:dhcp
    - make_dname for bcache should use backing device uuid
    - zfsroot: add additional checks, do not require disk 'serial' attribute

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

PASSED: Continuous integration, rev:220dcd49a531ee5b4a48f47bf6ae84ae699090e3
https://jenkins.ubuntu.com/server/job/curtin-ci/945/
Executed test runs:
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-amd64/945
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-arm64/945
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-ppc64el/945
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-s390x/945

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

review: Approve (continuous-integration)

diff --git a/curtin/block/__init__.py b/curtin/block/__init__.py
index 50e953e..a8ee8a6 100644
--- a/curtin/block/__init__.py
+++ b/curtin/block/__init__.py
@@ -378,7 +378,7 @@ def stop_all_unused_multipath_devices():
         LOG.warn("Failed to stop multipath devices: %s", e)
 
 
-def rescan_block_devices():
+def rescan_block_devices(warn_on_fail=True):
     """
     run 'blockdev --rereadpt' for all block devices not currently mounted
     """
@@ -399,13 +399,15 @@ def rescan_block_devices():
     try:
         util.subp(cmd, capture=True)
     except util.ProcessExecutionError as e:
-        # FIXME: its less than ideal to swallow this error, but until
-        # we fix LP: #1489521 we kind of need to.
-        LOG.warn("Error rescanning devices, possibly known issue LP: #1489521")
-        # Reformatting the exception output so as to not trigger
-        # vmtest scanning for Unexepected errors in install logfile
-        LOG.warn("cmd: %s\nstdout:%s\nstderr:%s\nexit_code:%s", e.cmd,
-                 e.stdout, e.stderr, e.exit_code)
+        if warn_on_fail:
+            # FIXME: its less than ideal to swallow this error, but until
+            # we fix LP: #1489521 we kind of need to.
+            LOG.warn(
+                "Error rescanning devices, possibly known issue LP: #1489521")
+            # Reformatting the exception output so as to not trigger
+            # vmtest scanning for Unexepected errors in install logfile
+            LOG.warn("cmd: %s\nstdout:%s\nstderr:%s\nexit_code:%s", e.cmd,
+                     e.stdout, e.stderr, e.exit_code)
 
     udevadm_settle()
 
@@ -753,8 +755,9 @@ def check_dos_signature(device):
     # the underlying disk uses a larger logical block size, so the start of
     # this signature must be at 0x1fe
     # https://en.wikipedia.org/wiki/Master_boot_record#Sector_layout
-    return (is_block_device(device) and util.file_size(device) >= 0x200 and
-            (util.load_file(device, decode=False, read_len=2, offset=0x1fe) ==
+    devname = dev_path(path_to_kname(device))
+    return (is_block_device(devname) and util.file_size(devname) >= 0x200 and
+            (util.load_file(devname, decode=False, read_len=2, offset=0x1fe) ==
              b'\x55\xAA'))
 
 
@@ -769,10 +772,11 @@ def check_efi_signature(device):
     # the start of the gpt partition table header shoult have the signaure
     # 'EFI PART'.
     # https://en.wikipedia.org/wiki/GUID_Partition_Table
-    sector_size = get_blockdev_sector_size(device)[0]
-    return (is_block_device(device) and
-            util.file_size(device) >= 2 * sector_size and
-            (util.load_file(device, decode=False, read_len=8,
+    devname = dev_path(path_to_kname(device))
+    sector_size = get_blockdev_sector_size(devname)[0]
+    return (is_block_device(devname) and
+            util.file_size(devname) >= 2 * sector_size and
+            (util.load_file(devname, decode=False, read_len=8,
                             offset=sector_size) == b'EFI PART'))
 
 
diff --git a/curtin/block/bcache.py b/curtin/block/bcache.py
new file mode 100644
index 0000000..852cef2
--- /dev/null
+++ b/curtin/block/bcache.py
@@ -0,0 +1,87 @@
+# This file is part of curtin. See LICENSE file for copyright and license info.
+
+import os
+
+from curtin import util
+from curtin.log import LOG
+from . import sys_block_path
+
+
+def superblock_asdict(device=None, data=None):
+    """ Convert output from bcache-super-show into a dictionary"""
+
+    if not device and not data:
+        raise ValueError('Supply a device name, or data to parse')
+
+    if not data:
+        data, _err = util.subp(['bcache-super-show', device], capture=True)
+    bcache_super = {}
+    for line in data.splitlines():
+        if not line:
+            continue
+        values = [val for val in line.split('\t') if val]
+        bcache_super.update({values[0]: values[1]})
+
+    return bcache_super
+
+
+def parse_sb_version(sb_version):
+    """ Convert sb_version string to integer if possible"""
+    try:
+        # 'sb.version': '1 [backing device]'
+        # 'sb.version': '3 [caching device]'
+        version = int(sb_version.split()[0])
+    except (AttributeError, ValueError):
+        LOG.warning("Failed to parse bcache 'sb.version' field"
+                    " as integer: %s", sb_version)
+        return None
+
+    return version
+
+
+def is_backing(device, superblock=False):
+    """ Test if device is a bcache backing device
+
+    A runtime check for an active bcache backing device is to
+    examine /sys/class/block/<kname>/bcache/label
+
+    However if a device is not active then read the superblock
+    of the device and check that sb.version == 1"""
+
+    if not superblock:
+        sys_block = sys_block_path(device)
+        bcache_sys_attr = os.path.join(sys_block, 'bcache', 'label')
+        return os.path.exists(bcache_sys_attr)
+    else:
+        bcache_super = superblock_asdict(device=device)
+        sb_version = parse_sb_version(bcache_super['sb.version'])
+        return bcache_super and sb_version == 1
+
+
+def is_caching(device, superblock=False):
+    """ Test if device is a bcache caching device
+
+    A runtime check for an active bcache backing device is to
+    examine /sys/class/block/<kname>/bcache/cache_replacement_policy
+
+    However if a device is not active then read the superblock
+    of the device and check that sb.version == 3"""
+
+    if not superblock:
+        sys_block = sys_block_path(device)
+        bcache_sysattr = os.path.join(sys_block, 'bcache',
+                                      'cache_replacement_policy')
+        return os.path.exists(bcache_sysattr)
+    else:
+        bcache_super = superblock_asdict(device=device)
+        sb_version = parse_sb_version(bcache_super['sb.version'])
+        return bcache_super and sb_version == 3
+
+
+def write_label(label, device):
+    """ write label to bcache device """
+    sys_block = sys_block_path(device)
+    bcache_sys_attr = os.path.join(sys_block, 'bcache', 'label')
+    util.write_file(bcache_sys_attr, content=label)
+
+# vi: ts=4 expandtab syntax=python
diff --git a/curtin/block/clear_holders.py b/curtin/block/clear_holders.py
index d697f9b..20c572b 100644
--- a/curtin/block/clear_holders.py
+++ b/curtin/block/clear_holders.py
@@ -110,6 +110,9 @@ def shutdown_bcache(device):
                          'Device path must start with /sys/class/block/',
                          device)
 
+    LOG.info('Wiping superblock on bcache device: %s', device)
+    _wipe_superblock(block.sysfs_to_devpath(device), exclusive=False)
+
     # bcache device removal should be fast but in an extreme
     # case, might require the cache device to flush large
     # amounts of data to a backing device.  The strategy here
@@ -189,14 +192,27 @@ def shutdown_lvm(device):
     name_file = os.path.join(device, 'dm', 'name')
     lvm_name = util.load_file(name_file).strip()
     (vg_name, lv_name) = lvm.split_lvm_name(lvm_name)
+    vg_lv_name = "%s/%s" % (vg_name, lv_name)
+    devname = "/dev/" + vg_lv_name
+
+    # wipe contents of the logical volume first
+    LOG.info('Wiping lvm logical volume: %s', devname)
+    block.quick_zero(devname, partitions=False)
 
-    # use dmsetup as lvm commands require valid /etc/lvm/* metadata
-    LOG.debug('using "dmsetup remove" on %s', lvm_name)
-    util.subp(['dmsetup', 'remove', lvm_name])
+    # remove the logical volume
+    LOG.debug('using "lvremove" on %s', vg_lv_name)
+    util.subp(['lvremove', '--force', '--force', vg_lv_name])
 
     # if that was the last lvol in the volgroup, get rid of volgroup
     if len(lvm.get_lvols_in_volgroup(vg_name)) == 0:
+        pvols = lvm.get_pvols_in_volgroup(vg_name)
         util.subp(['vgremove', '--force', '--force', vg_name], rcs=[0, 5])
+
+        # wipe the underlying physical volumes
+        for pv in pvols:
+            LOG.info('Wiping lvm physical volume: %s', pv)
+            block.quick_zero(pv, partitions=False)
+
     # refresh lvmetad
     lvm.lvm_scan()
 
@@ -213,10 +229,31 @@ def shutdown_mdadm(device):
     """
     Shutdown specified mdadm device.
     """
+
     blockdev = block.sysfs_to_devpath(device)
+
+    LOG.info('Wiping superblock on raid device: %s', device)
+    _wipe_superblock(blockdev, exclusive=False)
+
+    md_devs = (
+        mdadm.md_get_devices_list(blockdev) +
+        mdadm.md_get_spares_list(blockdev))
+    mdadm.set_sync_action(blockdev, action="idle")
+    mdadm.set_sync_action(blockdev, action="frozen")
+    for mddev in md_devs:
+        try:
+            mdadm.fail_device(blockdev, mddev)
+            mdadm.remove_device(blockdev, mddev)
+        except util.ProcessExecutionError as e:
+            LOG.debug('Non-fatal error clearing raid array: %s', e.stderr)
+            pass
+
     LOG.debug('using mdadm.mdadm_stop on dev: %s', blockdev)
     mdadm.mdadm_stop(blockdev)
 
+    for mddev in md_devs:
+        mdadm.zero_device(mddev)
+
     # mdadm stop operation is asynchronous so we must wait for the kernel to
     # release resources. For more details see  LP: #1682456
     try:
@@ -244,32 +281,49 @@ def wipe_superblock(device):
     blockdev = block.sysfs_to_devpath(device)
     # when operating on a disk that used to have a dos part table with an
     # extended partition, attempting to wipe the extended partition will fail
-    if block.is_extended_partition(blockdev):
-        LOG.info("extended partitions do not need wiping, so skipping: '%s'",
-                 blockdev)
-    else:
-        # release zfs member by exporting the pool
-        if block.is_zfs_member(blockdev):
-            poolname = zfs.device_to_poolname(blockdev)
+    try:
+        if block.is_extended_partition(blockdev):
+            LOG.info("extended partitions do not need wiping, so skipping:"
+                     " '%s'", blockdev)
+            return
+    except OSError as e:
+        if util.is_file_not_found_exc(e):
+            LOG.debug('Device to wipe disappeared: %s', e)
+            LOG.debug('/proc/partitions says: %s',
+                      util.load_file('/proc/partitions'))
+
+            (parent, partnum) = block.get_blockdev_for_partition(blockdev)
+            out, _e = util.subp(['sfdisk', '-d', parent],
+                                capture=True, combine_capture=True)
+            LOG.debug('Disk partition info:\n%s', out)
+            return
+        else:
+            raise e
+
+    # release zfs member by exporting the pool
+    if block.is_zfs_member(blockdev):
+        poolname = zfs.device_to_poolname(blockdev)
+        # only export pools that have been imported
+        if poolname in zfs.zpool_list():
             zfs.zpool_export(poolname)
 
-        if is_swap_device(blockdev):
-            shutdown_swap(blockdev)
-
-        # some volumes will be claimed by the bcache layer but do not surface
-        # an actual /dev/bcacheN device which owns the parts (backing, cache)
-        # The result is that some volumes cannot be wiped while bcache claims
-        # the device.  Resolve this by stopping bcache layer on those volumes
-        # if present.
-        for bcache_path in ['bcache', 'bcache/set']:
-            stop_path = os.path.join(device, bcache_path)
-            if os.path.exists(stop_path):
-                LOG.debug('Attempting to release bcache layer from device: %s',
-                          device)
-                maybe_stop_bcache_device(stop_path)
-                continue
+    if is_swap_device(blockdev):
+        shutdown_swap(blockdev)
+
+    # some volumes will be claimed by the bcache layer but do not surface
+    # an actual /dev/bcacheN device which owns the parts (backing, cache)
+    # The result is that some volumes cannot be wiped while bcache claims
+    # the device.  Resolve this by stopping bcache layer on those volumes
+    # if present.
+    for bcache_path in ['bcache', 'bcache/set']:
+        stop_path = os.path.join(device, bcache_path)
+        if os.path.exists(stop_path):
+            LOG.debug('Attempting to release bcache layer from device: %s',
+                      device)
+            maybe_stop_bcache_device(stop_path)
+            continue
 
-        _wipe_superblock(blockdev)
+    _wipe_superblock(blockdev)
 
 
 def _wipe_superblock(blockdev, exclusive=True):
@@ -510,28 +564,7 @@ def clear_holders(base_paths, try_preserve=False):
     LOG.info('Current device storage tree:\n%s',
              '\n'.join(format_holders_tree(tree) for tree in holder_trees))
     ordered_devs = plan_shutdown_holder_trees(holder_trees)
-
-    # run wipe-superblock on layered devices
-    for dev_info in ordered_devs:
-        dev_type = DEV_TYPES.get(dev_info['dev_type'])
-        shutdown_function = dev_type.get('shutdown')
-        if not shutdown_function:
-            continue
-
-        if try_preserve and shutdown_function in DATA_DESTROYING_HANDLERS:
-            LOG.info('shutdown function for holder type: %s is destructive. '
-                     'attempting to preserve data, so skipping' %
-                     dev_info['dev_type'])
-            continue
-
-        # for layered block devices, wipe first, then shutdown
-        if dev_info['dev_type'] in ['bcache', 'raid']:
-            LOG.info("Wiping superblock on layered device type: "
-                     "'%s' syspath: '%s'", dev_info['dev_type'],
-                     dev_info['device'])
-            # we just want to wipe data, we don't care about exclusive
-            _wipe_superblock(block.sysfs_to_devpath(dev_info['device']),
-                             exclusive=False)
+    LOG.info('Shutdown Plan:\n%s', "\n".join(map(str, ordered_devs)))
 
     # run shutdown functions
     for dev_info in ordered_devs:
@@ -546,11 +579,12 @@ def clear_holders(base_paths, try_preserve=False):
                      dev_info['dev_type'])
             continue
 
+        # scan before we check
+        block.rescan_block_devices(warn_on_fail=False)
         if os.path.exists(dev_info['device']):
             LOG.info("shutdown running on holder type: '%s' syspath: '%s'",
                      dev_info['dev_type'], dev_info['device'])
             shutdown_function(dev_info['device'])
-            udev.udevadm_settle()
 
 
 def start_clear_holders_deps():
@@ -576,8 +610,11 @@ def start_clear_holders_deps():
     util.load_kernel_module('bcache')
     # the zfs module is needed to find and export devices which may be in-use
     # and need to be cleared, only on xenial+.
-    if not util.lsb_release()['codename'] in ['precise', 'trusty']:
-        util.load_kernel_module('zfs')
+    try:
+        if zfs.zfs_supported():
+            util.load_kernel_module('zfs')
+    except RuntimeError as e:
+        LOG.warning('Failed to load zfs kernel module: %s', e)
 
 
 # anything that is not identified can assumed to be a 'disk' or similar
diff --git a/curtin/block/iscsi.py b/curtin/block/iscsi.py
index 461f615..0c666b6 100644
--- a/curtin/block/iscsi.py
+++ b/curtin/block/iscsi.py
@@ -416,18 +416,17 @@ class IscsiDisk(object):
             self.portal, self.target, self.lun)
 
     def connect(self):
-        if self.target in iscsiadm_sessions():
-            return
-
-        iscsiadm_discovery(self.portal)
+        if self.target not in iscsiadm_sessions():
+            iscsiadm_discovery(self.portal)
 
-        iscsiadm_authenticate(self.target, self.portal, self.user,
-                              self.password, self.iuser, self.ipassword)
+            iscsiadm_authenticate(self.target, self.portal, self.user,
+                                  self.password, self.iuser, self.ipassword)
 
-        iscsiadm_login(self.target, self.portal)
+            iscsiadm_login(self.target, self.portal)
 
-        udev.udevadm_settle(self.devdisk_path)
+            udev.udevadm_settle(self.devdisk_path)
 
+        # always set automatic mode
         iscsiadm_set_automatic(self.target, self.portal)
 
     def disconnect(self):
diff --git a/curtin/block/mdadm.py b/curtin/block/mdadm.py
index 2e73e71..e0fe0d3 100644
--- a/curtin/block/mdadm.py
+++ b/curtin/block/mdadm.py
@@ -237,6 +237,44 @@ def mdadm_examine(devpath, export=MDADM_USE_EXPORT):
     return data
 
 
+def set_sync_action(devpath, action=None, retries=None):
+    assert_valid_devpath(devpath)
+    if not action:
+        return
+
+    if not retries:
+        retries = [0.2] * 60
+
+    sync_action = md_sysfs_attr_path(devpath, 'sync_action')
+    if not os.path.exists(sync_action):
+        # arrays without sync_action can't set values
+        return
+
+    LOG.info("mdadm set sync_action=%s on array %s", action, devpath)
+    for (attempt, wait) in enumerate(retries):
+        try:
+            LOG.debug('mdadm: set sync_action %s attempt %s',
+                      devpath, attempt)
+            val = md_sysfs_attr(devpath, 'sync_action').strip()
+            LOG.debug('sync_action = "%s" ? "%s"', val, action)
+            if val != action:
+                LOG.debug("mdadm: setting array sync_action=%s", action)
+                try:
+                    util.write_file(sync_action, content=action)
+                except (IOError, OSError) as e:
+                    LOG.debug("mdadm: (non-fatal) write to %s failed %s",
+                              sync_action, e)
+            else:
+                LOG.debug("mdadm: set array sync_action=%s SUCCESS", action)
+                return
+
+        except util.ProcessExecutionError:
+            LOG.debug(
+                "mdadm: set sync_action failed, retrying in %s seconds", wait)
+            time.sleep(wait)
+            pass
+
+
 def mdadm_stop(devpath, retries=None):
     assert_valid_devpath(devpath)
     if not retries:
@@ -305,6 +343,33 @@ def mdadm_remove(devpath):
     LOG.debug("mdadm remove:\n%s\n%s", out, err)
 
 
+def fail_device(mddev, arraydev):
+    assert_valid_devpath(mddev)
+
+    LOG.info("mdadm mark faulty: %s in array %s", arraydev, mddev)
+    out, err = util.subp(["mdadm", "--fail", mddev, arraydev],
+                         rcs=[0], capture=True)
+    LOG.debug("mdadm mark faulty:\n%s\n%s", out, err)
+
+
+def remove_device(mddev, arraydev):
+    assert_valid_devpath(mddev)
+
+    LOG.info("mdadm remove %s from array %s", arraydev, mddev)
+    out, err = util.subp(["mdadm", "--remove", mddev, arraydev],
+                         rcs=[0], capture=True)
+    LOG.debug("mdadm remove:\n%s\n%s", out, err)
+
+
+def zero_device(devpath):
+    assert_valid_devpath(devpath)
+
+    LOG.info("mdadm zero superblock on %s", devpath)
+    out, err = util.subp(["mdadm", "--zero-superblock", devpath],
+                         rcs=[0], capture=True)
+    LOG.debug("mdadm zero superblock:\n%s\n%s", out, err)
+
+
 def mdadm_query_detail(md_devname, export=MDADM_USE_EXPORT):
     valid_mdname(md_devname)
 
diff --git a/curtin/block/zfs.py b/curtin/block/zfs.py
index 7670af4..cfb07a9 100644
--- a/curtin/block/zfs.py
+++ b/curtin/block/zfs.py
@@ -21,6 +21,9 @@ ZFS_DEFAULT_PROPERTIES = {
     'normalization': 'formD',
 }
 
+ZFS_UNSUPPORTED_ARCHES = ['i386']
+ZFS_UNSUPPORTED_RELEASES = ['precise', 'trusty']
+
 
 def _join_flags(optflag, params):
     """
@@ -69,6 +72,28 @@ def _join_pool_volume(poolname, volume):
     return os.path.normpath("%s/%s" % (poolname, volume))
 
 
+def zfs_supported():
+    """ Determine if the runtime system supports zfs.
+    returns: True if system supports zfs
+    raises: RuntimeError: if system does not support zfs
+    """
+    arch = util.get_platform_arch()
+    if arch in ZFS_UNSUPPORTED_ARCHES:
+        raise RuntimeError("zfs is not supported on architecture: %s" % arch)
+
+    release = util.lsb_release()['codename']
+    if release in ZFS_UNSUPPORTED_RELEASES:
+        raise RuntimeError("zfs is not supported on release: %s" % release)
+
+    try:
+        util.subp(['modinfo', 'zfs'], capture=True)
+    except util.ProcessExecutionError as err:
+        if err.stderr.startswith("modinfo: ERROR: Module zfs not found."):
+            raise RuntimeError("zfs kernel module is not available: %s" % err)
+
+    return True
+
+
 def zpool_create(poolname, vdevs, mountpoint=None, altroot=None,
                  pool_properties=None, zfs_properties=None):
     """
@@ -184,7 +209,7 @@ def zfs_mount(poolname, volume):
 
 def zpool_list():
     """
-    Return a list of zfs pool names
+    Return a list of zfs pool names which have been imported
 
     :returns: List of strings
     """
diff --git a/curtin/commands/apt_config.py b/curtin/commands/apt_config.py
index 971f78f..41c329e 100644
--- a/curtin/commands/apt_config.py
+++ b/curtin/commands/apt_config.py
@@ -38,6 +38,9 @@ PORTS_MIRRORS = {"PRIMARY": "http://ports.ubuntu.com/ubuntu-ports",
 PRIMARY_ARCHES = ['amd64', 'i386']
 PORTS_ARCHES = ['s390x', 'arm64', 'armhf', 'powerpc', 'ppc64el']
 
+APT_SOURCES_PROPOSED = (
+    "deb $MIRROR $RELEASE-proposed main restricted universe multiverse")
+
 
 def get_default_mirrors(arch=None):
     """returns the default mirrors for the target. These depend on the
@@ -385,6 +388,8 @@ def add_apt_sources(srcdict, target=None, template_params=None,
         if 'source' not in ent:
             continue
         source = ent['source']
+        if source == 'proposed':
+            source = APT_SOURCES_PROPOSED
         source = util.render_string(source, template_params)
 
         if not ent['filename'].startswith("/"):
diff --git a/curtin/commands/block_meta.py b/curtin/commands/block_meta.py
index 504a16b..f5b82cf 100644
--- a/curtin/commands/block_meta.py
+++ b/curtin/commands/block_meta.py
@@ -1,8 +1,8 @@
 # This file is part of curtin. See LICENSE file for copyright and license info.
 
-from collections import OrderedDict
+from collections import OrderedDict, namedtuple
 from curtin import (block, config, util)
-from curtin.block import (mdadm, mkfs, clear_holders, lvm, iscsi, zfs)
+from curtin.block import (bcache, mdadm, mkfs, clear_holders, lvm, iscsi, zfs)
 from curtin.log import LOG
 from curtin.reporter import events
 
@@ -17,6 +17,12 @@ import sys
 import tempfile
 import time
 
+FstabData = namedtuple(
+    "FstabData", ('spec', 'path', 'fstype', 'options', 'freq', 'passno',
+                  'device'))
+FstabData.__new__.__defaults__ = (None, None, None, "", "0", "0", None)
+
+
 SIMPLE = 'simple'
 SIMPLE_BOOT = 'simple-boot'
 CUSTOM = 'custom'
@@ -224,7 +230,15 @@ def make_dname(volume, storage_config):
         md_uuid = md_data.get('MD_UUID')
         rule.append(compose_udev_equality("ENV{MD_UUID}", md_uuid))
     elif vol.get('type') == "bcache":
-        rule.append(compose_udev_equality("ENV{DEVNAME}", path))
+        # bind dname to bcache backing device's dev.uuid as the bcache minor
+        # device numbers are not stable across reboots.
+        backing_dev = get_path_to_storage_volume(vol.get('backing_device'),
+                                                 storage_config)
+        bcache_super = bcache.superblock_asdict(device=backing_dev)
+        if bcache_super and bcache_super['sb.version'].startswith('1'):
+                bdev_uuid = bcache_super['dev.uuid']
+        rule.append(compose_udev_equality("ENV{CACHED_UUID}", bdev_uuid))
+        bcache.write_label(sanitize_dname(dname), backing_dev)
     elif vol.get('type') == "lvm_partition":
         volgroup_name = storage_config.get(vol.get('volgroup')).get('name')
         dname = "%s-%s" % (volgroup_name, dname)
@@ -241,8 +255,7 @@ def make_dname(volume, storage_config):
         LOG.warning(
             "dname modified to remove invalid chars. old: '{}' new: '{}'"
             .format(dname, sanitized))
-
-    rule.append("SYMLINK+=\"disk/by-dname/%s\"" % sanitized)
+    rule.append("SYMLINK+=\"disk/by-dname/%s\"\n" % sanitized)
     LOG.debug("Writing dname udev rule '{}'".format(str(rule)))
     util.ensure_dir(rules_dir)
     rule_file = os.path.join(rules_dir, '{}.rules'.format(sanitized))
@@ -621,6 +634,142 @@ def format_handler(info, storage_config):
         udevadm_trigger([volume_path])
 
 
+def mount_data(info, storage_config):
+    """Return information necessary for a mount or fstab entry.
+
+    :param info: a 'mount' type from storage config.
+    :param storage_config: related storage_config ordered dict by id.
+
+    :return FstabData type."""
+    if info.get('type') != "mount":
+        raise ValueError("entry is not type 'mount' (%s)" % info)
+
+    spec = info.get('spec')
+    fstype = info.get('fstype')
+    path = info.get('path')
+    freq = str(info.get('freq', 0))
+    passno = str(info.get('passno', 0))
+
+    # turn empty options into "defaults", which works in fstab and mount -o.
+    if not info.get('options'):
+        options = ["defaults"]
+    else:
+        options = info.get('options').split(",")
+
+    volume_path = None
+
+    if 'device' not in info:
+        missing = [m for m in ('spec', 'fstype') if not info.get(m)]
+        if not (fstype and spec):
+            raise ValueError(
+                "mount entry without 'device' missing: %s. (%s)" %
+                (missing, info))
+
+    else:
+        if info['device'] not in storage_config:
+            raise ValueError(
+                "mount entry refers to non-existant device %s: (%s)" %
+                (info['device'], info))
+        if not (fstype and spec):
+            format_info = storage_config.get(info['device'])
+            if not fstype:
+                fstype = format_info['fstype']
+            if not spec:
+                if format_info.get('volume') not in storage_config:
+                    raise ValueError(
+                        "format type refers to non-existant id %s: (%s)" %
+                        (format_info.get('volume'), format_info))
+                volume_path = get_path_to_storage_volume(
+                    format_info['volume'],  storage_config)
+                if "_netdev" not in options:
+                    if iscsi.volpath_is_iscsi(volume_path):
+                        options.append("_netdev")
+
+    if fstype in ("fat", "fat12", "fat16", "fat32", "fat64"):
+        fstype = "vfat"
+
+    return FstabData(
+        spec, path, fstype, ",".join(options), freq, passno, volume_path)
+
+
+def fstab_line_for_data(fdata):
+    """Return a string representing fdata in /etc/fstab format.
+
+    :param fdata: a FstabData type
+    :return a newline terminated string for /etc/fstab."""
+    path = fdata.path
+    if not path:
+        if fdata.fstype == "swap":
+            path = "none"
+        else:
+            raise ValueError("empty path in %s." % str(fdata))
+
+    if fdata.spec is None:
+        if not fdata.device:
+            raise ValueError("FstabData missing both spec and device.")
+        uuid = block.get_volume_uuid(fdata.device)
+        spec = ("UUID=%s" % uuid) if uuid else fdata.device
+    else:
+        spec = fdata.spec
+
+    if fdata.options in (None, "", "defaults"):
+        if fdata.fstype == "swap":
+            options = "sw"
+        else:
+            options = "defaults"
+    else:
+        options = fdata.options
+
+    return ' '.join((spec, path, fdata.fstype, options,
+                     fdata.freq, fdata.passno)) + "\n"
+
+
+def mount_fstab_data(fdata, target=None):
+    """mount the FstabData fdata with root at target.
+
+    :param fdata: a FstabData type
+    :return None."""
+    mp = util.target_path(target, fdata.path)
+    if fdata.device:
+        device = fdata.device
+    else:
+        if fdata.spec.startswith("/") and not fdata.spec.startswith("/dev/"):
+            device = util.target_path(target, fdata.spec)
+        else:
+            device = fdata.spec
+
+    options = fdata.options if fdata.options else "defaults"
+
+    mcmd = ['mount']
+    if fdata.fstype not in ("bind", None, "none"):
+        mcmd.extend(['-t', fdata.fstype])
+    mcmd.extend(['-o', options, device, mp])
+
+    if fdata.fstype == "bind" or "bind" in options.split(","):
+        # for bind mounts, create the 'src' dir (mount -o bind src target)
+        util.ensure_dir(device)
+    util.ensure_dir(mp)
+
+    try:
+        util.subp(mcmd, capture=True)
+    except util.ProcessExecutionError as e:
+        LOG.exception(e)
+        msg = 'Mount failed: %s @ %s with options %s' % (device, mp, options)
+        LOG.error(msg)
+        raise RuntimeError(msg)
+
+
+def mount_apply(fdata, target=None, fstab=None):
+    if fdata.fstype != "swap":
+        mount_fstab_data(fdata, target=target)
+
+    # Add volume to fstab
+    if fstab:
+        util.write_file(fstab, fstab_line_for_data(fdata), omode="a")
+    else:
+        LOG.info("fstab not in environment, so not writing")
+
+
 def mount_handler(info, storage_config):
     """ Handle storage config type: mount
 
@@ -636,74 +785,8 @@ def mount_handler(info, storage_config):
     fstab entry.
     """
     state = util.load_command_environment()
-    path = info.get('path')
-    filesystem = storage_config.get(info.get('device'))
-    mount_options = info.get('options')
-    # handle unset, or empty('') strings
-    if not mount_options:
-        mount_options = 'defaults'
-
-    if not path and filesystem.get('fstype') != "swap":
-        raise ValueError("path to mountpoint must be specified")
-    volume = storage_config.get(filesystem.get('volume'))
-
-    # Get path to volume
-    volume_path = get_path_to_storage_volume(filesystem.get('volume'),
-                                             storage_config)
-
-    if filesystem.get('fstype') != "swap":
-        # Figure out what point should be
-        while len(path) > 0 and path[0] == "/":
-            path = path[1:]
-        mount_point = os.path.sep.join([state['target'], path])
-        mount_point = os.path.normpath(mount_point)
-
-        options = mount_options.split(",")
-        # If the volume_path's kname is backed by iSCSI or (in the case of
-        # LVM/DM) if any of its slaves are backed by iSCSI, then we need to
-        # append _netdev to the fstab line
-        if iscsi.volpath_is_iscsi(volume_path):
-            LOG.debug("Marking volume_path:%s as '_netdev'", volume_path)
-            options.append("_netdev")
-
-        # Create mount point if does not exist
-        util.ensure_dir(mount_point)
-
-        # Mount volume, with options
-        try:
-            opts = ['-o', ','.join(options)]
-            util.subp(['mount', volume_path, mount_point] + opts, capture=True)
-        except util.ProcessExecutionError as e:
-            LOG.exception(e)
-            msg = ('Mount failed: %s @ %s with options %s' % (volume_path,
-                                                              mount_point,
-                                                              ",".join(opts)))
-            LOG.error(msg)
-            raise RuntimeError(msg)
-
-        # set path
-        path = "/%s" % path
-
-    else:
-        path = "none"
-        options = ["sw"]
-
-    # Add volume to fstab
-    if state['fstab']:
-        uuid = block.get_volume_uuid(volume_path)
-        location = ("UUID=%s" % uuid) if uuid else (
-                    get_path_to_storage_volume(volume.get('id'),
-                                               storage_config))
-
-        fstype = filesystem.get('fstype')
-        if fstype in ["fat", "fat12", "fat16", "fat32", "fat64"]:
-            fstype = "vfat"
-
-        fstab_entry = "%s %s %s %s 0 0\n" % (location, path, fstype,
-                                             ",".join(options))
-        util.write_file(state['fstab'], fstab_entry, omode='a')
-    else:
-        LOG.info("fstab not in environment, so not writing")
+    mount_apply(mount_data(info, storage_config),
+                target=state.get('target'), fstab=state.get('fstab'))
 
 
 def lvm_volgroup_handler(info, storage_config):
@@ -1180,6 +1263,8 @@ def zpool_handler(info, storage_config):
     """
     Create a zpool based in storage_configuration
     """
+    zfs.zfs_supported()
+
     state = util.load_command_environment()
 
     # extract /dev/disk/by-id paths for each volume used
@@ -1197,9 +1282,11 @@ def zpool_handler(info, storage_config):
     for vdev in vdevs:
         byid = block.disk_to_byid_path(vdev)
         if not byid:
-            msg = 'Cannot find by-id path to zpool device "%s"' % vdev
-            LOG.error(msg)
-            raise RuntimeError(msg)
+            msg = ('Cannot find by-id path to zpool device "%s". '
+                   'The zpool may fail to import of path names change.' % vdev)
+            LOG.warning(msg)
+            byid = vdev
+
         vdevs_byid.append(byid)
 
     LOG.info('Creating zpool %s with vdevs %s', poolname, vdevs_byid)
@@ -1211,6 +1298,7 @@ def zfs_handler(info, storage_config):
     """
     Create a zfs filesystem
     """
+    zfs.zfs_supported()
     state = util.load_command_environment()
     poolname = get_poolname(info, storage_config)
     volume = info.get('volume')
@@ -1279,6 +1367,15 @@ def zfsroot_update_storage_config(storage_config):
             "zfsroot Mountpoint entry for / has device=%s, expected '%s'" %
             (mount.get("device"), root['id']))
 
+    # validate that the boot disk is GPT partitioned
+    bootdevs = [d for i, d in storage_config.items() if d.get('grub_device')]
+    bootdev = bootdevs[0]
+    if bootdev.get('ptable') != 'gpt':
+        raise ValueError(
+            'zfsroot requires bootdisk with GPT partition table'
+            ' found "%s" on disk id="%s"' %
+            (bootdev.get('ptable'), bootdev.get('id')))
+
     LOG.info('Enabling experimental zfsroot!')
 
     ret = OrderedDict()
diff --git a/curtin/commands/curthooks.py b/curtin/commands/curthooks.py
index 422fb63..d45c3a8 100644
--- a/curtin/commands/curthooks.py
+++ b/curtin/commands/curthooks.py
@@ -486,9 +486,9 @@ def copy_dname_rules(rules_d, target):
     if not rules_d:
         LOG.warn("no udev rules directory to copy")
         return
+    target_rules_dir = util.target_path(target, "etc/udev/rules.d")
     for rule in os.listdir(rules_d):
-        target_file = os.path.join(
-            target, "etc/udev/rules.d", "%s.rules" % rule)
+        target_file = os.path.join(target_rules_dir, rule)
         shutil.copy(os.path.join(rules_d, rule), target_file)
 
 
diff --git a/curtin/util.py b/curtin/util.py
index 12a5446..de0eb88 100644
--- a/curtin/util.py
+++ b/curtin/util.py
@@ -1009,6 +1009,40 @@ def is_uefi_bootable():
     return os.path.exists('/sys/firmware/efi') is True
 
 
+def parse_efibootmgr(content):
+    efikey_to_dict_key = {
+        'BootCurrent': 'current',
+        'Timeout': 'timeout',
+        'BootOrder': 'order',
+    }
+
+    output = {}
+    for line in content.splitlines():
+        split = line.split(':')
+        if len(split) == 2:
+            key = split[0].strip()
+            output_key = efikey_to_dict_key.get(key, None)
+            if output_key:
+                output[output_key] = split[1].strip()
+                if output_key == 'order':
+                    output[output_key] = output[output_key].split(',')
+    output['entries'] = {
+        entry: {
+            'name': name.strip(),
+            'path': path.strip(),
+        }
+        for entry, name, path in re.findall(
+            r"^Boot(?P<entry>[0-9a-fA-F]{4})\*?\s(?P<name>.+)\t"
+            r"(?P<path>.*)$",
+            content, re.MULTILINE)
+    }
+    if 'order' in output:
+        new_order = [item for item in output['order']
+                     if item in output['entries']]
+        output['order'] = new_order
+    return output
+
+
 def get_efibootmgr(target):
     """Return mapping of EFI information.
 
@@ -1032,33 +1066,9 @@ def get_efibootmgr(target):
             }
         }
     """
-    efikey_to_dict_key = {
-        'BootCurrent': 'current',
-        'Timeout': 'timeout',
-        'BootOrder': 'order',
-    }
     with ChrootableTarget(target) as in_chroot:
         stdout, _ = in_chroot.subp(['efibootmgr', '-v'], capture=True)
-        output = {}
-        for line in stdout.splitlines():
-            split = line.split(':')
-            if len(split) == 2:
-                key = split[0].strip()
-                output_key = efikey_to_dict_key.get(key, None)
-                if output_key:
-                    output[output_key] = split[1].strip()
-                    if output_key == 'order':
-                        output[output_key] = output[output_key].split(',')
-        output['entries'] = {
-            entry: {
-                'name': name.strip(),
-                'path': path.strip(),
-            }
-            for entry, name, path in re.findall(
-                r"^Boot(?P<entry>[0-9a-fA-F]{4})\*?\s(?P<name>.+)\t"
-                r"(?P<path>.*)$",
-                stdout, re.MULTILINE)
-        }
+        output = parse_efibootmgr(stdout)
         return output
 
 
diff --git a/debian/changelog b/debian/changelog
index cc0ac06..cba455d 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,21 @@
+curtin (18.1-17-gae48e86f-0ubuntu1~18.04.1) bionic; urgency=medium
+
+  * New upstream snapshot. (LP: #1772044)
+    - tests: replace usage of mock.assert_called
+    - tools: jenkins-runner show curtin version in output.
+    - zfs: implement a supported check to handle i386
+    - Support mount entries not tied to a device, including bind and tmpfs.
+    - block/clear_holders/mdadm: refactor handling of layered device wiping
+    - clear_holders: only export zpools that have been imported
+    - vmtests: allow env control of apt, system_upgrade, package upgrade
+    - util.get_efibootmgr: filter bootorder by found entries
+    - vmtests: adjust lvm_iscsi dnames to match configuration
+    - vmtest: always boot with BOOTIF and ip=:::::BOOTIF:dhcp
+    - make_dname for bcache should use backing device uuid
+    - zfsroot: add additional checks, do not require disk 'serial' attribute
+
+ -- Ryan Harper <[e-mail]>  Fri, 18 May 2018 13:58:58 -0500
+
 curtin (18.1-5-g572ae5d6-0ubuntu1) bionic; urgency=medium
 
   * New upstream snapshot.
diff --git a/doc/topics/integration-testing.rst b/doc/topics/integration-testing.rst
index d1a849f..7753068 100644
--- a/doc/topics/integration-testing.rst
+++ b/doc/topics/integration-testing.rst
@@ -307,6 +307,22 @@ Some environment variables affect the running of vmtest
    This allows us to avoid failures when running curtin from an Ubuntu
    package or from some other "stale" source.
 
+- ``CURTIN_VMTEST_ADD_REPOS``: default ''
+   This is a comma delimited list of apt repositories that will be
+   added to the target environment.  If there are repositories
+   provided here, the and CURTIN_VMTEST_SYSTEM_UPGRADE is at its default
+   setting (auto), then a upgrade will be done to make sure to include
+   any new packages.
+
+- ``CURTIN_VMTEST_SYSTEM_UPGRADE``: default 'auto'
+   The default setting of 'auto' means to do a system upgrade if
+   there are additional repos added.  To enable this explicitly, set
+   to any non "0" value.
+
+- ``CURTIN_VMTEST_UPGRADE_PACKAGES``: default ''
+   This is a comma delimited string listing packages that should have
+   an 'apt-get install' done to them in curtin late commands.
+
 
 Environment 'boolean' values
 ============================
diff --git a/doc/topics/storage.rst b/doc/topics/storage.rst
index 403a20b..ca6253c 100644
--- a/doc/topics/storage.rst
+++ b/doc/topics/storage.rst
@@ -277,6 +277,8 @@ exists and will not modify the partition.
    device: disk0
    flag: boot
 
+.. _format:
+
 Format Command
 ~~~~~~~~~~~~~~
 The format command makes filesystems on a volume. The filesystem type and
@@ -290,7 +292,10 @@ target volume can be specified, as well as a few other options.
   Utilizing the the ``fstype: zfsroot`` will indicate to curtin
   that it should automatically inject the appropriate ``type: zpool``
   and ``type: zfs`` command structures based on which target ``volume``
-  is specified in the ``format`` command.
+  is specified in the ``format`` command.  There may be only *one*
+  zfsroot entry.  The disk that contains the zfsroot must be partitioned
+  with a GPT partition table.  Curtin will fail to install if these
+  requirements are not met.
 
 The ``fstype`` key specifies what type of filesystem format curtin should use
 for this volume. Curtin knows about common Linux filesystems such as ext4/3 and
@@ -366,9 +371,8 @@ in ``/dev``.
 
 **device**: *<device id>*
 
-The ``device`` key refers to the ``id`` of the target device in the storage
-config. The target device must already contain a valid filesystem and be
-accessible.
+The ``device`` key refers to the ``id`` of a :ref:`Format <format>` entry.
+One of ``device`` or ``spec`` must be present.
 
 .. note::
 
@@ -376,6 +380,12 @@ accessible.
   fstab entry will contain ``_netdev`` to indicate networking is
   required to mount this filesystem.
 
+**fstype**: *<fileystem type>*
+
+``fstype`` is only required if ``device`` is not present.  It indicates
+the filesystem type and will be used for mount operations and written
+to ``/etc/fstab``
+
 **options**: *<mount(8) comma-separated options string>*
 
 The ``options`` key will replace the default options value of ``defaults``.
@@ -393,6 +403,14 @@ The ``options`` key will replace the default options value of ``defaults``.
   If either of the environments (install or target) do not have support for
   the provided options, the behavior is undefined.
 
+**spec**: *<fs_spec>*
+
+The ``spec`` attribute defines the fsspec as defined in fstab(5).
+If ``spec`` is present with ``device``, then mounts will be done
+according to ``spec`` rather than determined via inspection of ``device``.
+If ``spec`` is present without ``device`` then ``fstype`` must be present.
+
+
 **Config Example**::
 
  - id: disk0-part1-fs1-mount0
@@ -401,6 +419,41 @@ The ``options`` key will replace the default options value of ``defaults``.
    device: disk0-part1-fs1
    options: 'noatime,errors=remount-ro'
 
+**Bind Mount**
+
+Below is an example of configuring a bind mount.
+
+.. code-block:: yaml
+
+ - id: bind1
+   fstype: "none"
+   options: "bind"
+   path: "/var/lib"
+   spec: "/my/bind-over-var-lib"
+   type: mount
+
+That would result in a fstab entry like::
+
+  /my/bind-over-var-lib /var/lib none bind 0 0
+
+**Tmpfs Mount**
+
+Below is an example of configuring a tmpfsbind mount.
+
+.. code-block:: yaml
+
+    - id: tmpfs1
+      type: mount
+      spec: "none"
+      path: "/my/tmpfs"
+      options: size=4194304
+      fstype: "tmpfs"
+
+That would result in a fstab entry like::
+
+  none /my/tmpfs tmpfs size=4194304 0 0
+
+
 Lvm Volgroup Command
 ~~~~~~~~~~~~~~~~~~~~
 The lvm_volgroup command creates LVM Physical Volumes (PV) and connects them in
@@ -651,6 +704,10 @@ when constructing ZFS datasets.
 
 The ``vdevs`` key specifies a list of items in the storage configuration to use
 in building a ZFS storage pool.  This can be a partition or a whole disk.
+It is recommended that vdevs are ``disks`` which have a 'serial' attribute
+which allows Curtin to build a /dev/disk/by-id path which is a persistent
+path, however, if not available Curtin will accept 'path' attributes but
+warn that the zpool may be unstable due to missing by-id device path.
 
 **mountpoint**: *<mountpoint>*
 
diff --git a/examples/tests/dirty_disks_config.yaml b/examples/tests/dirty_disks_config.yaml
index 18d331d..75d44c3 100644
--- a/examples/tests/dirty_disks_config.yaml
+++ b/examples/tests/dirty_disks_config.yaml
@@ -22,6 +22,11 @@ bucket:
     done
     swapon --show
     exit 0
+  - &zpool_export |
+      #!/bin/sh
+      # disable any rpools to trigger disks with zfs_member label but inactive
+      # pools
+      zpool export rpool ||:
 
 early_commands:
   # running block-meta custom from the install environment
@@ -34,3 +39,4 @@ early_commands:
               WORKING_DIR=/tmp/my.bdir/work.d, 
               curtin, --showtrace, -v, block-meta, --umount, custom]
   enable_swaps: [sh, -c, *swapon]
+  disable_rpool: [sh, -c, *zpool_export]
diff --git a/examples/tests/filesystem_battery.yaml b/examples/tests/filesystem_battery.yaml
index ba4fcac..3b1edbf 100644
--- a/examples/tests/filesystem_battery.yaml
+++ b/examples/tests/filesystem_battery.yaml
@@ -99,3 +99,26 @@ storage:
       label: myxfs
       volume: d2p10
       uuid: 9c537621-f2f4-4e24-a071-e05012a1a997
+    - id: tmpfs1
+      type: mount
+      spec: "none"
+      path: "/my/tmpfs"
+      options: size=4194304
+      fstype: "tmpfs"
+    - id: ramfs1
+      type: mount
+      spec: "none"
+      path: "/my/ramfs"
+      fstype: "ramfs"
+    - id: bind1
+      fstype: "none"
+      options: "bind"
+      path: "/var/lib"
+      spec: "/my/bind-over-var-lib"
+      type: mount
+    - id: bind2
+      fstype: "none"
+      options: "bind,ro"
+      path: "/my/bind-ro-etc"
+      spec: "/etc"
+      type: mount
diff --git a/examples/tests/mdadm_bcache_complex.yaml b/examples/tests/mdadm_bcache_complex.yaml
deleted file mode 100644
index c9c2f05..0000000
--- a/examples/tests/mdadm_bcache_complex.yaml
+++ /dev/null
@@ -1,128 +0,0 @@
-storage:
-  version: 1
-  config:
-     - grub_device: true
-       id: sda
-       type: disk
-       wipe: superblock
-       ptable: gpt
-       model: QEMU HARDDISK
-       serial: disk-a
-       name: main_disk
-     - id: bios_boot_partition
-       type: partition
-       size: 1MB
-       device: sda
-       flag: bios_grub
-     - id: sda1
-       type: partition
-       size: 2GB
-       device: sda
-     - id: sda2
-       type: partition
-       size: 1GB
-       device: sda
-     - id: sda3
-       type: partition
-       size: 1GB
-       device: sda
-     - id: sda4
-       type: partition
-       size: 1GB
-       device: sda
-     - id: sda5
-       type: partition
-       size: 1GB
-       device: sda
-     - id: sda6
-       type: partition
-       size: 1GB
-       device: sda
-     - id: sda7
-       type: partition
-       size: 1GB
-       device: sda
-     - id: sdb
-       type: disk
-       wipe: superblock
-       model: QEMU HARDDISK
-       serial: disk-b
-       name: second_disk
-     - id: sdc
-       type: disk
-       wipe: superblock
-       ptable: gpt
-       model: QEMU HARDDISK
-       serial: disk-c
-       name: third_disk
-     - id: sdc1
-       type: partition
-       size: 3GB
-       device: sdc
-     - id: mddevice
-       name: md0
-       type: raid
-       raidlevel: 1
-       devices:
-         - sda2
-         - sda3
-       spare_devices:
-         - sda4
-     - id: bcache1_raid
-       type: bcache
-       name: cached_array
-       backing_device: mddevice
-       cache_device: sda5
-       cache_mode: writeback
-     - id: bcache_normal
-       type: bcache
-       name: cached_array_2
-       backing_device: sda6
-       cache_device: sda5
-       cache_mode: writethrough
-     - id: bcachefoo
-       type: bcache
-       name: cached_array_3
-       backing_device: sdc1
-       cache_device: sdb
-       cache_mode: writearound
-     - id: sda1_extradisk
-       type: format
-       fstype: ext4
-       volume: sda1
-     - id: sda7_boot
-       type: format
-       fstype: ext4
-       volume: sda7
-     - id: bcache_raid_storage
-       type: format
-       fstype: ext4
-       volume: bcache1_raid
-     - id: bcache_normal_storage
-       type: format
-       fstype: ext4
-       volume: bcache_normal
-     - id: bcachefoo_fulldiskascache_storage
-       type: format
-       fstype: ext4
-       volume: bcachefoo
-     - id: bcache_root
-       type: mount
-       path: /
-       device: bcachefoo_fulldiskascache_storage
-     - id: bcache1_raid_mount
-       type: mount
-       path: /media/data
-       device: bcache_raid_storage
-     - id: bcache0_mount
-       type: mount
-       path: /media/bcache_normal
-       device: bcache_normal_storage
-     - id: sda1_non_root_mount
-       type: mount
-       path: /media/sda1
-       device: sda1_extradisk
-     - id: sda7_boot_mount
-       type: mount
-       path: /boot
-       device: sda7_boot
diff --git a/tests/unittests/helpers.py b/tests/unittests/helpers.py
index bd07708..58e068b 100644
--- a/tests/unittests/helpers.py
+++ b/tests/unittests/helpers.py
@@ -63,7 +63,9 @@ class CiTestCase(TestCase):
         # the file is not created or modified.
         if _dir is None:
             _dir = self.tmp_dir()
-        return os.path.normpath(os.path.abspath(os.path.join(_dir, path)))
+
+        return os.path.normpath(
+            os.path.abspath(os.path.sep.join((_dir, path))))
 
 
 def dir2dict(startdir, prefix=None):
diff --git a/tests/unittests/test_block_zfs.py b/tests/unittests/test_block_zfs.py
index 883f727..c61a6da 100644
--- a/tests/unittests/test_block_zfs.py
+++ b/tests/unittests/test_block_zfs.py
@@ -1,5 +1,8 @@
+import mock
+
 from curtin.config import merge_config
 from curtin.block import zfs
+from curtin.util import ProcessExecutionError
 from .helpers import CiTestCase
 
 
@@ -375,4 +378,97 @@ class TestBlockZfsDeviceToPoolname(CiTestCase):
         self.mock_blkid.assert_called_with(devs=[devname])
 
 
+class TestBlockZfsZfsSupported(CiTestCase):
+
+    def setUp(self):
+        super(TestBlockZfsZfsSupported, self).setUp()
+        self.add_patch('curtin.block.zfs.util.subp', 'mock_subp')
+        self.add_patch('curtin.block.zfs.util.get_platform_arch', 'mock_arch')
+        self.add_patch('curtin.block.zfs.util.lsb_release', 'mock_release')
+        self.mock_release.return_value = {'codename': 'xenial'}
+        self.mock_arch.return_value = 'x86_64'
+
+    def test_supported_arch(self):
+        self.assertTrue(zfs.zfs_supported())
+
+    def test_unsupported_arch(self):
+        self.mock_arch.return_value = 'i386'
+        with self.assertRaises(RuntimeError):
+            zfs.zfs_supported()
+
+    def test_unsupported_releases(self):
+        for rel in ['precise', 'trusty']:
+            self.mock_release.return_value = {'codename': rel}
+            with self.assertRaises(RuntimeError):
+                zfs.zfs_supported()
+
+    def test_missing_module(self):
+        missing = 'modinfo: ERROR: Module zfs not found.\n     '
+        self.mock_subp.side_effect = ProcessExecutionError(stdout='',
+                                                           stderr=missing,
+                                                           exit_code='1')
+        with self.assertRaises(RuntimeError):
+            zfs.zfs_supported()
+
+
+class TestZfsSupported(CiTestCase):
+
+    def setUp(self):
+        super(TestZfsSupported, self).setUp()
+
+    @mock.patch('curtin.block.zfs.util')
+    def test_zfs_supported_returns_true(self, mock_util):
+        """zfs_supported returns True on supported platforms"""
+        mock_util.get_platform_arch.return_value = 'amd64'
+        mock_util.lsb_release.return_value = {'codename': 'bionic'}
+        mock_util.subp.return_value = ("", "")
+
+        self.assertNotIn(mock_util.get_platform_arch.return_value,
+                         zfs.ZFS_UNSUPPORTED_ARCHES)
+        self.assertNotIn(mock_util.lsb_release.return_value['codename'],
+                         zfs.ZFS_UNSUPPORTED_RELEASES)
+        self.assertTrue(zfs.zfs_supported())
+
+    @mock.patch('curtin.block.zfs.util')
+    def test_zfs_supported_raises_exception_on_bad_arch(self, mock_util):
+        """zfs_supported raises RuntimeError on unspported arches"""
+        mock_util.lsb_release.return_value = {'codename': 'bionic'}
+        mock_util.subp.return_value = ("", "")
+        for arch in zfs.ZFS_UNSUPPORTED_ARCHES:
+            mock_util.get_platform_arch.return_value = arch
+            with self.assertRaises(RuntimeError):
+                zfs.zfs_supported()
+
+    @mock.patch('curtin.block.zfs.util')
+    def test_zfs_supported_raises_execption_on_bad_releases(self, mock_util):
+        """zfs_supported raises RuntimeError on unspported releases"""
+        mock_util.get_platform_arch.return_value = 'amd64'
+        mock_util.subp.return_value = ("", "")
+        for release in zfs.ZFS_UNSUPPORTED_RELEASES:
+            mock_util.lsb_release.return_value = {'codename': release}
+            with self.assertRaises(RuntimeError):
+                zfs.zfs_supported()
+
+    @mock.patch('curtin.block.zfs.util.subprocess.Popen')
+    @mock.patch('curtin.block.zfs.util.lsb_release')
+    @mock.patch('curtin.block.zfs.util.get_platform_arch')
+    def test_zfs_supported_raises_exception_on_missing_module(self,
+                                                              m_arch,
+                                                              m_release,
+                                                              m_popen):
+        """zfs_supported raises RuntimeError on missing zfs module"""
+
+        m_arch.return_value = 'amd64'
+        m_release.return_value = {'codename': 'bionic'}
+        process_mock = mock.Mock()
+        attrs = {
+            'returncode': 1,
+            'communicate.return_value':
+                ('output', "modinfo: ERROR: Module zfs not found."),
+        }
+        process_mock.configure_mock(**attrs)
+        m_popen.return_value = process_mock
+        with self.assertRaises(RuntimeError):
+            zfs.zfs_supported()
+
 # vi: ts=4 expandtab syntax=python
diff --git a/tests/unittests/test_clear_holders.py b/tests/unittests/test_clear_holders.py
index 183cd20..ceb5615 100644
--- a/tests/unittests/test_clear_holders.py
+++ b/tests/unittests/test_clear_holders.py
@@ -132,6 +132,7 @@ class TestClearHolders(CiTestCase):
             mock_block.path_to_kname.assert_called_with(self.test_syspath)
             mock_get_dmsetup_uuid.assert_called_with(self.test_syspath)
 
+    @mock.patch('curtin.block.clear_holders.block')
     @mock.patch('curtin.block.clear_holders.udev.udevadm_settle')
     @mock.patch('curtin.block.clear_holders.get_bcache_sys_path')
     @mock.patch('curtin.block.clear_holders.util')
@@ -140,7 +141,7 @@ class TestClearHolders(CiTestCase):
     @mock.patch('curtin.block.clear_holders.get_bcache_using_dev')
     def test_shutdown_bcache(self, mock_get_bcache, mock_log, mock_os,
                              mock_util, mock_get_bcache_block,
-                             mock_udevadm_settle):
+                             mock_udevadm_settle, mock_block):
         """test clear_holders.shutdown_bcache"""
         #
         # pass in a sysfs path to a bcache block device,
@@ -152,6 +153,7 @@ class TestClearHolders(CiTestCase):
         #
 
         device = self.test_syspath
+        mock_block.sys_block_path.return_value = '/dev/null'
         bcache_cset_uuid = 'c08ae789-a964-46fb-a66e-650f0ae78f94'
 
         mock_os.path.exists.return_value = True
@@ -197,6 +199,7 @@ class TestClearHolders(CiTestCase):
         self.assertEqual(0, len(mock_util.call_args_list))
         self.assertEqual(0, len(mock_get_bcache_block.call_args_list))
 
+    @mock.patch('curtin.block.clear_holders.block')
     @mock.patch('curtin.block.clear_holders.get_bcache_sys_path')
     @mock.patch('curtin.block.clear_holders.util')
     @mock.patch('curtin.block.clear_holders.os')
@@ -204,18 +207,20 @@ class TestClearHolders(CiTestCase):
     @mock.patch('curtin.block.clear_holders.get_bcache_using_dev')
     def test_shutdown_bcache_no_device(self, mock_get_bcache, mock_log,
                                        mock_os, mock_util,
-                                       mock_get_bcache_block):
+                                       mock_get_bcache_block, mock_block):
         device = "/sys/class/block/null"
+        mock_block.sysfs_to_devpath.return_value = '/dev/null'
         mock_os.path.exists.return_value = False
 
         clear_holders.shutdown_bcache(device)
 
-        self.assertEqual(1, len(mock_log.info.call_args_list))
+        self.assertEqual(3, len(mock_log.info.call_args_list))
         self.assertEqual(1, len(mock_os.path.exists.call_args_list))
         self.assertEqual(0, len(mock_get_bcache.call_args_list))
         self.assertEqual(0, len(mock_util.call_args_list))
         self.assertEqual(0, len(mock_get_bcache_block.call_args_list))
 
+    @mock.patch('curtin.block.clear_holders.block')
     @mock.patch('curtin.block.clear_holders.get_bcache_sys_path')
     @mock.patch('curtin.block.clear_holders.util')
     @mock.patch('curtin.block.clear_holders.os')
@@ -223,8 +228,9 @@ class TestClearHolders(CiTestCase):
     @mock.patch('curtin.block.clear_holders.get_bcache_using_dev')
     def test_shutdown_bcache_no_cset(self, mock_get_bcache, mock_log,
                                      mock_os, mock_util,
-                                     mock_get_bcache_block):
+                                     mock_get_bcache_block, mock_block):
         device = "/sys/class/block/null"
+        mock_block.sysfs_to_devpath.return_value = '/dev/null'
         mock_os.path.exists.side_effect = iter([
                 True,   # backing device exists
                 False,  # cset device not present (already removed)
@@ -236,7 +242,7 @@ class TestClearHolders(CiTestCase):
 
         clear_holders.shutdown_bcache(device)
 
-        self.assertEqual(2, len(mock_log.info.call_args_list))
+        self.assertEqual(4, len(mock_log.info.call_args_list))
         self.assertEqual(3, len(mock_os.path.exists.call_args_list))
         self.assertEqual(1, len(mock_get_bcache.call_args_list))
         self.assertEqual(1, len(mock_get_bcache_block.call_args_list))
@@ -252,6 +258,7 @@ class TestClearHolders(CiTestCase):
             mock.call(device, retries=retries),
             mock.call(device + '/bcache', retries=retries)])
 
+    @mock.patch('curtin.block.clear_holders.block')
     @mock.patch('curtin.block.clear_holders.udev.udevadm_settle')
     @mock.patch('curtin.block.clear_holders.get_bcache_sys_path')
     @mock.patch('curtin.block.clear_holders.util')
@@ -262,8 +269,10 @@ class TestClearHolders(CiTestCase):
                                                      mock_log, mock_os,
                                                      mock_util,
                                                      mock_get_bcache_block,
-                                                     mock_udevadm_settle):
+                                                     mock_udevadm_settle,
+                                                     mock_block):
         device = "/sys/class/block/null"
+        mock_block.sysfs_to_devpath.return_value = '/dev/null'
         mock_os.path.exists.side_effect = iter([
                 True,  # backing device exists
                 True,  # cset device not present (already removed)
@@ -276,7 +285,7 @@ class TestClearHolders(CiTestCase):
 
         clear_holders.shutdown_bcache(device)
 
-        self.assertEqual(2, len(mock_log.info.call_args_list))
+        self.assertEqual(4, len(mock_log.info.call_args_list))
         self.assertEqual(3, len(mock_os.path.exists.call_args_list))
         self.assertEqual(1, len(mock_get_bcache.call_args_list))
         self.assertEqual(1, len(mock_get_bcache_block.call_args_list))
@@ -293,6 +302,7 @@ class TestClearHolders(CiTestCase):
             mock.call(device, retries=self.remove_retries)
         ])
 
+    @mock.patch('curtin.block.clear_holders.block')
     @mock.patch('curtin.block.clear_holders.udev.udevadm_settle')
     @mock.patch('curtin.block.clear_holders.get_bcache_sys_path')
     @mock.patch('curtin.block.clear_holders.util')
@@ -303,8 +313,10 @@ class TestClearHolders(CiTestCase):
                                                     mock_log, mock_os,
                                                     mock_util,
                                                     mock_get_bcache_block,
-                                                    mock_udevadm_settle):
+                                                    mock_udevadm_settle,
+                                                    mock_block):
         device = "/sys/class/block/null"
+        mock_block.sysfs_to_devpath.return_value = '/dev/null'
         mock_os.path.exists.side_effect = iter([
                 True,   # backing device exists
                 True,   # cset device not present (already removed)
@@ -317,7 +329,7 @@ class TestClearHolders(CiTestCase):
 
         clear_holders.shutdown_bcache(device)
 
-        self.assertEqual(2, len(mock_log.info.call_args_list))
+        self.assertEqual(4, len(mock_log.info.call_args_list))
         self.assertEqual(3, len(mock_os.path.exists.call_args_list))
         self.assertEqual(1, len(mock_get_bcache.call_args_list))
         self.assertEqual(1, len(mock_get_bcache_block.call_args_list))
@@ -333,6 +345,8 @@ class TestClearHolders(CiTestCase):
         ])
 
     # test bcache shutdown with 'stop' sysfs write failure
+    @mock.patch('curtin.block.clear_holders.block')
+    @mock.patch('curtin.block.wipe_volume')
     @mock.patch('curtin.block.clear_holders.udev.udevadm_settle')
     @mock.patch('curtin.block.clear_holders.get_bcache_sys_path')
     @mock.patch('curtin.block.clear_holders.util')
@@ -343,9 +357,12 @@ class TestClearHolders(CiTestCase):
                                                     mock_log, mock_os,
                                                     mock_util,
                                                     mock_get_bcache_block,
-                                                    mock_udevadm_settle):
+                                                    mock_udevadm_settle,
+                                                    mock_wipe,
+                                                    mock_block):
         """Test writes sysfs write failures pass if file not present"""
         device = "/sys/class/block/null"
+        mock_block.sysfs_to_devpath.return_value = '/dev/null'
         mock_os.path.exists.side_effect = iter([
                 True,   # backing device exists
                 True,   # cset device not present (already removed)
@@ -363,7 +380,7 @@ class TestClearHolders(CiTestCase):
 
         clear_holders.shutdown_bcache(device)
 
-        self.assertEqual(2, len(mock_log.info.call_args_list))
+        self.assertEqual(4, len(mock_log.info.call_args_list))
         self.assertEqual(3, len(mock_os.path.exists.call_args_list))
         self.assertEqual(1, len(mock_get_bcache.call_args_list))
         self.assertEqual(1, len(mock_get_bcache_block.call_args_list))
@@ -378,15 +395,20 @@ class TestClearHolders(CiTestCase):
             mock.call(cset, retries=self.remove_retries)
         ])
 
+    @mock.patch('curtin.block.quick_zero')
     @mock.patch('curtin.block.clear_holders.LOG')
     @mock.patch('curtin.block.clear_holders.block.sys_block_path')
     @mock.patch('curtin.block.clear_holders.lvm')
     @mock.patch('curtin.block.clear_holders.util')
-    def test_shutdown_lvm(self, mock_util, mock_lvm, mock_syspath, mock_log):
+    def test_shutdown_lvm(self, mock_util, mock_lvm, mock_syspath, mock_log,
+                          mock_zero):
         """test clear_holders.shutdown_lvm"""
         lvm_name = b'ubuntu--vg-swap\n'
         vg_name = 'ubuntu-vg'
         lv_name = 'swap'
+        vg_lv_name = "%s/%s" % (vg_name, lv_name)
+        devname = "/dev/" + vg_lv_name
+        pvols = ['/dev/wda1', '/dev/wda2']
         mock_syspath.return_value = self.test_blockdev
         mock_util.load_file.return_value = lvm_name
         mock_lvm.split_lvm_name.return_value = (vg_name, lv_name)
@@ -394,18 +416,22 @@ class TestClearHolders(CiTestCase):
         clear_holders.shutdown_lvm(self.test_blockdev)
         mock_syspath.assert_called_with(self.test_blockdev)
         mock_util.load_file.assert_called_with(self.test_blockdev + '/dm/name')
+        mock_zero.assert_called_with(devname, partitions=False)
         mock_lvm.split_lvm_name.assert_called_with(lvm_name.strip())
         self.assertTrue(mock_log.debug.called)
         mock_util.subp.assert_called_with(
-            ['dmsetup', 'remove', lvm_name.strip()])
-
+            ['lvremove', '--force', '--force', vg_lv_name])
         mock_lvm.get_lvols_in_volgroup.assert_called_with(vg_name)
         self.assertEqual(len(mock_util.subp.call_args_list), 1)
-        self.assertTrue(mock_lvm.lvm_scan.called)
         mock_lvm.get_lvols_in_volgroup.return_value = []
+        self.assertTrue(mock_lvm.lvm_scan.called)
+        mock_lvm.get_pvols_in_volgroup.return_value = pvols
         clear_holders.shutdown_lvm(self.test_blockdev)
         mock_util.subp.assert_called_with(
             ['vgremove', '--force', '--force', vg_name], rcs=[0, 5])
+        for pv in pvols:
+            mock_zero.assert_any_call(pv, partitions=False)
+        self.assertTrue(mock_lvm.lvm_scan.called)
 
     @mock.patch('curtin.block.clear_holders.block')
     @mock.patch('curtin.block.clear_holders.util')
@@ -417,18 +443,38 @@ class TestClearHolders(CiTestCase):
         mock_util.subp.assert_called_with(
             ['cryptsetup', 'remove', self.test_blockdev], capture=True)
 
+    @mock.patch('curtin.block.wipe_volume')
+    @mock.patch('curtin.block.path_to_kname')
+    @mock.patch('curtin.block.sysfs_to_devpath')
     @mock.patch('curtin.block.clear_holders.time')
     @mock.patch('curtin.block.clear_holders.util')
     @mock.patch('curtin.block.clear_holders.LOG')
     @mock.patch('curtin.block.clear_holders.mdadm')
-    @mock.patch('curtin.block.clear_holders.block')
-    def test_shutdown_mdadm(self, mock_block, mock_mdadm, mock_log, mock_util,
-                            mock_time):
+    def test_shutdown_mdadm(self, mock_mdadm, mock_log, mock_util,
+                            mock_time, mock_sysdev, mock_path, mock_wipe):
         """test clear_holders.shutdown_mdadm"""
-        mock_block.sysfs_to_devpath.return_value = self.test_blockdev
-        mock_block.path_to_kname.return_value = self.test_blockdev
+        devices = ['/dev/wda1', '/dev/wda2']
+        spares = ['/dev/wdb1']
+        md_devs = (devices + spares)
+        mock_sysdev.return_value = self.test_blockdev
+        mock_path.return_value = self.test_blockdev
         mock_mdadm.md_present.return_value = False
+        mock_mdadm.md_get_devices_list.return_value = devices
+        mock_mdadm.md_get_spares_list.return_value = spares
+
         clear_holders.shutdown_mdadm(self.test_syspath)
+
+        mock_wipe.assert_called_with(
+            self.test_blockdev, exclusive=False, mode='superblock')
+        mock_mdadm.set_sync_action.assert_has_calls([
+                mock.call(self.test_blockdev, action="idle"),
+                mock.call(self.test_blockdev, action="frozen")])
+        mock_mdadm.fail_device.assert_has_calls(
+            [mock.call(self.test_blockdev, dev) for dev in md_devs])
+        mock_mdadm.remove_device.assert_has_calls(
+            [mock.call(self.test_blockdev, dev) for dev in md_devs])
+        mock_mdadm.zero_device.assert_has_calls(
+            [mock.call(dev) for dev in md_devs])
         mock_mdadm.mdadm_stop.assert_called_with(self.test_blockdev)
         mock_mdadm.md_present.assert_called_with(self.test_blockdev)
         self.assertTrue(mock_log.debug.called)
@@ -510,6 +556,7 @@ class TestClearHolders(CiTestCase):
         mock_block.is_extended_partition.return_value = False
         mock_block.is_zfs_member.return_value = True
         mock_zfs.device_to_poolname.return_value = 'fake_pool'
+        mock_zfs.zpool_list.return_value = ['fake_pool']
         clear_holders.wipe_superblock(self.test_syspath)
         mock_block.sysfs_to_devpath.assert_called_with(self.test_syspath)
         mock_zfs.zpool_export.assert_called_with('fake_pool')
@@ -676,29 +723,31 @@ class TestClearHolders(CiTestCase):
         mock_gen_holders_tree.return_value = self.example_holders_trees[1][1]
         clear_holders.assert_clear(device)
 
+    @mock.patch('curtin.block.clear_holders.zfs')
     @mock.patch('curtin.block.clear_holders.mdadm')
     @mock.patch('curtin.block.clear_holders.util')
-    def test_start_clear_holders_deps(self, mock_util, mock_mdadm):
-        mock_util.lsb_release.return_value = {'codename': 'xenial'}
+    def test_start_clear_holders_deps(self, mock_util, mock_mdadm, mock_zfs):
+        mock_zfs.zfs_supported.return_value = True
         clear_holders.start_clear_holders_deps()
         mock_mdadm.mdadm_assemble.assert_called_with(
             scan=True, ignore_errors=True)
         mock_util.load_kernel_module.assert_has_calls([
                 mock.call('bcache'), mock.call('zfs')])
 
+    @mock.patch('curtin.block.clear_holders.zfs')
     @mock.patch('curtin.block.clear_holders.mdadm')
     @mock.patch('curtin.block.clear_holders.util')
-    def test_start_clear_holders_deps_nozfs(self, mock_util, mock_mdadm):
-        """ test that we skip zfs modprobe on precise, trusty """
-        for codename in ['precise', 'trusty']:
-            mock_util.lsb_release.return_value = {'codename': codename}
-            clear_holders.start_clear_holders_deps()
-            mock_mdadm.mdadm_assemble.assert_called_with(
-                scan=True, ignore_errors=True)
-            mock_util.load_kernel_module.assert_has_calls(
-                [mock.call('bcache')])
-            self.assertNotIn(mock.call('zfs'),
-                             mock_util.load_kernel_module.call_args_list)
+    def test_start_clear_holders_deps_nozfs(self, mock_util, mock_mdadm,
+                                            mock_zfs):
+        """test that we skip zfs modprobe on unsupported platforms"""
+        mock_zfs.zfs_supported.return_value = False
+        clear_holders.start_clear_holders_deps()
+        mock_mdadm.mdadm_assemble.assert_called_with(
+            scan=True, ignore_errors=True)
+        mock_util.load_kernel_module.assert_has_calls(
+            [mock.call('bcache')])
+        self.assertNotIn(mock.call('zfs'),
+                         mock_util.load_kernel_module.call_args_list)
 
     @mock.patch('curtin.block.clear_holders.util')
     def test_shutdown_swap_calls_swapoff(self, mock_util):
diff --git a/tests/unittests/test_commands_block_meta.py b/tests/unittests/test_commands_block_meta.py
index 4937ec0..a6a0b13 100644
--- a/tests/unittests/test_commands_block_meta.py
+++ b/tests/unittests/test_commands_block_meta.py
@@ -2,7 +2,9 @@
 
 from argparse import Namespace
 from collections import OrderedDict
+import copy
 from mock import patch, call
+import os
 
 from curtin.commands import block_meta
 from curtin import util
@@ -321,49 +323,447 @@ class TestBlockMeta(CiTestCase):
             rendered_fstab = fh.read()
 
         print(rendered_fstab)
-        self.assertEqual(rendered_fstab, expected)
+        self.assertEqual(expected, rendered_fstab)
+
+
+class TestZpoolHandler(CiTestCase):
+    @patch('curtin.commands.block_meta.zfs')
+    @patch('curtin.commands.block_meta.block')
+    @patch('curtin.commands.block_meta.util')
+    @patch('curtin.commands.block_meta.get_path_to_storage_volume')
+    def test_zpool_handler_falls_back_to_path_when_no_byid(self, m_getpath,
+                                                           m_util, m_block,
+                                                           m_zfs):
+        storage_config = OrderedDict()
+        info = {'type': 'zpool', 'id': 'myrootfs_zfsroot_pool',
+                'pool': 'rpool', 'vdevs': ['disk1p1'], 'mountpoint': '/'}
+        disk_path = "/wark/mydev"
+        m_getpath.return_value = disk_path
+        m_block.disk_to_byid_path.return_value = None
+        m_util.load_command_environment.return_value = {'target': 'mytarget'}
+        block_meta.zpool_handler(info, storage_config)
+        m_zfs.zpool_create.assert_called_with(info['pool'], [disk_path],
+                                              mountpoint="/",
+                                              altroot="mytarget")
 
 
 class TestZFSRootUpdates(CiTestCase):
-    def test_basic_zfsroot_update_storage_config(self):
-        zfsroot_id = 'myrootfs'
-        base = [
-            {'id': 'disk1', 'type': 'disk', 'ptable': 'gpt',
-             'serial': 'dev_vda', 'name': 'main_disk', 'wipe': 'superblock',
-             'grub_device': True},
-            {'id': 'disk1p1', 'type': 'partition', 'number': '1',
-             'size': '9G', 'device': 'disk1'},
-            {'id': 'bios_boot', 'type': 'partition', 'size': '1M',
-             'number': '2', 'device': 'disk1', 'flag': 'bios_grub'}]
-        zfsroots = [
-            {'id': zfsroot_id, 'type': 'format', 'fstype': 'zfsroot',
-             'volume': 'disk1p1', 'label': 'cloudimg-rootfs'},
-            {'id': 'disk1p1_mount', 'type': 'mount', 'path': '/',
-             'device': zfsroot_id}]
-        extra = [
-            {'id': 'extra', 'type': 'disk', 'ptable': 'gpt',
-             'wipe': 'superblock'}
-        ]
+    zfsroot_id = 'myrootfs'
+    base = [
+        {'id': 'disk1', 'type': 'disk', 'ptable': 'gpt',
+         'serial': 'dev_vda', 'name': 'main_disk', 'wipe': 'superblock',
+         'grub_device': True},
+        {'id': 'disk1p1', 'type': 'partition', 'number': '1',
+         'size': '9G', 'device': 'disk1'},
+        {'id': 'bios_boot', 'type': 'partition', 'size': '1M',
+         'number': '2', 'device': 'disk1', 'flag': 'bios_grub'}]
+    zfsroots = [
+        {'id': zfsroot_id, 'type': 'format', 'fstype': 'zfsroot',
+         'volume': 'disk1p1', 'label': 'cloudimg-rootfs'},
+        {'id': 'disk1p1_mount', 'type': 'mount', 'path': '/',
+         'device': zfsroot_id}]
+    extra = [
+        {'id': 'extra', 'type': 'disk', 'ptable': 'gpt',
+         'wipe': 'superblock'}
+    ]
 
+    def test_basic_zfsroot_update_storage_config(self):
         zfsroot_volname = "/ROOT/zfsroot"
-        pool_id = zfsroot_id + '_zfsroot_pool'
+        pool_id = self.zfsroot_id + '_zfsroot_pool'
         newents = [
             {'type': 'zpool', 'id': pool_id,
              'pool': 'rpool', 'vdevs': ['disk1p1'], 'mountpoint': '/'},
-            {'type': 'zfs', 'id': zfsroot_id + '_zfsroot_container',
+            {'type': 'zfs', 'id': self.zfsroot_id + '_zfsroot_container',
              'pool': pool_id, 'volume': '/ROOT',
              'properties': {'canmount': 'off', 'mountpoint': 'none'}},
-            {'type': 'zfs', 'id': zfsroot_id + '_zfsroot_fs',
+            {'type': 'zfs', 'id': self.zfsroot_id + '_zfsroot_fs',
              'pool': pool_id, 'volume': zfsroot_volname,
              'properties': {'canmount': 'noauto', 'mountpoint': '/'}},
         ]
         expected = OrderedDict(
-            [(i['id'], i) for i in base + newents + extra])
+            [(i['id'], i) for i in self.base + newents + self.extra])
 
         scfg = block_meta.extract_storage_ordered_dict(
-            {'storage': {'version': 1, 'config': base + zfsroots + extra}})
+            {'storage': {'version': 1,
+                         'config': self.base + self.zfsroots + self.extra}})
         found = block_meta.zfsroot_update_storage_config(scfg)
         print(util.json_dumps([(k, v) for k, v in found.items()]))
         self.assertEqual(expected, found)
 
+    def test_basic_zfsroot_raise_valueerror_no_gpt(self):
+        msdos_base = copy.deepcopy(self.base)
+        msdos_base[0]['ptable'] = 'msdos'
+        scfg = block_meta.extract_storage_ordered_dict(
+            {'storage': {'version': 1,
+                         'config': msdos_base + self.zfsroots + self.extra}})
+        with self.assertRaises(ValueError):
+            block_meta.zfsroot_update_storage_config(scfg)
+
+    def test_basic_zfsroot_raise_valueerror_multi_zfsroot(self):
+        extra_disk = [
+            {'id': 'disk2', 'type': 'disk', 'ptable': 'gpt',
+             'serial': 'dev_vdb', 'name': 'extra_disk', 'wipe': 'superblock'}]
+        second_zfs = [
+            {'id': 'zfsroot2', 'type': 'format', 'fstype': 'zfsroot',
+             'volume': 'disk2', 'label': ''}]
+        scfg = block_meta.extract_storage_ordered_dict(
+            {'storage': {'version': 1,
+                         'config': (self.base + extra_disk +
+                                    self.zfsroots + second_zfs)}})
+        with self.assertRaises(ValueError):
+            block_meta.zfsroot_update_storage_config(scfg)
+
+
+class TestFstabData(CiTestCase):
+    mnt = {'id': 'm1', 'type': 'mount', 'device': 'fs1', 'path': '/',
+           'options': 'noatime'}
+    base_cfg = [
+        {'id': 'xda', 'type': 'disk', 'ptable': 'msdos'},
+        {'id': 'xda1', 'type': 'partition', 'size': '3GB',
+         'device': 'xda'},
+        {'id': 'fs1', 'type': 'format', 'fstype': 'ext4',
+         'volume': 'xda1', 'label': 'rfs'},
+    ]
+
+    def _my_gptsv(self, d_id, _scfg):
+        """local test replacement for get_path_to_storage_volume."""
+        if d_id in ("xda", "xda1"):
+            return "/dev/" + d_id
+        raise RuntimeError("Unexpected call to gptsv with %s" % d_id)
+
+    def test_mount_data_raises_valueerror_if_not_mount(self):
+        """mount_data on non-mount type raises ValueError."""
+        mnt = self.mnt.copy()
+        mnt['type'] = "not-mount"
+        with self.assertRaisesRegexp(ValueError, r".*not type 'mount'"):
+            block_meta.mount_data(mnt, {mnt['id']: mnt})
+
+    def test_mount_data_no_device_or_spec_raises_valueerror(self):
+        """test_mount_data raises ValueError if no device or spec."""
+        mnt = self.mnt.copy()
+        del mnt['device']
+        with self.assertRaisesRegexp(ValueError, r".*mount.*missing.*"):
+            block_meta.mount_data(mnt, {mnt['id']: mnt})
+
+    def test_mount_data_invalid_device_ref_raises_valueerror(self):
+        """test_mount_data raises ValueError if device is invalid ref."""
+        mnt = self.mnt.copy()
+        mnt['device'] = 'myinvalid'
+        scfg = OrderedDict([(i['id'], i) for i in self.base_cfg + [mnt]])
+        with self.assertRaisesRegexp(ValueError, r".*refers.*myinvalid"):
+            block_meta.mount_data(mnt, scfg)
+
+    def test_mount_data_invalid_format_ref_raises_valueerror(self):
+        """test_mount_data raises ValueError if format.volume is invalid."""
+        mycfg = copy.deepcopy(self.base_cfg) + [self.mnt.copy()]
+        scfg = OrderedDict([(i['id'], i) for i in mycfg])
+        # change the 'volume' entry for the 'format' type.
+        scfg['fs1']['volume'] = 'myinvalidvol'
+        with self.assertRaisesRegexp(ValueError, r".*refers.*myinvalidvol"):
+            block_meta.mount_data(scfg['m1'], scfg)
+
+    def test_non_device_mount_with_spec(self):
+        """mount_info with a spec does not need device."""
+        info = {'id': 'xm1', 'spec': 'none', 'type': 'mount',
+                'fstype': 'tmpfs', 'path': '/tmpfs'}
+        self.assertEqual(
+            block_meta.FstabData(
+                spec="none", fstype="tmpfs", path="/tmpfs",
+                options="defaults", freq="0", passno="0", device=None),
+            block_meta.mount_data(info, {'xm1': info}))
+
+    @patch('curtin.block.iscsi.volpath_is_iscsi')
+    @patch('curtin.commands.block_meta.get_path_to_storage_volume')
+    def test_device_mount_basic(self, m_gptsv, m_is_iscsi):
+        """Test mount_data for FstabData with a device."""
+        m_gptsv.side_effect = self._my_gptsv
+        m_is_iscsi.return_value = False
+
+        scfg = OrderedDict(
+            [(i['id'], i) for i in self.base_cfg + [self.mnt]])
+        self.assertEqual(
+            block_meta.FstabData(
+                spec=None, fstype="ext4", path="/",
+                options="noatime", freq="0", passno="0", device="/dev/xda1"),
+            block_meta.mount_data(scfg['m1'], scfg))
+
+    @patch('curtin.block.iscsi.volpath_is_iscsi', return_value=False)
+    @patch('curtin.commands.block_meta.get_path_to_storage_volume')
+    def test_device_mount_boot_efi(self, m_gptsv, m_is_iscsi):
+        """Test mount_data fat fs gets converted to vfat."""
+        bcfg = copy.deepcopy(self.base_cfg)
+        bcfg[2]['fstype'] = 'fat32'
+        mnt = {'id': 'm1', 'type': 'mount', 'device': 'fs1',
+               'path': '/boot/efi'}
+        m_gptsv.side_effect = self._my_gptsv
+
+        scfg = OrderedDict(
+            [(i['id'], i) for i in bcfg + [mnt]])
+        self.assertEqual(
+            block_meta.FstabData(
+                spec=None, fstype="vfat", path="/boot/efi",
+                options="defaults", freq="0", passno="0", device="/dev/xda1"),
+            block_meta.mount_data(scfg['m1'], scfg))
+
+    @patch('curtin.block.iscsi.volpath_is_iscsi')
+    @patch('curtin.commands.block_meta.get_path_to_storage_volume')
+    def test_device_mount_iscsi(self, m_gptsv, m_is_iscsi):
+        """mount_data for a iscsi device should have _netdev in opts."""
+        m_gptsv.side_effect = self._my_gptsv
+        m_is_iscsi.return_value = True
+
+        scfg = OrderedDict([(i['id'], i) for i in self.base_cfg + [self.mnt]])
+        self.assertEqual(
+            block_meta.FstabData(
+                spec=None, fstype="ext4", path="/",
+                options="noatime,_netdev", freq="0", passno="0",
+                device="/dev/xda1"),
+            block_meta.mount_data(scfg['m1'], scfg))
+
+    @patch('curtin.block.iscsi.volpath_is_iscsi')
+    @patch('curtin.commands.block_meta.get_path_to_storage_volume')
+    def test_spec_fstype_override_inline(self, m_gptsv, m_is_iscsi):
+        """spec and fstype are preferred over lookups from 'device' ref.
+
+        If a mount entry has 'fstype' and 'spec', those are prefered over
+        values looked up via the 'device' reference present in the entry.
+        The test here enforces that the device reference present in
+        the mount entry is not looked up, that isn't strictly necessary.
+        """
+        m_gptsv.side_effect = Exception(
+            "Unexpected Call to get_path_to_storage_volume")
+        m_is_iscsi.return_value = Exception(
+            "Unexpected Call to volpath_is_iscsi")
+
+        myspec = '/dev/disk/by-label/LABEL=rfs'
+        mnt = {'id': 'm1', 'type': 'mount', 'device': 'fs1', 'path': '/',
+               'options': 'noatime', 'spec': myspec, 'fstype': 'ext3'}
+        scfg = OrderedDict([(i['id'], i) for i in self.base_cfg + [mnt]])
+        self.assertEqual(
+            block_meta.FstabData(
+                spec=myspec, fstype="ext3", path="/",
+                options="noatime", freq="0", passno="0",
+                device=None),
+            block_meta.mount_data(mnt, scfg))
+
+    @patch('curtin.commands.block_meta.mount_fstab_data')
+    def test_mount_apply_skips_mounting_swap(self, m_mount_fstab_data):
+        """mount_apply does not mount swap fs, but should write fstab."""
+        fdata = block_meta.FstabData(
+            spec="/dev/xxxx1", path="none", fstype='swap')
+        fstab = self.tmp_path("fstab")
+        block_meta.mount_apply(fdata, fstab=fstab)
+        contents = util.load_file(fstab)
+        self.assertEqual(0, m_mount_fstab_data.call_count)
+        self.assertIn("/dev/xxxx1", contents)
+        self.assertIn("swap", contents)
+
+    @patch('curtin.commands.block_meta.mount_fstab_data')
+    def test_mount_apply_calls_mount_fstab_data(self, m_mount_fstab_data):
+        """mount_apply should call mount_fstab_data to mount."""
+        fdata = block_meta.FstabData(
+            spec="/dev/xxxx1", path="none", fstype='ext3')
+        target = self.tmp_dir()
+        block_meta.mount_apply(fdata, target=target, fstab=None)
+        self.assertEqual([call(fdata, target=target)],
+                         m_mount_fstab_data.call_args_list)
+
+    @patch('curtin.commands.block_meta.mount_fstab_data')
+    def test_mount_apply_appends_to_fstab(self, m_mount_fstab_data):
+        """mount_apply should append to fstab."""
+        fdslash = block_meta.FstabData(
+            spec="/dev/disk2", path="/", fstype='ext4')
+        fdboot = block_meta.FstabData(
+            spec="/dev/disk1", path="/boot", fstype='ext3')
+        fstab = self.tmp_path("fstab")
+        existing_line = "# this is my line"
+        util.write_file(fstab, existing_line + "\n")
+        block_meta.mount_apply(fdslash, fstab=fstab)
+        block_meta.mount_apply(fdboot, fstab=fstab)
+
+        self.assertEqual(2, m_mount_fstab_data.call_count)
+        lines = util.load_file(fstab).splitlines()
+        self.assertEqual(existing_line, lines[0])
+        self.assertIn("/dev/disk2", lines[1])
+        self.assertIn("/dev/disk1", lines[2])
+
+    def test_fstab_line_for_data_swap(self):
+        """fstab_line_for_data return value for swap fstab line."""
+        fdata = block_meta.FstabData(
+            spec="/dev/disk2", path="none", fstype='swap')
+        self.assertEqual(
+            ["/dev/disk2", "none", "swap", "sw", "0", "0"],
+            block_meta.fstab_line_for_data(fdata).split())
+
+    def test_fstab_line_for_data_swap_no_path(self):
+        """fstab_line_for_data return value for swap with path=None."""
+        fdata = block_meta.FstabData(
+            spec="/dev/disk2", path=None, fstype='swap')
+        self.assertEqual(
+            ["/dev/disk2", "none", "swap", "sw", "0", "0"],
+            block_meta.fstab_line_for_data(fdata).split())
+
+    def test_fstab_line_for_data_not_swap_and_no_path(self):
+        """fstab_line_for_data raises ValueError if no path and not swap."""
+        fdata = block_meta.FstabData(
+            spec="/dev/disk2", device=None, path="", fstype='ext3')
+        with self.assertRaisesRegexp(ValueError, r".*empty.*path"):
+            block_meta.fstab_line_for_data(fdata)
+
+    def test_fstab_line_for_data_with_options(self):
+        """fstab_line_for_data return value with options."""
+        fdata = block_meta.FstabData(
+            spec="/dev/disk2", path="/mnt", fstype='btrfs', options='noatime')
+        self.assertEqual(
+            ["/dev/disk2", "/mnt", "btrfs", "noatime", "0", "0"],
+            block_meta.fstab_line_for_data(fdata).split())
+
+    def test_fstab_line_for_data_with_passno_and_freq(self):
+        """fstab_line_for_data should respect passno and freq."""
+        fdata = block_meta.FstabData(
+            spec="/dev/d1", path="/mnt", fstype='ext4', freq="1", passno="2")
+        self.assertEqual(
+            ["1", "2"], block_meta.fstab_line_for_data(fdata).split()[4:6])
+
+    def test_fstab_line_for_data_raises_error_without_spec_or_device(self):
+        """fstab_line_for_data should raise ValueError if no spec or device."""
+        fdata = block_meta.FstabData(
+            spec=None, device=None, path="/", fstype='ext3')
+        match = r".*missing.*spec.*device"
+        with self.assertRaisesRegexp(ValueError, match):
+            block_meta.fstab_line_for_data(fdata)
+
+    @patch('curtin.block.get_volume_uuid')
+    def test_fstab_line_for_data_uses_uuid(self, m_get_uuid):
+        """fstab_line_for_data with a device mounts by uuid."""
+        fdata = block_meta.FstabData(
+            device="/dev/disk2", path="/mnt", fstype='ext4')
+        uuid = 'b30d2389-5152-4fbc-8f18-0385ef3046c5'
+        m_get_uuid.side_effect = lambda d: uuid if d == "/dev/disk2" else None
+        self.assertEqual(
+            ["UUID=%s" % uuid, "/mnt", "ext4", "defaults", "0", "0"],
+            block_meta.fstab_line_for_data(fdata).split())
+        self.assertEqual(1, m_get_uuid.call_count)
+
+    @patch('curtin.block.get_volume_uuid')
+    def test_fstab_line_for_data_uses_device_if_no_uuid(self, m_get_uuid):
+        """fstab_line_for_data with a device and no uuid uses device."""
+        fdata = block_meta.FstabData(
+            device="/dev/disk2", path="/mnt", fstype='ext4')
+        m_get_uuid.return_value = None
+        self.assertEqual(
+            ["/dev/disk2", "/mnt", "ext4", "defaults", "0", "0"],
+            block_meta.fstab_line_for_data(fdata).split())
+        self.assertEqual(1, m_get_uuid.call_count)
+
+    @patch('curtin.block.get_volume_uuid')
+    def test_fstab_line_for_data__spec_and_dev_prefers_spec(self, m_get_uuid):
+        """fstab_line_for_data should prefer spec over device."""
+        spec = "/dev/xvda1"
+        fdata = block_meta.FstabData(
+            spec=spec, device="/dev/disk/by-uuid/7AC9-DEFF",
+            path="/mnt", fstype='ext4')
+        m_get_uuid.return_value = None
+        self.assertEqual(
+            ["/dev/xvda1", "/mnt", "ext4", "defaults", "0", "0"],
+            block_meta.fstab_line_for_data(fdata).split())
+        self.assertEqual(0, m_get_uuid.call_count)
+
+    @patch('curtin.util.ensure_dir')
+    @patch('curtin.util.subp')
+    def test_mount_fstab_data_without_target(self, m_subp, m_ensure_dir):
+        """mount_fstab_data with no target param does the right thing."""
+        fdata = block_meta.FstabData(
+            device="/dev/disk1", path="/mnt", fstype='ext4')
+        block_meta.mount_fstab_data(fdata)
+        self.assertEqual(
+            call(['mount', "-t", "ext4", "-o", "defaults",
+                  "/dev/disk1", "/mnt"], capture=True),
+            m_subp.call_args)
+        self.assertTrue(m_ensure_dir.called)
+
+    def _check_mount_fstab_subp(self, fdata, expected, target=None):
+        # expected currently is like: mount <device> <mp>
+        # and thus mp will always be target + fdata.path
+        if target is None:
+            target = self.tmp_dir()
+
+        expected = [a if a != "_T_MP" else util.target_path(target, fdata.path)
+                    for a in expected]
+        with patch("curtin.util.subp") as m_subp:
+            block_meta.mount_fstab_data(fdata, target=target)
+
+        self.assertEqual(call(expected, capture=True), m_subp.call_args)
+        self.assertTrue(os.path.isdir(self.tmp_path(fdata.path, target)))
+
+    def test_mount_fstab_data_with_spec_and_device(self):
+        """mount_fstab_data with spec and device should use device."""
+        self._check_mount_fstab_subp(
+            block_meta.FstabData(
+                spec="LABEL=foo", device="/dev/disk1", path="/mnt",
+                fstype='ext4'),
+            ['mount', "-t", "ext4", "-o", "defaults", "/dev/disk1", "_T_MP"])
+
+    def test_mount_fstab_data_with_spec_that_is_path(self):
+        """If spec is a path outside of /dev, then prefix target."""
+        target = self.tmp_dir()
+        spec = "/mydata"
+        self._check_mount_fstab_subp(
+            block_meta.FstabData(
+                spec=spec, path="/var/lib", fstype="none", options="bind"),
+            ['mount', "-o", "bind", self.tmp_path(spec, target), "_T_MP"],
+            target)
+
+    def test_mount_fstab_data_bind_type_creates_src(self):
+        """Bind mounts should have both src and target dir created."""
+        target = self.tmp_dir()
+        spec = "/mydata"
+        self._check_mount_fstab_subp(
+            block_meta.FstabData(
+                spec=spec, path="/var/lib", fstype="none", options="bind"),
+            ['mount', "-o", "bind", self.tmp_path(spec, target), "_T_MP"],
+            target)
+        self.assertTrue(os.path.isdir(self.tmp_path(spec, target)))
+
+    def test_mount_fstab_data_with_spec_that_is_device(self):
+        """If spec looks like a path to a device, then use it."""
+        spec = "/dev/xxda1"
+        self._check_mount_fstab_subp(
+            block_meta.FstabData(spec=spec, path="/var/", fstype="ext3"),
+            ['mount', "-t", "ext3", "-o", "defaults", spec, "_T_MP"])
+
+    def test_mount_fstab_data_with_device_no_spec(self):
+        """mount_fstab_data mounts by spec if present, not require device."""
+        spec = "/dev/xxda1"
+        self._check_mount_fstab_subp(
+            block_meta.FstabData(spec=spec, path="/home", fstype="ext3"),
+            ['mount', "-t", "ext3", "-o", "defaults", spec, "_T_MP"])
+
+    def test_mount_fstab_data_with_uses_options(self):
+        """mount_fstab_data mounts with -o options."""
+        device = "/dev/xxda1"
+        opts = "option1,option2,x=4"
+        self._check_mount_fstab_subp(
+            block_meta.FstabData(
+                device=device, path="/var", fstype="ext3", options=opts),
+            ['mount', "-t", "ext3", "-o", opts, device, "_T_MP"])
+
+    @patch('curtin.util.subp')
+    def test_mount_fstab_data_does_not_swallow_subp_exception(self, m_subp):
+        """verify that subp exception gets raised.
+
+        The implementation there could/should change to raise the
+        ProcessExecutionError directly.  Currently raises a RuntimeError."""
+        my_error = util.ProcessExecutionError(
+            stdout="", stderr="BOOM", exit_code=4)
+        m_subp.side_effect = my_error
+
+        mp = self.tmp_path("my-mountpoint")
+        with self.assertRaisesRegexp(RuntimeError, r"Mount failed.*"):
+            block_meta.mount_fstab_data(
+                block_meta.FstabData(device="/dev/disk1", path="/var"),
+                target=mp)
+        # dir should be created before call to subp failed.
+        self.assertTrue(os.path.isdir(mp))
+
 # vi: ts=4 expandtab syntax=python
diff --git a/tests/unittests/test_make_dname.py b/tests/unittests/test_make_dname.py
index 87fa754..2b92a88 100644
--- a/tests/unittests/test_make_dname.py
+++ b/tests/unittests/test_make_dname.py
@@ -26,6 +26,12 @@ class TestMakeDname(CiTestCase):
                      'name': 'lpartition1', 'volgroup': 'lvol_id'},
         'lpart2_id': {'type': 'lvm_partition', 'id': 'lpart2_id',
                       'name': 'lvm part/2', 'volgroup': 'lvol_id'},
+        'bcache1_id': {'type': 'bcache', 'id': 'bcache1_id',
+                       'name': 'my-cached-data'}
+    }
+    bcache_super_show = {
+        'sb.version': '1 [backing device]',
+        'dev.uuid': 'f36394c0-3cc0-4423-8d6f-ffac130f171a',
     }
     disk_blkid = textwrap.dedent("""
         DEVNAME=/dev/sda
@@ -48,7 +54,7 @@ class TestMakeDname(CiTestCase):
     def _formatted_rule(self, identifiers, target):
         rule = ['SUBSYSTEM=="block"', 'ACTION=="add|change"']
         rule.extend(['ENV{%s}=="%s"' % ident for ident in identifiers])
-        rule.append('SYMLINK+="disk/by-dname/{}"'.format(target))
+        rule.append('SYMLINK+="disk/by-dname/{}"\n'.format(target))
         return ', '.join(rule)
 
     @mock.patch('curtin.commands.block_meta.LOG')
@@ -188,6 +194,27 @@ class TestMakeDname(CiTestCase):
             self.rule_file.format(res_dname),
             self._formatted_rule(rule_identifiers, res_dname))
 
+    @mock.patch('curtin.commands.block_meta.LOG')
+    @mock.patch('curtin.commands.block_meta.bcache')
+    @mock.patch('curtin.commands.block_meta.get_path_to_storage_volume')
+    @mock.patch('curtin.commands.block_meta.util')
+    def test_make_dname_bcache(self, mock_util, mock_get_path, mock_bcache,
+                               mock_log):
+        """ check bcache dname uses backing device uuid to link dname """
+        mock_get_path.return_value = '/my/dev/huge-storage'
+        mock_bcache.superblock_asdict.return_value = self.bcache_super_show
+        mock_util.load_command_environment.return_value = self.state
+
+        res_dname = 'my-cached-data'
+        backing_uuid = 'f36394c0-3cc0-4423-8d6f-ffac130f171a'
+        rule_identifiers = [('CACHED_UUID', backing_uuid)]
+        block_meta.make_dname('bcache1_id', self.storage_config)
+        self.assertTrue(mock_log.debug.called)
+        self.assertFalse(mock_log.warning.called)
+        mock_util.write_file.assert_called_with(
+            self.rule_file.format(res_dname),
+            self._formatted_rule(rule_identifiers, res_dname))
+
     def test_sanitize_dname(self):
         unsanitized_to_sanitized = [
             ('main_disk', 'main_disk'),
diff --git a/tests/unittests/test_util.py b/tests/unittests/test_util.py
index eb431b0..65175c5 100644
--- a/tests/unittests/test_util.py
+++ b/tests/unittests/test_util.py
@@ -860,6 +860,53 @@ class TestGetEFIBootMGR(CiTestCase):
             }
         }, observed)
 
+    def test_parses_output_filter_missing(self):
+        """ensure parsing ignores items in order that don't have entries"""
+        self.in_chroot_subp_output.append((dedent(
+            """\
+            BootCurrent: 0000
+            Timeout: 1 seconds
+            BootOrder: 0000,0002,0001,0003,0004,0005,0006,0007
+            Boot0000* ubuntu	HD(1,GPT)/File(\\EFI\\ubuntu\\shimx64.efi)
+            Boot0001* CD/DVD Drive 	BBS(CDROM,,0x0)
+            Boot0002* Hard Drive 	BBS(HD,,0x0)
+            Boot0003* UEFI:CD/DVD Drive	BBS(129,,0x0)
+            Boot0004* UEFI:Removable Device	BBS(130,,0x0)
+            Boot0005* UEFI:Network Device	BBS(131,,0x0)
+            """), ''))
+        observed = util.get_efibootmgr('target')
+        self.assertEquals({
+            'current': '0000',
+            'timeout': '1 seconds',
+            'order': ['0000', '0002', '0001', '0003', '0004', '0005'],
+            'entries': {
+                '0000': {
+                    'name': 'ubuntu',
+                    'path': 'HD(1,GPT)/File(\\EFI\\ubuntu\\shimx64.efi)',
+                },
+                '0001': {
+                    'name': 'CD/DVD Drive',
+                    'path': 'BBS(CDROM,,0x0)',
+                },
+                '0002': {
+                    'name': 'Hard Drive',
+                    'path': 'BBS(HD,,0x0)',
+                },
+                '0003': {
+                    'name': 'UEFI:CD/DVD Drive',
+                    'path': 'BBS(129,,0x0)',
+                },
+                '0004': {
+                    'name': 'UEFI:Removable Device',
+                    'path': 'BBS(130,,0x0)',
+                },
+                '0005': {
+                    'name': 'UEFI:Network Device',
+                    'path': 'BBS(131,,0x0)',
+                },
+            }
+        }, observed)
+
 
 class TestUsesSystemd(CiTestCase):
 
diff --git a/tests/vmtests/__init__.py b/tests/vmtests/__init__.py
index b5aa538..5c30a83 100644
--- a/tests/vmtests/__init__.py
+++ b/tests/vmtests/__init__.py
@@ -49,6 +49,10 @@ OUTPUT_DISK_NAME = 'output_disk.img'
 BOOT_TIMEOUT = int(os.environ.get("CURTIN_VMTEST_BOOT_TIMEOUT", 300))
 INSTALL_TIMEOUT = int(os.environ.get("CURTIN_VMTEST_INSTALL_TIMEOUT", 3000))
 REUSE_TOPDIR = bool(int(os.environ.get("CURTIN_VMTEST_REUSE_TOPDIR", 0)))
+ADD_REPOS = os.environ.get("CURTIN_VMTEST_ADD_REPOS", "")
+UPGRADE_PACKAGES = os.environ.get("CURTIN_VMTEST_UPGRADE_PACKAGES", "")
+SYSTEM_UPGRADE = os.environ.get("CURTIN_VMTEST_SYSTEM_UPGRADE", "auto")
+
 
 _UNSUPPORTED_UBUNTU = None
 
@@ -346,8 +350,23 @@ class TempDir(object):
                               stdout=DEVNULL, stderr=subprocess.STDOUT)
 
 
+def skip_if_flag(flag):
+    def decorator(func):
+        """the name test_wrapper below has to start with test, or nose's
+           filter will not run it."""
+        def test_wrapper(self, *args, **kwargs):
+            val = getattr(self, flag, None)
+            if val:
+                self.skipTest("skip due to %s=%s" % (flag, val))
+            else:
+                return func(self, *args, **kwargs)
+        return test_wrapper
+    return decorator
+
+
 class VMBaseClass(TestCase):
     __test__ = False
+    expected_failure = False
     arch_skip = []
     boot_timeout = BOOT_TIMEOUT
     collect_scripts = [textwrap.dedent("""
@@ -708,8 +727,8 @@ class VMBaseClass(TestCase):
         cmd.extend([
             "--root-arg=root=%s" % root_url,
             "--append=overlayroot=tmpfs",
-            "--append=ip=dhcp",        # enable networking
         ])
+
         # getting resolvconf configured is only fixed in bionic
         # the iscsi_auto handles resolvconf setup via call to
         # configure_networking in initramfs
@@ -733,7 +752,7 @@ class VMBaseClass(TestCase):
         cls.network_state = curtin_net.parse_net_config(cls.conf_file)
         logger.debug("Network state: {}".format(cls.network_state))
 
-        # build -n arg list with macaddrs from net_config physical config
+        # build --netdev=arg list with 'physical' nics from net_config
         macs = []
         interfaces = {}
         if cls.network_state:
@@ -744,16 +763,14 @@ class VMBaseClass(TestCase):
             hwaddr = iface.get('mac_address')
             if iface['type'] == 'physical' and hwaddr:
                 macs.append(hwaddr)
-        netdevs = []
-        if len(macs) > 0:
-            # take first mac and mark it as the boot interface to prevent DHCP
-            # on multiple interfaces which can hang the install.
-            cmd.extend(["--append=BOOTIF=01-%s" % macs[0].replace(":", "-")])
-            for mac in macs:
-                netdevs.extend(["--netdev=" + DEFAULT_BRIDGE +
-                                ",mac={}".format(mac)])
-        else:
-            netdevs.extend(["--netdev=" + DEFAULT_BRIDGE])
+
+        if len(macs) == 0:
+            macs = ["52:54:00:12:34:01"]
+
+        netdevs = ["--netdev=%s,mac=%s" % (DEFAULT_BRIDGE, m) for m in macs]
+
+        # Add kernel parameters to simulate network boot from first nic.
+        cmd.extend(kernel_boot_cmdline_for_mac(macs[0]))
 
         # build disk arguments
         disks = []
@@ -843,6 +860,38 @@ class VMBaseClass(TestCase):
             logger.info('Detected centos, adding default config %s',
                         centos_default)
 
+        add_repos = ADD_REPOS
+        system_upgrade = SYSTEM_UPGRADE
+        upgrade_packages = UPGRADE_PACKAGES
+        if add_repos:
+            # enable if user has set a value here
+            if system_upgrade == "auto":
+                system_upgrade = True
+            logger.info('Adding apt repositories: %s', add_repos)
+            repo_cfg = os.path.join(cls.td.install, 'add_repos.cfg')
+            util.write_file(repo_cfg,
+                            generate_repo_config(add_repos.split(",")))
+            configs.append(repo_cfg)
+        elif system_upgrade == "auto":
+            system_upgrade = False
+
+        if system_upgrade:
+            logger.info('Enabling system_upgrade')
+            system_upgrade_cfg = os.path.join(cls.td.install,
+                                              'system_upgrade.cfg')
+            util.write_file(system_upgrade_cfg,
+                            "system_upgrade: {enabled: true}\n")
+            configs.append(system_upgrade_cfg)
+
+        if upgrade_packages:
+            logger.info('Adding late-commands to install packages: %s',
+                        upgrade_packages)
+            upgrade_pkg_cfg = os.path.join(cls.td.install, 'upgrade_pkg.cfg')
+            util.write_file(
+                upgrade_pkg_cfg,
+                generate_upgrade_config(upgrade_packages.split(",")))
+            configs.append(upgrade_pkg_cfg)
+
         # set reporting logger
         cls.reporting_log = os.path.join(cls.td.logs, 'webhooks-events.json')
         reporting_logger = CaptureReporting(cls.reporting_log)
@@ -925,6 +974,10 @@ class VMBaseClass(TestCase):
             else:
                 logger.warn("Boot for install did not produce a console log.")
 
+        if cls.expected_failure:
+            logger.debug('Expected Failure: skipping boot stage')
+            return
+
         logger.debug('')
         try:
             if os.path.exists(cls.install_log):
@@ -1268,6 +1321,7 @@ class VMBaseClass(TestCase):
             ret[val[0]] = val[1]
         return ret
 
+    @skip_if_flag('expected_failure')
     def test_fstab(self):
         if self.fstab_expected is None:
             return
@@ -1283,13 +1337,21 @@ class VMBaseClass(TestCase):
                         self.assertEqual(fstab_entry.split(' ')[1],
                                          mntpoint)
 
+    @skip_if_flag('expected_failure')
     def test_dname(self, disk_to_check=None):
+        if "trusty" in [self.release, self.target_release]:
+            raise SkipTest(
+                "(LP: #1523037): dname does not work on trusty kernels")
+
         if not disk_to_check:
             disk_to_check = self.disk_to_check
         if disk_to_check is None:
+            logger.debug('test_dname: no disks to check')
             return
+        logger.debug('test_dname: checking disks: %s', disk_to_check)
         path = self.collect_path("ls_dname")
         if not os.path.exists(path):
+            logger.debug('test_dname: no "ls_dname" file: %s', path)
             return
         contents = util.load_file(path)
         for diskname, part in self.disk_to_check:
@@ -1298,6 +1360,7 @@ class VMBaseClass(TestCase):
                 self.assertIn(link, contents)
             self.assertIn(diskname, contents)
 
+    @skip_if_flag('expected_failure')
     def test_reporting_data(self):
         with open(self.reporting_log, 'r') as fp:
             data = json.load(fp)
@@ -1317,6 +1380,7 @@ class VMBaseClass(TestCase):
         self.assertIn('path', files)
         self.assertEqual('/tmp/install.log', files.get('path', ''))
 
+    @skip_if_flag('expected_failure')
     def test_interfacesd_eth0_removed(self):
         """ Check that curtin has removed /etc/network/interfaces.d/eth0.cfg
             by examining the output of a find /etc/network > find_interfaces.d
@@ -1325,9 +1389,9 @@ class VMBaseClass(TestCase):
         self.assertNotIn("/etc/network/interfaces.d/eth0.cfg",
                          interfacesd.split("\n"))
 
+    @skip_if_flag('expected_failure')
     def test_installed_correct_kernel_package(self):
         """ Test curtin installs the correct kernel package.  """
-
         # target_distro is set for non-ubuntu targets
         if self.target_distro is not None:
             raise SkipTest("Can't check non-ubuntu kernel packages")
@@ -1374,6 +1438,7 @@ class VMBaseClass(TestCase):
             self._debian_packages = pkgs
         return self._debian_packages
 
+    @skip_if_flag('expected_failure')
     def test_swaps_used(self):
         cfg = yaml.load(self.load_collect_file("root/curtin-install-cfg.yaml"))
         stgcfg = cfg.get("storage", {}).get("config", [])
@@ -1476,7 +1541,7 @@ class PsuedoVMBaseClass(VMBaseClass):
     def test_fstab(self):
         pass
 
-    def test_dname(self):
+    def test_dname(self, disk_to_check=None):
         pass
 
     def test_interfacesd_eth0_removed(self):
@@ -1512,14 +1577,19 @@ def get_rfc4173(ip, port, target, user=None, pword=None,
 
 
 def find_error_context(err_match, contents, nrchars=200):
+    traceback_end = re.compile(r'Error:.*')
+    end_match = traceback_end.search(contents, err_match.start())
     context_start = err_match.start() - nrchars
-    context_end = err_match.end() + nrchars
+    if end_match:
+        context_end = end_match.end()
+    else:
+        context_end = err_match.end() + nrchars
     # extract contents, split into lines, drop the first and last partials
     # recombine and return
     return "\n".join(contents[context_start:context_end].splitlines()[1:-1])
 
 
-def check_install_log(install_log):
+def check_install_log(install_log, nrchars=200):
     # look if install is OK via curtin 'Installation ok"
     # if we dont find that, scan for known error messages and report
     # if we don't see any errors, fail with general error
@@ -1533,7 +1603,7 @@ def check_install_log(install_log):
                    'ImportError: No module named.*',
                    'Unexpected error while running command',
                    'E: Unable to locate package.*',
-                   'Traceback.*most recent call last.*:']))
+                   'cloud-init.*: Traceback.*']))
 
     install_is_ok = re.findall(install_pass, install_log)
     # always scan for errors
@@ -1542,7 +1612,7 @@ def check_install_log(install_log):
         errmsg = ('Failed to verify Installation is OK')
 
     for e in found_errors:
-        errors.append(find_error_context(e, install_log))
+        errors.append(find_error_context(e, install_log, nrchars=nrchars))
         errmsg = ('Errors during curtin installer')
 
     return errmsg, errors
@@ -1737,6 +1807,27 @@ def get_lan_ip():
     return addr
 
 
+def kernel_boot_cmdline_for_mac(mac):
+    """Return kernel command line arguments for initramfs dhcp on mac.
+
+    Ubuntu initramfs respect klibc's ip= format for network config in
+    initramfs.  That format is:
+       ip=addr:server:gateway:netmask:interface:proto
+    see /usr/share/doc/libklibc/README.ipconfig.gz for more info.
+
+    If no 'interface' field is provided, dhcp will be tried on all.  To allow
+    specifying the interface in ip= parameter without knowing the name of the
+    device that the kernel will choose, cloud-initramfs-dyn-netconf replaces
+    'BOOTIF' in the ip= parameter with the name found in BOOTIF.
+
+    Network bootloaders append to kernel command line
+      BOOTIF=01-<mac-address> to indicate which mac they booted from.
+
+    Paired with BOOTIF replacement this ends up being: ip=::::eth0:dhcp."""
+    return ["--append=ip=:::::BOOTIF:dhcp",
+            "--append=BOOTIF=01-%s" % mac.replace(":", "-")]
+
+
 def is_unsupported_ubuntu(release):
     global _UNSUPPORTED_UBUNTU
     udi = 'ubuntu-distro-info'
@@ -1758,6 +1849,42 @@ def is_unsupported_ubuntu(release):
     return release in _UNSUPPORTED_UBUNTU
 
 
+def generate_repo_config(repos):
+    """Generate apt yaml configuration to add specified repositories.
+
+    @param repos: A list of add-apt-repository strings.
+                  'proposed' is a special case to enable the proposed
+                  pocket of a particular release.
+    @returns: string:  A yaml string
+    """
+    sources = {"add_repos_%02d" % idx: {'source': v}
+               for idx, v in enumerate(repos)}
+    return yaml.dump({'apt': {'sources': sources}})
+
+
+def generate_upgrade_config(packages, singlecmd=True):
+    """Generate late_command yaml to install packages with apt.
+
+    @param packages: list of package names.
+    @param singlecmd: Boolean, defaults to True which combines
+                      package installs into a single apt command
+                      If False, a separate command is issued for
+                      each package.
+    @returns: String of yaml
+    """
+    if not packages:
+        return ""
+    cmds = {}
+    base_cmd = ['curtin', 'in-target', '--', 'apt-get', '-y', 'install']
+    if singlecmd:
+        cmds["install_pkg_00"] = base_cmd + packages
+    else:
+        for idx, package in enumerate(packages):
+            cmds["install_pkg_%02d" % idx] = base_cmd + package
+
+    return yaml.dump({'late_commands': cmds})
+
+
 apply_keep_settings()
 logger = _initialize_logging()
 
diff --git a/tests/vmtests/helpers.py b/tests/vmtests/helpers.py
index 7fc92e1..10e20b3 100644
--- a/tests/vmtests/helpers.py
+++ b/tests/vmtests/helpers.py
@@ -86,18 +86,7 @@ def check_call(cmd, signal=signal.SIGTERM, **kwargs):
     return Command(cmd, signal).run(**kwargs)
 
 
-def find_releases_by_distro():
-    """
-    Returns a dictionary of distros and the distro releases that will be tested
-
-    distros:
-        ubuntu:
-            releases: []
-            krels: []
-        centos:
-            releases: []
-            krels: []
-    """
+def find_testcases():
     # Use the TestLoder to load all test cases defined within tests/vmtests/
     # and figure out what distros and releases they are testing. Any tests
     # which are disabled will be excluded.
@@ -108,32 +97,60 @@ def find_releases_by_distro():
     root_dir = os.path.split(os.path.split(tests_dir)[0])[0]
     # Find all test modules defined in curtin/tests/vmtests/
     module_test_suites = loader.discover(tests_dir, top_level_dir=root_dir)
-    # find all distros and releases tested for each distro
-    releases = []
-    krels = []
-    rel_by_dist = {}
     for mts in module_test_suites:
         for class_test_suite in mts:
             for test_case in class_test_suite:
                 # skip disabled tests
                 if not getattr(test_case, '__test__', False):
                     continue
-                for (dist, rel, krel) in (
-                        (getattr(test_case, a, None) for a in attrs)
-                        for attrs in (('distro', 'release', 'krel'),
-                                      ('target_distro', 'target_release',
-                                       'krel'))):
-
-                    if dist and rel:
-                        distro = rel_by_dist.get(dist, {'releases': [],
-                                                        'krels': []})
-                        releases = distro.get('releases')
-                        krels = distro.get('krels')
-                        if rel not in releases:
-                            releases.append(rel)
-                        if krel and krel not in krels:
-                            krels.append(krel)
-                        rel_by_dist.update({dist: distro})
+                yield test_case
+
+
+def find_arches():
+    """
+    Return a list of uniq arch values from test cases
+    """
+    arches = []
+    for test_case in find_testcases():
+        arch = getattr(test_case, 'arch', None)
+        if arch and arch not in arches:
+            arches.append(arch)
+    return arches
+
+
+def find_releases_by_distro():
+    """
+    Returns a dictionary of distros and the distro releases that will be tested
+
+    distros:
+        ubuntu:
+            releases: []
+            krels: []
+        centos:
+            releases: []
+            krels: []
+    """
+    # find all distros and releases tested for each distro
+    releases = []
+    krels = []
+    rel_by_dist = {}
+    for test_case in find_testcases():
+        for (dist, rel, krel) in (
+                (getattr(test_case, a, None) for a in attrs)
+                for attrs in (('distro', 'release', 'krel'),
+                              ('target_distro', 'target_release',
+                               'krel'))):
+
+            if dist and rel:
+                distro = rel_by_dist.get(dist, {'releases': [],
+                                                'krels': []})
+                releases = distro.get('releases')
+                krels = distro.get('krels')
+                if rel not in releases:
+                    releases.append(rel)
+                if krel and krel not in krels:
+                    krels.append(krel)
+                rel_by_dist.update({dist: distro})
 
     return rel_by_dist
 
diff --git a/tests/vmtests/test_basic.py b/tests/vmtests/test_basic.py
index 2d98514..2e47cb6 100644
--- a/tests/vmtests/test_basic.py
+++ b/tests/vmtests/test_basic.py
@@ -6,6 +6,7 @@ from . import (
 from .releases import base_vm_classes as relbase
 
 import textwrap
+from unittest import SkipTest
 
 
 class TestBasicAbs(VMBaseClass):
@@ -58,7 +59,10 @@ class TestBasicAbs(VMBaseClass):
              "proc_partitions",
              "root/curtin-install.log", "root/curtin-install-cfg.yaml"])
 
-    def test_ptable(self):
+    def test_ptable(self, disk_to_check=None):
+        if "trusty" in [self.release, self.target_release]:
+            raise SkipTest("No PTTYPE blkid output on trusty")
+
         blkid_info = self.get_blkid_data("blkid_output_vda")
         self.assertEquals(blkid_info["PTTYPE"], "dos")
 
@@ -143,18 +147,14 @@ class TestBasicAbs(VMBaseClass):
 class TrustyTestBasic(relbase.trusty, TestBasicAbs):
     __test__ = True
 
-    # FIXME(LP: #1523037): dname does not work on trusty, so we cannot expect
-    # sda-part2 to exist in /dev/disk/by-dname as we can on other releases
-    # when dname works on trusty, then we need to re-enable by removing line.
-    def test_dname(self):
-        print("test_dname does not work for Trusty")
 
-    def test_ptable(self):
-        print("test_ptable does not work for Trusty")
+class TrustyHWEXTestBasic(relbase.trusty_hwe_x, TrustyTestBasic):
+    __test__ = True
 
 
-class TrustyHWEXTestBasic(relbase.trusty_hwe_x, TrustyTestBasic):
+class XenialGAi386TestBasic(relbase.xenial_ga, TestBasicAbs):
     __test__ = True
+    arch = 'i386'
 
 
 class XenialGATestBasic(relbase.xenial_ga, TestBasicAbs):
@@ -210,6 +210,9 @@ class TestBasicScsiAbs(TestBasicAbs):
              "ls_disk_id", "proc_partitions"])
 
     def test_ptable(self):
+        if "trusty" in [self.release, self.target_release]:
+            raise SkipTest("No PTTYPE blkid output on trusty")
+
         blkid_info = self.get_blkid_data("blkid_output_sda")
         self.assertEquals(blkid_info["PTTYPE"], "dos")
 
diff --git a/tests/vmtests/test_centos_basic.py b/tests/vmtests/test_centos_basic.py
index b576279..7857e74 100644
--- a/tests/vmtests/test_centos_basic.py
+++ b/tests/vmtests/test_centos_basic.py
@@ -11,7 +11,6 @@ import textwrap
 class CentosTestBasicAbs(VMBaseClass):
     __test__ = False
     conf_file = "examples/tests/centos_basic.yaml"
-    extra_kern_args = "BOOTIF=eth0-52:54:00:12:34:00"
     # XXX: command | tee output is required for Centos under SELinux
     # http://danwalsh.livejournal.com/22860.html
     collect_scripts = VMBaseClass.collect_scripts + [textwrap.dedent(
@@ -74,7 +73,6 @@ class Centos66FromXenialTestBasic(relbase.centos66fromxenial,
 
 class CentosTestBasicNetworkAbs(TestNetworkBaseTestsAbs):
     conf_file = "examples/tests/centos_basic.yaml"
-    extra_kern_args = "BOOTIF=eth0-52:54:00:12:34:00"
     collect_scripts = TestNetworkBaseTestsAbs.collect_scripts + [
         textwrap.dedent("""
             cd OUTPUT_COLLECT_D
diff --git a/tests/vmtests/test_fs_battery.py b/tests/vmtests/test_fs_battery.py
index 5798d48..423cc1e 100644
--- a/tests/vmtests/test_fs_battery.py
+++ b/tests/vmtests/test_fs_battery.py
@@ -52,6 +52,12 @@ class TestFsBattery(VMBaseClass):
         cat /proc/partitions > proc_partitions
         find /etc/network/interfaces.d > find_interfacesd
         cat /proc/cmdline > cmdline
+        cat /etc/fstab > fstab
+        cat /proc/1/mountinfo > mountinfo
+
+        for p in /my/bind-over-var-lib/apt /my/bind-ro-etc/passwd; do
+            [ -e "$p" ] && echo "$p: present" || echo "$p: missing"
+        done > my-path-checks
 
         set +x
         serial="fsbattery"
@@ -151,6 +157,49 @@ class TestFsBattery(VMBaseClass):
                     ["%s umount: PASS" % k for k in entries])
         self.assertEqual(sorted(expected), sorted(results))
 
+    def test_fstab_has_mounts(self):
+        """Verify each of the expected "my" mounts got into fstab."""
+        expected = [
+            "none /my/tmpfs tmpfs size=4194304 0 0".split(),
+            "none /my/ramfs ramfs defaults 0 0".split(),
+            "/my/bind-over-var-lib /var/lib none bind 0 0".split(),
+            "/etc /my/bind-ro-etc none bind,ro 0 0".split(),
+        ]
+        fstab_found = [
+            l.split() for l in self.load_collect_file("fstab").splitlines()]
+        self.assertEqual(expected, [e for e in expected if e in fstab_found])
+
+    def test_mountinfo_has_mounts(self):
+        """Verify the my mounts got into mountinfo.
+
+        This is a light check that things got mounted.  We do not check
+        options as to not break on different kernel behavior.
+        Maybe it could/should."""
+        # mountinfo has src and path as 4th and 5th field.
+        data = self.load_collect_file("mountinfo").splitlines()
+        dest_src = {}
+        for line in data:
+            toks = line.split()
+            if not (toks[3].startswith("/my/") or toks[4].startswith("/my/")):
+                continue
+            dest_src[toks[4]] = toks[3]
+        self.assertTrue("/my/ramfs" in dest_src)
+        self.assertTrue("/my/tmpfs" in dest_src)
+        self.assertEqual(dest_src.get("/var/lib"), "/my/bind-over-var-lib")
+        self.assertEqual(dest_src.get("/my/bind-ro-etc"), "/etc")
+
+    def test_expected_files_from_bind_mounts(self):
+        data = self.load_collect_file("my-path-checks")
+        # this file is <path>: (present|missing)
+        paths = {}
+        for line in data.splitlines():
+            path, _, val = line.partition(":")
+            paths[path] = val.strip()
+
+        self.assertEqual(
+            {'/my/bind-over-var-lib/apt': 'present',
+             '/my/bind-ro-etc/passwd': 'present'}, paths)
+
 
 class TrustyTestFsBattery(relbase.trusty, TestFsBattery):
     __test__ = True
diff --git a/tests/vmtests/test_lvm.py b/tests/vmtests/test_lvm.py
index 4d27186..ed708fd 100644
--- a/tests/vmtests/test_lvm.py
+++ b/tests/vmtests/test_lvm.py
@@ -2,7 +2,6 @@
 
 from . import VMBaseClass
 from .releases import base_vm_classes as relbase
-from unittest import SkipTest
 
 import textwrap
 
@@ -11,10 +10,15 @@ class TestLvmAbs(VMBaseClass):
     conf_file = "examples/tests/lvm.yaml"
     interactive = False
     extra_disks = ['10G']
+    dirty_disks = True
     collect_scripts = VMBaseClass.collect_scripts + [textwrap.dedent("""
         cd OUTPUT_COLLECT_D
         cat /etc/fstab > fstab
         ls /dev/disk/by-dname > ls_dname
+        ls -al /dev/disk/by-dname > lsal_dname
+        ls -al /dev/disk/by-id/ > ls_byid
+        ls -al /dev/disk/by-uuid/ > ls_byuuid
+        cat /proc/partitions > proc_partitions
         find /etc/network/interfaces.d > find_interfacesd
         pvdisplay -C --separator = -o vg_name,pv_name --noheadings > pvs
         lvdisplay -C --separator = -o lv_name,vg_name --noheadings > lvs
@@ -41,14 +45,6 @@ class TestLvmAbs(VMBaseClass):
         self.output_files_exist(
             ["fstab", "ls_dname"])
 
-    # FIXME(LP: #1523037): dname does not work on precise|trusty, so we cannot
-    # expect sda-part2 to exist in /dev/disk/by-dname as we can on other
-    # releases when dname works on trusty, then we need to re-enable by
-    # removing line.
-    def test_dname(self):
-        if self.release in ['precise', 'trusty']:
-            raise SkipTest("test_dname does not work for %s" % self.release)
-
 
 class TrustyTestLvm(relbase.trusty, TestLvmAbs):
     __test__ = True
diff --git a/tests/vmtests/test_lvm_iscsi.py b/tests/vmtests/test_lvm_iscsi.py
index 6b247c5..2a11d6e 100644
--- a/tests/vmtests/test_lvm_iscsi.py
+++ b/tests/vmtests/test_lvm_iscsi.py
@@ -9,6 +9,7 @@ import textwrap
 
 class TestLvmIscsiAbs(TestLvmAbs, TestBasicIscsiAbs):
     interactive = False
+    dirty_disks = True
     iscsi_disks = [
         {'size': '6G'},
         {'size': '5G', 'auth': 'user:passw0rd', 'iauth': 'iuser:ipassw0rd'}]
@@ -20,6 +21,8 @@ class TestLvmIscsiAbs(TestLvmAbs, TestBasicIscsiAbs):
         """
         cd OUTPUT_COLLECT_D
         ls -al /sys/class/block/dm*/slaves/  > dm_slaves
+        cp -a /etc/udev/rules.d udev_rules_d
+        cp -a /etc/iscsi etc_iscsi
         """)]
 
     fstab_expected = {
@@ -29,8 +32,11 @@ class TestLvmIscsiAbs(TestLvmAbs, TestBasicIscsiAbs):
         'UUID=a98f706b-b064-4682-8eb2-6c2c1284060c': '/mnt/iscsi4',
     }
     disk_to_check = [('main_disk', 1),
-                     ('main_disk', 5),
-                     ('main_disk', 6),
+                     ('main_disk', 2),
+                     ('iscsi_disk1', 5),
+                     ('iscsi_disk1', 6),
+                     ('iscsi_disk2', 5),
+                     ('iscsi_disk2', 6),
                      ('vg1-lv1', 0),
                      ('vg1-lv2', 0),
                      ('vg2-lv3', 0),
diff --git a/tests/vmtests/test_mdadm_bcache.py b/tests/vmtests/test_mdadm_bcache.py
index b0e8c8c..49d4782 100644
--- a/tests/vmtests/test_mdadm_bcache.py
+++ b/tests/vmtests/test_mdadm_bcache.py
@@ -17,11 +17,17 @@ class TestMdadmAbs(VMBaseClass):
         mdadm --detail --scan | grep -c ubuntu > mdadm_active1
         grep -c active /proc/mdstat > mdadm_active2
         ls /dev/disk/by-dname > ls_dname
+        ls -al /dev/disk/by-dname > lsal_dname
+        ls -al /dev/disk/by-uuid > lsal_uuid
         find /etc/network/interfaces.d > find_interfacesd
         cat /proc/mdstat | tee mdstat
         cat /proc/partitions | tee procpartitions
         ls -1 /sys/class/block | tee sys_class_block
         ls -1 /dev/md* | tee dev_md
+        ls -al /sys/fs/bcache/* > lsal_sys_fs_bcache_star
+        ls -al /dev/bcache* > lsal_dev_bcache_star
+        ls -al /dev/bcache/by_uuid/* > lsal_dev_bcache_byuuid_star
+        cp -a /var/log/syslog .
         """)]
 
     def test_mdadm_output_files_exist(self):
@@ -63,6 +69,7 @@ class TestMdadmBcacheAbs(TestMdadmAbs):
         cat /sys/block/bcache2/bcache/cache_mode >> bcache_cache_mode
         cat /proc/mounts > proc_mounts
         find /etc/network/interfaces.d > find_interfacesd
+        cp -a /etc/udev/rules.d etc_udev_rules.d
         """)]
     fstab_expected = {
         '/dev/vda1': '/media/sda1',
@@ -119,7 +126,6 @@ class TestMdadmBcacheAbs(TestMdadmAbs):
         self.check_file_regex("bcache_cache_mode", r"\[writearound\]")
 
     def test_bcache_dnames(self):
-        self.skip_by_date("1728742", fixby="2018-04-26")
         self.test_dname(disk_to_check=self.bcache_dnames)
 
 
@@ -131,26 +137,10 @@ class TrustyTestMdadmBcache(relbase.trusty, TestMdadmBcacheAbs):
         cls.skip_by_date("1754581", fixby="2018-06-22")
         super().setUpClass()
 
-    # FIXME(LP: #1523037): dname does not work on trusty
-    # when dname works on trusty, then we need to re-enable by removing line.
-    def test_dname(self):
-        print("test_dname does not work for Trusty")
-
-    def test_ptable(self):
-        print("test_ptable does not work for Trusty")
-
 
 class TrustyHWEXTestMdadmBcache(relbase.trusty_hwe_x, TestMdadmBcacheAbs):
     __test__ = True
 
-    # FIXME(LP: #1523037): dname does not work on trusty
-    # when dname works on trusty, then we need to re-enable by removing line.
-    def test_dname(self):
-        print("test_dname does not work for Trusty")
-
-    def test_ptable(self):
-        print("test_ptable does not work for Trusty")
-
 
 class XenialGATestMdadmBcache(relbase.xenial_ga, TestMdadmBcacheAbs):
     __test__ = True
@@ -186,14 +176,6 @@ class TestMirrorbootAbs(TestMdadmAbs):
 class TrustyTestMirrorboot(relbase.trusty, TestMirrorbootAbs):
     __test__ = True
 
-    # FIXME(LP: #1523037): dname does not work on trusty
-    # when dname works on trusty, then we need to re-enable by removing line.
-    def test_dname(self):
-        print("test_dname does not work for Trusty")
-
-    def test_ptable(self):
-        print("test_ptable does not work for Trusty")
-
 
 class TrustyHWEXTestMirrorboot(relbase.trusty_hwe_x, TrustyTestMirrorboot):
     # This tests kernel upgrade in target
@@ -234,14 +216,6 @@ class TrustyTestMirrorbootPartitions(relbase.trusty,
                                      TestMirrorbootPartitionsAbs):
     __test__ = True
 
-    # FIXME(LP: #1523037): dname does not work on trusty
-    # when dname works on trusty, then we need to re-enable by removing line.
-    def test_dname(self):
-        print("test_dname does not work for Trusty")
-
-    def test_ptable(self):
-        print("test_ptable does not work for Trusty")
-
 
 class TrustyHWEXTestMirrorbootPartitions(relbase.trusty_hwe_x,
                                          TrustyTestMirrorbootPartitions):
@@ -293,14 +267,6 @@ class TrustyTestMirrorbootPartitionsUEFI(relbase.trusty,
                                          TestMirrorbootPartitionsUEFIAbs):
     __test__ = True
 
-    # FIXME(LP: #1523037): dname does not work on trusty
-    # when dname works on trusty, then we need to re-enable by removing line.
-    def test_dname(self):
-        print("test_dname does not work for Trusty")
-
-    def test_ptable(self):
-        print("test_ptable does not work for Trusty")
-
 
 class XenialGATestMirrorbootPartitionsUEFI(relbase.xenial_ga,
                                            TestMirrorbootPartitionsUEFIAbs):
@@ -342,14 +308,6 @@ class TestRaid5bootAbs(TestMdadmAbs):
 class TrustyTestRaid5Boot(relbase.trusty, TestRaid5bootAbs):
     __test__ = True
 
-    # FIXME(LP: #1523037): dname does not work on trusty
-    # when dname works on trusty, then we need to re-enable by removing line.
-    def test_dname(self):
-        print("test_dname does not work for Trusty")
-
-    def test_ptable(self):
-        print("test_ptable does not work for Trusty")
-
 
 class TrustyHWEXTestRaid5Boot(relbase.trusty_hwe_x, TrustyTestRaid5Boot):
     # This tests kernel upgrade in target
@@ -404,14 +362,6 @@ class TestRaid6bootAbs(TestMdadmAbs):
 class TrustyTestRaid6boot(relbase.trusty, TestRaid6bootAbs):
     __test__ = True
 
-    # FIXME(LP: #1523037): dname does not work on trusty
-    # when dname works on trusty, then we need to re-enable by removing line.
-    def test_dname(self):
-        print("test_dname does not work for Trusty")
-
-    def test_ptable(self):
-        print("test_ptable does not work for Trusty")
-
 
 class TrustyHWEXTestRaid6boot(relbase.trusty_hwe_x, TrustyTestRaid6boot):
     __test__ = True
@@ -453,14 +403,6 @@ class TestRaid10bootAbs(TestMdadmAbs):
 class TrustyTestRaid10boot(relbase.trusty, TestRaid10bootAbs):
     __test__ = True
 
-    # FIXME(LP: #1523037): dname does not work on trusty
-    # when dname works on trusty, then we need to re-enable by removing line.
-    def test_dname(self):
-        print("test_dname does not work for Trusty")
-
-    def test_ptable(self):
-        print("test_ptable does not work for Trusty")
-
 
 class TrustyHWEXTestRaid10boot(relbase.trusty_hwe_x, TrustyTestRaid10boot):
     __test__ = True
@@ -562,14 +504,6 @@ class TestAllindataAbs(TestMdadmAbs):
 class TrustyTestAllindata(relbase.trusty, TestAllindataAbs):
     __test__ = False  # luks=no does not disable mounting of device
 
-    # FIXME(LP: #1523037): dname does not work on trusty
-    # when dname works on trusty, then we need to re-enable by removing line.
-    def test_dname(self):
-        print("test_dname does not work for Trusty")
-
-    def test_ptable(self):
-        print("test_ptable does not work for Trusty")
-
 
 class TrustyHWEXTestAllindata(relbase.trusty_hwe_x, TrustyTestAllindata):
     __test__ = False  # lukes=no does not disable mounting of device
diff --git a/tests/vmtests/test_network.py b/tests/vmtests/test_network.py
index 6ce4262..59a25fe 100644
--- a/tests/vmtests/test_network.py
+++ b/tests/vmtests/test_network.py
@@ -437,7 +437,6 @@ class TestNetworkBasicAbs(TestNetworkBaseTestsAbs):
 
 class CentosTestNetworkBasicAbs(TestNetworkBaseTestsAbs):
     conf_file = "examples/tests/centos_basic.yaml"
-    extra_kern_args = "BOOTIF=eth0-52:54:00:12:34:00"
     collect_scripts = TestNetworkBaseTestsAbs.collect_scripts + [
         textwrap.dedent("""
             cd OUTPUT_COLLECT_D
diff --git a/tests/vmtests/test_network_alias.py b/tests/vmtests/test_network_alias.py
index 258554f..903b395 100644
--- a/tests/vmtests/test_network_alias.py
+++ b/tests/vmtests/test_network_alias.py
@@ -19,7 +19,6 @@ class TestNetworkAliasAbs(TestNetworkBaseTestsAbs):
 
 
 class CentosTestNetworkAliasAbs(TestNetworkAliasAbs):
-    extra_kern_args = "BOOTIF=eth0-52:54:00:12:34:00"
     collect_scripts = TestNetworkAliasAbs.collect_scripts + [
         textwrap.dedent("""
             cd OUTPUT_COLLECT_D
diff --git a/tests/vmtests/test_network_bonding.py b/tests/vmtests/test_network_bonding.py
index 24cf60f..7d07413 100644
--- a/tests/vmtests/test_network_bonding.py
+++ b/tests/vmtests/test_network_bonding.py
@@ -16,7 +16,6 @@ class TestNetworkBondingAbs(TestNetworkBaseTestsAbs):
 
 
 class CentosTestNetworkBondingAbs(TestNetworkBondingAbs):
-    extra_kern_args = "BOOTIF=eth0-52:54:00:12:34:00"
     collect_scripts = TestNetworkBondingAbs.collect_scripts + [
         textwrap.dedent("""
             cd OUTPUT_COLLECT_D
diff --git a/tests/vmtests/test_network_bridging.py b/tests/vmtests/test_network_bridging.py
index 5691b00..ca8964e 100644
--- a/tests/vmtests/test_network_bridging.py
+++ b/tests/vmtests/test_network_bridging.py
@@ -184,7 +184,6 @@ class TestBridgeNetworkAbs(TestNetworkBaseTestsAbs):
 
 
 class CentosTestBridgeNetworkAbs(TestBridgeNetworkAbs):
-    extra_kern_args = "BOOTIF=eth0-52:54:00:12:34:00"
     collect_scripts = TestBridgeNetworkAbs.collect_scripts + [
         textwrap.dedent("""
             cd OUTPUT_COLLECT_D
diff --git a/tests/vmtests/test_network_ipv6.py b/tests/vmtests/test_network_ipv6.py
index 9bbfc1e..6d87dcf 100644
--- a/tests/vmtests/test_network_ipv6.py
+++ b/tests/vmtests/test_network_ipv6.py
@@ -25,7 +25,6 @@ class TestNetworkIPV6Abs(TestNetworkBaseTestsAbs):
 
 
 class CentosTestNetworkIPV6Abs(TestNetworkIPV6Abs):
-    extra_kern_args = "BOOTIF=eth0-bc:76:4e:06:96:b3"
     collect_scripts = TestNetworkIPV6Abs.collect_scripts + [
         textwrap.dedent("""
             cd OUTPUT_COLLECT_D
diff --git a/tests/vmtests/test_network_mtu.py b/tests/vmtests/test_network_mtu.py
index 86f4e48..41b1383 100644
--- a/tests/vmtests/test_network_mtu.py
+++ b/tests/vmtests/test_network_mtu.py
@@ -120,7 +120,6 @@ class TestNetworkMtuAbs(TestNetworkIPV6Abs):
 
 class CentosTestNetworkMtuAbs(TestNetworkMtuAbs):
     conf_file = "examples/tests/network_mtu.yaml"
-    extra_kern_args = "BOOTIF=eth0-52:54:00:12:34:00"
     collect_scripts = TestNetworkMtuAbs.collect_scripts + [
         textwrap.dedent("""
             cd OUTPUT_COLLECT_D
diff --git a/tests/vmtests/test_network_static.py b/tests/vmtests/test_network_static.py
index 2d226c0..d96d3eb 100644
--- a/tests/vmtests/test_network_static.py
+++ b/tests/vmtests/test_network_static.py
@@ -13,7 +13,6 @@ class TestNetworkStaticAbs(TestNetworkBaseTestsAbs):
 
 
 class CentosTestNetworkStaticAbs(TestNetworkStaticAbs):
-    extra_kern_args = "BOOTIF=eth0-52:54:00:12:34:00"
     collect_scripts = TestNetworkBaseTestsAbs.collect_scripts + [
         textwrap.dedent("""
             cd OUTPUT_COLLECT_D
diff --git a/tests/vmtests/test_network_vlan.py b/tests/vmtests/test_network_vlan.py
index 00eb445..3cb6eae 100644
--- a/tests/vmtests/test_network_vlan.py
+++ b/tests/vmtests/test_network_vlan.py
@@ -54,7 +54,6 @@ class TestNetworkVlanAbs(TestNetworkBaseTestsAbs):
 
 
 class CentosTestNetworkVlanAbs(TestNetworkVlanAbs):
-    extra_kern_args = "BOOTIF=eth0-d4:be:d9:a8:49:13"
     collect_scripts = TestNetworkVlanAbs.collect_scripts + [
         textwrap.dedent("""
             cd OUTPUT_COLLECT_D
diff --git a/tests/vmtests/test_nvme.py b/tests/vmtests/test_nvme.py
index 1ba3d3d..a9e3bc3 100644
--- a/tests/vmtests/test_nvme.py
+++ b/tests/vmtests/test_nvme.py
@@ -58,28 +58,10 @@ class TestNvmeAbs(VMBaseClass):
 class TrustyTestNvme(relbase.trusty, TestNvmeAbs):
     __test__ = True
 
-    # FIXME(LP: #1523037): dname does not work on trusty, so we cannot expect
-    # sda-part2 to exist in /dev/disk/by-dname as we can on other releases
-    # when dname works on trusty, then we need to re-enable by removing line.
-    def test_dname(self):
-        print("test_dname does not work for Trusty")
-
-    def test_ptable(self):
-        print("test_ptable does not work for Trusty")
-
 
 class TrustyHWEXTestNvme(relbase.trusty_hwe_x, TestNvmeAbs):
     __test__ = True
 
-    # FIXME(LP: #1523037): dname does not work on trusty, so we cannot expect
-    # sda-part2 to exist in /dev/disk/by-dname as we can on other releases
-    # when dname works on trusty, then we need to re-enable by removing line.
-    def test_dname(self):
-        print("test_dname does not work for Trusty")
-
-    def test_ptable(self):
-        print("test_ptable does not work for Trusty")
-
 
 class XenialGATestNvme(relbase.xenial_ga, TestNvmeAbs):
     __test__ = True
diff --git a/tests/vmtests/test_raid5_bcache.py b/tests/vmtests/test_raid5_bcache.py
index 8a47e94..aa2bebf 100644
--- a/tests/vmtests/test_raid5_bcache.py
+++ b/tests/vmtests/test_raid5_bcache.py
@@ -69,10 +69,6 @@ class TestMdadmBcacheAbs(TestMdadmAbs):
 
 class TrustyTestRaid5Bcache(relbase.trusty, TestMdadmBcacheAbs):
     __test__ = True
-    # FIXME(LP: #1523037): dname does not work on trusty, so we cannot expect
-    # sda-part2 to exist in /dev/disk/by-dname as we can on other releases
-    # when dname works on trusty, then we need to re-enable by removing line.
-    disk_to_check = [('md0', 0)]
 
 
 class TrustyHWEUTestRaid5Bcache(relbase.trusty_hwe_u, TrustyTestRaid5Bcache):
diff --git a/tests/vmtests/test_uefi_basic.py b/tests/vmtests/test_uefi_basic.py
index d6a58eb..517554f 100644
--- a/tests/vmtests/test_uefi_basic.py
+++ b/tests/vmtests/test_uefi_basic.py
@@ -95,15 +95,6 @@ class PreciseHWETUefiTestBasic(relbase.precise_hwe_t, PreciseUefiTestBasic):
 class TrustyUefiTestBasic(relbase.trusty, TestBasicAbs):
     __test__ = True
 
-    # FIXME(LP: #1523037): dname does not work on trusty, so we cannot expect
-    # sda-part2 to exist in /dev/disk/by-dname as we can on other releases
-    # when dname works on trusty, then we need to re-enable by removing line.
-    def test_dname(self):
-        print("test_dname does not work for Trusty")
-
-    def test_ptable(self):
-        print("test_ptable does not work for Trusty")
-
 
 class TrustyHWEXUefiTestBasic(relbase.trusty_hwe_x, TrustyUefiTestBasic):
     __test__ = True
diff --git a/tests/vmtests/test_zfsroot.py b/tests/vmtests/test_zfsroot.py
index 4487185..1ebc616 100644
--- a/tests/vmtests/test_zfsroot.py
+++ b/tests/vmtests/test_zfsroot.py
@@ -1,4 +1,4 @@
-from . import VMBaseClass
+from . import VMBaseClass, check_install_log, skip_if_flag
 from .releases import base_vm_classes as relbase
 
 import textwrap
@@ -33,6 +33,7 @@ class TestZfsRootAbs(VMBaseClass):
             echo "$v" > apt-proxy
         """)]
 
+    @skip_if_flag('expected_failure')
     def test_output_files_exist(self):
         self.output_files_exist(
             ["blkid_output_vda", "blkid_output_vda1", "blkid_output_vda2",
@@ -40,21 +41,49 @@ class TestZfsRootAbs(VMBaseClass):
              "proc_partitions",
              "root/curtin-install.log", "root/curtin-install-cfg.yaml"])
 
+    @skip_if_flag('expected_failure')
     def test_ptable(self):
         blkid_info = self.get_blkid_data("blkid_output_vda")
         self.assertEquals(blkid_info["PTTYPE"], "gpt")
 
+    @skip_if_flag('expected_failure')
     def test_zfs_list(self):
         """Check rpoot/ROOT/zfsroot is mounted at slash"""
         self.output_files_exist(['zfs_list'])
         self.check_file_regex('zfs_list', r"rpool/ROOT/zfsroot.*/\n")
 
+    @skip_if_flag('expected_failure')
     def test_proc_cmdline_has_root_zfs(self):
         """Check /proc/cmdline has root=ZFS=<pool>"""
         self.output_files_exist(['proc_cmdline'])
         self.check_file_regex('proc_cmdline', r"root=ZFS=rpool/ROOT/zfsroot")
 
 
+class UnsupportedZfs(VMBaseClass):
+    expected_failure = True
+    collect_scripts = []
+    interactive = False
+
+    def test_install_log_finds_zfs_runtime_error(self):
+        with open(self.install_log, 'rb') as lfh:
+            install_log = lfh.read().decode('utf-8', errors='replace')
+        errmsg, errors = check_install_log(install_log)
+        found_zfs = False
+        print("errors: %s" % (len(errors)))
+        for idx, err in enumerate(errors):
+            print("%s:\n%s" % (idx, err))
+            if 'RuntimeError' in err:
+                found_zfs = True
+                break
+        self.assertTrue(found_zfs)
+
+
+class XenialGAi386TestZfsRoot(relbase.xenial_ga, TestZfsRootAbs,
+                              UnsupportedZfs):
+    __test__ = True
+    arch = 'i386'
+
+
 class XenialGATestZfsRoot(relbase.xenial_ga, TestZfsRootAbs):
     __test__ = True
 
@@ -81,3 +110,13 @@ class TestZfsRootFsTypeAbs(TestZfsRootAbs):
 
 class XenialGATestZfsRootFsType(relbase.xenial_ga, TestZfsRootFsTypeAbs):
     __test__ = True
+
+
+class XenialGAi386TestZfsRootFsType(relbase.xenial_ga, TestZfsRootFsTypeAbs,
+                                    UnsupportedZfs):
+    __test__ = True
+    arch = 'i386'
+
+
+class BionicTestZfsRootFsType(relbase.bionic, TestZfsRootFsTypeAbs):
+    __test__ = True
diff --git a/tools/jenkins-runner b/tools/jenkins-runner
index 1d0ac73..85c6234 100755
--- a/tools/jenkins-runner
+++ b/tools/jenkins-runner
@@ -54,6 +54,8 @@ parallel=${CURTIN_VMTEST_PARALLEL}
 ntargs=( )
 while [ $# -ne 0 ]; do
     case "$1" in
+        # allow setting these environment variables on cmdline.
+        CURTIN_VMTEST_*=*) export "$1";;
         -p|--parallel) parallel="$2"; shift;;
         --parallel=*) parallel=${1#*=};;
         -p[0-9]|-p-1|-p[0-9][0-9]) parallel=${1#-p};;
@@ -81,6 +83,16 @@ if [ -n "$parallel" -a "$parallel" != "0" -a "$parallel" != "1" ]; then
     pargs=( --process-timeout=86400 "--processes=$parallel" )
 fi
 
+curtexe="${CURTIN_VMTEST_CURTIN_EXE:-./bin/curtin}"
+CURTIN_VMTEST_CURTIN_EXE_VERSION=$($curtexe version) ||
+    fail "failed to get version from '$curtexe version'"
+if [ "$curtexe" = "./bin/curtin" ]; then
+    CURTIN_VMTEST_CURTIN_VERSION="$CURTIN_VMTEST_CURTIN_EXE_VERSION"
+else
+    CURTIN_VMTEST_CURTIN_VERSION="$(./bin/curtin version)" ||
+        fail "failed to get version from ./bin/curtin version"
+fi
+
 if [ -n "$TGT_IPC_SOCKET" ]; then
     error "existing TGT_IPC_SOCKET=${TGT_IPC_SOCKET}"
 elif command -v tgtd >/dev/null 2>&1; then
diff --git a/tools/vmtest-sync-images b/tools/vmtest-sync-images
index 26a1962..3d82b62 100755
--- a/tools/vmtest-sync-images
+++ b/tools/vmtest-sync-images
@@ -17,11 +17,9 @@ sys.path.insert(1, os.path.realpath(os.path.join(
 from tests.vmtests import (
     IMAGE_DIR, IMAGE_SRC_URL, sync_images)
 from tests.vmtests.image_sync import ITEM_NAME_FILTERS
-from tests.vmtests.helpers import find_releases_by_distro
+from tests.vmtests.helpers import (find_arches, find_releases_by_distro)
 from curtin.util import get_platform_arch
 
-DEFAULT_ARCH = get_platform_arch()
-
 
 def _fmt_list_filter(filter_name, matches):
     return '~'.join((filter_name, '|'.join(matches)))
@@ -53,7 +51,7 @@ if __name__ == '__main__':
                         os.unlink(fpath)
 
     arg_releases = [r for r in sys.argv[1:] if r != "--clean"]
-    arch_filters = ['arch={}'.format(DEFAULT_ARCH)]
+    arch_filters = [_fmt_list_filter('arch', find_arches())]
     filter_sets = []
     if len(arg_releases):
         filter_sets.append([_fmt_list_filter('release', arg_releases),