Merge ~chad.smith/curtin:ubuntu/xenial into curtin:ubuntu/xenial

[Chad Smith]

new upstream snapshot for release into xenial

LP: #1795712

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

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

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

review: Approve (continuous-integration)

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

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

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

review: Approve (continuous-integration)

diff --git a/bin/curtin b/bin/curtin
index 6c4e457..793fbcb 100755
--- a/bin/curtin
+++ b/bin/curtin
@@ -1,7 +1,7 @@
 #!/bin/sh
 # This file is part of curtin. See LICENSE file for copyright and license info.
 
-PY3OR2_MAIN="curtin.commands.main"
+PY3OR2_MAIN="curtin"
 PY3OR2_MCHECK="curtin.deps.check"
 PY3OR2_PYTHONS=${PY3OR2_PYTHONS:-"python3:python"}
 PYTHON=${PY3OR2_PYTHON}
diff --git a/curtin/__init__.py b/curtin/__init__.py
index 002454b..ee35ca3 100644
--- a/curtin/__init__.py
+++ b/curtin/__init__.py
@@ -10,6 +10,8 @@ KERNEL_CMDLINE_COPY_TO_INSTALL_SEP = "---"
 FEATURES = [
     # curtin can apply centos networking via centos_apply_network_config
     'CENTOS_APPLY_NETWORK_CONFIG',
+    # curtin can configure centos storage devices and boot devices
+    'CENTOS_CURTHOOK_SUPPORT',
     # install supports the 'network' config version 1
     'NETWORK_CONFIG_V1',
     # reporter supports 'webhook' type
diff --git a/curtin/__main__.py b/curtin/__main__.py
new file mode 100644
index 0000000..5b6aeca
--- /dev/null
+++ b/curtin/__main__.py
@@ -0,0 +1,4 @@
+if __name__ == '__main__':
+    from .commands.main import main
+    import sys
+    sys.exit(main())
diff --git a/curtin/block/__init__.py b/curtin/block/__init__.py
index a8ee8a6..490c268 100644
--- a/curtin/block/__init__.py
+++ b/curtin/block/__init__.py
@@ -378,24 +378,28 @@ def stop_all_unused_multipath_devices():
         LOG.warn("Failed to stop multipath devices: %s", e)
 
 
-def rescan_block_devices(warn_on_fail=True):
+def rescan_block_devices(devices=None, warn_on_fail=True):
     """
     run 'blockdev --rereadpt' for all block devices not currently mounted
     """
-    unused = get_unused_blockdev_info()
-    devices = []
-    for devname, data in unused.items():
-        if data.get('RM') == "1":
-            continue
-        if data.get('RO') != "0" or data.get('TYPE') != "disk":
-            continue
-        devices.append(data['device_path'])
+    if not devices:
+        unused = get_unused_blockdev_info()
+        devices = []
+        for devname, data in unused.items():
+            if data.get('RM') == "1":
+                continue
+            if data.get('RO') != "0" or data.get('TYPE') != "disk":
+                continue
+            devices.append(data['device_path'])
 
     if not devices:
         LOG.debug("no devices found to rescan")
         return
 
-    cmd = ['blockdev', '--rereadpt'] + devices
+    # blockdev needs /dev/ parameters, convert if needed
+    cmd = ['blockdev', '--rereadpt'] + [dev if dev.startswith('/dev/')
+                                        else sysfs_to_devpath(dev)
+                                        for dev in devices]
     try:
         util.subp(cmd, capture=True)
     except util.ProcessExecutionError as e:
@@ -999,75 +1003,17 @@ def wipe_volume(path, mode="superblock", exclusive=True):
         raise ValueError("wipe mode %s not supported" % mode)
 
 
-def storage_config_required_packages(storage_config, mapping):
-    """Read storage configuration dictionary and determine
-       which packages are required for the supplied configuration
-       to function.  Return a list of packaged to install.
-    """
-
-    if not storage_config or not isinstance(storage_config, dict):
-        raise ValueError('Invalid storage configuration.  '
-                         'Must be a dict:\n %s' % storage_config)
-
-    if not mapping or not isinstance(mapping, dict):
-        raise ValueError('Invalid storage mapping.  Must be a dict')
-
-    if 'storage' in storage_config:
-        storage_config = storage_config.get('storage')
-
-    needed_packages = []
-
-    # get reqs by device operation type
-    dev_configs = set(operation['type']
-                      for operation in storage_config['config'])
-
-    for dev_type in dev_configs:
-        if dev_type in mapping:
-            needed_packages.extend(mapping[dev_type])
-
-    # for any format operations, check the fstype and
-    # determine if we need any mkfs tools as well.
-    format_configs = set([operation['fstype']
-                         for operation in storage_config['config']
-                         if operation['type'] == 'format'])
-    for format_type in format_configs:
-        if format_type in mapping:
-            needed_packages.extend(mapping[format_type])
-
-    return needed_packages
-
-
-def detect_required_packages_mapping():
-    """Return a dictionary providing a versioned configuration which maps
-       storage configuration elements to the packages which are required
-       for functionality.
-
-       The mapping key is either a config type value, or an fstype value.
-
-    """
-    version = 1
-    mapping = {
-        version: {
-            'handler': storage_config_required_packages,
-            'mapping': {
-                'bcache': ['bcache-tools'],
-                'btrfs': ['btrfs-tools'],
-                'ext2': ['e2fsprogs'],
-                'ext3': ['e2fsprogs'],
-                'ext4': ['e2fsprogs'],
-                'jfs': ['jfsutils'],
-                'lvm_partition': ['lvm2'],
-                'lvm_volgroup': ['lvm2'],
-                'ntfs': ['ntfs-3g'],
-                'raid': ['mdadm'],
-                'reiserfs': ['reiserfsprogs'],
-                'xfs': ['xfsprogs'],
-                'zfsroot': ['zfsutils-linux', 'zfs-initramfs'],
-                'zfs': ['zfsutils-linux', 'zfs-initramfs'],
-                'zpool': ['zfsutils-linux', 'zfs-initramfs'],
-            },
-        },
-    }
-    return mapping
+def get_supported_filesystems():
+    """ Return a list of filesystems that the kernel currently supports
+        as read from /proc/filesystems.
+
+        Raises RuntimeError if /proc/filesystems does not exist.
+    """
+    proc_fs = "/proc/filesystems"
+    if not os.path.exists(proc_fs):
+        raise RuntimeError("Unable to read 'filesystems' from %s" % proc_fs)
+
+    return [l.split('\t')[1].strip()
+            for l in util.load_file(proc_fs).splitlines()]
 
 # vi: ts=4 expandtab syntax=python
diff --git a/curtin/block/clear_holders.py b/curtin/block/clear_holders.py
index 20c572b..a05c9ca 100644
--- a/curtin/block/clear_holders.py
+++ b/curtin/block/clear_holders.py
@@ -300,12 +300,18 @@ def wipe_superblock(device):
         else:
             raise e
 
+    # gather any partitions
+    partitions = block.get_sysfs_partitions(device)
+
     # release zfs member by exporting the pool
-    if block.is_zfs_member(blockdev):
+    if zfs.zfs_supported() and 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)
+            try:
+                zfs.zpool_export(poolname)
+            except util.ProcessExecutionError as e:
+                LOG.warning('Failed to export zpool "%s": %s', poolname, e)
 
     if is_swap_device(blockdev):
         shutdown_swap(blockdev)
@@ -325,6 +331,27 @@ def wipe_superblock(device):
 
     _wipe_superblock(blockdev)
 
+    # if we had partitions, make sure they've been removed
+    if partitions:
+        LOG.debug('%s had partitions, issuing partition reread', device)
+        retries = [.5, .5, 1, 2, 5, 7]
+        for attempt, wait in enumerate(retries):
+            try:
+                # only rereadpt on wiped device
+                block.rescan_block_devices(devices=[blockdev])
+                # may raise IOError, OSError due to wiped partition table
+                curparts = block.get_sysfs_partitions(device)
+                if len(curparts) == 0:
+                    return
+            except (IOError, OSError):
+                if attempt + 1 >= len(retries):
+                    raise
+
+            LOG.debug("%s partitions still present, rereading pt"
+                      " (%s/%s).  sleeping %ss before retry",
+                      device, attempt + 1, len(retries), wait)
+            time.sleep(wait)
+
 
 def _wipe_superblock(blockdev, exclusive=True):
     """ No checks, just call wipe_volume """
@@ -579,8 +606,6 @@ 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'])
@@ -602,19 +627,18 @@ def start_clear_holders_deps():
     # all disks and partitions should be sufficient to remove the mdadm
     # metadata
     mdadm.mdadm_assemble(scan=True, ignore_errors=True)
+    # scan and activate for logical volumes
+    lvm.lvm_scan()
+    lvm.activate_volgroups()
     # the bcache module needs to be present to properly detect bcache devs
     # on some systems (precise without hwe kernel) it may not be possible to
     # lad the bcache module bcause it is not present in the kernel. if this
     # happens then there is no need to halt installation, as the bcache devices
     # will never appear and will never prevent the disk from being reformatted
     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+.
-    try:
-        if zfs.zfs_supported():
-            util.load_kernel_module('zfs')
-    except RuntimeError as e:
-        LOG.warning('Failed to load zfs kernel module: %s', e)
+
+    if not zfs.zfs_supported():
+        LOG.warning('zfs filesystem is not supported in this environment')
 
 
 # anything that is not identified can assumed to be a 'disk' or similar
diff --git a/curtin/block/deps.py b/curtin/block/deps.py
new file mode 100644
index 0000000..930f764
--- /dev/null
+++ b/curtin/block/deps.py
@@ -0,0 +1,103 @@
+# This file is part of curtin. See LICENSE file for copyright and license info.
+
+from curtin.distro import DISTROS
+from curtin.block import iscsi
+
+
+def storage_config_required_packages(storage_config, mapping):
+    """Read storage configuration dictionary and determine
+       which packages are required for the supplied configuration
+       to function.  Return a list of packaged to install.
+    """
+
+    if not storage_config or not isinstance(storage_config, dict):
+        raise ValueError('Invalid storage configuration.  '
+                         'Must be a dict:\n %s' % storage_config)
+
+    if not mapping or not isinstance(mapping, dict):
+        raise ValueError('Invalid storage mapping.  Must be a dict')
+
+    if 'storage' in storage_config:
+        storage_config = storage_config.get('storage')
+
+    needed_packages = []
+
+    # get reqs by device operation type
+    dev_configs = set(operation['type']
+                      for operation in storage_config['config'])
+
+    for dev_type in dev_configs:
+        if dev_type in mapping:
+            needed_packages.extend(mapping[dev_type])
+
+    # for disks with path: iscsi: we need iscsi tools
+    iscsi_vols = iscsi.get_iscsi_volumes_from_config(storage_config)
+    if len(iscsi_vols) > 0:
+        needed_packages.extend(mapping['iscsi'])
+
+    # for any format operations, check the fstype and
+    # determine if we need any mkfs tools as well.
+    format_configs = set([operation['fstype']
+                         for operation in storage_config['config']
+                         if operation['type'] == 'format'])
+    for format_type in format_configs:
+        if format_type in mapping:
+            needed_packages.extend(mapping[format_type])
+
+    return needed_packages
+
+
+def detect_required_packages_mapping(osfamily=DISTROS.debian):
+    """Return a dictionary providing a versioned configuration which maps
+       storage configuration elements to the packages which are required
+       for functionality.
+
+       The mapping key is either a config type value, or an fstype value.
+
+    """
+    distro_mapping = {
+        DISTROS.debian: {
+            'bcache': ['bcache-tools'],
+            'btrfs': ['btrfs-tools'],
+            'ext2': ['e2fsprogs'],
+            'ext3': ['e2fsprogs'],
+            'ext4': ['e2fsprogs'],
+            'jfs': ['jfsutils'],
+            'iscsi': ['open-iscsi'],
+            'lvm_partition': ['lvm2'],
+            'lvm_volgroup': ['lvm2'],
+            'ntfs': ['ntfs-3g'],
+            'raid': ['mdadm'],
+            'reiserfs': ['reiserfsprogs'],
+            'xfs': ['xfsprogs'],
+            'zfsroot': ['zfsutils-linux', 'zfs-initramfs'],
+            'zfs': ['zfsutils-linux', 'zfs-initramfs'],
+            'zpool': ['zfsutils-linux', 'zfs-initramfs'],
+        },
+        DISTROS.redhat: {
+            'bcache': [],
+            'btrfs': ['btrfs-progs'],
+            'ext2': ['e2fsprogs'],
+            'ext3': ['e2fsprogs'],
+            'ext4': ['e2fsprogs'],
+            'jfs': [],
+            'iscsi': ['iscsi-initiator-utils'],
+            'lvm_partition': ['lvm2'],
+            'lvm_volgroup': ['lvm2'],
+            'ntfs': [],
+            'raid': ['mdadm'],
+            'reiserfs': [],
+            'xfs': ['xfsprogs'],
+            'zfsroot': [],
+            'zfs': [],
+            'zpool': [],
+        },
+    }
+    if osfamily not in distro_mapping:
+        raise ValueError('No block package mapping for distro: %s' % osfamily)
+
+    return {1: {'handler': storage_config_required_packages,
+                'mapping': distro_mapping.get(osfamily)}}
+
+
+# vi: ts=4 expandtab syntax=python
diff --git a/curtin/block/iscsi.py b/curtin/block/iscsi.py
index 0c666b6..3c46500 100644
--- a/curtin/block/iscsi.py
+++ b/curtin/block/iscsi.py
@@ -9,7 +9,7 @@ import os
 import re
 import shutil
 
-from curtin import (util, udev)
+from curtin import (paths, util, udev)
 from curtin.block import (get_device_slave_knames,
                           path_to_kname)
 
@@ -230,29 +230,45 @@ def connected_disks():
     return _ISCSI_DISKS
 
 
-def get_iscsi_disks_from_config(cfg):
+def get_iscsi_volumes_from_config(cfg):
     """Parse a curtin storage config and return a list
-       of iscsi disk objects for each configuration present
+       of iscsi disk rfc4173 uris for each configuration present.
     """
     if not cfg:
         cfg = {}
 
-    sconfig = cfg.get('storage', {}).get('config', {})
-    if not sconfig:
+    if 'storage' in cfg:
+        sconfig = cfg.get('storage', {}).get('config', [])
+    else:
+        sconfig = cfg.get('config', [])
+    if not sconfig or not isinstance(sconfig, list):
         LOG.warning('Configuration dictionary did not contain'
                     ' a storage configuration')
         return []
 
+    return [disk['path'] for disk in sconfig
+            if disk['type'] == 'disk' and
+            disk.get('path', "").startswith('iscsi:')]
+
+
+def get_iscsi_disks_from_config(cfg):
+    """Return a list of IscsiDisk objects for each iscsi volume present."""
     # Construct IscsiDisk objects for each iscsi volume present
-    iscsi_disks = [IscsiDisk(disk['path']) for disk in sconfig
-                   if disk['type'] == 'disk' and
-                   disk.get('path', "").startswith('iscsi:')]
+    iscsi_disks = [IscsiDisk(volume) for volume in
+                   get_iscsi_volumes_from_config(cfg)]
     LOG.debug('Found %s iscsi disks in storage config', len(iscsi_disks))
     return iscsi_disks
 
 
+def get_iscsi_ports_from_config(cfg):
+    """Return a set of ports that may be used when connecting to volumes."""
+    ports = set([d.port for d in get_iscsi_disks_from_config(cfg)])
+    LOG.debug('Found iscsi ports in use: %s', ports)
+    return ports
+
+
 def disconnect_target_disks(target_root_path=None):
-    target_nodes_path = util.target_path(target_root_path, '/etc/iscsi/nodes')
+    target_nodes_path = paths.target_path(target_root_path, '/etc/iscsi/nodes')
     fails = []
     if os.path.isdir(target_nodes_path):
         for target in os.listdir(target_nodes_path):
diff --git a/curtin/block/lvm.py b/curtin/block/lvm.py
index 8643245..b3f8bcb 100644
--- a/curtin/block/lvm.py
+++ b/curtin/block/lvm.py
@@ -4,6 +4,7 @@
 This module provides some helper functions for manipulating lvm devices
 """
 
+from curtin import distro
 from curtin import util
 from curtin.log import LOG
 import os
@@ -57,20 +58,38 @@ def lvmetad_running():
                                          '/run/lvmetad.pid'))
 
 
-def lvm_scan():
+def activate_volgroups():
+    """
+    Activate available volgroups and logical volumes within.
+
+    # found
+    % vgchange -ay
+      1 logical volume(s) in volume group "vg1sdd" now active
+
+    # none found (no output)
+    % vgchange -ay
+    """
+
+    # vgchange handles syncing with udev by default
+    # see man 8 vgchange and flag --noudevsync
+    out, _ = util.subp(['vgchange', '--activate=y'], capture=True)
+    if out:
+        LOG.info(out)
+
+
+def lvm_scan(activate=True):
     """
     run full scan for volgroups, logical volumes and physical volumes
     """
-    # the lvm tools lvscan, vgscan and pvscan on ubuntu precise do not
-    # support the flag --cache. the flag is present for the tools in ubuntu
-    # trusty and later. since lvmetad is used in current releases of
-    # ubuntu, the --cache flag is needed to ensure that the data cached by
+    # prior to xenial, lvmetad is not packaged, so even if a tool supports
+    # flag --cache it has no effect. In Xenial and newer the --cache flag is
+    # used (if lvmetad is running) to ensure that the data cached by
     # lvmetad is updated.
 
     # before appending the cache flag though, check if lvmetad is running. this
     # ensures that we do the right thing even if lvmetad is supported but is
     # not running
-    release = util.lsb_release().get('codename')
+    release = distro.lsb_release().get('codename')
     if release in [None, 'UNAVAILABLE']:
         LOG.warning('unable to find release number, assuming xenial or later')
         release = 'xenial'
diff --git a/curtin/block/mdadm.py b/curtin/block/mdadm.py
index e0fe0d3..4ad6aa7 100644
--- a/curtin/block/mdadm.py
+++ b/curtin/block/mdadm.py
@@ -13,6 +13,7 @@ import time
 
 from curtin.block import (dev_short, dev_path, is_valid_device, sys_block_path)
 from curtin.block import get_holders
+from curtin.distro import lsb_release
 from curtin import (util, udev)
 from curtin.log import LOG
 
@@ -95,7 +96,7 @@ VALID_RAID_ARRAY_STATES = (
     checks the mdadm version and will return True if we can use --export
     for key=value list with enough info, false if version is less than
 '''
-MDADM_USE_EXPORT = util.lsb_release()['codename'] not in ['precise', 'trusty']
+MDADM_USE_EXPORT = lsb_release()['codename'] not in ['precise', 'trusty']
 
 #
 # mdadm executors
@@ -184,7 +185,7 @@ def mdadm_create(md_devname, raidlevel, devices, spares=None, md_name=""):
             cmd.append(device)
 
     # Create the raid device
-    util.subp(["udevadm", "settle"])
+    udev.udevadm_settle()
     util.subp(["udevadm", "control", "--stop-exec-queue"])
     try:
         util.subp(cmd, capture=True)
@@ -208,8 +209,7 @@ def mdadm_create(md_devname, raidlevel, devices, spares=None, md_name=""):
         raise
 
     util.subp(["udevadm", "control", "--start-exec-queue"])
-    util.subp(["udevadm", "settle",
-               "--exit-if-exists=%s" % md_devname])
+    udev.udevadm_settle(exists=md_devname)
 
 
 def mdadm_examine(devpath, export=MDADM_USE_EXPORT):
diff --git a/curtin/block/mkfs.py b/curtin/block/mkfs.py
index a199d05..4a1e1f9 100644
--- a/curtin/block/mkfs.py
+++ b/curtin/block/mkfs.py
@@ -3,12 +3,13 @@
 # This module wraps calls to mkfs.<fstype> and determines the appropriate flags
 # for each filesystem type
 
-from curtin import util
 from curtin import block
+from curtin import distro
+from curtin import util
 
 import string
 import os
-from uuid import uuid1
+from uuid import uuid4
 
 mkfs_commands = {
     "btrfs": "mkfs.btrfs",
@@ -102,7 +103,7 @@ def valid_fstypes():
 
 def get_flag_mapping(flag_name, fs_family, param=None, strict=False):
     ret = []
-    release = util.lsb_release()['codename']
+    release = distro.lsb_release()['codename']
     overrides = release_flag_mapping_overrides.get(release, {})
     if flag_name in overrides and fs_family in overrides[flag_name]:
         flag_sym = overrides[flag_name][fs_family]
@@ -191,7 +192,7 @@ def mkfs(path, fstype, strict=False, label=None, uuid=None, force=False):
 
     # If uuid is not specified, generate one and try to use it
     if uuid is None:
-        uuid = str(uuid1())
+        uuid = str(uuid4())
     cmd.extend(get_flag_mapping("uuid", fs_family, param=uuid, strict=strict))
 
     if fs_family == "fat":
diff --git a/curtin/block/zfs.py b/curtin/block/zfs.py
index cfb07a9..5615144 100644
--- a/curtin/block/zfs.py
+++ b/curtin/block/zfs.py
@@ -7,8 +7,9 @@ and volumes."""
 import os
 
 from curtin.config import merge_config
+from curtin import distro
 from curtin import util
-from . import blkid
+from . import blkid, get_supported_filesystems
 
 ZPOOL_DEFAULT_PROPERTIES = {
     'ashift': 12,
@@ -73,6 +74,15 @@ def _join_pool_volume(poolname, volume):
 
 
 def zfs_supported():
+    """Return a boolean indicating if zfs is supported."""
+    try:
+        zfs_assert_supported()
+        return True
+    except RuntimeError:
+        return False
+
+
+def zfs_assert_supported():
     """ Determine if the runtime system supports zfs.
     returns: True if system supports zfs
     raises: RuntimeError: if system does not support zfs
@@ -81,17 +91,19 @@ def zfs_supported():
     if arch in ZFS_UNSUPPORTED_ARCHES:
         raise RuntimeError("zfs is not supported on architecture: %s" % arch)
 
-    release = util.lsb_release()['codename']
+    release = distro.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)
+    if 'zfs' not in get_supported_filesystems():
+        try:
+            util.load_kernel_module('zfs')
+        except util.ProcessExecutionError as err:
+            raise RuntimeError("Failed to load 'zfs' kernel module: %s" % err)
 
-    return True
+    missing_progs = [p for p in ('zpool', 'zfs') if not util.which(p)]
+    if missing_progs:
+        raise RuntimeError("Missing zfs utils: %s" % ','.join(missing_progs))
 
 
 def zpool_create(poolname, vdevs, mountpoint=None, altroot=None,
diff --git a/curtin/commands/__main__.py b/curtin/commands/__main__.py
new file mode 100644
index 0000000..41c6d17
--- /dev/null
+++ b/curtin/commands/__main__.py
@@ -0,0 +1,4 @@
+if __name__ == '__main__':
+    from .main import main
+    import sys
+    sys.exit(main())
diff --git a/curtin/commands/apply_net.py b/curtin/commands/apply_net.py
index ffd474e..ddc5056 100644
--- a/curtin/commands/apply_net.py
+++ b/curtin/commands/apply_net.py
@@ -7,6 +7,7 @@ from .. import log
 import curtin.net as net
 import curtin.util as util
 from curtin import config
+from curtin import paths
 from . import populate_one_subcmd
 
 
@@ -123,7 +124,7 @@ def _patch_ifupdown_ipv6_mtu_hook(target,
 
     for hook in ['prehook', 'posthook']:
         fn = hookfn[hook]
-        cfg = util.target_path(target, path=fn)
+        cfg = paths.target_path(target, path=fn)
         LOG.info('Injecting fix for ipv6 mtu settings: %s', cfg)
         util.write_file(cfg, contents[hook], mode=0o755)
 
@@ -136,7 +137,7 @@ def _disable_ipv6_privacy_extensions(target,
        Resolve this by allowing the cloud-image setting to win. """
 
     LOG.debug('Attempting to remove ipv6 privacy extensions')
-    cfg = util.target_path(target, path=path)
+    cfg = paths.target_path(target, path=path)
     if not os.path.exists(cfg):
         LOG.warn('Failed to find ipv6 privacy conf file %s', cfg)
         return
@@ -182,7 +183,7 @@ def _maybe_remove_legacy_eth0(target,
          - with unknown content, leave it and warn
     """
 
-    cfg = util.target_path(target, path=path)
+    cfg = paths.target_path(target, path=path)
     if not os.path.exists(cfg):
         LOG.warn('Failed to find legacy network conf file %s', cfg)
         return
diff --git a/curtin/commands/apt_config.py b/curtin/commands/apt_config.py
index 41c329e..9ce25b3 100644
--- a/curtin/commands/apt_config.py
+++ b/curtin/commands/apt_config.py
@@ -13,7 +13,7 @@ import sys
 import yaml
 
 from curtin.log import LOG
-from curtin import (config, util, gpg)
+from curtin import (config, distro, gpg, paths, util)
 
 from . import populate_one_subcmd
 
@@ -61,7 +61,7 @@ def handle_apt(cfg, target=None):
         curthooks if a global apt config was provided or via the "apt"
         standalone command.
     """
-    release = util.lsb_release(target=target)['codename']
+    release = distro.lsb_release(target=target)['codename']
     arch = util.get_architecture(target)
     mirrors = find_apt_mirror_info(cfg, arch)
     LOG.debug("Apt Mirror info: %s", mirrors)
@@ -148,7 +148,7 @@ def apply_debconf_selections(cfg, target=None):
             pkg = re.sub(r"[:\s].*", "", line)
             pkgs_cfgd.add(pkg)
 
-    pkgs_installed = util.get_installed_packages(target)
+    pkgs_installed = distro.get_installed_packages(target)
 
     LOG.debug("pkgs_cfgd: %s", pkgs_cfgd)
     LOG.debug("pkgs_installed: %s", pkgs_installed)
@@ -164,7 +164,7 @@ def apply_debconf_selections(cfg, target=None):
 def clean_cloud_init(target):
     """clean out any local cloud-init config"""
     flist = glob.glob(
-        util.target_path(target, "/etc/cloud/cloud.cfg.d/*dpkg*"))
+        paths.target_path(target, "/etc/cloud/cloud.cfg.d/*dpkg*"))
 
     LOG.debug("cleaning cloud-init config from: %s", flist)
     for dpkg_cfg in flist:
@@ -194,7 +194,7 @@ def rename_apt_lists(new_mirrors, target=None):
     """rename_apt_lists - rename apt lists to preserve old cache data"""
     default_mirrors = get_default_mirrors(util.get_architecture(target))
 
-    pre = util.target_path(target, APT_LISTS)
+    pre = paths.target_path(target, APT_LISTS)
     for (name, omirror) in default_mirrors.items():
         nmirror = new_mirrors.get(name)
         if not nmirror:
@@ -299,7 +299,7 @@ def generate_sources_list(cfg, release, mirrors, target=None):
     if tmpl is None:
         LOG.info("No custom template provided, fall back to modify"
                  "mirrors in %s on the target system", aptsrc)
-        tmpl = util.load_file(util.target_path(target, aptsrc))
+        tmpl = util.load_file(paths.target_path(target, aptsrc))
         # Strategy if no custom template was provided:
         # - Only replacing mirrors
         # - no reason to replace "release" as it is from target anyway
@@ -310,24 +310,24 @@ def generate_sources_list(cfg, release, mirrors, target=None):
         tmpl = mirror_to_placeholder(tmpl, default_mirrors['SECURITY'],
                                      "$SECURITY")
 
-    orig = util.target_path(target, aptsrc)
+    orig = paths.target_path(target, aptsrc)
     if os.path.exists(orig):
         os.rename(orig, orig + ".curtin.old")
 
     rendered = util.render_string(tmpl, params)
     disabled = disable_suites(cfg.get('disable_suites'), rendered, release)
-    util.write_file(util.target_path(target, aptsrc), disabled, mode=0o644)
+    util.write_file(paths.target_path(target, aptsrc), disabled, mode=0o644)
 
     # protect the just generated sources.list from cloud-init
     cloudfile = "/etc/cloud/cloud.cfg.d/curtin-preserve-sources.cfg"
     # this has to work with older cloud-init as well, so use old key
     cloudconf = yaml.dump({'apt_preserve_sources_list': True}, indent=1)
     try:
-        util.write_file(util.target_path(target, cloudfile),
+        util.write_file(paths.target_path(target, cloudfile),
                         cloudconf, mode=0o644)
     except IOError:
         LOG.exception("Failed to protect source.list from cloud-init in (%s)",
-                      util.target_path(target, cloudfile))
+                      paths.target_path(target, cloudfile))
         raise
 
 
@@ -409,7 +409,7 @@ def add_apt_sources(srcdict, target=None, template_params=None,
                     raise
             continue
 
-        sourcefn = util.target_path(target, ent['filename'])
+        sourcefn = paths.target_path(target, ent['filename'])
         try:
             contents = "%s\n" % (source)
             util.write_file(sourcefn, contents, omode="a")
@@ -417,8 +417,8 @@ def add_apt_sources(srcdict, target=None, template_params=None,
             LOG.exception("failed write to file %s: %s", sourcefn, detail)
             raise
 
-    util.apt_update(target=target, force=True,
-                    comment="apt-source changed config")
+    distro.apt_update(target=target, force=True,
+                      comment="apt-source changed config")
 
     return
 
diff --git a/curtin/commands/block_meta.py b/curtin/commands/block_meta.py
index f5b82cf..197c1fd 100644
--- a/curtin/commands/block_meta.py
+++ b/curtin/commands/block_meta.py
@@ -1,9 +1,10 @@
 # This file is part of curtin. See LICENSE file for copyright and license info.
 
 from collections import OrderedDict, namedtuple
-from curtin import (block, config, util)
+from curtin import (block, config, paths, util)
 from curtin.block import (bcache, mdadm, mkfs, clear_holders, lvm, iscsi, zfs)
-from curtin.log import LOG
+from curtin import distro
+from curtin.log import LOG, logged_time
 from curtin.reporter import events
 
 from . import populate_one_subcmd
@@ -48,6 +49,7 @@ CMD_ARGUMENTS = (
 )
 
 
+@logged_time("BLOCK_META")
 def block_meta(args):
     # main entry point for the block-meta command.
     state = util.load_command_environment()
@@ -729,12 +731,12 @@ def mount_fstab_data(fdata, target=None):
 
     :param fdata: a FstabData type
     :return None."""
-    mp = util.target_path(target, fdata.path)
+    mp = paths.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)
+            device = paths.target_path(target, fdata.spec)
         else:
             device = fdata.spec
 
@@ -855,7 +857,7 @@ def lvm_partition_handler(info, storage_config):
         # Use 'wipesignatures' (if available) and 'zero' to clear target lv
         # of any fs metadata
         cmd = ["lvcreate", volgroup, "--name", name, "--zero=y"]
-        release = util.lsb_release()['codename']
+        release = distro.lsb_release()['codename']
         if release not in ['precise', 'trusty']:
             cmd.extend(["--wipesignatures=y"])
 
@@ -1263,7 +1265,7 @@ def zpool_handler(info, storage_config):
     """
     Create a zpool based in storage_configuration
     """
-    zfs.zfs_supported()
+    zfs.zfs_assert_supported()
 
     state = util.load_command_environment()
 
@@ -1298,7 +1300,8 @@ def zfs_handler(info, storage_config):
     """
     Create a zfs filesystem
     """
-    zfs.zfs_supported()
+    zfs.zfs_assert_supported()
+
     state = util.load_command_environment()
     poolname = get_poolname(info, storage_config)
     volume = info.get('volume')
diff --git a/curtin/commands/curthooks.py b/curtin/commands/curthooks.py
index d45c3a8..480eca4 100644
--- a/curtin/commands/curthooks.py
+++ b/curtin/commands/curthooks.py
@@ -11,12 +11,18 @@ import textwrap
 
 from curtin import config
 from curtin import block
+from curtin import distro
+from curtin.block import iscsi
 from curtin import net
 from curtin import futil
 from curtin.log import LOG
+from curtin import paths
 from curtin import swap
 from curtin import util
 from curtin import version as curtin_version
+from curtin.block import deps as bdeps
+from curtin.distro import DISTROS
+from curtin.net import deps as ndeps
 from curtin.reporter import events
 from curtin.commands import apply_net, apt_config
 from curtin.url_helper import get_maas_version
@@ -173,10 +179,10 @@ def install_kernel(cfg, target):
     # target only has required packages installed.  See LP:1640519
     fk_packages = get_flash_kernel_pkgs()
     if fk_packages:
-        util.install_packages(fk_packages.split(), target=target)
+        distro.install_packages(fk_packages.split(), target=target)
 
     if kernel_package:
-        util.install_packages([kernel_package], target=target)
+        distro.install_packages([kernel_package], target=target)
         return
 
     # uname[2] is kernel name (ie: 3.16.0-7-generic)
@@ -193,24 +199,24 @@ def install_kernel(cfg, target):
         LOG.warn("Couldn't detect kernel package to install for %s."
                  % kernel)
         if kernel_fallback is not None:
-            util.install_packages([kernel_fallback], target=target)
+            distro.install_packages([kernel_fallback], target=target)
         return
 
     package = "linux-{flavor}{map_suffix}".format(
         flavor=flavor, map_suffix=map_suffix)
 
-    if util.has_pkg_available(package, target):
-        if util.has_pkg_installed(package, target):
+    if distro.has_pkg_available(package, target):
+        if distro.has_pkg_installed(package, target):
             LOG.debug("Kernel package '%s' already installed", package)
         else:
             LOG.debug("installing kernel package '%s'", package)
-            util.install_packages([package], target=target)
+            distro.install_packages([package], target=target)
     else:
         if kernel_fallback is not None:
             LOG.info("Kernel package '%s' not available.  "
                      "Installing fallback package '%s'.",
                      package, kernel_fallback)
-            util.install_packages([kernel_fallback], target=target)
+            distro.install_packages([kernel_fallback], target=target)
         else:
             LOG.warn("Kernel package '%s' not available and no fallback."
                      " System may not boot.", package)
@@ -273,7 +279,7 @@ def uefi_reorder_loaders(grubcfg, target):
         LOG.debug("Currently booted UEFI loader might no longer boot.")
 
 
-def setup_grub(cfg, target):
+def setup_grub(cfg, target, osfamily=DISTROS.debian):
     # target is the path to the mounted filesystem
 
     # FIXME: these methods need moving to curtin.block
@@ -292,7 +298,7 @@ def setup_grub(cfg, target):
     storage_cfg_odict = None
     try:
         storage_cfg_odict = extract_storage_ordered_dict(cfg)
-    except ValueError as e:
+    except ValueError:
         pass
 
     if storage_cfg_odict:
@@ -324,7 +330,7 @@ def setup_grub(cfg, target):
             try:
                 (blockdev, part) = block.get_blockdev_for_partition(maybepart)
                 blockdevs.add(blockdev)
-            except ValueError as e:
+            except ValueError:
                 # if there is no syspath for this device such as a lvm
                 # or raid device, then a ValueError is raised here.
                 LOG.debug("failed to find block device for %s", maybepart)
@@ -353,24 +359,6 @@ def setup_grub(cfg, target):
         else:
             instdevs = list(blockdevs)
 
-    # UEFI requires grub-efi-{arch}. If a signed version of that package
-    # exists then it will be installed.
-    if util.is_uefi_bootable():
-        arch = util.get_architecture()
-        pkgs = ['grub-efi-%s' % arch]
-
-        # Architecture might support a signed UEFI loader
-        uefi_pkg_signed = 'grub-efi-%s-signed' % arch
-        if util.has_pkg_available(uefi_pkg_signed):
-            pkgs.append(uefi_pkg_signed)
-
-        # AMD64 has shim-signed for SecureBoot support
-        if arch == "amd64":
-            pkgs.append("shim-signed")
-
-        # Install the UEFI packages needed for the architecture
-        util.install_packages(pkgs, target=target)
-
     env = os.environ.copy()
 
     replace_default = grubcfg.get('replace_linux_default', True)
@@ -399,6 +387,7 @@ def setup_grub(cfg, target):
             else:
                 LOG.debug("NOT enabling UEFI nvram updates")
                 LOG.debug("Target system may not boot")
+        args.append('--os-family=%s' % osfamily)
         args.append(target)
 
         # capture stdout and stderr joined.
@@ -435,14 +424,21 @@ def copy_crypttab(crypttab, target):
     shutil.copy(crypttab, os.path.sep.join([target, 'etc/crypttab']))
 
 
-def copy_iscsi_conf(nodes_dir, target):
+def copy_iscsi_conf(nodes_dir, target, target_nodes_dir='etc/iscsi/nodes'):
     if not nodes_dir:
         LOG.warn("nodes directory must be specified, not copying")
         return
 
     LOG.info("copying iscsi nodes database into target")
-    shutil.copytree(nodes_dir, os.path.sep.join([target,
-                    'etc/iscsi/nodes']))
+    tdir = os.path.sep.join([target, target_nodes_dir])
+    if not os.path.exists(tdir):
+        shutil.copytree(nodes_dir, tdir)
+    else:
+        # if /etc/iscsi/nodes exists, copy dirs underneath
+        for ndir in os.listdir(nodes_dir):
+            source_dir = os.path.join(nodes_dir, ndir)
+            target_dir = os.path.join(tdir, ndir)
+            shutil.copytree(source_dir, target_dir)
 
 
 def copy_mdadm_conf(mdadm_conf, target):
@@ -486,7 +482,7 @@ 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")
+    target_rules_dir = paths.target_path(target, "etc/udev/rules.d")
     for rule in os.listdir(rules_d):
         target_file = os.path.join(target_rules_dir, rule)
         shutil.copy(os.path.join(rules_d, rule), target_file)
@@ -532,11 +528,19 @@ def add_swap(cfg, target, fstab):
                         maxsize=maxsize)
 
 
-def detect_and_handle_multipath(cfg, target):
-    DEFAULT_MULTIPATH_PACKAGES = ['multipath-tools-boot']
+def detect_and_handle_multipath(cfg, target, osfamily=DISTROS.debian):
+    DEFAULT_MULTIPATH_PACKAGES = {
+        DISTROS.debian: ['multipath-tools-boot'],
+        DISTROS.redhat: ['device-mapper-multipath'],
+    }
+    if osfamily not in DEFAULT_MULTIPATH_PACKAGES:
+        raise ValueError(
+                'No multipath package mapping for distro: %s' % osfamily)
+
     mpcfg = cfg.get('multipath', {})
     mpmode = mpcfg.get('mode', 'auto')
-    mppkgs = mpcfg.get('packages', DEFAULT_MULTIPATH_PACKAGES)
+    mppkgs = mpcfg.get('packages',
+                       DEFAULT_MULTIPATH_PACKAGES.get(osfamily))
     mpbindings = mpcfg.get('overwrite_bindings', True)
 
     if isinstance(mppkgs, str):
@@ -549,23 +553,28 @@ def detect_and_handle_multipath(cfg, target):
         return
 
     LOG.info("Detected multipath devices. Installing support via %s", mppkgs)
+    needed = [pkg for pkg in mppkgs if pkg
+              not in distro.get_installed_packages(target)]
+    if needed:
+        distro.install_packages(needed, target=target, osfamily=osfamily)
 
-    util.install_packages(mppkgs, target=target)
     replace_spaces = True
-    try:
-        # check in-target version
-        pkg_ver = util.get_package_version('multipath-tools', target=target)
-        LOG.debug("get_package_version:\n%s", pkg_ver)
-        LOG.debug("multipath version is %s (major=%s minor=%s micro=%s)",
-                  pkg_ver['semantic_version'], pkg_ver['major'],
-                  pkg_ver['minor'], pkg_ver['micro'])
-        # multipath-tools versions < 0.5.0 do _NOT_ want whitespace replaced
-        # i.e. 0.4.X in Trusty.
-        if pkg_ver['semantic_version'] < 500:
-            replace_spaces = False
-    except Exception as e:
-        LOG.warn("failed reading multipath-tools version, "
-                 "assuming it wants no spaces in wwids: %s", e)
+    if osfamily == DISTROS.debian:
+        try:
+            # check in-target version
+            pkg_ver = distro.get_package_version('multipath-tools',
+                                                 target=target)
+            LOG.debug("get_package_version:\n%s", pkg_ver)
+            LOG.debug("multipath version is %s (major=%s minor=%s micro=%s)",
+                      pkg_ver['semantic_version'], pkg_ver['major'],
+                      pkg_ver['minor'], pkg_ver['micro'])
+            # multipath-tools versions < 0.5.0 do _NOT_
+            # want whitespace replaced i.e. 0.4.X in Trusty.
+            if pkg_ver['semantic_version'] < 500:
+                replace_spaces = False
+        except Exception as e:
+            LOG.warn("failed reading multipath-tools version, "
+                     "assuming it wants no spaces in wwids: %s", e)
 
     multipath_cfg_path = os.path.sep.join([target, '/etc/multipath.conf'])
     multipath_bind_path = os.path.sep.join([target, '/etc/multipath/bindings'])
@@ -574,7 +583,7 @@ def detect_and_handle_multipath(cfg, target):
     if not os.path.isfile(multipath_cfg_path):
         # Without user_friendly_names option enabled system fails to boot
         # if any of the disks has spaces in its name. Package multipath-tools
-        # has bug opened for this issue (LP: 1432062) but it was not fixed yet.
+        # has bug opened for this issue LP: #1432062 but it was not fixed yet.
         multipath_cfg_content = '\n'.join(
             ['# This file was created by curtin while installing the system.',
              'defaults {',
@@ -593,7 +602,13 @@ def detect_and_handle_multipath(cfg, target):
         mpname = "mpath0"
         grub_dev = "/dev/mapper/" + mpname
         if partno is not None:
-            grub_dev += "-part%s" % partno
+            if osfamily == DISTROS.debian:
+                grub_dev += "-part%s" % partno
+            elif osfamily == DISTROS.redhat:
+                grub_dev += "p%s" % partno
+            else:
+                raise ValueError(
+                        'Unknown grub_dev mapping for distro: %s' % osfamily)
 
         LOG.debug("configuring multipath install for root=%s wwid=%s",
                   grub_dev, wwid)
@@ -606,31 +621,54 @@ def detect_and_handle_multipath(cfg, target):
              ''])
         util.write_file(multipath_bind_path, content=multipath_bind_content)
 
-        grub_cfg = os.path.sep.join(
-            [target, '/etc/default/grub.d/50-curtin-multipath.cfg'])
+        if osfamily == DISTROS.debian:
+            grub_cfg = os.path.sep.join(
+                [target, '/etc/default/grub.d/50-curtin-multipath.cfg'])
+            omode = 'w'
+        elif osfamily == DISTROS.redhat:
+            grub_cfg = os.path.sep.join([target, '/etc/default/grub'])
+            omode = 'a'
+        else:
+            raise ValueError(
+                    'Unknown grub_cfg mapping for distro: %s' % osfamily)
+
         msg = '\n'.join([
-            '# Written by curtin for multipath device wwid "%s"' % wwid,
+            '# Written by curtin for multipath device %s %s' % (mpname, wwid),
             'GRUB_DEVICE=%s' % grub_dev,
             'GRUB_DISABLE_LINUX_UUID=true',
             ''])
-        util.write_file(grub_cfg, content=msg)
-
+        util.write_file(grub_cfg, omode=omode, content=msg)
     else:
         LOG.warn("Not sure how this will boot")
 
-    # Initrams needs to be updated to include /etc/multipath.cfg
-    # and /etc/multipath/bindings files.
-    update_initramfs(target, all_kernels=True)
+    if osfamily == DISTROS.debian:
+        # Initrams needs to be updated to include /etc/multipath.cfg
+        # and /etc/multipath/bindings files.
+        update_initramfs(target, all_kernels=True)
+    elif osfamily == DISTROS.redhat:
+        # Write out initramfs/dracut config for multipath
+        dracut_conf_multipath = os.path.sep.join(
+            [target, '/etc/dracut.conf.d/10-curtin-multipath.conf'])
+        msg = '\n'.join([
+            '# Written by curtin for multipath device wwid "%s"' % wwid,
+            'force_drivers+=" dm-multipath "',
+            'add_dracutmodules+="multipath"',
+            'install_items+="/etc/multipath.conf /etc/multipath/bindings"',
+            ''])
+        util.write_file(dracut_conf_multipath, content=msg)
+    else:
+        raise ValueError(
+                'Unknown initramfs mapping for distro: %s' % osfamily)
 
 
-def detect_required_packages(cfg):
+def detect_required_packages(cfg, osfamily=DISTROS.debian):
     """
     detect packages that will be required in-target by custom config items
     """
 
     mapping = {
-        'storage': block.detect_required_packages_mapping(),
-        'network': net.detect_required_packages_mapping(),
+        'storage': bdeps.detect_required_packages_mapping(osfamily=osfamily),
+        'network': ndeps.detect_required_packages_mapping(osfamily=osfamily),
     }
 
     needed_packages = []
@@ -657,16 +695,16 @@ def detect_required_packages(cfg):
     return needed_packages
 
 
-def install_missing_packages(cfg, target):
+def install_missing_packages(cfg, target, osfamily=DISTROS.debian):
     ''' describe which operation types will require specific packages
 
     'custom_config_key': {
          'pkg1': ['op_name_1', 'op_name_2', ...]
      }
     '''
-
-    installed_packages = util.get_installed_packages(target)
-    needed_packages = set([pkg for pkg in detect_required_packages(cfg)
+    installed_packages = distro.get_installed_packages(target)
+    needed_packages = set([pkg for pkg in
+                           detect_required_packages(cfg, osfamily=osfamily)
                            if pkg not in installed_packages])
 
     arch_packages = {
@@ -678,8 +716,35 @@ def install_missing_packages(cfg, target):
             if pkg not in needed_packages:
                 needed_packages.add(pkg)
 
+    # UEFI requires grub-efi-{arch}. If a signed version of that package
+    # exists then it will be installed.
+    if util.is_uefi_bootable():
+        uefi_pkgs = []
+        if osfamily == DISTROS.redhat:
+            # centos/redhat doesn't support 32-bit?
+            uefi_pkgs.extend(['grub2-efi-x64-modules'])
+        elif osfamily == DISTROS.debian:
+            arch = util.get_architecture()
+            uefi_pkgs.append('grub-efi-%s' % arch)
+
+            # Architecture might support a signed UEFI loader
+            uefi_pkg_signed = 'grub-efi-%s-signed' % arch
+            if distro.has_pkg_available(uefi_pkg_signed):
+                uefi_pkgs.append(uefi_pkg_signed)
+
+            # AMD64 has shim-signed for SecureBoot support
+            if arch == "amd64":
+                uefi_pkgs.append("shim-signed")
+        else:
+            raise ValueError('Unknown grub2 package list for distro: %s' %
+                             osfamily)
+        needed_packages.update([pkg for pkg in uefi_pkgs
+                                if pkg not in installed_packages])
+
     # Filter out ifupdown network packages on netplan enabled systems.
-    if 'ifupdown' not in installed_packages and 'nplan' in installed_packages:
+    has_netplan = ('nplan' in installed_packages or
+                   'netplan.io' in installed_packages)
+    if 'ifupdown' not in installed_packages and has_netplan:
         drops = set(['bridge-utils', 'ifenslave', 'vlan'])
         if needed_packages.union(drops):
             LOG.debug("Skipping install of %s.  Not needed on netplan system.",
@@ -694,10 +759,10 @@ def install_missing_packages(cfg, target):
                 reporting_enabled=True, level="INFO",
                 description="Installing packages on target system: " +
                 str(to_add)):
-            util.install_packages(to_add, target=target)
+            distro.install_packages(to_add, target=target, osfamily=osfamily)
 
 
-def system_upgrade(cfg, target):
+def system_upgrade(cfg, target, osfamily=DISTROS.debian):
     """run system-upgrade (apt-get dist-upgrade) or other in target.
 
     config:
@@ -716,7 +781,7 @@ def system_upgrade(cfg, target):
         LOG.debug("system_upgrade disabled by config.")
         return
 
-    util.system_upgrade(target=target)
+    distro.system_upgrade(target=target, osfamily=osfamily)
 
 
 def inject_pollinate_user_agent_config(ua_cfg, target):
@@ -726,7 +791,7 @@ def inject_pollinate_user_agent_config(ua_cfg, target):
     if not isinstance(ua_cfg, dict):
         raise ValueError('ua_cfg is not a dictionary: %s', ua_cfg)
 
-    pollinate_cfg = util.target_path(target, '/etc/pollinate/add-user-agent')
+    pollinate_cfg = paths.target_path(target, '/etc/pollinate/add-user-agent')
     comment = "# written by curtin"
     content = "\n".join(["%s/%s %s" % (ua_key, ua_val, comment)
                          for ua_key, ua_val in ua_cfg.items()]) + "\n"
@@ -749,6 +814,8 @@ def handle_pollinate_user_agent(cfg, target):
       curtin version
       maas version (via endpoint URL, if present)
     """
+    if not util.which('pollinate', target=target):
+        return
 
     pcfg = cfg.get('pollinate')
     if not isinstance(pcfg, dict):
@@ -774,6 +841,63 @@ def handle_pollinate_user_agent(cfg, target):
     inject_pollinate_user_agent_config(uacfg, target)
 
 
+def configure_iscsi(cfg, state_etcd, target, osfamily=DISTROS.debian):
+    # If a /etc/iscsi/nodes/... file was created by block_meta then it
+    # needs to be copied onto the target system
+    nodes = os.path.join(state_etcd, "nodes")
+    if not os.path.exists(nodes):
+        return
+
+    LOG.info('Iscsi configuration found, enabling service')
+    if osfamily == DISTROS.redhat:
+        # copy iscsi node config to target image
+        LOG.debug('Copying iscsi node config to target')
+        copy_iscsi_conf(nodes, target, target_nodes_dir='var/lib/iscsi/nodes')
+
+        # update in-target config
+        with util.ChrootableTarget(target) as in_chroot:
+            # enable iscsid service
+            LOG.debug('Enabling iscsi daemon')
+            in_chroot.subp(['chkconfig', 'iscsid', 'on'])
+
+            # update selinux config for iscsi ports required
+            for port in [str(port) for port in
+                         iscsi.get_iscsi_ports_from_config(cfg)]:
+                LOG.debug('Adding iscsi port %s to selinux iscsi_port_t list',
+                          port)
+                in_chroot.subp(['semanage', 'port', '-a', '-t',
+                                'iscsi_port_t', '-p', 'tcp', port])
+
+    elif osfamily == DISTROS.debian:
+        copy_iscsi_conf(nodes, target)
+    else:
+        raise ValueError(
+                'Unknown iscsi requirements for distro: %s' % osfamily)
+
+
+def configure_mdadm(cfg, state_etcd, target, osfamily=DISTROS.debian):
+    # If a mdadm.conf file was created by block_meta than it needs
+    # to be copied onto the target system
+    mdadm_location = os.path.join(state_etcd, "mdadm.conf")
+    if not os.path.exists(mdadm_location):
+        return
+
+    conf_map = {
+        DISTROS.debian: 'etc/mdadm/mdadm.conf',
+        DISTROS.redhat: 'etc/mdadm.conf',
+    }
+    if osfamily not in conf_map:
+        raise ValueError(
+                'Unknown mdadm conf mapping for distro: %s' % osfamily)
+    LOG.info('Mdadm configuration found, enabling service')
+    shutil.copy(mdadm_location, paths.target_path(target,
+                                                  conf_map[osfamily]))
+    if osfamily == DISTROS.debian:
+        # as per LP: #964052 reconfigure mdadm
+        util.subp(['dpkg-reconfigure', '--frontend=noninteractive', 'mdadm'],
+                  data=None, target=target)
+
+
 def handle_cloudconfig(cfg, base_dir=None):
     """write cloud-init configuration files into base_dir.
 
@@ -843,21 +967,11 @@ def ubuntu_core_curthooks(cfg, target=None):
                         content=config.dump_config({'network': netconfig}))
 
 
-def rpm_get_dist_id(target):
-    """Use rpm command to extract the '%rhel' distro macro which returns
-       the major os version id (6, 7, 8).  This works for centos or rhel
-    """
-    with util.ChrootableTarget(target) as in_chroot:
-        dist, _ = in_chroot.subp(['rpm', '-E', '%rhel'], capture=True)
-    return dist.rstrip()
-
-
-def centos_apply_network_config(netcfg, target=None):
+def redhat_upgrade_cloud_init(netcfg, target=None, osfamily=DISTROS.redhat):
     """ CentOS images execute built-in curthooks which only supports
         simple networking configuration.  This hook enables advanced
         network configuration via config passthrough to the target.
     """
-
     def cloud_init_repo(version):
         if not version:
             raise ValueError('Missing required version parameter')
@@ -866,9 +980,9 @@ def centos_apply_network_config(netcfg, target=None):
 
     if netcfg:
         LOG.info('Removing embedded network configuration (if present)')
-        ifcfgs = glob.glob(util.target_path(target,
-                                            'etc/sysconfig/network-scripts') +
-                           '/ifcfg-*')
+        ifcfgs = glob.glob(
+            paths.target_path(target, 'etc/sysconfig/network-scripts') +
+            '/ifcfg-*')
         # remove ifcfg-* (except ifcfg-lo)
         for ifcfg in ifcfgs:
             if os.path.basename(ifcfg) != "ifcfg-lo":
@@ -882,29 +996,27 @@ def centos_apply_network_config(netcfg, target=None):
         # if in-target cloud-init is not updated, upgrade via cloud-init repo
         if not passthrough:
             cloud_init_yum_repo = (
-                util.target_path(target,
-                                 'etc/yum.repos.d/curtin-cloud-init.repo'))
+                paths.target_path(target,
+                                  'etc/yum.repos.d/curtin-cloud-init.repo'))
             # Inject cloud-init daily yum repo
             util.write_file(cloud_init_yum_repo,
-                            content=cloud_init_repo(rpm_get_dist_id(target)))
+                            content=cloud_init_repo(
+                                distro.rpm_get_dist_id(target)))
 
             # we separate the installation of repository packages (epel,
             # cloud-init-el-release) as we need a new invocation of yum
             # to read the newly installed repo files.
-            YUM_CMD = ['yum', '-y', '--noplugins', 'install']
-            retries = [1] * 30
-            with util.ChrootableTarget(target) as in_chroot:
-                # ensure up-to-date ca-certificates to handle https mirror
-                # connections
-                in_chroot.subp(YUM_CMD + ['ca-certificates'], capture=True,
-                               log_captured=True, retries=retries)
-                in_chroot.subp(YUM_CMD + ['epel-release'], capture=True,
-                               log_captured=True, retries=retries)
-                in_chroot.subp(YUM_CMD + ['cloud-init-el-release'],
-                               log_captured=True, capture=True,
-                               retries=retries)
-                in_chroot.subp(YUM_CMD + ['cloud-init'], capture=True,
-                               log_captured=True, retries=retries)
+
+            # ensure up-to-date ca-certificates to handle https mirror
+            # connections
+            distro.install_packages(['ca-certificates'], target=target,
+                                    osfamily=osfamily)
+            distro.install_packages(['epel-release'], target=target,
+                                    osfamily=osfamily)
+            distro.install_packages(['cloud-init-el-release'], target=target,
+                                    osfamily=osfamily)
+            distro.install_packages(['cloud-init'], target=target,
+                                    osfamily=osfamily)
 
             # remove cloud-init el-stable bootstrap repo config as the
             # cloud-init-el-release package points to the correct repo
@@ -917,127 +1029,136 @@ def centos_apply_network_config(netcfg, target=None):
                                    capture=False, rcs=[0])
                 except util.ProcessExecutionError:
                     LOG.debug('Image missing bridge-utils package, installing')
-                    in_chroot.subp(YUM_CMD + ['bridge-utils'], capture=True,
-                                   log_captured=True, retries=retries)
+                    distro.install_packages(['bridge-utils'], target=target,
+                                            osfamily=osfamily)
 
     LOG.info('Passing network configuration through to target')
     net.render_netconfig_passthrough(target, netconfig={'network': netcfg})
 
 
-def target_is_ubuntu_core(target):
-    """Check if Ubuntu-Core specific directory is present at target"""
-    if target:
-        return os.path.exists(util.target_path(target,
-                                               'system-data/var/lib/snapd'))
-    return False
-
-
-def target_is_centos(target):
-    """Check if CentOS specific file is present at target"""
-    if target:
-        return os.path.exists(util.target_path(target, 'etc/centos-release'))
+# Public API, maas may call this from internal curthooks
+centos_apply_network_config = redhat_upgrade_cloud_init
 
-    return False
 
+def redhat_apply_selinux_autorelabel(target):
+    """Creates file /.autorelabel.
 
-def target_is_rhel(target):
-    """Check if RHEL specific file is present at target"""
-    if target:
-        return os.path.exists(util.target_path(target, 'etc/redhat-release'))
+    This is used by SELinux to relabel all of the
+    files on the filesystem to have the correct
+    security context. Without this SSH login will
+    fail.
+    """
+    LOG.debug('enabling selinux autorelabel')
+    open(paths.target_path(target, '.autorelabel'), 'a').close()
 
-    return False
 
+def redhat_update_dracut_config(target, cfg):
+    initramfs_mapping = {
+        'lvm': {'conf': 'lvmconf', 'modules': 'lvm'},
+        'raid': {'conf': 'mdadmconf', 'modules': 'mdraid'},
+    }
 
-def curthooks(args):
-    state = util.load_command_environment()
+    # no need to update initramfs if no custom storage
+    if 'storage' not in cfg:
+        return False
 
-    if args.target is not None:
-        target = args.target
-    else:
-        target = state['target']
+    storage_config = cfg.get('storage', {}).get('config')
+    if not storage_config:
+        raise ValueError('Invalid storage config')
+
+    add_conf = set()
+    add_modules = set()
+    for scfg in storage_config:
+        if scfg['type'] == 'raid':
+            add_conf.add(initramfs_mapping['raid']['conf'])
+            add_modules.add(initramfs_mapping['raid']['modules'])
+        elif scfg['type'] in ['lvm_volgroup', 'lvm_partition']:
+            add_conf.add(initramfs_mapping['lvm']['conf'])
+            add_modules.add(initramfs_mapping['lvm']['modules'])
+
+    dconfig = ['# Written by curtin for custom storage config']
+    dconfig.append('add_dracutmodules+="%s"' % (" ".join(add_modules)))
+    for conf in add_conf:
+        dconfig.append('%s="yes"' % conf)
+
+    # Write out initramfs/dracut config for storage config
+    dracut_conf_storage = os.path.sep.join(
+        [target, '/etc/dracut.conf.d/50-curtin-storage.conf'])
+    msg = '\n'.join(dconfig + [''])
+    LOG.debug('Updating redhat dracut config')
+    util.write_file(dracut_conf_storage, content=msg)
+    return True
+
+
+def redhat_update_initramfs(target, cfg):
+    if not redhat_update_dracut_config(target, cfg):
+        LOG.debug('Skipping redhat initramfs update, no custom storage config')
+        return
+    kver_cmd = ['rpm', '-q', '--queryformat',
+                '%{VERSION}-%{RELEASE}.%{ARCH}', 'kernel']
+    with util.ChrootableTarget(target) as in_chroot:
+        LOG.debug('Finding redhat kernel version: %s', kver_cmd)
+        kver, _err = in_chroot.subp(kver_cmd, capture=True)
+        LOG.debug('Found kver=%s' % kver)
+        initramfs = '/boot/initramfs-%s.img' % kver
+        dracut_cmd = ['dracut', '-f', initramfs, kver]
+        LOG.debug('Rebuilding initramfs with: %s', dracut_cmd)
+        in_chroot.subp(dracut_cmd, capture=True)
 
-    if target is None:
-        sys.stderr.write("Unable to find target.  "
-                         "Use --target or set TARGET_MOUNT_POINT\n")
-        sys.exit(2)
 
-    cfg = config.load_command_config(args, state)
+def builtin_curthooks(cfg, target, state):
+    LOG.info('Running curtin builtin curthooks')
     stack_prefix = state.get('report_stack_prefix', '')
-
-    # if curtin-hooks hook exists in target we can defer to the in-target hooks
-    if util.run_hook_if_exists(target, 'curtin-hooks'):
-        # For vmtests to force execute centos_apply_network_config, uncomment
-        # the value in examples/tests/centos_defaults.yaml
-        if cfg.get('_ammend_centos_curthooks'):
-            if cfg.get('cloudconfig'):
-                handle_cloudconfig(
-                    cfg['cloudconfig'],
-                    base_dir=util.target_path(target, 'etc/cloud/cloud.cfg.d'))
-
-            if target_is_centos(target) or target_is_rhel(target):
-                LOG.info('Detected RHEL/CentOS image, running extra hooks')
-                with events.ReportEventStack(
-                        name=stack_prefix, reporting_enabled=True,
-                        level="INFO",
-                        description="Configuring CentOS for first boot"):
-                    centos_apply_network_config(cfg.get('network', {}), target)
-        sys.exit(0)
-
-    if target_is_ubuntu_core(target):
-        LOG.info('Detected Ubuntu-Core image, running hooks')
+    state_etcd = os.path.split(state['fstab'])[0]
+
+    distro_info = distro.get_distroinfo(target=target)
+    if not distro_info:
+        raise RuntimeError('Failed to determine target distro')
+    osfamily = distro_info.family
+    LOG.info('Configuring target system for distro: %s osfamily: %s',
+             distro_info.variant, osfamily)
+    if osfamily == DISTROS.debian:
         with events.ReportEventStack(
-                name=stack_prefix, reporting_enabled=True, level="INFO",
-                description="Configuring Ubuntu-Core for first boot"):
-            ubuntu_core_curthooks(cfg, target)
-        sys.exit(0)
-
-    with events.ReportEventStack(
-            name=stack_prefix + '/writing-config',
-            reporting_enabled=True, level="INFO",
-            description="configuring apt configuring apt"):
-        do_apt_config(cfg, target)
-        disable_overlayroot(cfg, target)
+                name=stack_prefix + '/writing-apt-config',
+                reporting_enabled=True, level="INFO",
+                description="configuring apt configuring apt"):
+            do_apt_config(cfg, target)
+            disable_overlayroot(cfg, target)
 
-    # LP: #1742560 prevent zfs-dkms from being installed (Xenial)
-    if util.lsb_release(target=target)['codename'] == 'xenial':
-        util.apt_update(target=target)
-        with util.ChrootableTarget(target) as in_chroot:
-            in_chroot.subp(['apt-mark', 'hold', 'zfs-dkms'])
+        # LP: #1742560 prevent zfs-dkms from being installed (Xenial)
+        if distro.lsb_release(target=target)['codename'] == 'xenial':
+            distro.apt_update(target=target)
+            with util.ChrootableTarget(target) as in_chroot:
+                in_chroot.subp(['apt-mark', 'hold', 'zfs-dkms'])
 
     # packages may be needed prior to installing kernel
     with events.ReportEventStack(
             name=stack_prefix + '/installing-missing-packages',
             reporting_enabled=True, level="INFO",
             description="installing missing packages"):
-        install_missing_packages(cfg, target)
+        install_missing_packages(cfg, target, osfamily=osfamily)
 
-    # If a /etc/iscsi/nodes/... file was created by block_meta then it
-    # needs to be copied onto the target system
-    nodes_location = os.path.join(os.path.split(state['fstab'])[0],
-                                  "nodes")
-    if os.path.exists(nodes_location):
-        copy_iscsi_conf(nodes_location, target)
-        # do we need to reconfigure open-iscsi?
-
-    # If a mdadm.conf file was created by block_meta than it needs to be copied
-    # onto the target system
-    mdadm_location = os.path.join(os.path.split(state['fstab'])[0],
-                                  "mdadm.conf")
-    if os.path.exists(mdadm_location):
-        copy_mdadm_conf(mdadm_location, target)
-        # as per https://bugs.launchpad.net/ubuntu/+source/mdadm/+bug/964052
-        # reconfigure mdadm
-        util.subp(['dpkg-reconfigure', '--frontend=noninteractive', 'mdadm'],
-                  data=None, target=target)
+    with events.ReportEventStack(
+            name=stack_prefix + '/configuring-iscsi-service',
+            reporting_enabled=True, level="INFO",
+            description="configuring iscsi service"):
+        configure_iscsi(cfg, state_etcd, target, osfamily=osfamily)
 
     with events.ReportEventStack(
-            name=stack_prefix + '/installing-kernel',
+            name=stack_prefix + '/configuring-mdadm-service',
             reporting_enabled=True, level="INFO",
-            description="installing kernel"):
-        setup_zipl(cfg, target)
-        install_kernel(cfg, target)
-        run_zipl(cfg, target)
-        restore_dist_interfaces(cfg, target)
+            description="configuring raid (mdadm) service"):
+        configure_mdadm(cfg, state_etcd, target, osfamily=osfamily)
+
+    if osfamily == DISTROS.debian:
+        with events.ReportEventStack(
+                name=stack_prefix + '/installing-kernel',
+                reporting_enabled=True, level="INFO",
+                description="installing kernel"):
+            setup_zipl(cfg, target)
+            install_kernel(cfg, target)
+            run_zipl(cfg, target)
+            restore_dist_interfaces(cfg, target)
 
     with events.ReportEventStack(
             name=stack_prefix + '/setting-up-swap',
@@ -1045,6 +1166,23 @@ def curthooks(args):
             description="setting up swap"):
         add_swap(cfg, target, state.get('fstab'))
 
+    if osfamily == DISTROS.redhat:
+        # set cloud-init maas datasource for centos images
+        if cfg.get('cloudconfig'):
+            handle_cloudconfig(
+                cfg['cloudconfig'],
+                base_dir=paths.target_path(target,
+                                           'etc/cloud/cloud.cfg.d'))
+
+        # For vmtests to force execute redhat_upgrade_cloud_init, uncomment
+        # the value in examples/tests/centos_defaults.yaml
+        if cfg.get('_ammend_centos_curthooks'):
+            with events.ReportEventStack(
+                    name=stack_prefix + '/upgrading cloud-init',
+                    reporting_enabled=True, level="INFO",
+                    description="Upgrading cloud-init in target"):
+                redhat_upgrade_cloud_init(cfg.get('network', {}), target)
+
     with events.ReportEventStack(
             name=stack_prefix + '/apply-networking-config',
             reporting_enabled=True, level="INFO",
@@ -1061,29 +1199,44 @@ def curthooks(args):
             name=stack_prefix + '/configuring-multipath',
             reporting_enabled=True, level="INFO",
             description="configuring multipath"):
-        detect_and_handle_multipath(cfg, target)
+        detect_and_handle_multipath(cfg, target, osfamily=osfamily)
 
     with events.ReportEventStack(
             name=stack_prefix + '/system-upgrade',
             reporting_enabled=True, level="INFO",
             description="updating packages on target system"):
-        system_upgrade(cfg, target)
+        system_upgrade(cfg, target, osfamily=osfamily)
+
+    if osfamily == DISTROS.redhat:
+        with events.ReportEventStack(
+                name=stack_prefix + '/enabling-selinux-autorelabel',
+                reporting_enabled=True, level="INFO",
+                description="enabling selinux autorelabel mode"):
+            redhat_apply_selinux_autorelabel(target)
+
+        with events.ReportEventStack(
+                name=stack_prefix + '/updating-initramfs-configuration',
+                reporting_enabled=True, level="INFO",
+                description="updating initramfs configuration"):
+            redhat_update_initramfs(target, cfg)
 
     with events.ReportEventStack(
             name=stack_prefix + '/pollinate-user-agent',
             reporting_enabled=True, level="INFO",
-            description="configuring pollinate user-agent on target system"):
+            description="configuring pollinate user-agent on target"):
         handle_pollinate_user_agent(cfg, target)
 
-    # If a crypttab file was created by block_meta than it needs to be copied
-    # onto the target system, and update_initramfs() needs to be run, so that
-    # the cryptsetup hooks are properly configured on the installed system and
-    # it will be able to open encrypted volumes at boot.
-    crypttab_location = os.path.join(os.path.split(state['fstab'])[0],
-                                     "crypttab")
-    if os.path.exists(crypttab_location):
-        copy_crypttab(crypttab_location, target)
-        update_initramfs(target)
+    if osfamily == DISTROS.debian:
+        # If a crypttab file was created by block_meta than it needs to be
+        # copied onto the target system, and update_initramfs() needs to be
+        # run, so that the cryptsetup hooks are properly configured on the
+        # installed system and it will be able to open encrypted volumes
+        # at boot.
+        crypttab_location = os.path.join(os.path.split(state['fstab'])[0],
+                                         "crypttab")
+        if os.path.exists(crypttab_location):
+            copy_crypttab(crypttab_location, target)
+            update_initramfs(target)
 
     # If udev dname rules were created, copy them to target
     udev_rules_d = os.path.join(state['scratch'], "rules.d")
@@ -1100,8 +1253,41 @@ def curthooks(args):
             machine.startswith('aarch64') and not util.is_uefi_bootable()):
         update_initramfs(target)
     else:
-        setup_grub(cfg, target)
+        setup_grub(cfg, target, osfamily=osfamily)
+
+
+def curthooks(args):
+    state = util.load_command_environment()
+
+    if args.target is not None:
+        target = args.target
+    else:
+        target = state['target']
+
+    if target is None:
+        sys.stderr.write("Unable to find target.  "
+                         "Use --target or set TARGET_MOUNT_POINT\n")
+        sys.exit(2)
+
+    cfg = config.load_command_config(args, state)
+    stack_prefix = state.get('report_stack_prefix', '')
+    curthooks_mode = cfg.get('curthooks', {}).get('mode', 'auto')
+
+    # UC is special, handle it first.
+    if distro.is_ubuntu_core(target):
+        LOG.info('Detected Ubuntu-Core image, running hooks')
+        with events.ReportEventStack(
+                name=stack_prefix, reporting_enabled=True, level="INFO",
+                description="Configuring Ubuntu-Core for first boot"):
+            ubuntu_core_curthooks(cfg, target)
+        sys.exit(0)
+
+    # user asked for target, or auto mode
+    if curthooks_mode in ['auto', 'target']:
+        if util.run_hook_if_exists(target, 'curtin-hooks'):
+            sys.exit(0)
 
+    builtin_curthooks(cfg, target, state)
     sys.exit(0)
 
 
diff --git a/curtin/commands/extract.py b/curtin/commands/extract.py
index 69a9d18..ec7a791 100644
--- a/curtin/commands/extract.py
+++ b/curtin/commands/extract.py
@@ -59,7 +59,7 @@ def extract_root_tgz_url(url, target):
 def extract_root_fsimage_url(url, target):
     path = _path_from_file_url(url)
     if path != url or os.path.isfile(path):
-        return _extract_root_fsimage(path(url), target)
+        return _extract_root_fsimage(path, target)
 
     wfp = tempfile.NamedTemporaryFile(suffix=".img", delete=False)
     wfp.close()
diff --git a/curtin/commands/features.py b/curtin/commands/features.py
new file mode 100644
index 0000000..0f6085b
--- /dev/null
+++ b/curtin/commands/features.py
@@ -0,0 +1,20 @@
+# This file is part of curtin. See LICENSE file for copyright and license info.
+"""List the supported feature names to stdout."""
+
+import sys
+from .. import FEATURES
+from . import populate_one_subcmd
+
+CMD_ARGUMENTS = ((tuple()))
+
+
+def features_main(args):
+    sys.stdout.write("\n".join(sorted(FEATURES)) + "\n")
+    sys.exit(0)
+
+
+def POPULATE_SUBCMD(parser):
+    populate_one_subcmd(parser, CMD_ARGUMENTS, features_main)
+    parser.description = __doc__
+
+# vi: ts=4 expandtab syntax=python
diff --git a/curtin/commands/in_target.py b/curtin/commands/in_target.py
index 8e839c0..c6f7abd 100644
--- a/curtin/commands/in_target.py
+++ b/curtin/commands/in_target.py
@@ -4,7 +4,7 @@ import os
 import pty
 import sys
 
-from curtin import util
+from curtin import paths, util
 
 from . import populate_one_subcmd
 
@@ -41,7 +41,7 @@ def in_target_main(args):
         sys.exit(2)
 
     daemons = args.allow_daemons
-    if util.target_path(args.target) == "/":
+    if paths.target_path(args.target) == "/":
         sys.stderr.write("WARN: Target is /, daemons are allowed.\n")
         daemons = True
     cmd = args.command_args
diff --git a/curtin/commands/install.py b/curtin/commands/install.py
index a8c4cf9..244683c 100644
--- a/curtin/commands/install.py
+++ b/curtin/commands/install.py
@@ -13,9 +13,11 @@ import tempfile
 
 from curtin.block import iscsi
 from curtin import config
+from curtin import distro
 from curtin import util
+from curtin import paths
 from curtin import version
-from curtin.log import LOG
+from curtin.log import LOG, logged_time
 from curtin.reporter.legacy import load_reporter
 from curtin.reporter import events
 from . import populate_one_subcmd
@@ -80,7 +82,7 @@ def copy_install_log(logfile, target, log_target_path):
     LOG.debug('Copying curtin install log from %s to target/%s',
               logfile, log_target_path)
     util.write_file(
-        filename=util.target_path(target, log_target_path),
+        filename=paths.target_path(target, log_target_path),
         content=util.load_file(logfile, decode=False),
         mode=0o400, omode="wb")
 
@@ -111,12 +113,22 @@ class WorkingDir(object):
     def __init__(self, config):
         top_d = tempfile.mkdtemp()
         state_d = os.path.join(top_d, 'state')
+        scratch_d = os.path.join(top_d, 'scratch')
+        for p in (state_d, scratch_d):
+            os.mkdir(p)
+
         target_d = config.get('install', {}).get('target')
         if not target_d:
             target_d = os.path.join(top_d, 'target')
-        scratch_d = os.path.join(top_d, 'scratch')
-        for p in (state_d, target_d, scratch_d):
-            os.mkdir(p)
+        try:
+            util.ensure_dir(target_d)
+        except OSError as e:
+            raise ValueError(
+                "Unable to create target directory '%s': %s" %
+                (target_d, e))
+        if os.listdir(target_d) != []:
+            raise ValueError(
+                "Provided target dir '%s' was not empty." % target_d)
 
         netconf_f = os.path.join(state_d, 'network_config')
         netstate_f = os.path.join(state_d, 'network_state')
@@ -309,7 +321,7 @@ def apply_kexec(kexec, target):
         raise TypeError("kexec is not a dict.")
 
     if not util.which('kexec'):
-        util.install_packages('kexec-tools')
+        distro.install_packages('kexec-tools')
 
     if not os.path.isfile(target_grubcfg):
         raise ValueError("%s does not exist in target" % grubcfg)
@@ -380,6 +392,7 @@ def migrate_proxy_settings(cfg):
     cfg['proxy'] = proxy
 
 
+@logged_time("INSTALL_COMMAND")
 def cmd_install(args):
     from .collect_logs import create_log_tarfile
     cfg = deepcopy(CONFIG_BUILTIN)
@@ -429,6 +442,7 @@ def cmd_install(args):
 
     writeline_and_stdout(logfile, INSTALL_START_MSG)
     args.reportstack.post_files = post_files
+    workingd = None
     try:
         workingd = WorkingDir(cfg)
         dd_images = util.get_dd_images(cfg.get('sources', {}))
@@ -469,12 +483,12 @@ def cmd_install(args):
         raise e
     finally:
         log_target_path = instcfg.get('save_install_log', SAVE_INSTALL_LOG)
-        if log_target_path:
+        if log_target_path and workingd:
             copy_install_log(logfile, workingd.target, log_target_path)
 
         if instcfg.get('unmount', "") == "disabled":
             LOG.info('Skipping unmount: config disabled target unmounting')
-        else:
+        elif workingd:
             # unmount everything (including iscsi disks)
             util.do_umount(workingd.target, recursive=True)
 
diff --git a/curtin/commands/main.py b/curtin/commands/main.py
index 779bb03..bccfc51 100644
--- a/curtin/commands/main.py
+++ b/curtin/commands/main.py
@@ -16,9 +16,9 @@ VERSIONSTR = version.version_string()
 SUB_COMMAND_MODULES = [
     'apply_net', 'apt-config', 'block-attach-iscsi', 'block-detach-iscsi',
     'block-info', 'block-meta', 'block-wipe', 'clear-holders', 'curthooks',
-    'collect-logs', 'extract', 'hook', 'install', 'mkfs', 'in-target',
-    'net-meta', 'pack', 'swap', 'system-install', 'system-upgrade', 'unmount',
-    'version',
+    'collect-logs', 'extract', 'features',
+    'hook', 'install', 'mkfs', 'in-target', 'net-meta', 'pack', 'swap',
+    'system-install', 'system-upgrade', 'unmount', 'version',
 ]
 
 
diff --git a/curtin/commands/system_install.py b/curtin/commands/system_install.py
index 05d70af..6d7b736 100644
--- a/curtin/commands/system_install.py
+++ b/curtin/commands/system_install.py
@@ -7,6 +7,7 @@ import curtin.util as util
 
 from . import populate_one_subcmd
 from curtin.log import LOG
+from curtin import distro
 
 
 def system_install_pkgs_main(args):
@@ -16,7 +17,7 @@ def system_install_pkgs_main(args):
 
     exit_code = 0
     try:
-        util.install_packages(
+        distro.install_packages(
             pkglist=args.packages, target=args.target,
             allow_daemons=args.allow_daemons)
     except util.ProcessExecutionError as e:
diff --git a/curtin/commands/system_upgrade.py b/curtin/commands/system_upgrade.py
index fe10fac..d4f6735 100644
--- a/curtin/commands/system_upgrade.py
+++ b/curtin/commands/system_upgrade.py
@@ -7,6 +7,7 @@ import curtin.util as util
 
 from . import populate_one_subcmd
 from curtin.log import LOG
+from curtin import distro
 
 
 def system_upgrade_main(args):
@@ -16,8 +17,8 @@ def system_upgrade_main(args):
 
     exit_code = 0
     try:
-        util.system_upgrade(target=args.target,
-                            allow_daemons=args.allow_daemons)
+        distro.system_upgrade(target=args.target,
+                              allow_daemons=args.allow_daemons)
     except util.ProcessExecutionError as e:
         LOG.warn("system upgrade failed: %s" % e)
         exit_code = e.exit_code
diff --git a/curtin/deps/__init__.py b/curtin/deps/__init__.py
index 7014895..96df4f6 100644
--- a/curtin/deps/__init__.py
+++ b/curtin/deps/__init__.py
@@ -6,13 +6,13 @@ import sys
 from curtin.util import (
     ProcessExecutionError,
     get_architecture,
-    install_packages,
     is_uefi_bootable,
-    lsb_release,
     subp,
     which,
 )
 
+from curtin.distro import install_packages, lsb_release
+
 REQUIRED_IMPORTS = [
     # import string to execute, python2 package, python3 package
     ('import yaml', 'python-yaml', 'python3-yaml'),
@@ -177,7 +177,7 @@ def install_deps(verbosity=False, dry_run=False, allow_daemons=True):
     ret = 0
     try:
         install_packages(missing_pkgs, allow_daemons=allow_daemons,
-                         aptopts=["--no-install-recommends"])
+                         opts=["--no-install-recommends"])
     except ProcessExecutionError as e:
         sys.stderr.write("%s\n" % e)
         ret = e.exit_code
diff --git a/curtin/distro.py b/curtin/distro.py
new file mode 100644
index 0000000..f2a78ed
--- /dev/null
+++ b/curtin/distro.py
@@ -0,0 +1,512 @@
+# This file is part of curtin. See LICENSE file for copyright and license info.
+import glob
+from collections import namedtuple
+import os
+import re
+import shutil
+import tempfile
+
+from .paths import target_path
+from .util import (
+    ChrootableTarget,
+    find_newer,
+    load_file,
+    load_shell_content,
+    ProcessExecutionError,
+    set_unexecutable,
+    string_types,
+    subp,
+    which
+)
+from .log import LOG
+
+DistroInfo = namedtuple('DistroInfo', ('variant', 'family'))
+DISTRO_NAMES = ['arch', 'centos', 'debian', 'fedora', 'freebsd', 'gentoo',
+                'opensuse', 'redhat', 'rhel', 'sles', 'suse', 'ubuntu']
+
+
+# python2.7 lacks  PEP 435, so we must make use an alternative for py2.7/3.x
+# https://stackoverflow.com/questions/36932/how-can-i-represent-an-enum-in-python
+def distro_enum(*distros):
+    return namedtuple('Distros', distros)(*distros)
+
+
+DISTROS = distro_enum(*DISTRO_NAMES)
+
+OS_FAMILIES = {
+    DISTROS.debian: [DISTROS.debian, DISTROS.ubuntu],
+    DISTROS.redhat: [DISTROS.centos, DISTROS.fedora, DISTROS.redhat,
+                     DISTROS.rhel],
+    DISTROS.gentoo: [DISTROS.gentoo],
+    DISTROS.freebsd: [DISTROS.freebsd],
+    DISTROS.suse: [DISTROS.opensuse, DISTROS.sles, DISTROS.suse],
+    DISTROS.arch: [DISTROS.arch],
+}
+
+# invert the mapping for faster lookup of variants
+DISTRO_TO_OSFAMILY = (
+    {variant: family for family, variants in OS_FAMILIES.items()
+     for variant in variants})
+
+_LSB_RELEASE = {}
+
+
+def name_to_distro(distname):
+    try:
+        return DISTROS[DISTROS.index(distname)]
+    except (IndexError, AttributeError):
+        LOG.error('Unknown distro name: %s', distname)
+
+
+def lsb_release(target=None):
+    if target_path(target) != "/":
+        # do not use or update cache if target is provided
+        return _lsb_release(target)
+
+    global _LSB_RELEASE
+    if not _LSB_RELEASE:
+        data = _lsb_release()
+        _LSB_RELEASE.update(data)
+    return _LSB_RELEASE
+
+
+def os_release(target=None):
+    data = {}
+    os_release = target_path(target, 'etc/os-release')
+    if os.path.exists(os_release):
+        data = load_shell_content(load_file(os_release),
+                                  add_empty=False, empty_val=None)
+    if not data:
+        for relfile in [target_path(target, rel) for rel in
+                        ['etc/centos-release', 'etc/redhat-release']]:
+            data = _parse_redhat_release(release_file=relfile, target=target)
+            if data:
+                break
+
+    return data
+
+
+def _parse_redhat_release(release_file=None, target=None):
+    """Return a dictionary of distro info fields from /etc/redhat-release.
+
+    Dict keys will align with /etc/os-release keys:
+        ID, VERSION_ID, VERSION_CODENAME
+    """
+
+    if not release_file:
+        release_file = target_path('etc/redhat-release')
+    if not os.path.exists(release_file):
+        return {}
+    redhat_release = load_file(release_file)
+    redhat_regex = (
+        r'(?P<name>.+) release (?P<version>[\d\.]+) '
+        r'\((?P<codename>[^)]+)\)')
+    match = re.match(redhat_regex, redhat_release)
+    if match:
+        group = match.groupdict()
+        group['name'] = group['name'].lower().partition(' linux')[0]
+        if group['name'] == 'red hat enterprise':
+            group['name'] = 'redhat'
+        return {'ID': group['name'], 'VERSION_ID': group['version'],
+                'VERSION_CODENAME': group['codename']}
+    return {}
+
+
+def get_distroinfo(target=None):
+    variant_name = os_release(target=target)['ID']
+    variant = name_to_distro(variant_name)
+    family = DISTRO_TO_OSFAMILY.get(variant)
+    return DistroInfo(variant, family)
+
+
+def get_distro(target=None):
+    distinfo = get_distroinfo(target=target)
+    return distinfo.variant
+
+
+def get_osfamily(target=None):
+    distinfo = get_distroinfo(target=target)
+    return distinfo.family
+
+
+def is_ubuntu_core(target=None):
+    """Check if Ubuntu-Core specific directory is present at target"""
+    return os.path.exists(target_path(target, 'system-data/var/lib/snapd'))
+
+
+def is_centos(target=None):
+    """Check if CentOS specific file is present at target"""
+    return os.path.exists(target_path(target, 'etc/centos-release'))
+
+
+def is_rhel(target=None):
+    """Check if RHEL specific file is present at target"""
+    return os.path.exists(target_path(target, 'etc/redhat-release'))
+
+
+def _lsb_release(target=None):
+    fmap = {'Codename': 'codename', 'Description': 'description',
+            'Distributor ID': 'id', 'Release': 'release'}
+
+    data = {}
+    try:
+        out, _ = subp(['lsb_release', '--all'], capture=True, target=target)
+        for line in out.splitlines():
+            fname, _, val = line.partition(":")
+            if fname in fmap:
+                data[fmap[fname]] = val.strip()
+        missing = [k for k in fmap.values() if k not in data]
+        if len(missing):
+            LOG.warn("Missing fields in lsb_release --all output: %s",
+                     ','.join(missing))
+
+    except ProcessExecutionError as err:
+        LOG.warn("Unable to get lsb_release --all: %s", err)
+        data = {v: "UNAVAILABLE" for v in fmap.values()}
+
+    return data
+
+
+def apt_update(target=None, env=None, force=False, comment=None,
+               retries=None):
+
+    marker = "tmp/curtin.aptupdate"
+
+    if env is None:
+        env = os.environ.copy()
+
+    if retries is None:
+        # by default run apt-update up to 3 times to allow
+        # for transient failures
+        retries = (1, 2, 3)
+
+    if comment is None:
+        comment = "no comment provided"
+
+    if comment.endswith("\n"):
+        comment = comment[:-1]
+
+    marker = target_path(target, marker)
+    # if marker exists, check if there are files that would make it obsolete
+    listfiles = [target_path(target, "/etc/apt/sources.list")]
+    listfiles += glob.glob(
+        target_path(target, "etc/apt/sources.list.d/*.list"))
+
+    if os.path.exists(marker) and not force:
+        if len(find_newer(marker, listfiles)) == 0:
+            return
+
+    restore_perms = []
+
+    abs_tmpdir = tempfile.mkdtemp(dir=target_path(target, "/tmp"))
+    try:
+        abs_slist = abs_tmpdir + "/sources.list"
+        abs_slistd = abs_tmpdir + "/sources.list.d"
+        ch_tmpdir = "/tmp/" + os.path.basename(abs_tmpdir)
+        ch_slist = ch_tmpdir + "/sources.list"
+        ch_slistd = ch_tmpdir + "/sources.list.d"
+
+        # this file gets executed on apt-get update sometimes. (LP: #1527710)
+        motd_update = target_path(
+            target, "/usr/lib/update-notifier/update-motd-updates-available")
+        pmode = set_unexecutable(motd_update)
+        if pmode is not None:
+            restore_perms.append((motd_update, pmode),)
+
+        # create tmpdir/sources.list with all lines other than deb-src
+        # avoid apt complaining by using existing and empty dir for sourceparts
+        os.mkdir(abs_slistd)
+        with open(abs_slist, "w") as sfp:
+            for sfile in listfiles:
+                with open(sfile, "r") as fp:
+                    contents = fp.read()
+                for line in contents.splitlines():
+                    line = line.lstrip()
+                    if not line.startswith("deb-src"):
+                        sfp.write(line + "\n")
+
+        update_cmd = [
+            'apt-get', '--quiet',
+            '--option=Acquire::Languages=none',
+            '--option=Dir::Etc::sourcelist=%s' % ch_slist,
+            '--option=Dir::Etc::sourceparts=%s' % ch_slistd,
+            'update']
+
+        # do not using 'run_apt_command' so we can use 'retries' to subp
+        with ChrootableTarget(target, allow_daemons=True) as inchroot:
+            inchroot.subp(update_cmd, env=env, retries=retries)
+    finally:
+        for fname, perms in restore_perms:
+            os.chmod(fname, perms)
+        if abs_tmpdir:
+            shutil.rmtree(abs_tmpdir)
+
+    with open(marker, "w") as fp:
+        fp.write(comment + "\n")
+
+
+def run_apt_command(mode, args=None, opts=None, env=None, target=None,
+                    execute=True, allow_daemons=False):
+    defopts = ['--quiet', '--assume-yes',
+               '--option=Dpkg::options::=--force-unsafe-io',
+               '--option=Dpkg::Options::=--force-confold']
+    if args is None:
+        args = []
+
+    if opts is None:
+        opts = []
+
+    if env is None:
+        env = os.environ.copy()
+        env['DEBIAN_FRONTEND'] = 'noninteractive'
+
+    if which('eatmydata', target=target):
+        emd = ['eatmydata']
+    else:
+        emd = []
+
+    cmd = emd + ['apt-get'] + defopts + opts + [mode] + args
+    if not execute:
+        return env, cmd
+
+    apt_update(target, env=env, comment=' '.join(cmd))
+    with ChrootableTarget(target, allow_daemons=allow_daemons) as inchroot:
+        return inchroot.subp(cmd, env=env)
+
+
+def run_yum_command(mode, args=None, opts=None, env=None, target=None,
+                    execute=True, allow_daemons=False):
+    defopts = ['--assumeyes', '--quiet']
+
+    if args is None:
+        args = []
+
+    if opts is None:
+        opts = []
+
+    cmd = ['yum'] + defopts + opts + [mode] + args
+    if not execute:
+        return env, cmd
+
+    if mode in ["install", "update", "upgrade"]:
+        return yum_install(mode, args, opts=opts, env=env, target=target,
+                           allow_daemons=allow_daemons)
+
+    with ChrootableTarget(target, allow_daemons=allow_daemons) as inchroot:
+        return inchroot.subp(cmd, env=env)
+
+
+def yum_install(mode, packages=None, opts=None, env=None, target=None,
+                allow_daemons=False):
+
+    defopts = ['--assumeyes', '--quiet']
+
+    if packages is None:
+        packages = []
+
+    if opts is None:
+        opts = []
+
+    if mode not in ['install', 'update', 'upgrade']:
+        raise ValueError(
+            'Unsupported mode "%s" for yum package install/upgrade' % mode)
+
+    # download first, then install/upgrade from cache
+    cmd = ['yum'] + defopts + opts + [mode]
+    dl_opts = ['--downloadonly', '--setopt=keepcache=1']
+    inst_opts = ['--cacheonly']
+
+    # rpm requires /dev /sys and /proc be mounted, use ChrootableTarget
+    with ChrootableTarget(target, allow_daemons=allow_daemons) as inchroot:
+        inchroot.subp(cmd + dl_opts + packages,
+                      env=env, retries=[1] * 10)
+        return inchroot.subp(cmd + inst_opts + packages, env=env)
+
+
+def rpm_get_dist_id(target=None):
+    """Use rpm command to extract the '%rhel' distro macro which returns
+       the major os version id (6, 7, 8).  This works for centos or rhel
+    """
+    with ChrootableTarget(target) as in_chroot:
+        dist, _ = in_chroot.subp(['rpm', '-E', '%rhel'], capture=True)
+    return dist.rstrip()
+
+
+def system_upgrade(opts=None, target=None, env=None, allow_daemons=False,
+                   osfamily=None):
+    LOG.debug("Upgrading system in %s", target)
+
+    distro_cfg = {
+        DISTROS.debian: {'function': 'run_apt_command',
+                         'subcommands': ('dist-upgrade', 'autoremove')},
+        DISTROS.redhat: {'function': 'run_yum_command',
+                         'subcommands': ('upgrade')},
+    }
+    if osfamily not in distro_cfg:
+        raise ValueError('Distro "%s" does not have system_upgrade support',
+                         osfamily)
+
+    for mode in distro_cfg[osfamily]['subcommands']:
+        ret = distro_cfg[osfamily]['function'](
+                mode, opts=opts, target=target,
+                env=env, allow_daemons=allow_daemons)
+    return ret
+
+
+def install_packages(pkglist, osfamily=None, opts=None, target=None, env=None,
+                     allow_daemons=False):
+    if isinstance(pkglist, str):
+        pkglist = [pkglist]
+
+    if not osfamily:
+        osfamily = get_osfamily(target=target)
+
+    installer_map = {
+        DISTROS.debian: run_apt_command,
+        DISTROS.redhat: run_yum_command,
+    }
+
+    install_cmd = installer_map.get(osfamily)
+    if not install_cmd:
+        raise ValueError('No packge install command for distro: %s' %
+                         osfamily)
+
+    return install_cmd('install', args=pkglist, opts=opts, target=target,
+                       env=env, allow_daemons=allow_daemons)
+
+
+def has_pkg_available(pkg, target=None, osfamily=None):
+    if not osfamily:
+        osfamily = get_osfamily(target=target)
+
+    if osfamily not in [DISTROS.debian, DISTROS.redhat]:
+        raise ValueError('has_pkg_available: unsupported distro family: %s',
+                         osfamily)
+
+    if osfamily == DISTROS.debian:
+        out, _ = subp(['apt-cache', 'pkgnames'], capture=True, target=target)
+        for item in out.splitlines():
+            if pkg == item.strip():
+                return True
+        return False
+
+    if osfamily == DISTROS.redhat:
+        out, _ = run_yum_command('list', opts=['--cacheonly'])
+        for item in out.splitlines():
+            if item.lower().startswith(pkg.lower()):
+                return True
+        return False
+
+
+def get_installed_packages(target=None):
+    if which('dpkg-query', target=target):
+        (out, _) = subp(['dpkg-query', '--list'], target=target, capture=True)
+    elif which('rpm', target=target):
+        # rpm requires /dev /sys and /proc be mounted, use ChrootableTarget
+        with ChrootableTarget(target) as in_chroot:
+            (out, _) = in_chroot.subp(['rpm', '-qa', '--queryformat',
+                                       'ii %{NAME} %{VERSION}-%{RELEASE}\n'],
+                                      target=target, capture=True)
+    if not out:
+        raise ValueError('No package query tool')
+
+    pkgs_inst = set()
+    for line in out.splitlines():
+        try:
+            (state, pkg, other) = line.split(None, 2)
+        except ValueError:
+            continue
+        if state.startswith("hi") or state.startswith("ii"):
+            pkgs_inst.add(re.sub(":.*", "", pkg))
+
+    return pkgs_inst
+
+
+def has_pkg_installed(pkg, target=None):
+    try:
+        out, _ = subp(['dpkg-query', '--show', '--showformat',
+                       '${db:Status-Abbrev}', pkg],
+                      capture=True, target=target)
+        return out.rstrip() == "ii"
+    except ProcessExecutionError:
+        return False
+
+
+def parse_dpkg_version(raw, name=None, semx=None):
+    """Parse a dpkg version string into various parts and calcualate a
+       numerical value of the version for use in comparing package versions
+
+       Native packages (without a '-'), will have the package version treated
+       as the upstream version.
+
+       returns a dictionary with fields:
+          'major' (int), 'minor' (int), 'micro' (int),
+          'semantic_version' (int),
+          'extra' (string), 'raw' (string), 'upstream' (string),
+          'name' (present only if name is not None)
+    """
+    if not isinstance(raw, string_types):
+        raise TypeError(
+            "Invalid type %s for parse_dpkg_version" % raw.__class__)
+
+    if semx is None:
+        semx = (10000, 100, 1)
+
+    if "-" in raw:
+        upstream = raw.rsplit('-', 1)[0]
+    else:
+        # this is a native package, package version treated as upstream.
+        upstream = raw
+
+    match = re.search(r'[^0-9.]', upstream)
+    if match:
+        extra = upstream[match.start():]
+        upstream_base = upstream[:match.start()]
+    else:
+        upstream_base = upstream
+        extra = None
+
+    toks = upstream_base.split(".", 2)
+    if len(toks) == 3:
+        major, minor, micro = toks
+    elif len(toks) == 2:
+        major, minor, micro = (toks[0], toks[1], 0)
+    elif len(toks) == 1:
+        major, minor, micro = (toks[0], 0, 0)
+
+    version = {
+        'major': int(major),
+        'minor': int(minor),
+        'micro': int(micro),
+        'extra': extra,
+        'raw': raw,
+        'upstream': upstream,
+    }
+    if name:
+        version['name'] = name
+
+    if semx:
+        try:
+            version['semantic_version'] = int(
+                int(major) * semx[0] + int(minor) * semx[1] +
+                int(micro) * semx[2])
+        except (ValueError, IndexError):
+            version['semantic_version'] = None
+
+    return version
+
+
+def get_package_version(pkg, target=None, semx=None):
+    """Use dpkg-query to extract package pkg's version string
+       and parse the version string into a dictionary
+    """
+    try:
+        out, _ = subp(['dpkg-query', '--show', '--showformat',
+                       '${Version}', pkg], capture=True, target=target)
+        raw = out.rstrip()
+        return parse_dpkg_version(raw, name=pkg, semx=semx)
+    except ProcessExecutionError:
+        return None
+
+
+# vi: ts=4 expandtab syntax=python
diff --git a/curtin/futil.py b/curtin/futil.py
index 506964e..e603f88 100644
--- a/curtin/futil.py
+++ b/curtin/futil.py
@@ -5,7 +5,8 @@ import pwd
 import os
 import warnings
 
-from .util import write_file, target_path
+from .util import write_file
+from .paths import target_path
 from .log import LOG
 
 
diff --git a/curtin/log.py b/curtin/log.py
index 4844460..446ba2c 100644
--- a/curtin/log.py
+++ b/curtin/log.py
@@ -1,6 +1,9 @@
 # This file is part of curtin. See LICENSE file for copyright and license info.
 
 import logging
+import time
+
+from functools import wraps
 
 # Logging items for easy access
 getLogger = logging.getLogger
@@ -56,6 +59,46 @@ def _getLogger(name='curtin'):
 if not logging.getLogger().handlers:
     logging.getLogger().addHandler(NullHandler())
 
+
+def _repr_call(name, *args, **kwargs):
+    return "%s(%s)" % (
+        name,
+        ', '.join([str(repr(a)) for a in args] +
+                  ["%s=%s" % (k, repr(v)) for k, v in kwargs.items()]))
+
+
+def log_call(func, *args, **kwargs):
+    return log_time(
+        "TIMED %s: " % _repr_call(func.__name__, *args, **kwargs),
+        func, *args, **kwargs)
+
+
+def log_time(msg, func, *args, **kwargs):
+    start = time.time()
+    try:
+        return func(*args, **kwargs)
+    finally:
+        LOG.debug(msg + "%.3f", (time.time() - start))
+
+
+def logged_call():
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            return log_call(func, *args, **kwargs)
+        return wrapper
+    return decorator
+
+
+def logged_time(msg):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            return log_time("TIMED %s: " % msg, func, *args, **kwargs)
+        return wrapper
+    return decorator
+
+
 LOG = _getLogger()
 
 # vi: ts=4 expandtab syntax=python
diff --git a/curtin/net/__init__.py b/curtin/net/__init__.py
index b4c9b59..ef2ba26 100644
--- a/curtin/net/__init__.py
+++ b/curtin/net/__init__.py
@@ -572,63 +572,4 @@ def get_interface_mac(ifname):
     return read_sys_net(ifname, "address", enoent=False)
 
 
-def network_config_required_packages(network_config, mapping=None):
-
-    if network_config is None:
-        network_config = {}
-
-    if not isinstance(network_config, dict):
-        raise ValueError('Invalid network configuration.  Must be a dict')
-
-    if mapping is None:
-        mapping = {}
-
-    if not isinstance(mapping, dict):
-        raise ValueError('Invalid network mapping.  Must be a dict')
-
-    # allow top-level 'network' key
-    if 'network' in network_config:
-        network_config = network_config.get('network')
-
-    # v1 has 'config' key and uses type: devtype elements
-    if 'config' in network_config:
-        dev_configs = set(device['type']
-                          for device in network_config['config'])
-    else:
-        # v2 has no config key
-        dev_configs = set(cfgtype for (cfgtype, cfg) in
-                          network_config.items() if cfgtype not in ['version'])
-
-    needed_packages = []
-    for dev_type in dev_configs:
-        if dev_type in mapping:
-            needed_packages.extend(mapping[dev_type])
-
-    return needed_packages
-
-
-def detect_required_packages_mapping():
-    """Return a dictionary providing a versioned configuration which maps
-       network configuration elements to the packages which are required
-       for functionality.
-    """
-    mapping = {
-        1: {
-            'handler': network_config_required_packages,
-            'mapping': {
-                'bond': ['ifenslave'],
-                'bridge': ['bridge-utils'],
-                'vlan': ['vlan']},
-        },
-        2: {
-            'handler': network_config_required_packages,
-            'mapping': {
-                'bonds': ['ifenslave'],
-                'bridges': ['bridge-utils'],
-                'vlans': ['vlan']}
-        },
-    }
-
-    return mapping
-
 # vi: ts=4 expandtab syntax=python
diff --git a/curtin/net/deps.py b/curtin/net/deps.py
new file mode 100644
index 0000000..b98961d
--- /dev/null
+++ b/curtin/net/deps.py
@@ -0,0 +1,72 @@
+# This file is part of curtin. See LICENSE file for copyright and license info.
+
+from curtin.distro import DISTROS
+
+
+def network_config_required_packages(network_config, mapping=None):
+
+    if network_config is None:
+        network_config = {}
+
+    if not isinstance(network_config, dict):
+        raise ValueError('Invalid network configuration.  Must be a dict')
+
+    if mapping is None:
+        mapping = {}
+
+    if not isinstance(mapping, dict):
+        raise ValueError('Invalid network mapping.  Must be a dict')
+
+    # allow top-level 'network' key
+    if 'network' in network_config:
+        network_config = network_config.get('network')
+
+    # v1 has 'config' key and uses type: devtype elements
+    if 'config' in network_config:
+        dev_configs = set(device['type']
+                          for device in network_config['config'])
+    else:
+        # v2 has no config key
+        dev_configs = set(cfgtype for (cfgtype, cfg) in
+                          network_config.items() if cfgtype not in ['version'])
+
+    needed_packages = []
+    for dev_type in dev_configs:
+        if dev_type in mapping:
+            needed_packages.extend(mapping[dev_type])
+
+    return needed_packages
+
+
+def detect_required_packages_mapping(osfamily=DISTROS.debian):
+    """Return a dictionary providing a versioned configuration which maps
+       network configuration elements to the packages which are required
+       for functionality.
+    """
+    # keys ending with 's' are v2 values
+    distro_mapping = {
+        DISTROS.debian: {
+            'bond': ['ifenslave'],
+            'bonds': [],
+            'bridge': ['bridge-utils'],
+            'bridges': [],
+            'vlan': ['vlan'],
+            'vlans': []},
+        DISTROS.redhat: {
+            'bond': [],
+            'bonds': [],
+            'bridge': [],
+            'bridges': [],
+            'vlan': [],
+            'vlans': []},
+    }
+    if osfamily not in distro_mapping:
+        raise ValueError('No net package mapping for distro: %s' % osfamily)
+
+    return {1: {'handler': network_config_required_packages,
+                'mapping': distro_mapping.get(osfamily)},
+            2: {'handler': network_config_required_packages,
+                'mapping': distro_mapping.get(osfamily)}}
+
+
+# vi: ts=4 expandtab syntax=python
diff --git a/curtin/paths.py b/curtin/paths.py
new file mode 100644
index 0000000..064b060
--- /dev/null
+++ b/curtin/paths.py
@@ -0,0 +1,34 @@
+# This file is part of curtin. See LICENSE file for copyright and license info.
+import os
+
+try:
+    string_types = (basestring,)
+except NameError:
+    string_types = (str,)
+
+
+def target_path(target, path=None):
+    # return 'path' inside target, accepting target as None
+    if target in (None, ""):
+        target = "/"
+    elif not isinstance(target, string_types):
+        raise ValueError("Unexpected input for target: %s" % target)
+    else:
+        target = os.path.abspath(target)
+        # abspath("//") returns "//" specifically for 2 slashes.
+        if target.startswith("//"):
+            target = target[1:]
+
+    if not path:
+        return target
+
+    if not isinstance(path, string_types):
+        raise ValueError("Unexpected input for path: %s" % path)
+
+    # os.path.join("/etc", "/foo") returns "/foo". Chomp all leading /.
+    while len(path) and path[0] == "/":
+        path = path[1:]
+
+    return os.path.join(target, path)
+
+# vi: ts=4 expandtab syntax=python
diff --git a/curtin/udev.py b/curtin/udev.py
index 92e38ff..13d9cc5 100644
--- a/curtin/udev.py
+++ b/curtin/udev.py
@@ -2,6 +2,7 @@
 
 import os
 from curtin import util
+from curtin.log import logged_call
 
 
 def compose_udev_equality(key, value):
@@ -40,6 +41,7 @@ def generate_udev_rule(interface, mac):
     return '%s\n' % rule
 
 
+@logged_call()
 def udevadm_settle(exists=None, timeout=None):
     settle_cmd = ["udevadm", "settle"]
     if exists:
diff --git a/curtin/url_helper.py b/curtin/url_helper.py
index d4d43a9..43c5c36 100644
--- a/curtin/url_helper.py
+++ b/curtin/url_helper.py
@@ -227,7 +227,7 @@ def geturl(url, headers=None, headers_cb=None, exception_cb=None,
         try:
             return _geturl(url=url, headers=headers, headers_cb=headers_cb,
                            exception_cb=exception_cb, data=data)
-        except _ReRaisedException as e:
+        except _ReRaisedException:
             raise curexc.exc
         except Exception as e:
             curexc = e
diff --git a/curtin/util.py b/curtin/util.py
index de0eb88..238d7c5 100644
--- a/curtin/util.py
+++ b/curtin/util.py
@@ -4,7 +4,6 @@ import argparse
 import collections
 from contextlib import contextmanager
 import errno
-import glob
 import json
 import os
 import platform
@@ -38,15 +37,16 @@ except NameError:
     # python3 does not have a long type.
     numeric_types = (int, float)
 
-from .log import LOG
+from . import paths
+from .log import LOG, log_call
 
 _INSTALLED_HELPERS_PATH = 'usr/lib/curtin/helpers'
 _INSTALLED_MAIN = 'usr/bin/curtin'
 
-_LSB_RELEASE = {}
 _USES_SYSTEMD = None
 _HAS_UNSHARE_PID = None
 
+
 _DNS_REDIRECT_IP = None
 
 # matcher used in template rendering functions
@@ -61,7 +61,7 @@ def _subp(args, data=None, rcs=None, env=None, capture=False,
         rcs = [0]
     devnull_fp = None
 
-    tpath = target_path(target)
+    tpath = paths.target_path(target)
     chroot_args = [] if tpath == "/" else ['chroot', target]
     sh_args = ['sh', '-c'] if shell else []
     if isinstance(args, string_types):
@@ -103,10 +103,11 @@ def _subp(args, data=None, rcs=None, env=None, capture=False,
         (out, err) = sp.communicate(data)
 
         # Just ensure blank instead of none.
-        if not out and capture:
-            out = b''
-        if not err and capture:
-            err = b''
+        if capture or combine_capture:
+            if not out:
+                out = b''
+            if not err:
+                err = b''
         if decode:
             def ldecode(data, m='utf-8'):
                 if not isinstance(data, bytes):
@@ -164,7 +165,7 @@ def _get_unshare_pid_args(unshare_pid=None, target=None, euid=None):
     if euid is None:
         euid = os.geteuid()
 
-    tpath = target_path(target)
+    tpath = paths.target_path(target)
 
     unshare_pid_in = unshare_pid
     if unshare_pid is None:
@@ -206,6 +207,8 @@ def subp(*args, **kwargs):
         boolean indicating if stderr should be redirected to stdout. When True,
         interleaved stderr and stdout will be returned as the first element of
         a tuple.
+        if combine_capture is True, then output is captured independent of
+        the value of capture.
     :param log_captured:
         boolean indicating if output should be logged on capture.  If
         True, then stderr and stdout will be logged at DEBUG level.  If
@@ -521,6 +524,8 @@ def do_umount(mountpoint, recursive=False):
 
 
 def ensure_dir(path, mode=None):
+    if path == "":
+        path = "."
     try:
         os.makedirs(path)
     except OSError as e:
@@ -590,7 +595,7 @@ def disable_daemons_in_root(target):
          'done',
          ''])
 
-    fpath = target_path(target, "/usr/sbin/policy-rc.d")
+    fpath = paths.target_path(target, "/usr/sbin/policy-rc.d")
 
     if os.path.isfile(fpath):
         return False
@@ -601,7 +606,7 @@ def disable_daemons_in_root(target):
 
 def undisable_daemons_in_root(target):
     try:
-        os.unlink(target_path(target, "/usr/sbin/policy-rc.d"))
+        os.unlink(paths.target_path(target, "/usr/sbin/policy-rc.d"))
     except OSError as e:
         if e.errno != errno.ENOENT:
             raise
@@ -613,7 +618,7 @@ class ChrootableTarget(object):
     def __init__(self, target, allow_daemons=False, sys_resolvconf=True):
         if target is None:
             target = "/"
-        self.target = target_path(target)
+        self.target = paths.target_path(target)
         self.mounts = ["/dev", "/proc", "/sys"]
         self.umounts = []
         self.disabled_daemons = False
@@ -623,14 +628,14 @@ class ChrootableTarget(object):
 
     def __enter__(self):
         for p in self.mounts:
-            tpath = target_path(self.target, p)
+            tpath = paths.target_path(self.target, p)
             if do_mount(p, tpath, opts='--bind'):
                 self.umounts.append(tpath)
 
         if not self.allow_daemons:
             self.disabled_daemons = disable_daemons_in_root(self.target)
 
-        rconf = target_path(self.target, "/etc/resolv.conf")
+        rconf = paths.target_path(self.target, "/etc/resolv.conf")
         target_etc = os.path.dirname(rconf)
         if self.target != "/" and os.path.isdir(target_etc):
             # never muck with resolv.conf on /
@@ -655,13 +660,13 @@ class ChrootableTarget(object):
             undisable_daemons_in_root(self.target)
 
         # if /dev is to be unmounted, udevadm settle (LP: #1462139)
-        if target_path(self.target, "/dev") in self.umounts:
-            subp(['udevadm', 'settle'])
+        if paths.target_path(self.target, "/dev") in self.umounts:
+            log_call(subp, ['udevadm', 'settle'])
 
         for p in reversed(self.umounts):
             do_umount(p)
 
-        rconf = target_path(self.target, "/etc/resolv.conf")
+        rconf = paths.target_path(self.target, "/etc/resolv.conf")
         if self.sys_resolvconf and self.rconf_d:
             os.rename(os.path.join(self.rconf_d, "resolv.conf"), rconf)
             shutil.rmtree(self.rconf_d)
@@ -671,7 +676,7 @@ class ChrootableTarget(object):
         return subp(*args, **kwargs)
 
     def path(self, path):
-        return target_path(self.target, path)
+        return paths.target_path(self.target, path)
 
 
 def is_exe(fpath):
@@ -680,29 +685,29 @@ def is_exe(fpath):
 
 
 def which(program, search=None, target=None):
-    target = target_path(target)
+    target = paths.target_path(target)
 
     if os.path.sep in program:
         # if program had a '/' in it, then do not search PATH
         # 'which' does consider cwd here. (cd / && which bin/ls) = bin/ls
         # so effectively we set cwd to / (or target)
-        if is_exe(target_path(target, program)):
+        if is_exe(paths.target_path(target, program)):
             return program
 
     if search is None:
-        paths = [p.strip('"') for p in
-                 os.environ.get("PATH", "").split(os.pathsep)]
+        candpaths = [p.strip('"') for p in
+                     os.environ.get("PATH", "").split(os.pathsep)]
         if target == "/":
-            search = paths
+            search = candpaths
         else:
-            search = [p for p in paths if p.startswith("/")]
+            search = [p for p in candpaths if p.startswith("/")]
 
     # normalize path input
     search = [os.path.abspath(p) for p in search]
 
     for path in search:
         ppath = os.path.sep.join((path, program))
-        if is_exe(target_path(target, ppath)):
+        if is_exe(paths.target_path(target, ppath)):
             return ppath
 
     return None
@@ -768,91 +773,6 @@ def get_architecture(target=None):
     return out.strip()
 
 
-def has_pkg_available(pkg, target=None):
-    out, _ = subp(['apt-cache', 'pkgnames'], capture=True, target=target)
-    for item in out.splitlines():
-        if pkg == item.strip():
-            return True
-    return False
-
-
-def get_installed_packages(target=None):
-    (out, _) = subp(['dpkg-query', '--list'], target=target, capture=True)
-
-    pkgs_inst = set()
-    for line in out.splitlines():
-        try:
-            (state, pkg, other) = line.split(None, 2)
-        except ValueError:
-            continue
-        if state.startswith("hi") or state.startswith("ii"):
-            pkgs_inst.add(re.sub(":.*", "", pkg))
-
-    return pkgs_inst
-
-
-def has_pkg_installed(pkg, target=None):
-    try:
-        out, _ = subp(['dpkg-query', '--show', '--showformat',
-                       '${db:Status-Abbrev}', pkg],
-                      capture=True, target=target)
-        return out.rstrip() == "ii"
-    except ProcessExecutionError:
-        return False
-
-
-def parse_dpkg_version(raw, name=None, semx=None):
-    """Parse a dpkg version string into various parts and calcualate a
-       numerical value of the version for use in comparing package versions
-
-       returns a dictionary with the results
-    """
-    if semx is None:
-        semx = (10000, 100, 1)
-
-    upstream = raw.split('-')[0]
-    toks = upstream.split(".", 2)
-    if len(toks) == 3:
-        major, minor, micro = toks
-    elif len(toks) == 2:
-        major, minor, micro = (toks[0], toks[1], 0)
-    elif len(toks) == 1:
-        major, minor, micro = (toks[0], 0, 0)
-
-    version = {
-        'major': major,
-        'minor': minor,
-        'micro': micro,
-        'raw': raw,
-        'upstream': upstream,
-    }
-    if name:
-        version['name'] = name
-
-    if semx:
-        try:
-            version['semantic_version'] = int(
-                int(major) * semx[0] + int(minor) * semx[1] +
-                int(micro) * semx[2])
-        except (ValueError, IndexError):
-            version['semantic_version'] = None
-
-    return version
-
-
-def get_package_version(pkg, target=None, semx=None):
-    """Use dpkg-query to extract package pkg's version string
-       and parse the version string into a dictionary
-    """
-    try:
-        out, _ = subp(['dpkg-query', '--show', '--showformat',
-                       '${Version}', pkg], capture=True, target=target)
-        raw = out.rstrip()
-        return parse_dpkg_version(raw, name=pkg, semx=semx)
-    except ProcessExecutionError:
-        return None
-
-
 def find_newer(src, files):
     mtime = os.stat(src).st_mtime
     return [f for f in files if
@@ -877,134 +797,6 @@ def set_unexecutable(fname, strict=False):
     return cur
 
 
-def apt_update(target=None, env=None, force=False, comment=None,
-               retries=None):
-
-    marker = "tmp/curtin.aptupdate"
-    if target is None:
-        target = "/"
-
-    if env is None:
-        env = os.environ.copy()
-
-    if retries is None:
-        # by default run apt-update up to 3 times to allow
-        # for transient failures
-        retries = (1, 2, 3)
-
-    if comment is None:
-        comment = "no comment provided"
-
-    if comment.endswith("\n"):
-        comment = comment[:-1]
-
-    marker = target_path(target, marker)
-    # if marker exists, check if there are files that would make it obsolete
-    listfiles = [target_path(target, "/etc/apt/sources.list")]
-    listfiles += glob.glob(
-        target_path(target, "etc/apt/sources.list.d/*.list"))
-
-    if os.path.exists(marker) and not force:
-        if len(find_newer(marker, listfiles)) == 0:
-            return
-
-    restore_perms = []
-
-    abs_tmpdir = tempfile.mkdtemp(dir=target_path(target, "/tmp"))
-    try:
-        abs_slist = abs_tmpdir + "/sources.list"
-        abs_slistd = abs_tmpdir + "/sources.list.d"
-        ch_tmpdir = "/tmp/" + os.path.basename(abs_tmpdir)
-        ch_slist = ch_tmpdir + "/sources.list"
-        ch_slistd = ch_tmpdir + "/sources.list.d"
-
-        # this file gets executed on apt-get update sometimes. (LP: #1527710)
-        motd_update = target_path(
-            target, "/usr/lib/update-notifier/update-motd-updates-available")
-        pmode = set_unexecutable(motd_update)
-        if pmode is not None:
-            restore_perms.append((motd_update, pmode),)
-
-        # create tmpdir/sources.list with all lines other than deb-src
-        # avoid apt complaining by using existing and empty dir for sourceparts
-        os.mkdir(abs_slistd)
-        with open(abs_slist, "w") as sfp:
-            for sfile in listfiles:
-                with open(sfile, "r") as fp:
-                    contents = fp.read()
-                for line in contents.splitlines():
-                    line = line.lstrip()
-                    if not line.startswith("deb-src"):
-                        sfp.write(line + "\n")
-
-        update_cmd = [
-            'apt-get', '--quiet',
-            '--option=Acquire::Languages=none',
-            '--option=Dir::Etc::sourcelist=%s' % ch_slist,
-            '--option=Dir::Etc::sourceparts=%s' % ch_slistd,
-            'update']
-
-        # do not using 'run_apt_command' so we can use 'retries' to subp
-        with ChrootableTarget(target, allow_daemons=True) as inchroot:
-            inchroot.subp(update_cmd, env=env, retries=retries)
-    finally:
-        for fname, perms in restore_perms:
-            os.chmod(fname, perms)
-        if abs_tmpdir:
-            shutil.rmtree(abs_tmpdir)
-
-    with open(marker, "w") as fp:
-        fp.write(comment + "\n")
-
-
-def run_apt_command(mode, args=None, aptopts=None, env=None, target=None,
-                    execute=True, allow_daemons=False):
-    opts = ['--quiet', '--assume-yes',
-            '--option=Dpkg::options::=--force-unsafe-io',
-            '--option=Dpkg::Options::=--force-confold']
-
-    if args is None:
-        args = []
-
-    if aptopts is None:
-        aptopts = []
-
-    if env is None:
-        env = os.environ.copy()
-        env['DEBIAN_FRONTEND'] = 'noninteractive'
-
-    if which('eatmydata', target=target):
-        emd = ['eatmydata']
-    else:
-        emd = []
-
-    cmd = emd + ['apt-get'] + opts + aptopts + [mode] + args
-    if not execute:
-        return env, cmd
-
-    apt_update(target, env=env, comment=' '.join(cmd))
-    with ChrootableTarget(target, allow_daemons=allow_daemons) as inchroot:
-        return inchroot.subp(cmd, env=env)
-
-
-def system_upgrade(aptopts=None, target=None, env=None, allow_daemons=False):
-    LOG.debug("Upgrading system in %s", target)
-    for mode in ('dist-upgrade', 'autoremove'):
-        ret = run_apt_command(
-            mode, aptopts=aptopts, target=target,
-            env=env, allow_daemons=allow_daemons)
-    return ret
-
-
-def install_packages(pkglist, aptopts=None, target=None, env=None,
-                     allow_daemons=False):
-    if isinstance(pkglist, str):
-        pkglist = [pkglist]
-    return run_apt_command(
-        'install', args=pkglist,
-        aptopts=aptopts, target=target, env=env, allow_daemons=allow_daemons)
-
-
 def is_uefi_bootable():
     return os.path.exists('/sys/firmware/efi') is True
 
@@ -1076,7 +868,7 @@ def run_hook_if_exists(target, hook):
     """
     Look for "hook" in "target" and run it
     """
-    target_hook = target_path(target, '/curtin/' + hook)
+    target_hook = paths.target_path(target, '/curtin/' + hook)
     if os.path.isfile(target_hook):
         LOG.debug("running %s" % target_hook)
         subp([target_hook])
@@ -1231,41 +1023,6 @@ def is_file_not_found_exc(exc):
             exc.errno in (errno.ENOENT, errno.EIO, errno.ENXIO))
 
 
-def _lsb_release(target=None):
-    fmap = {'Codename': 'codename', 'Description': 'description',
-            'Distributor ID': 'id', 'Release': 'release'}
-
-    data = {}
-    try:
-        out, _ = subp(['lsb_release', '--all'], capture=True, target=target)
-        for line in out.splitlines():
-            fname, _, val = line.partition(":")
-            if fname in fmap:
-                data[fmap[fname]] = val.strip()
-        missing = [k for k in fmap.values() if k not in data]
-        if len(missing):
-            LOG.warn("Missing fields in lsb_release --all output: %s",
-                     ','.join(missing))
-
-    except ProcessExecutionError as err:
-        LOG.warn("Unable to get lsb_release --all: %s", err)
-        data = {v: "UNAVAILABLE" for v in fmap.values()}
-
-    return data
-
-
-def lsb_release(target=None):
-    if target_path(target) != "/":
-        # do not use or update cache if target is provided
-        return _lsb_release(target)
-
-    global _LSB_RELEASE
-    if not _LSB_RELEASE:
-        data = _lsb_release()
-        _LSB_RELEASE.update(data)
-    return _LSB_RELEASE
-
-
 class MergedCmdAppend(argparse.Action):
     """This appends to a list in order of appearence both the option string
        and the value"""
@@ -1400,31 +1157,6 @@ def is_resolvable_url(url):
     return is_resolvable(urlparse(url).hostname)
 
 
-def target_path(target, path=None):
-    # return 'path' inside target, accepting target as None
-    if target in (None, ""):
-        target = "/"
-    elif not isinstance(target, string_types):
-        raise ValueError("Unexpected input for target: %s" % target)
-    else:
-        target = os.path.abspath(target)
-        # abspath("//") returns "//" specifically for 2 slashes.
-        if target.startswith("//"):
-            target = target[1:]
-
-    if not path:
-        return target
-
-    if not isinstance(path, string_types):
-        raise ValueError("Unexpected input for path: %s" % path)
-
-    # os.path.join("/etc", "/foo") returns "/foo". Chomp all leading /.
-    while len(path) and path[0] == "/":
-        path = path[1:]
-
-    return os.path.join(target, path)
-
-
 class RunInChroot(ChrootableTarget):
     """Backwards compatibility for RunInChroot (LP: #1617375).
     It needs to work like:
diff --git a/debian/changelog b/debian/changelog
index eccc322..10e5fbd 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,48 @@
+curtin (18.1-56-g3aafe77d-0ubuntu1~16.04.1) xenial-proposed; urgency=medium
+
+  * New upstream snapshot. (LP: #1795712)
+    - vmtest: Fix typo in skip-by-date.
+    - vmtest: kick skip-by-date for 1671951.
+    - tools/jenkins-runner: Error if both filters and tests are given.
+    - vmtests: prevent tests from modifying cls.collect_scripts
+    - Enable custom storage configuration for centos images
+    - vmtest: ensure we collect /var/log/journal only once
+    - Don't allow reads of /proc and modprobe zfs through
+    - clear-holders: handle missing zpool/zfs tools when wiping
+    - clear-holders: rescan for lvm devices after assembling raid arrays
+    - vmtest: enable persistent journal and collect at boot time
+    - Add timing and logging functions.
+    - parse_dpkg_version: support non-numeric in version string.
+    - Add main so that 'python3 -m curtin' does the right thing.
+    - Add subcommand 'features'.
+    - block: use uuid4 (random) when autogenerating UUIDS for filesystems
+    - vmtests: Increase size of root filesystems.
+    - clear-holders: reread ptable after wiping disks with partitions
+    - vmtest: Skip proposed pocket on dev release when 'proposed' in ADD_REPOS.
+    - tests: remove Ubuntu Artful [Joshua Powers]
+    - vmtests: Let a raised SkipTest go through skip_by_date.
+    - vmtests: Increase root fs to give upgrades to -proposed more space.
+    - vmtest: Order the vmtest_pollinate late_command earlier.
+    - vmtest: always add 'curtin/vmtest' to installed pollinate user_agent.
+    - vmtests: make skip_by_date a decorator that runs and reports.
+    - vmtests: always declare certain attributes and remove redundant tests.
+    - vmtests: Add Cosmic release to tests [Joshua Powers]
+    - vmtests: skip TrustyTestMdadmBcache until 2019-01-22.
+    - tox: use simplestreams from git repository rather than bzr.
+    - document that you can set ptable on raids [Michael Hudson-Doyle]
+    - vmtests: move skip-by date of xfs root and xfs boot out 1 year.
+    - vmtests: network_mtu move fixby date out 4 months from last value
+    - Fix WorkingDir class to support already existing target directory.
+    - Fix extraction of local filesystem image.
+    - Fix tip-pyflakes imported but unused call to util.get_platform_arch
+    - subp: update return value of subp with combine_capture=True.
+    - tox: add a xenial environments, default envlist changes.
+    - tests: Fix race on utcnow during timestamped curtin-log dir creation
+    - curtainer: patch source version from --source.
+    - pyflakes: fix unused variable references identified by pyflakes 2.0.0.
+
+ -- Chad Smith <[e-mail]>  Tue, 02 Oct 2018 16:47:10 -0600
+
 curtin (18.1-17-gae48e86f-0ubuntu1~16.04.1) xenial; urgency=medium
 
   * New upstream snapshot. (LP: #1772044)
diff --git a/doc/topics/config.rst b/doc/topics/config.rst
index 76e520d..218bc17 100644
--- a/doc/topics/config.rst
+++ b/doc/topics/config.rst
@@ -14,6 +14,7 @@ Curtin's top level config keys are as follows:
 - apt_mirrors (``apt_mirrors``)
 - apt_proxy (``apt_proxy``)
 - block-meta (``block``)
+- curthooks (``curthooks``)
 - debconf_selections (``debconf_selections``)
 - disable_overlayroot (``disable_overlayroot``)
 - grub (``grub``)
@@ -110,6 +111,45 @@ Specify the filesystem label on the boot partition.
           label: my-boot-partition
 
 
+curthooks
+~~~~~~~~~
+Configure how Curtin determines what :ref:`curthooks` to run during the installation
+process.
+
+**mode**: *<['auto', 'builtin', 'target']>*
+
+The default mode is ``auto``.
+
+In ``auto`` mode, curtin will execute curthooks within the image if present.
+For images without curthooks inside, curtin will execute its built-in hooks.
+
+Currently the built-in curthooks support the following OS families:
+
+- Ubuntu
+- Centos
+
+When specifying ``builtin``, curtin will only run the curthooks present in
+Curtin ignoring any curthooks that may be present in the target operating
+system.
+
+When specifying ``target``, curtin will attempt run the curthooks in the target
+operating system.  If the target does NOT contain any curthooks, then the
+built-in curthooks will be run instead.
+
+Any errors during execution of curthooks (built-in or target) will fail the
+installation.
+
+**Example**::
+
+  # ignore any target curthooks
+  curthooks:
+    mode: builtin
+
+  # Only run target curthooks, fall back to built-in
+  curthooks:
+    mode: target
+
+
 debconf_selections
 ~~~~~~~~~~~~~~~~~~
 Curtin will update the target with debconf set-selection values.  Users will
diff --git a/doc/topics/curthooks.rst b/doc/topics/curthooks.rst
index e5f341b..c59aeaf 100644
--- a/doc/topics/curthooks.rst
+++ b/doc/topics/curthooks.rst
@@ -1,7 +1,13 @@
+.. _curthooks:
+
 ========================================
-Curthooks / New OS Support 
+Curthooks / New OS Support
 ========================================
-Curtin has built-in support for installation of Ubuntu.
+Curtin has built-in support for installation of:
+
+ - Ubuntu
+ - Centos
+
 Other operating systems are supported through a mechanism called
 'curthooks' or 'curtin-hooks'.
 
@@ -47,11 +53,21 @@ details.  Specifically interesting to this stage are:
  - ``CONFIG``: This is a path to the curtin config file.  It is provided so
    that additional configuration could be provided through to the OS
    customization.
+ - ``WORKING_DIR``: This is a path to a temporary directory where curtin
+   stores state and configuration files.
 
 .. **TODO**: We should add 'PYTHON' or 'CURTIN_PYTHON' to this environment
    so that the hook can easily run a python program with the same python
    that curtin ran with (ie, python2 or python3).
 
+Running built-in hooks
+----------------------
+
+Curthooks may opt to run the built-in curthooks that are already provided in
+curtin itself.  To do so, an in-image curthook can import the ``curthooks``
+module and invoke the ``builtin_curthooks`` function passing in the required
+parameters: config, target, and state.
+
 
 Networking configuration
 ------------------------
diff --git a/doc/topics/integration-testing.rst b/doc/topics/integration-testing.rst
index 7753068..6093b55 100644
--- a/doc/topics/integration-testing.rst
+++ b/doc/topics/integration-testing.rst
@@ -314,6 +314,10 @@ Some environment variables affect the running of vmtest
    setting (auto), then a upgrade will be done to make sure to include
    any new packages.
 
+   The string 'proposed' is handled specially.  It will enable the
+   Ubuntu -proposed pocket for non-devel releases.  If you wish to test
+   the -proposed pocket for a devel release, use 'PROPOSED'.
+
 - ``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
diff --git a/doc/topics/storage.rst b/doc/topics/storage.rst
index ca6253c..b28964b 100644
--- a/doc/topics/storage.rst
+++ b/doc/topics/storage.rst
@@ -60,9 +60,9 @@ table. A disk command may contain all or some of the following keys:
 
 **ptable**: *msdos, gpt*
 
-If the ``ptable`` key is present and a valid type of partition table, curtin
-will create an empty partition table of that type on the disk.  At the moment,
-msdos and gpt partition tables are supported.
+If the ``ptable`` key is present and a curtin will create an empty
+partition table of that type on the disk.  Curtin supports msdos and
+gpt partition tables.
 
 **serial**: *<serial number>*
 
@@ -613,6 +613,11 @@ The ``spare_devices`` key specifies a list of the devices that will be used for
 spares in the raid array. Each device must be referenced by ``id`` and the
 device must be previously defined in the storage configuration.  May be empty.
 
+**ptable**: *msdos, gpt*
+
+To partition the array rather than mounting it directly, the
+``ptable`` key must be present and a valid type of partition table,
+i.e. msdos or gpt.
 
 **Config Example**::
 
@@ -801,6 +806,7 @@ Learn by examples.
 - LVM
 - Bcache
 - RAID Boot
+- Partitioned RAID
 - RAID5 + Bcache
 - ZFS Root Simple
 - ZFS Root
@@ -1045,6 +1051,76 @@ RAID Boot
          path: /
          device: md_root
 
+Partitioned RAID
+~~~~~~~~~~~~~~~~
+
+::
+
+  storage:
+    config:
+    - type: disk
+      id: disk-0
+      ptable: gpt
+      path: /dev/vda
+      wipe: superblock
+      grub_device: true
+    - type: disk
+      id: disk-1
+      path: /dev/vdb
+      wipe: superblock
+    - type: disk
+      id: disk-2
+      path: /dev/vdc
+      wipe: superblock
+    - type: partition
+      id: part-0
+      device: disk-0
+      size: 1048576
+      flag: bios_grub
+    - type: partition
+      id: part-1
+      device: disk-0
+      size: 21471690752
+    - id: raid-0
+      type: raid
+      name: md0
+      raidlevel: 1
+      devices: [disk-2, disk-1]
+      ptable: gpt
+    - type: partition
+      id: part-2
+      device: raid-0
+      size: 10737418240
+    - type: partition
+      id: part-3
+      device: raid-0
+      size: 10735321088,
+    - type: format
+      id: fs-0
+      fstype: ext4
+      volume: part-1
+    - type: format
+      id: fs-1
+      fstype: xfs
+      volume: part-2
+    - type: format
+      id: fs-2
+      fstype: ext4
+      volume: part-3
+    - type: mount
+      id: mount-0
+      device: fs-0
+      path: /
+    - type: mount
+      id: mount-1
+      device: fs-1
+      path: /srv
+    - type: mount
+      id: mount-2
+      device: fs-2
+      path: /home
+    version: 1
+
 
 RAID5 + Bcache
 ~~~~~~~~~~~~~~
diff --git a/examples/tests/dirty_disks_config.yaml b/examples/tests/dirty_disks_config.yaml
index 75d44c3..fb9a0d6 100644
--- a/examples/tests/dirty_disks_config.yaml
+++ b/examples/tests/dirty_disks_config.yaml
@@ -27,6 +27,31 @@ bucket:
       # disable any rpools to trigger disks with zfs_member label but inactive
       # pools
       zpool export rpool ||:
+  - &lvm_stop |
+      #!/bin/sh
+      # This function disables any existing lvm logical volumes that
+      # have been created during the early storage config stage
+      # and simulates the effect of booting into a system with existing
+      # (but inactive) lvm configuration.
+      for vg in `pvdisplay -C --separator = -o vg_name --noheadings`; do
+         vgchange -an $vg ||:
+      done
+      # disable the automatic pvscan, we want to test that curtin
+      # can find/enable logical volumes without this service
+      command -v systemctl && systemctl mask lvm2-pvscan\@.service
+      # remove any existing metadata written from early disk config
+      rm -rf /etc/lvm/archive /etc/lvm/backup
+  - &mdadm_stop  |
+      #!/bin/sh
+      # This function disables any existing raid devices which may
+      # have been created during the early storage config stage
+      # and simulates the effect of booting into a system with existing
+      # but inactive mdadm configuration.
+      for md in /dev/md*; do
+          mdadm --stop $md ||:
+      done
+      # remove any existing metadata written from early disk config
+      rm -f /etc/mdadm/mdadm.conf
 
 early_commands:
   # running block-meta custom from the install environment
@@ -34,9 +59,11 @@ early_commands:
   # the disks exactly as in this config before the rest of the install
   # will just blow it all away.  We have clean out other environment
   # that could unintentionally mess things up.
-  blockmeta: [env, -u, OUTPUT_FSTAB,
+  01-blockmeta: [env, -u, OUTPUT_FSTAB,
               TARGET_MOUNT_POINT=/tmp/my.bdir/target,
               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]
+  02-enable_swaps: [sh, -c, *swapon]
+  03-disable_rpool: [sh, -c, *zpool_export]
+  04-lvm_stop: [sh, -c, *lvm_stop]
+  05-mdadm_stop: [sh, -c, *mdadm_stop]
diff --git a/examples/tests/filesystem_battery.yaml b/examples/tests/filesystem_battery.yaml
index 3b1edbf..4eae5b6 100644
--- a/examples/tests/filesystem_battery.yaml
+++ b/examples/tests/filesystem_battery.yaml
@@ -113,8 +113,8 @@ storage:
     - id: bind1
       fstype: "none"
       options: "bind"
-      path: "/var/lib"
-      spec: "/my/bind-over-var-lib"
+      path: "/var/cache"
+      spec: "/my/bind-over-var-cache"
       type: mount
     - id: bind2
       fstype: "none"
diff --git a/examples/tests/install_disable_unmount.yaml b/examples/tests/install_disable_unmount.yaml
index d3e583f..c0cd759 100644
--- a/examples/tests/install_disable_unmount.yaml
+++ b/examples/tests/install_disable_unmount.yaml
@@ -14,5 +14,5 @@ post_cmds:
 late_commands:
   01_get_proc_mounts: [sh, -c, *cat_proc_mounts]
   02_write_out_target: [sh, -c, *echo_target_mp]
-  03_unmount_target: [curtin, unmount]
-  04_get_proc_mounts: [cat, /proc/mounts]
+  99a_unmount_target: [curtin, unmount]
+  99b_get_proc_mounts: [cat, /proc/mounts]
diff --git a/examples/tests/lvmoverraid.yaml b/examples/tests/lvmoverraid.yaml
new file mode 100644
index 0000000..a1d41e9
--- /dev/null
+++ b/examples/tests/lvmoverraid.yaml
@@ -0,0 +1,98 @@
+storage:
+    config:
+    -   grub_device: true
+        id: disk-0
+        model: QEMU_HARDDISK
+        name: 'main_disk'
+        serial: disk-a
+        preserve: false
+        ptable: gpt
+        type: disk
+        wipe: superblock
+    -   grub_device: false
+        id: disk-2
+        name: 'disk-2'
+        serial: disk-b
+        preserve: false
+        type: disk
+        wipe: superblock
+    -   grub_device: false
+        id: disk-1
+        name: 'disk-1'
+        serial: disk-c
+        preserve: false
+        type: disk
+        wipe: superblock
+    -   grub_device: false
+        id: disk-3
+        name: 'disk-3'
+        serial: disk-d
+        preserve: false
+        type: disk
+        wipe: superblock
+    -   grub_device: false
+        id: disk-4
+        name: 'disk-4'
+        serial: disk-e
+        preserve: false
+        type: disk
+        wipe: superblock
+    -   device: disk-0
+        flag: bios_grub
+        id: part-0
+        preserve: false
+        size: 1048576
+        type: partition
+    -   device: disk-0
+        flag: ''
+        id: part-1
+        preserve: false
+        size: 4G
+        type: partition
+    -   devices:
+        - disk-2
+        - disk-1
+        id: raid-0
+        name: md0
+        raidlevel: 1
+        spare_devices: []
+        type: raid
+    -   devices:
+        - disk-3
+        - disk-4
+        id: raid-1
+        name: md1
+        raidlevel: 1
+        spare_devices: []
+        type: raid
+    -   devices:
+        - raid-0
+        - raid-1
+        id: vg-0
+        name: vg0
+        type: lvm_volgroup
+    -   id: lv-0
+        name: lv-0
+        size: 3G
+        type: lvm_partition
+        volgroup: vg-0
+    -   fstype: ext4
+        id: fs-0
+        preserve: false
+        type: format
+        volume: part-1
+    -   fstype: ext4
+        id: fs-1
+        preserve: false
+        type: format
+        volume: lv-0
+    -   device: fs-0
+        id: mount-0
+        path: /
+        type: mount
+    -   device: fs-1
+        id: mount-1
+        path: /home
+        type: mount
+    version: 1
+
diff --git a/examples/tests/mirrorboot-msdos-partition.yaml b/examples/tests/mirrorboot-msdos-partition.yaml
index 1a418fa..2b111a7 100644
--- a/examples/tests/mirrorboot-msdos-partition.yaml
+++ b/examples/tests/mirrorboot-msdos-partition.yaml
@@ -47,7 +47,7 @@ storage:
        name: md0-part1
        number: 1
        offset: 4194304B
-       size: 2GB
+       size: 3GB
        type: partition
        uuid: 4f4fa336-2762-48e4-ae54-9451141665cd
        wipe: superblock
@@ -55,7 +55,7 @@ storage:
        id: md0-part2
        name: md0-part2
        number: 2
-       size: 2GB
+       size: 1.5GB
        type: partition
        uuid: c2d21fd3-3cde-4432-8eab-f08594bbe76e
        wipe: superblock
diff --git a/examples/tests/mirrorboot-uefi.yaml b/examples/tests/mirrorboot-uefi.yaml
index e1f393f..ca55be9 100644
--- a/examples/tests/mirrorboot-uefi.yaml
+++ b/examples/tests/mirrorboot-uefi.yaml
@@ -30,7 +30,7 @@ storage:
     id: sda-part2
     name: sda-part2
     number: 2
-    size: 2G
+    size: 3G
     type: partition
     uuid: 47c97eae-f35d-473f-8f3d-d64161d571f1
     wipe: superblock
@@ -38,7 +38,7 @@ storage:
     id: sda-part3
     name: sda-part3
     number: 3
-    size: 2G
+    size: 1G
     type: partition
     uuid: e3202633-841c-4936-a520-b18d1f7938ea
     wipe: superblock
@@ -56,7 +56,7 @@ storage:
     id: sdb-part2
     name: sdb-part2
     number: 2
-    size: 2G
+    size: 3G
     type: partition
     uuid: a33a83dd-d1bf-4940-bf3e-6d931de85dbc
     wipe: superblock
@@ -72,7 +72,7 @@ storage:
     id: sdb-part3
     name: sdb-part3
     number: 3
-    size: 2G
+    size: 1G
     type: partition
     uuid: 27e29758-fdcf-4c6a-8578-c92f907a8a9d
     wipe: superblock
diff --git a/examples/tests/vmtest_defaults.yaml b/examples/tests/vmtest_defaults.yaml
new file mode 100644
index 0000000..b1512a8
--- /dev/null
+++ b/examples/tests/vmtest_defaults.yaml
@@ -0,0 +1,24 @@
+# this updates pollinate in the installed target to add a vmtest identifier.
+# specifically pollinate's user-agent should contain 'curtin/vmtest'.
+_vmtest_pollinate:
+ - &pvmtest |
+   cfg="/etc/pollinate/add-user-agent"
+   [ -d "${cfg%/*}" ] || exit 0
+   echo curtin/vmtest >> "$cfg"
+
+# this enables a persitent journald if target system has journald
+# and does not have /var/log/journal directory already
+_persist_journal:
+ - &persist_journal |
+   command -v journalctl && {
+       jdir=/var/log/journal
+       [ -e ${jdir} ] || {
+           mkdir -p ${jdir}
+           systemd-tmpfiles --create --prefix ${jdir}
+       }
+    }
+    exit 0
+
+late_commands:
+  01_vmtest_pollinate: ['curtin', 'in-target', '--', 'sh', '-c', *pvmtest]
+  02_persist_journal: ['curtin', 'in-target', '--', 'sh', '-c', *persist_journal]
diff --git a/helpers/common b/helpers/common
index ac2d0f3..f9217b7 100644
--- a/helpers/common
+++ b/helpers/common
@@ -541,18 +541,18 @@ get_carryover_params() {
 }
 
 install_grub() {
-    local long_opts="uefi,update-nvram"
+    local long_opts="uefi,update-nvram,os-family:"
     local getopt_out="" mp_efi=""
     getopt_out=$(getopt --name "${0##*/}" \
         --options "" --long "${long_opts}" -- "$@") &&
         eval set -- "${getopt_out}"
 
-    local uefi=0
-    local update_nvram=0
+    local uefi=0 update_nvram=0 os_family=""
 
     while [ $# -ne 0 ]; do
         cur="$1"; next="$2";
         case "$cur" in
+            --os-family) os_family=${next};;
             --uefi) uefi=$((${uefi}+1));;
             --update-nvram) update_nvram=$((${update_nvram}+1));;
             --) shift; break;;
@@ -595,29 +595,88 @@ install_grub() {
         error "$mp_dev ($fstype) is not a block device!"; return 1;
     fi
 
-    # get dpkg arch
-    local dpkg_arch=""
-    dpkg_arch=$(chroot "$mp" dpkg --print-architecture)
-    r=$?
+    local os_variant=""
+    if [ -e "${mp}/etc/os-release" ]; then
+        os_variant=$(chroot "$mp" \
+                     /bin/sh -c 'echo $(. /etc/os-release; echo $ID)')
+    else
+        # Centos6 doesn't have os-release, so check for centos/redhat release
+        # looks like: CentOS release 6.9 (Final)
+        for rel in $(ls ${mp}/etc/*-release); do
+            os_variant=$(awk '{print tolower($1)}' $rel)
+            [ -n "$os_variant" ] && break
+        done
+    fi
+    [ $? != 0 ] &&
+        { error "Failed to read ID from $mp/etc/os-release"; return 1; }
+
+    local rhel_ver=""
+    case $os_variant in
+        debian|ubuntu) os_family="debian";;
+        centos|rhel)
+            os_family="redhat"
+            rhel_ver=$(chroot "$mp" rpm -E '%rhel')
+        ;;
+    esac
+
+    # ensure we have both settings, family and variant are needed
+    [ -n "${os_variant}" -a -n "${os_family}" ] ||
+        { error "Failed to determine os variant and family"; return 1; }
+
+    # get target arch
+    local target_arch="" r="1"
+    case $os_family in
+        debian)
+            target_arch=$(chroot "$mp" dpkg --print-architecture)
+            r=$?
+            ;;
+        redhat)
+            target_arch=$(chroot "$mp" rpm -E '%_arch')
+            r=$?
+            ;;
+    esac
     [ $r -eq 0 ] || {
-        error "failed to get dpkg architecture [$r]"
+        error "failed to get target architecture [$r]"
         return 1;
     }
 
     # grub is not the bootloader you are looking for
-    if [ "${dpkg_arch}" = "s390x" ]; then
-	return 0;
+    if [ "${target_arch}" = "s390x" ]; then
+	    return 0;
     fi
 
     # set correct grub package
-    local grub_name="grub-pc"
-    local grub_target="i386-pc"
-    if [ "${dpkg_arch#ppc64}" != "${dpkg_arch}" ]; then
+    local grub_name=""
+    local grub_target=""
+    case "$target_arch" in
+        i386|amd64)
+            # debian
+            grub_name="grub-pc"
+            grub_target="i386-pc"
+            ;;
+        x86_64)
+            case $rhel_ver in
+               6) grub_name="grub";;
+               7) grub_name="grub2-pc";;
+               *)
+                   error "Unknown rhel_ver [$rhel_ver]";
+                   return 1;
+               ;;
+            esac
+            grub_target="i386-pc"
+            ;;
+    esac
+    if [ "${target_arch#ppc64}" != "${target_arch}" ]; then
         grub_name="grub-ieee1275"
         grub_target="powerpc-ieee1275"
     elif [ "$uefi" -ge 1 ]; then
-        grub_name="grub-efi-$dpkg_arch"
-        case "$dpkg_arch" in
+        grub_name="grub-efi-$target_arch"
+        case "$target_arch" in
+            x86_64)
+                # centos 7+, no centos6 support
+                grub_name="grub2-efi-x64-modules"
+                grub_target="x86_64-efi"
+                ;;
             amd64)
                 grub_target="x86_64-efi";;
             arm64)
@@ -626,9 +685,19 @@ install_grub() {
     fi
 
     # check that the grub package is installed
-    tmp=$(chroot "$mp" dpkg-query --show \
-        --showformat='${Status}\n' $grub_name)
-    r=$?
+    local r=$?
+    case $os_family in
+        debian)
+            tmp=$(chroot "$mp" dpkg-query --show \
+                --showformat='${Status}\n' $grub_name)
+            r=$?
+            ;;
+        redhat)
+            tmp=$(chroot "$mp" rpm -q \
+                --queryformat='install ok installed\n' $grub_name)
+            r=$?
+            ;;
+    esac
     if [ $r -ne 0 -a $r -ne 1 ]; then
         error "failed to check if $grub_name installed";
         return 1;
@@ -636,11 +705,16 @@ install_grub() {
     case "$tmp" in
         install\ ok\ installed) :;;
         *) debug 1 "$grub_name not installed, not doing anything";
-            return 0;;
+            return 1;;
     esac
 
     local grub_d="etc/default/grub.d"
     local mygrub_cfg="$grub_d/50-curtin-settings.cfg"
+    case $os_family in
+        redhat)
+            grub_d="etc/default"
+            mygrub_cfg="etc/default/grub";;
+    esac
     [ -d "$mp/$grub_d" ] || mkdir -p "$mp/$grub_d" ||
         { error "Failed to create $grub_d"; return 1; }
 
@@ -659,14 +733,23 @@ install_grub() {
         error "Failed to get carryover parrameters from cmdline"; 
         return 1;
     }
+    # always append rd.auto=1 for centos
+    case $os_family in
+        redhat)
+            newargs="$newargs rd.auto=1";;
+    esac
     debug 1 "carryover command line params: $newargs"
 
-    : > "$mp/$mygrub_cfg" ||
-        { error "Failed to write '$mygrub_cfg'"; return 1; }
+    case $os_family in
+       debian)
+        : > "$mp/$mygrub_cfg" ||
+            { error "Failed to write '$mygrub_cfg'"; return 1; }
+        ;;
+    esac
     {
         [ "${REPLACE_GRUB_LINUX_DEFAULT:-1}" = "0" ] ||
             echo "GRUB_CMDLINE_LINUX_DEFAULT=\"$newargs\""
-        echo "# disable grub os prober that might find other OS installs."
+        echo "# Curtin disable grub os prober that might find other OS installs."
         echo "GRUB_DISABLE_OS_PROBER=true"
         echo "GRUB_TERMINAL=console"
     } >> "$mp/$mygrub_cfg"
@@ -692,30 +775,46 @@ install_grub() {
         nvram="--no-nvram"
         if [ "$update_nvram" -ge 1 ]; then
             nvram=""
-        fi    
+        fi
         debug 1 "curtin uefi: installing ${grub_name} to: /boot/efi"
         chroot "$mp" env DEBIAN_FRONTEND=noninteractive sh -exc '
             echo "before grub-install efiboot settings"
-            efibootmgr || echo "WARN: efibootmgr exited $?"
-            dpkg-reconfigure "$1"
-            update-grub
+            efibootmgr -v || echo "WARN: efibootmgr exited $?"
+            bootid="$4"
+            grubpost=""
+            case $bootid in
+                debian|ubuntu)
+                    grubcmd="grub-install"
+                    dpkg-reconfigure "$1"
+                    update-grub
+                    ;;
+                centos|redhat|rhel)
+                    grubcmd="grub2-install"
+                    grubpost="grub2-mkconfig -o /boot/grub2/grub.cfg"
+                    ;;
+                *)
+                    echo "Unsupported OS: $bootid" 1>&2
+                    exit 1
+                    ;;
+            esac
             # grub-install in 12.04 does not contain --no-nvram, --target,
             # or --efi-directory
             target="--target=$2"
             no_nvram="$3"
             efi_dir="--efi-directory=/boot/efi"
-            gi_out=$(grub-install --help 2>&1)
+            gi_out=$($grubcmd --help 2>&1)
             echo "$gi_out" | grep -q -- "$no_nvram" || no_nvram=""
             echo "$gi_out" | grep -q -- "--target" || target=""
             echo "$gi_out" | grep -q -- "--efi-directory" || efi_dir=""
-            grub-install $target $efi_dir \
-                --bootloader-id=ubuntu --recheck $no_nvram' -- \
-            "${grub_name}" "${grub_target}" "$nvram" </dev/null ||
+            $grubcmd $target $efi_dir \
+                --bootloader-id=$bootid --recheck $no_nvram
+            [ -z "$grubpost" ] || $grubpost;' \
+            -- "${grub_name}" "${grub_target}" "$nvram" "$os_variant" </dev/null ||
             { error "failed to install grub!"; return 1; }
 
         chroot "$mp" sh -exc '
             echo "after grub-install efiboot settings"
-            efibootmgr || echo "WARN: efibootmgr exited $?"
+            efibootmgr -v || echo "WARN: efibootmgr exited $?"
             ' -- </dev/null ||
             { error "failed to list efi boot entries!"; return 1; }
     else
@@ -728,10 +827,32 @@ install_grub() {
         debug 1 "curtin non-uefi: installing ${grub_name} to: ${grubdevs[*]}"
         chroot "$mp" env DEBIAN_FRONTEND=noninteractive sh -exc '
             pkg=$1; shift;
-            dpkg-reconfigure "$pkg"
-            update-grub
-            for d in "$@"; do grub-install "$d" || exit; done' \
-            -- "${grub_name}" "${grubdevs[@]}" </dev/null ||
+            bootid=$1; shift;
+            bootver=$1; shift;
+            grubpost=""
+            case $bootid in
+                debian|ubuntu)
+                    grubcmd="grub-install"
+                    dpkg-reconfigure "$pkg"
+                    update-grub
+                    ;;
+                centos|redhat|rhel)
+                    case $bootver in
+                        6) grubcmd="grub-install";;
+                        7) grubcmd="grub2-install"
+                           grubpost="grub2-mkconfig -o /boot/grub2/grub.cfg";;
+                    esac
+                    ;;
+                *)
+                    echo "Unsupported OS: $bootid"; 1>&2
+                    exit 1
+                    ;;
+            esac
+            for d in "$@"; do
+                echo $grubcmd "$d";
+                $grubcmd "$d" || exit; done
+            [ -z "$grubpost" ] || $grubpost;' \
+            -- "${grub_name}" "${os_variant}" "${rhel_ver}" "${grubdevs[@]}" </dev/null ||
             { error "failed to install grub!"; return 1; }
     fi
 
diff --git a/tests/unittests/test_apt_custom_sources_list.py b/tests/unittests/test_apt_custom_sources_list.py
index 5567dd5..a427ae9 100644
--- a/tests/unittests/test_apt_custom_sources_list.py
+++ b/tests/unittests/test_apt_custom_sources_list.py
@@ -11,6 +11,8 @@ from mock import call
 import textwrap
 import yaml
 
+from curtin import distro
+from curtin import paths
 from curtin import util
 from curtin.commands import apt_config
 from .helpers import CiTestCase
@@ -106,7 +108,7 @@ class TestAptSourceConfigSourceList(CiTestCase):
                     # make test independent to executing system
                     with mock.patch.object(util, 'load_file',
                                            return_value=MOCKED_APT_SRC_LIST):
-                        with mock.patch.object(util, 'lsb_release',
+                        with mock.patch.object(distro, 'lsb_release',
                                                return_value={'codename':
                                                              'fakerel'}):
                             apt_config.handle_apt(cfg, TARGET)
@@ -115,10 +117,10 @@ class TestAptSourceConfigSourceList(CiTestCase):
 
         cloudfile = '/etc/cloud/cloud.cfg.d/curtin-preserve-sources.cfg'
         cloudconf = yaml.dump({'apt_preserve_sources_list': True}, indent=1)
-        calls = [call(util.target_path(TARGET, '/etc/apt/sources.list'),
+        calls = [call(paths.target_path(TARGET, '/etc/apt/sources.list'),
                       expected,
                       mode=0o644),
-                 call(util.target_path(TARGET, cloudfile),
+                 call(paths.target_path(TARGET, cloudfile),
                       cloudconf,
                       mode=0o644)]
         mockwrite.assert_has_calls(calls)
@@ -147,19 +149,19 @@ class TestAptSourceConfigSourceList(CiTestCase):
         arch = util.get_architecture()
         # would fail inside the unittest context
         with mock.patch.object(util, 'get_architecture', return_value=arch):
-            with mock.patch.object(util, 'lsb_release',
+            with mock.patch.object(distro, 'lsb_release',
                                    return_value={'codename': 'fakerel'}):
                 apt_config.handle_apt(cfg, target)
 
         self.assertEqual(
             EXPECTED_CONVERTED_CONTENT,
-            util.load_file(util.target_path(target, "/etc/apt/sources.list")))
-        cloudfile = util.target_path(
+            util.load_file(paths.target_path(target, "/etc/apt/sources.list")))
+        cloudfile = paths.target_path(
             target, '/etc/cloud/cloud.cfg.d/curtin-preserve-sources.cfg')
         self.assertEqual({'apt_preserve_sources_list': True},
                          yaml.load(util.load_file(cloudfile)))
 
-    @mock.patch("curtin.util.lsb_release")
+    @mock.patch("curtin.distro.lsb_release")
     @mock.patch("curtin.util.get_architecture", return_value="amd64")
     def test_trusty_source_lists(self, m_get_arch, m_lsb_release):
         """Support mirror equivalency with and without trailing /.
@@ -199,7 +201,7 @@ class TestAptSourceConfigSourceList(CiTestCase):
 
         release = 'trusty'
         comps = 'main universe multiverse restricted'
-        easl = util.target_path(target, 'etc/apt/sources.list')
+        easl = paths.target_path(target, 'etc/apt/sources.list')
 
         orig_content = tmpl.format(
             mirror=orig_primary, security=orig_security,
diff --git a/tests/unittests/test_apt_source.py b/tests/unittests/test_apt_source.py
index 2ede986..353cdf8 100644
--- a/tests/unittests/test_apt_source.py
+++ b/tests/unittests/test_apt_source.py
@@ -12,8 +12,9 @@ import socket
 import mock
 from mock import call
 
-from curtin import util
+from curtin import distro
 from curtin import gpg
+from curtin import util
 from curtin.commands import apt_config
 from .helpers import CiTestCase
 
@@ -77,7 +78,7 @@ class TestAptSourceConfig(CiTestCase):
 
     @staticmethod
     def _add_apt_sources(*args, **kwargs):
-        with mock.patch.object(util, 'apt_update'):
+        with mock.patch.object(distro, 'apt_update'):
             apt_config.add_apt_sources(*args, **kwargs)
 
     @staticmethod
@@ -86,7 +87,7 @@ class TestAptSourceConfig(CiTestCase):
         Get the most basic default mrror and release info to be used in tests
         """
         params = {}
-        params['RELEASE'] = util.lsb_release()['codename']
+        params['RELEASE'] = distro.lsb_release()['codename']
         arch = util.get_architecture()
         params['MIRROR'] = apt_config.get_default_mirrors(arch)["PRIMARY"]
         return params
@@ -472,7 +473,7 @@ class TestAptSourceConfig(CiTestCase):
                              'uri':
                              'http://testsec.ubuntu.com/%s/' % component}]}
         post = ("%s_dists_%s-updates_InRelease" %
-                (component, util.lsb_release()['codename']))
+                (component, distro.lsb_release()['codename']))
         fromfn = ("%s/%s_%s" % (pre, archive, post))
         tofn = ("%s/test.ubuntu.com_%s" % (pre, post))
 
@@ -937,7 +938,7 @@ class TestDebconfSelections(CiTestCase):
         m_set_sel.assert_not_called()
 
     @mock.patch("curtin.commands.apt_config.debconf_set_selections")
-    @mock.patch("curtin.commands.apt_config.util.get_installed_packages")
+    @mock.patch("curtin.commands.apt_config.distro.get_installed_packages")
     def test_set_sel_call_has_expected_input(self, m_get_inst, m_set_sel):
         data = {
             'set1': 'pkga pkga/q1 mybool false',
@@ -960,7 +961,7 @@ class TestDebconfSelections(CiTestCase):
 
     @mock.patch("curtin.commands.apt_config.dpkg_reconfigure")
     @mock.patch("curtin.commands.apt_config.debconf_set_selections")
-    @mock.patch("curtin.commands.apt_config.util.get_installed_packages")
+    @mock.patch("curtin.commands.apt_config.distro.get_installed_packages")
     def test_reconfigure_if_intersection(self, m_get_inst, m_set_sel,
                                          m_dpkg_r):
         data = {
@@ -985,7 +986,7 @@ class TestDebconfSelections(CiTestCase):
 
     @mock.patch("curtin.commands.apt_config.dpkg_reconfigure")
     @mock.patch("curtin.commands.apt_config.debconf_set_selections")
-    @mock.patch("curtin.commands.apt_config.util.get_installed_packages")
+    @mock.patch("curtin.commands.apt_config.distro.get_installed_packages")
     def test_reconfigure_if_no_intersection(self, m_get_inst, m_set_sel,
                                             m_dpkg_r):
         data = {'set1': 'pkga pkga/q1 mybool false'}
diff --git a/tests/unittests/test_block.py b/tests/unittests/test_block.py
index d9b19a4..9cf8383 100644
--- a/tests/unittests/test_block.py
+++ b/tests/unittests/test_block.py
@@ -647,4 +647,39 @@ class TestSlaveKnames(CiTestCase):
         knames = block.get_device_slave_knames(device)
         self.assertEqual(slaves, knames)
 
+
+class TestGetSupportedFilesystems(CiTestCase):
+
+    supported_filesystems = ['sysfs', 'rootfs', 'ramfs', 'ext4']
+
+    def _proc_filesystems_output(self, supported=None):
+        if not supported:
+            supported = self.supported_filesystems
+
+        def devname(fsname):
+            """ in-use filesystem modules not emit the 'nodev' prefix """
+            return '\t' if fsname.startswith('ext') else 'nodev\t'
+
+        return '\n'.join([devname(fs) + fs for fs in supported]) + '\n'
+
+    @mock.patch('curtin.block.util')
+    @mock.patch('curtin.block.os')
+    def test_get_supported_filesystems(self, mock_os, mock_util):
+        """ test parsing /proc/filesystems contents into a filesystem list"""
+        mock_os.path.exists.return_value = True
+        mock_util.load_file.return_value = self._proc_filesystems_output()
+
+        result = block.get_supported_filesystems()
+        self.assertEqual(sorted(self.supported_filesystems), sorted(result))
+
+    @mock.patch('curtin.block.util')
+    @mock.patch('curtin.block.os')
+    def test_get_supported_filesystems_no_proc_path(self, mock_os, mock_util):
+        """ missing /proc/filesystems raises RuntimeError """
+        mock_os.path.exists.return_value = False
+        with self.assertRaises(RuntimeError):
+            block.get_supported_filesystems()
+        self.assertEqual(0, mock_util.load_file.call_count)
+
+
 # vi: ts=4 expandtab syntax=python
diff --git a/tests/unittests/test_block_iscsi.py b/tests/unittests/test_block_iscsi.py
index afaf1f6..f8ef5d8 100644
--- a/tests/unittests/test_block_iscsi.py
+++ b/tests/unittests/test_block_iscsi.py
@@ -588,6 +588,13 @@ class TestBlockIscsiDiskFromConfig(CiTestCase):
         # utilize IscsiDisk str method for equality check
         self.assertEqual(str(expected_iscsi_disk), str(iscsi_disk))
 
+        # test with cfg.get('storage') since caller may already have
+        # grabbed the 'storage' value from the curtin config
+        iscsi_disk = iscsi.get_iscsi_disks_from_config(
+                        cfg.get('storage')).pop()
+        # utilize IscsiDisk str method for equality check
+        self.assertEqual(str(expected_iscsi_disk), str(iscsi_disk))
+
     def test_parse_iscsi_disk_from_config_no_iscsi(self):
         """Test parsing storage config with no iscsi disks included"""
         cfg = {
diff --git a/tests/unittests/test_block_lvm.py b/tests/unittests/test_block_lvm.py
index 341f2fa..c92c1ec 100644
--- a/tests/unittests/test_block_lvm.py
+++ b/tests/unittests/test_block_lvm.py
@@ -73,26 +73,27 @@ class TestBlockLvm(CiTestCase):
 
     @mock.patch('curtin.block.lvm.lvmetad_running')
     @mock.patch('curtin.block.lvm.util')
-    def test_lvm_scan(self, mock_util, mock_lvmetad):
+    @mock.patch('curtin.block.lvm.distro')
+    def test_lvm_scan(self, mock_distro, mock_util, mock_lvmetad):
         """check that lvm_scan formats commands correctly for each release"""
+        cmds = [['pvscan'], ['vgscan', '--mknodes']]
         for (count, (codename, lvmetad_status, use_cache)) in enumerate(
-                [('precise', False, False), ('precise', True, False),
-                 ('trusty', False, False), ('trusty', True, True),
-                 ('vivid', False, False), ('vivid', True, True),
-                 ('wily', False, False), ('wily', True, True),
+                [('precise', False, False),
+                 ('trusty', False, False),
                  ('xenial', False, False), ('xenial', True, True),
-                 ('yakkety', True, True), ('UNAVAILABLE', True, True),
                  (None, True, True), (None, False, False)]):
-            mock_util.lsb_release.return_value = {'codename': codename}
+            mock_distro.lsb_release.return_value = {'codename': codename}
             mock_lvmetad.return_value = lvmetad_status
             lvm.lvm_scan()
-            self.assertEqual(
-                len(mock_util.subp.call_args_list), 2 * (count + 1))
-            for (expected, actual) in zip(
-                    [['pvscan'], ['vgscan', '--mknodes']],
-                    mock_util.subp.call_args_list[2 * count:2 * count + 2]):
-                if use_cache:
-                    expected.append('--cache')
-                self.assertEqual(mock.call(expected, capture=True), actual)
+            expected = [cmd for cmd in cmds]
+            for cmd in expected:
+                if lvmetad_status:
+                    cmd.append('--cache')
+
+            calls = [mock.call(cmd, capture=True) for cmd in expected]
+            self.assertEqual(len(expected), len(mock_util.subp.call_args_list))
+            mock_util.subp.has_calls(calls)
+            mock_util.subp.reset_mock()
+
 
 # vi: ts=4 expandtab syntax=python
diff --git a/tests/unittests/test_block_mdadm.py b/tests/unittests/test_block_mdadm.py
index e2e109c..d017930 100644
--- a/tests/unittests/test_block_mdadm.py
+++ b/tests/unittests/test_block_mdadm.py
@@ -15,12 +15,13 @@ class TestBlockMdadmAssemble(CiTestCase):
     def setUp(self):
         super(TestBlockMdadmAssemble, self).setUp()
         self.add_patch('curtin.block.mdadm.util', 'mock_util')
+        self.add_patch('curtin.block.mdadm.lsb_release', 'mock_lsb_release')
         self.add_patch('curtin.block.mdadm.is_valid_device', 'mock_valid')
         self.add_patch('curtin.block.mdadm.udev', 'mock_udev')
 
         # Common mock settings
         self.mock_valid.return_value = True
-        self.mock_util.lsb_release.return_value = {'codename': 'precise'}
+        self.mock_lsb_release.return_value = {'codename': 'precise'}
         self.mock_util.subp.return_value = ('', '')
 
     def test_mdadm_assemble_scan(self):
@@ -88,12 +89,15 @@ class TestBlockMdadmCreate(CiTestCase):
     def setUp(self):
         super(TestBlockMdadmCreate, self).setUp()
         self.add_patch('curtin.block.mdadm.util', 'mock_util')
+        self.add_patch('curtin.block.mdadm.lsb_release', 'mock_lsb_release')
         self.add_patch('curtin.block.mdadm.is_valid_device', 'mock_valid')
         self.add_patch('curtin.block.mdadm.get_holders', 'mock_holders')
+        self.add_patch('curtin.block.mdadm.udev.udevadm_settle',
+                       'm_udevadm_settle')
 
         # Common mock settings
         self.mock_valid.return_value = True
-        self.mock_util.lsb_release.return_value = {'codename': 'precise'}
+        self.mock_lsb_release.return_value = {'codename': 'precise'}
         self.mock_holders.return_value = []
 
     def prepare_mock(self, md_devname, raidlevel, devices, spares):
@@ -115,8 +119,6 @@ class TestBlockMdadmCreate(CiTestCase):
             expected_calls.append(
                 call(["mdadm", "--zero-superblock", d], capture=True))
 
-        side_effects.append(("", ""))  # udevadm settle
-        expected_calls.append(call(["udevadm", "settle"]))
         side_effects.append(("", ""))  # udevadm control --stop-exec-queue
         expected_calls.append(call(["udevadm", "control",
                                     "--stop-exec-queue"]))
@@ -134,9 +136,6 @@ class TestBlockMdadmCreate(CiTestCase):
         side_effects.append(("", ""))  # udevadm control --start-exec-queue
         expected_calls.append(call(["udevadm", "control",
                                     "--start-exec-queue"]))
-        side_effects.append(("", ""))  # udevadm settle
-        expected_calls.append(call(["udevadm", "settle",
-                                    "--exit-if-exists=%s" % md_devname]))
 
         return (side_effects, expected_calls)
 
@@ -154,6 +153,8 @@ class TestBlockMdadmCreate(CiTestCase):
         mdadm.mdadm_create(md_devname=md_devname, raidlevel=raidlevel,
                            devices=devices, spares=spares)
         self.mock_util.subp.assert_has_calls(expected_calls)
+        self.m_udevadm_settle.assert_has_calls(
+            [call(), call(exists=md_devname)])
 
     def test_mdadm_create_raid0_devshort(self):
         md_devname = "md0"
@@ -237,14 +238,15 @@ class TestBlockMdadmExamine(CiTestCase):
     def setUp(self):
         super(TestBlockMdadmExamine, self).setUp()
         self.add_patch('curtin.block.mdadm.util', 'mock_util')
+        self.add_patch('curtin.block.mdadm.lsb_release', 'mock_lsb_release')
         self.add_patch('curtin.block.mdadm.is_valid_device', 'mock_valid')
 
         # Common mock settings
         self.mock_valid.return_value = True
-        self.mock_util.lsb_release.return_value = {'codename': 'precise'}
+        self.mock_lsb_release.return_value = {'codename': 'precise'}
 
     def test_mdadm_examine_export(self):
-        self.mock_util.lsb_release.return_value = {'codename': 'xenial'}
+        self.mock_lsb_release.return_value = {'codename': 'xenial'}
         self.mock_util.subp.return_value = (
             """
             MD_LEVEL=raid0
@@ -321,7 +323,7 @@ class TestBlockMdadmExamine(CiTestCase):
 class TestBlockMdadmStop(CiTestCase):
     def setUp(self):
         super(TestBlockMdadmStop, self).setUp()
-        self.add_patch('curtin.block.mdadm.util.lsb_release', 'mock_util_lsb')
+        self.add_patch('curtin.block.mdadm.lsb_release', 'mock_lsb_release')
         self.add_patch('curtin.block.mdadm.util.subp', 'mock_util_subp')
         self.add_patch('curtin.block.mdadm.util.write_file',
                        'mock_util_write_file')
@@ -334,7 +336,7 @@ class TestBlockMdadmStop(CiTestCase):
 
         # Common mock settings
         self.mock_valid.return_value = True
-        self.mock_util_lsb.return_value = {'codename': 'xenial'}
+        self.mock_lsb_release.return_value = {'codename': 'xenial'}
         self.mock_util_subp.side_effect = iter([
             ("", ""),  # mdadm stop device
         ])
@@ -489,11 +491,12 @@ class TestBlockMdadmRemove(CiTestCase):
     def setUp(self):
         super(TestBlockMdadmRemove, self).setUp()
         self.add_patch('curtin.block.mdadm.util', 'mock_util')
+        self.add_patch('curtin.block.mdadm.lsb_release', 'mock_lsb_release')
         self.add_patch('curtin.block.mdadm.is_valid_device', 'mock_valid')
 
         # Common mock settings
         self.mock_valid.return_value = True
-        self.mock_util.lsb_release.return_value = {'codename': 'xenial'}
+        self.mock_lsb_release.return_value = {'codename': 'xenial'}
         self.mock_util.subp.side_effect = [
             ("", ""),  # mdadm remove device
         ]
@@ -515,14 +518,15 @@ class TestBlockMdadmQueryDetail(CiTestCase):
     def setUp(self):
         super(TestBlockMdadmQueryDetail, self).setUp()
         self.add_patch('curtin.block.mdadm.util', 'mock_util')
+        self.add_patch('curtin.block.mdadm.lsb_release', 'mock_lsb_release')
         self.add_patch('curtin.block.mdadm.is_valid_device', 'mock_valid')
 
         # Common mock settings
         self.mock_valid.return_value = True
-        self.mock_util.lsb_release.return_value = {'codename': 'precise'}
+        self.mock_lsb_release.return_value = {'codename': 'precise'}
 
     def test_mdadm_query_detail_export(self):
-        self.mock_util.lsb_release.return_value = {'codename': 'xenial'}
+        self.mock_lsb_release.return_value = {'codename': 'xenial'}
         self.mock_util.subp.return_value = (
             """
             MD_LEVEL=raid1
@@ -593,13 +597,14 @@ class TestBlockMdadmDetailScan(CiTestCase):
     def setUp(self):
         super(TestBlockMdadmDetailScan, self).setUp()
         self.add_patch('curtin.block.mdadm.util', 'mock_util')
+        self.add_patch('curtin.block.mdadm.lsb_release', 'mock_lsb_release')
         self.add_patch('curtin.block.mdadm.is_valid_device', 'mock_valid')
 
         # Common mock settings
         self.scan_output = ("ARRAY /dev/md0 metadata=1.2 spares=2 name=0 " +
                             "UUID=b1eae2ff:69b6b02e:1d63bb53:ddfa6e4a")
         self.mock_valid.return_value = True
-        self.mock_util.lsb_release.return_value = {'codename': 'xenial'}
+        self.mock_lsb_release.return_value = {'codename': 'xenial'}
         self.mock_util.subp.side_effect = [
             (self.scan_output, ""),  # mdadm --detail --scan
         ]
@@ -628,10 +633,11 @@ class TestBlockMdadmMdHelpers(CiTestCase):
     def setUp(self):
         super(TestBlockMdadmMdHelpers, self).setUp()
         self.add_patch('curtin.block.mdadm.util', 'mock_util')
+        self.add_patch('curtin.block.mdadm.lsb_release', 'mock_lsb_release')
         self.add_patch('curtin.block.mdadm.is_valid_device', 'mock_valid')
 
         self.mock_valid.return_value = True
-        self.mock_util.lsb_release.return_value = {'codename': 'xenial'}
+        self.mock_lsb_release.return_value = {'codename': 'xenial'}
 
     def test_valid_mdname(self):
         mdname = "/dev/md0"
diff --git a/tests/unittests/test_block_mkfs.py b/tests/unittests/test_block_mkfs.py
index c756281..679f85b 100644
--- a/tests/unittests/test_block_mkfs.py
+++ b/tests/unittests/test_block_mkfs.py
@@ -37,11 +37,12 @@ class TestBlockMkfs(CiTestCase):
     @mock.patch("curtin.block.mkfs.block")
     @mock.patch("curtin.block.mkfs.os")
     @mock.patch("curtin.block.mkfs.util")
+    @mock.patch("curtin.block.mkfs.distro.lsb_release")
     def _run_mkfs_with_config(self, config, expected_cmd, expected_flags,
-                              mock_util, mock_os, mock_block,
+                              mock_lsb_release, mock_util, mock_os, mock_block,
                               release="wily", strict=False):
         # Pretend we are on wily as there are no known edge cases for it
-        mock_util.lsb_release.return_value = {"codename": release}
+        mock_lsb_release.return_value = {"codename": release}
         mock_os.path.exists.return_value = True
         mock_block.get_blockdev_sector_size.return_value = (512, 512)
 
diff --git a/tests/unittests/test_block_zfs.py b/tests/unittests/test_block_zfs.py
index c61a6da..9781946 100644
--- a/tests/unittests/test_block_zfs.py
+++ b/tests/unittests/test_block_zfs.py
@@ -378,15 +378,20 @@ class TestBlockZfsDeviceToPoolname(CiTestCase):
         self.mock_blkid.assert_called_with(devs=[devname])
 
 
-class TestBlockZfsZfsSupported(CiTestCase):
+class TestBlockZfsAssertZfsSupported(CiTestCase):
 
     def setUp(self):
-        super(TestBlockZfsZfsSupported, self).setUp()
+        super(TestBlockZfsAssertZfsSupported, 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.add_patch('curtin.block.zfs.distro.lsb_release', 'mock_release')
+        self.add_patch('curtin.block.zfs.util.which', 'mock_which')
+        self.add_patch('curtin.block.zfs.get_supported_filesystems',
+                       'mock_supfs')
         self.mock_arch.return_value = 'x86_64'
+        self.mock_release.return_value = {'codename': 'xenial'}
+        self.mock_supfs.return_value = ['zfs']
+        self.mock_which.return_value = True
 
     def test_supported_arch(self):
         self.assertTrue(zfs.zfs_supported())
@@ -394,81 +399,143 @@ class TestBlockZfsZfsSupported(CiTestCase):
     def test_unsupported_arch(self):
         self.mock_arch.return_value = 'i386'
         with self.assertRaises(RuntimeError):
-            zfs.zfs_supported()
+            zfs.zfs_assert_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()
+                zfs.zfs_assert_supported()
 
-    def test_missing_module(self):
-        missing = 'modinfo: ERROR: Module zfs not found.\n     '
+    @mock.patch('curtin.block.zfs.util.is_kmod_loaded')
+    @mock.patch('curtin.block.zfs.get_supported_filesystems')
+    def test_missing_module(self, mock_supfs, mock_kmod):
+        missing = 'modprobe: FATAL: Module zfs not found.\n     '
         self.mock_subp.side_effect = ProcessExecutionError(stdout='',
                                                            stderr=missing,
                                                            exit_code='1')
+        mock_supfs.return_value = ['ext4']
+        mock_kmod.return_value = False
         with self.assertRaises(RuntimeError):
-            zfs.zfs_supported()
+            zfs.zfs_assert_supported()
 
 
-class TestZfsSupported(CiTestCase):
+class TestAssertZfsSupported(CiTestCase):
 
     def setUp(self):
-        super(TestZfsSupported, self).setUp()
+        super(TestAssertZfsSupported, self).setUp()
 
+    @mock.patch('curtin.block.zfs.get_supported_filesystems')
+    @mock.patch('curtin.block.zfs.distro')
     @mock.patch('curtin.block.zfs.util')
-    def test_zfs_supported_returns_true(self, mock_util):
-        """zfs_supported returns True on supported platforms"""
+    def test_zfs_assert_supported_returns_true(self, mock_util, mock_distro,
+                                               mock_supfs):
+        """zfs_assert_supported returns True on supported platforms"""
         mock_util.get_platform_arch.return_value = 'amd64'
-        mock_util.lsb_release.return_value = {'codename': 'bionic'}
+        mock_distro.lsb_release.return_value = {'codename': 'bionic'}
         mock_util.subp.return_value = ("", "")
+        mock_supfs.return_value = ['zfs']
+        mock_util.which.side_effect = iter(['/wark/zpool', '/wark/zfs'])
 
         self.assertNotIn(mock_util.get_platform_arch.return_value,
                          zfs.ZFS_UNSUPPORTED_ARCHES)
-        self.assertNotIn(mock_util.lsb_release.return_value['codename'],
+        self.assertNotIn(mock_distro.lsb_release.return_value['codename'],
                          zfs.ZFS_UNSUPPORTED_RELEASES)
         self.assertTrue(zfs.zfs_supported())
 
+    @mock.patch('curtin.block.zfs.distro')
     @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'}
+    def test_zfs_assert_supported_raises_exception_on_bad_arch(self,
+                                                               mock_util,
+                                                               mock_distro):
+        """zfs_assert_supported raises RuntimeError on unspported arches"""
+        mock_distro.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()
+                zfs.zfs_assert_supported()
 
+    @mock.patch('curtin.block.zfs.distro')
     @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"""
+    def test_zfs_assert_supported_raises_exc_on_bad_releases(self, mock_util,
+                                                             mock_distro):
+        """zfs_assert_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}
+            mock_distro.lsb_release.return_value = {'codename': release}
             with self.assertRaises(RuntimeError):
-                zfs.zfs_supported()
+                zfs.zfs_assert_supported()
 
     @mock.patch('curtin.block.zfs.util.subprocess.Popen')
-    @mock.patch('curtin.block.zfs.util.lsb_release')
+    @mock.patch('curtin.block.zfs.util.is_kmod_loaded')
+    @mock.patch('curtin.block.zfs.get_supported_filesystems')
+    @mock.patch('curtin.block.zfs.distro.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"""
+    def test_zfs_assert_supported_raises_exc_on_missing_module(self,
+                                                               m_arch,
+                                                               m_release,
+                                                               m_supfs,
+                                                               m_kmod,
+                                                               m_popen,
+                                                               ):
+        """zfs_assert_supported raises RuntimeError modprobe zfs error"""
 
         m_arch.return_value = 'amd64'
         m_release.return_value = {'codename': 'bionic'}
+        m_supfs.return_value = ['ext4']
+        m_kmod.return_value = False
         process_mock = mock.Mock()
         attrs = {
             'returncode': 1,
             'communicate.return_value':
-                ('output', "modinfo: ERROR: Module zfs not found."),
+                ('output', 'modprobe: FATAL: Module zfs not found ...'),
         }
         process_mock.configure_mock(**attrs)
         m_popen.return_value = process_mock
         with self.assertRaises(RuntimeError):
-            zfs.zfs_supported()
+            zfs.zfs_assert_supported()
+
+    @mock.patch('curtin.block.zfs.get_supported_filesystems')
+    @mock.patch('curtin.block.zfs.util.lsb_release')
+    @mock.patch('curtin.block.zfs.util.get_platform_arch')
+    @mock.patch('curtin.block.zfs.util')
+    def test_zfs_assert_supported_raises_exc_on_missing_binaries(self,
+                                                                 mock_util,
+                                                                 m_arch,
+                                                                 m_release,
+                                                                 m_supfs):
+        """zfs_assert_supported raises RuntimeError if no zpool or zfs tools"""
+        mock_util.get_platform_arch.return_value = 'amd64'
+        mock_util.lsb_release.return_value = {'codename': 'bionic'}
+        mock_util.subp.return_value = ("", "")
+        m_supfs.return_value = ['zfs']
+        mock_util.which.return_value = None
+
+        with self.assertRaises(RuntimeError):
+            zfs.zfs_assert_supported()
+
+
+class TestZfsSupported(CiTestCase):
+
+    @mock.patch('curtin.block.zfs.zfs_assert_supported')
+    def test_zfs_supported(self, m_assert_zfs):
+        zfs_supported = True
+        m_assert_zfs.return_value = zfs_supported
+
+        result = zfs.zfs_supported()
+        self.assertEqual(zfs_supported, result)
+        self.assertEqual(1, m_assert_zfs.call_count)
+
+    @mock.patch('curtin.block.zfs.zfs_assert_supported')
+    def test_zfs_supported_returns_false_on_assert_fail(self, m_assert_zfs):
+        zfs_supported = False
+        m_assert_zfs.side_effect = RuntimeError('No zfs module')
+
+        result = zfs.zfs_supported()
+        self.assertEqual(zfs_supported, result)
+        self.assertEqual(1, m_assert_zfs.call_count)
+
 
 # vi: ts=4 expandtab syntax=python
diff --git a/tests/unittests/test_clear_holders.py b/tests/unittests/test_clear_holders.py
index ceb5615..d3f80a0 100644
--- a/tests/unittests/test_clear_holders.py
+++ b/tests/unittests/test_clear_holders.py
@@ -6,11 +6,12 @@ import os
 import textwrap
 
 from curtin.block import clear_holders
+from curtin.util import ProcessExecutionError
 from .helpers import CiTestCase
 
 
 class TestClearHolders(CiTestCase):
-    test_blockdev = '/dev/null'
+    test_blockdev = '/wark/dev/null'
     test_syspath = '/sys/class/block/null'
     remove_retries = [0.2] * 150  # clear_holders defaults to 30 seconds
     example_holders_trees = [
@@ -153,7 +154,7 @@ class TestClearHolders(CiTestCase):
         #
 
         device = self.test_syspath
-        mock_block.sys_block_path.return_value = '/dev/null'
+        mock_block.sys_block_path.return_value = self.test_blockdev
         bcache_cset_uuid = 'c08ae789-a964-46fb-a66e-650f0ae78f94'
 
         mock_os.path.exists.return_value = True
@@ -189,9 +190,8 @@ class TestClearHolders(CiTestCase):
     def test_shutdown_bcache_non_sysfs_device(self, mock_get_bcache, mock_log,
                                               mock_os, mock_util,
                                               mock_get_bcache_block):
-        device = "/dev/fakenull"
         with self.assertRaises(ValueError):
-            clear_holders.shutdown_bcache(device)
+            clear_holders.shutdown_bcache(self.test_blockdev)
 
         self.assertEqual(0, len(mock_get_bcache.call_args_list))
         self.assertEqual(0, len(mock_log.call_args_list))
@@ -208,11 +208,10 @@ class TestClearHolders(CiTestCase):
     def test_shutdown_bcache_no_device(self, mock_get_bcache, mock_log,
                                        mock_os, mock_util,
                                        mock_get_bcache_block, mock_block):
-        device = "/sys/class/block/null"
-        mock_block.sysfs_to_devpath.return_value = '/dev/null'
+        mock_block.sysfs_to_devpath.return_value = self.test_blockdev
         mock_os.path.exists.return_value = False
 
-        clear_holders.shutdown_bcache(device)
+        clear_holders.shutdown_bcache(self.test_syspath)
 
         self.assertEqual(3, len(mock_log.info.call_args_list))
         self.assertEqual(1, len(mock_os.path.exists.call_args_list))
@@ -229,18 +228,17 @@ class TestClearHolders(CiTestCase):
     def test_shutdown_bcache_no_cset(self, mock_get_bcache, mock_log,
                                      mock_os, mock_util,
                                      mock_get_bcache_block, mock_block):
-        device = "/sys/class/block/null"
-        mock_block.sysfs_to_devpath.return_value = '/dev/null'
+        mock_block.sysfs_to_devpath.return_value = self.test_blockdev
         mock_os.path.exists.side_effect = iter([
                 True,   # backing device exists
                 False,  # cset device not present (already removed)
                 True,   # backing device (still) exists
         ])
         mock_get_bcache.return_value = '/sys/fs/bcache/fake'
-        mock_get_bcache_block.return_value = device + '/bcache'
+        mock_get_bcache_block.return_value = self.test_syspath + '/bcache'
         mock_os.path.join.side_effect = os.path.join
 
-        clear_holders.shutdown_bcache(device)
+        clear_holders.shutdown_bcache(self.test_syspath)
 
         self.assertEqual(4, len(mock_log.info.call_args_list))
         self.assertEqual(3, len(mock_os.path.exists.call_args_list))
@@ -249,14 +247,15 @@ class TestClearHolders(CiTestCase):
         self.assertEqual(1, len(mock_util.write_file.call_args_list))
         self.assertEqual(2, len(mock_util.wait_for_removal.call_args_list))
 
-        mock_get_bcache.assert_called_with(device, strict=False)
-        mock_get_bcache_block.assert_called_with(device, strict=False)
-        mock_util.write_file.assert_called_with(device + '/bcache/stop',
-                                                '1', mode=None)
+        mock_get_bcache.assert_called_with(self.test_syspath, strict=False)
+        mock_get_bcache_block.assert_called_with(self.test_syspath,
+                                                 strict=False)
+        mock_util.write_file.assert_called_with(
+            self.test_syspath + '/bcache/stop', '1', mode=None)
         retries = self.remove_retries
         mock_util.wait_for_removal.assert_has_calls([
-            mock.call(device, retries=retries),
-            mock.call(device + '/bcache', retries=retries)])
+            mock.call(self.test_syspath, retries=retries),
+            mock.call(self.test_syspath + '/bcache', retries=retries)])
 
     @mock.patch('curtin.block.clear_holders.block')
     @mock.patch('curtin.block.clear_holders.udev.udevadm_settle')
@@ -271,8 +270,7 @@ class TestClearHolders(CiTestCase):
                                                      mock_get_bcache_block,
                                                      mock_udevadm_settle,
                                                      mock_block):
-        device = "/sys/class/block/null"
-        mock_block.sysfs_to_devpath.return_value = '/dev/null'
+        mock_block.sysfs_to_devpath.return_value = self.test_blockdev
         mock_os.path.exists.side_effect = iter([
                 True,  # backing device exists
                 True,  # cset device not present (already removed)
@@ -280,10 +278,10 @@ class TestClearHolders(CiTestCase):
         ])
         cset = '/sys/fs/bcache/fake'
         mock_get_bcache.return_value = cset
-        mock_get_bcache_block.return_value = device + '/bcache'
+        mock_get_bcache_block.return_value = self.test_syspath + '/bcache'
         mock_os.path.join.side_effect = os.path.join
 
-        clear_holders.shutdown_bcache(device)
+        clear_holders.shutdown_bcache(self.test_syspath)
 
         self.assertEqual(4, len(mock_log.info.call_args_list))
         self.assertEqual(3, len(mock_os.path.exists.call_args_list))
@@ -292,14 +290,15 @@ class TestClearHolders(CiTestCase):
         self.assertEqual(2, len(mock_util.write_file.call_args_list))
         self.assertEqual(3, len(mock_util.wait_for_removal.call_args_list))
 
-        mock_get_bcache.assert_called_with(device, strict=False)
-        mock_get_bcache_block.assert_called_with(device, strict=False)
+        mock_get_bcache.assert_called_with(self.test_syspath, strict=False)
+        mock_get_bcache_block.assert_called_with(self.test_syspath,
+                                                 strict=False)
         mock_util.write_file.assert_has_calls([
             mock.call(cset + '/stop', '1', mode=None),
-            mock.call(device + '/bcache/stop', '1', mode=None)])
+            mock.call(self.test_syspath + '/bcache/stop', '1', mode=None)])
         mock_util.wait_for_removal.assert_has_calls([
             mock.call(cset, retries=self.remove_retries),
-            mock.call(device, retries=self.remove_retries)
+            mock.call(self.test_syspath, retries=self.remove_retries)
         ])
 
     @mock.patch('curtin.block.clear_holders.block')
@@ -315,8 +314,7 @@ class TestClearHolders(CiTestCase):
                                                     mock_get_bcache_block,
                                                     mock_udevadm_settle,
                                                     mock_block):
-        device = "/sys/class/block/null"
-        mock_block.sysfs_to_devpath.return_value = '/dev/null'
+        mock_block.sysfs_to_devpath.return_value = self.test_blockdev
         mock_os.path.exists.side_effect = iter([
                 True,   # backing device exists
                 True,   # cset device not present (already removed)
@@ -324,10 +322,10 @@ class TestClearHolders(CiTestCase):
         ])
         cset = '/sys/fs/bcache/fake'
         mock_get_bcache.return_value = cset
-        mock_get_bcache_block.return_value = device + '/bcache'
+        mock_get_bcache_block.return_value = self.test_syspath + '/bcache'
         mock_os.path.join.side_effect = os.path.join
 
-        clear_holders.shutdown_bcache(device)
+        clear_holders.shutdown_bcache(self.test_syspath)
 
         self.assertEqual(4, len(mock_log.info.call_args_list))
         self.assertEqual(3, len(mock_os.path.exists.call_args_list))
@@ -336,7 +334,7 @@ class TestClearHolders(CiTestCase):
         self.assertEqual(1, len(mock_util.write_file.call_args_list))
         self.assertEqual(1, len(mock_util.wait_for_removal.call_args_list))
 
-        mock_get_bcache.assert_called_with(device, strict=False)
+        mock_get_bcache.assert_called_with(self.test_syspath, strict=False)
         mock_util.write_file.assert_has_calls([
             mock.call(cset + '/stop', '1', mode=None),
         ])
@@ -361,8 +359,7 @@ class TestClearHolders(CiTestCase):
                                                     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_block.sysfs_to_devpath.return_value = self.test_blockdev
         mock_os.path.exists.side_effect = iter([
                 True,   # backing device exists
                 True,   # cset device not present (already removed)
@@ -371,14 +368,14 @@ class TestClearHolders(CiTestCase):
         ])
         cset = '/sys/fs/bcache/fake'
         mock_get_bcache.return_value = cset
-        mock_get_bcache_block.return_value = device + '/bcache'
+        mock_get_bcache_block.return_value = self.test_syspath + '/bcache'
         mock_os.path.join.side_effect = os.path.join
 
         # make writes to sysfs fail
         mock_util.write_file.side_effect = IOError(errno.ENOENT,
                                                    "File not found")
 
-        clear_holders.shutdown_bcache(device)
+        clear_holders.shutdown_bcache(self.test_syspath)
 
         self.assertEqual(4, len(mock_log.info.call_args_list))
         self.assertEqual(3, len(mock_os.path.exists.call_args_list))
@@ -387,7 +384,7 @@ class TestClearHolders(CiTestCase):
         self.assertEqual(1, len(mock_util.write_file.call_args_list))
         self.assertEqual(1, len(mock_util.wait_for_removal.call_args_list))
 
-        mock_get_bcache.assert_called_with(device, strict=False)
+        mock_get_bcache.assert_called_with(self.test_syspath, strict=False)
         mock_util.write_file.assert_has_calls([
             mock.call(cset + '/stop', '1', mode=None),
         ])
@@ -528,10 +525,15 @@ class TestClearHolders(CiTestCase):
         self.assertTrue(mock_log.debug.called)
         self.assertTrue(mock_log.critical.called)
 
+    @mock.patch('curtin.block.clear_holders.is_swap_device')