From 18f05802f07f580ed31f38931b1103842397d598 Mon Sep 17 00:00:00 2001

From: Vojtech Trefny <vtrefny@redhat.com>

Date: Mon, 2 Nov 2020 14:19:52 +0100

Subject: [PATCH 01/17] Fix type of LVM VDO logical volumes

We should use "lvmvdolv" to make it similar to other "lvmXYZ"

types.

---

 blivet/devices/lvm.py | 2 +-

 1 file changed, 1 insertion(+), 1 deletion(-)

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

index d9e24a33..9639256d 100644

--- a/blivet/devices/lvm.py

+++ b/blivet/devices/lvm.py

@@ -1875,7 +1875,7 @@ def vg(self):

     @property

     def type(self):

-        return "vdolv"

+        return "lvmvdolv"

     @property

     def resizable(self):

From 7f4815e14075550f55f2afb44bfba461eacea1c4 Mon Sep 17 00:00:00 2001

From: Vojtech Trefny <vtrefny@redhat.com>

Date: Mon, 2 Nov 2020 14:21:33 +0100

Subject: [PATCH 02/17] Add VDO pool data LV to internal LVs during populate

---

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

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

 2 files changed, 9 insertions(+), 2 deletions(-)

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

index 9639256d..d0957d6a 100644

--- a/blivet/devices/lvm.py

+++ b/blivet/devices/lvm.py

@@ -1119,7 +1119,7 @@ class LVMInternalLVtype(Enum):

     @classmethod

     def get_type(cls, lv_attr, lv_name):  # pylint: disable=unused-argument

-        attr_letters = {cls.data: ("T", "C"),

+        attr_letters = {cls.data: ("T", "C", "D"),

                         cls.meta: ("e",),

                         cls.log: ("l", "L"),

                         cls.image: ("i", "I"),

@@ -1824,6 +1824,13 @@ def _remove_log_vol(self, lv):

         self._lvs.remove(lv)

         self.vg._remove_log_vol(lv)

+    @property

+    @util.requires_property("is_vdo_pool")

+    def _vdopool_data_lv(self):

+        if not self._internal_lvs:

+            return None

+        return self._internal_lvs[0]

+

     @property

     @util.requires_property("is_vdo_pool")

     def lvs(self):

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

index ff8bf59f..b1626306 100644

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

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

@@ -211,7 +211,7 @@ def add_lv(lv):

                     origin = self._devicetree.get_device_by_name(origin_device_name)

                 lv_kwargs["origin"] = origin

-            elif lv_attr[0] in 'IrielTCo' and lv_name.endswith(']'):

+            elif lv_attr[0] in 'IrielTCoD' and lv_name.endswith(']'):

                 # an internal LV, add the an instance of the appropriate class

                 # to internal_lvs for later processing when non-internal LVs are

                 # processed

From c164864955e371aef78b5020f28bf0c9d235ac7c Mon Sep 17 00:00:00 2001

From: Vojtech Trefny <vtrefny@redhat.com>

Date: Mon, 2 Nov 2020 14:22:12 +0100

Subject: [PATCH 03/17] Add availability functions for LVM VDO

VDO is currently available only on RHEL/CentOS so we need a

separate availability check for LVM VDO devices.

---

 blivet/devices/lvm.py        | 6 ++++++

 blivet/tasks/availability.py | 8 ++++++++

 2 files changed, 14 insertions(+)

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

index d0957d6a..ffc65dcd 100644

--- a/blivet/devices/lvm.py

+++ b/blivet/devices/lvm.py

@@ -1790,6 +1790,9 @@ def populate_ksdata(self, data):

 class LVMVDOPoolMixin(object):

+

+    _external_dependencies = [availability.BLOCKDEV_LVM_PLUGIN, availability.BLOCKDEV_LVM_PLUGIN_VDO]

+

     def __init__(self):

         self._lvs = []

@@ -1848,6 +1851,9 @@ def _create(self):

 class LVMVDOLogicalVolumeMixin(object):

+

+    _external_dependencies = [availability.BLOCKDEV_LVM_PLUGIN, availability.BLOCKDEV_LVM_PLUGIN_VDO]

+

     def __init__(self):

         pass

diff --git a/blivet/tasks/availability.py b/blivet/tasks/availability.py

index f3b76650..b107428e 100644

--- a/blivet/tasks/availability.py

+++ b/blivet/tasks/availability.py

@@ -372,6 +372,13 @@ def available_resource(name):

                                                                            blockdev.LVMTechMode.MODIFY)})

 BLOCKDEV_LVM_TECH = BlockDevMethod(BLOCKDEV_LVM)

+BLOCKDEV_LVM_VDO = BlockDevTechInfo(plugin_name="lvm",

+                                    check_fn=blockdev.lvm_is_tech_avail,

+                                    technologies={blockdev.LVMTech.VDO: (blockdev.LVMTechMode.CREATE |

+                                                                         blockdev.LVMTechMode.REMOVE |

+                                                                         blockdev.LVMTechMode.QUERY)})

+BLOCKDEV_LVM_TECH_VDO = BlockDevMethod(BLOCKDEV_LVM_VDO)

+

 # libblockdev mdraid plugin required technologies and modes

 BLOCKDEV_MD_ALL_MODES = (blockdev.MDTechMode.CREATE |

                          blockdev.MDTechMode.DELETE |

@@ -410,6 +417,7 @@ def available_resource(name):

 BLOCKDEV_DM_PLUGIN_RAID = blockdev_plugin("dm", BLOCKDEV_DM_TECH_RAID)

 BLOCKDEV_LOOP_PLUGIN = blockdev_plugin("loop", BLOCKDEV_LOOP_TECH)

 BLOCKDEV_LVM_PLUGIN = blockdev_plugin("lvm", BLOCKDEV_LVM_TECH)

+BLOCKDEV_LVM_PLUGIN_VDO = blockdev_plugin("lvm", BLOCKDEV_LVM_TECH_VDO)

 BLOCKDEV_MDRAID_PLUGIN = blockdev_plugin("mdraid", BLOCKDEV_MD_TECH)

 BLOCKDEV_MPATH_PLUGIN = blockdev_plugin("mpath", BLOCKDEV_MPATH_TECH)

 BLOCKDEV_SWAP_PLUGIN = blockdev_plugin("swap", BLOCKDEV_SWAP_TECH)

From d782620129d47a7b79b0e6b80455e6d93f8bcc88 Mon Sep 17 00:00:00 2001

From: Vojtech Trefny <vtrefny@redhat.com>

Date: Mon, 2 Nov 2020 14:27:55 +0100

Subject: [PATCH 04/17] Read the LVM VDO pool current size from the internal

 data LV

The pool device mapper device size is always 512k when active.

---

 blivet/devices/lvm.py | 9 +++++++++

 1 file changed, 9 insertions(+)

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

index ffc65dcd..73743fa8 100644

--- a/blivet/devices/lvm.py

+++ b/blivet/devices/lvm.py

@@ -1845,6 +1845,15 @@ def direct(self):

         """ Is this device directly accessible? """

         return False

+    def read_current_size(self):

+        log_method_call(self, exists=self.exists, path=self.path,

+                        sysfs_path=self.sysfs_path)

+        if self.size != Size(0):

+            return self.size

+        if self._vdopool_data_lv:

+            return self._vdopool_data_lv.read_current_size()

+        return Size(0)

+

     def _create(self):

         """ Create the device. """

         raise NotImplementedError

From 2da48ae84f4eac84e8cf998ee2402249a5a52626 Mon Sep 17 00:00:00 2001

From: Vojtech Trefny <vtrefny@redhat.com>

Date: Mon, 2 Nov 2020 14:29:43 +0100

Subject: [PATCH 05/17] Add "vdo_lv" property to LVMVDOPoolMixin

---

 blivet/devices/lvm.py | 7 +++++++

 1 file changed, 7 insertions(+)

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

index 73743fa8..2f93fa22 100644

--- a/blivet/devices/lvm.py

+++ b/blivet/devices/lvm.py

@@ -1840,6 +1840,13 @@ def lvs(self):

         """ A list of this VDO pool's LVs """

         return self._lvs[:]     # we don't want folks changing our list

+    @property

+    @util.requires_property("is_vdo_pool")

+    def vdo_lv(self):

+        if not self._lvs:

+            return None

+        return self._lvs[0]

+

     @property

     def direct(self):

         """ Is this device directly accessible? """

From bbfa2cbdc6cb85d405b895c66eb4867cea4218b4 Mon Sep 17 00:00:00 2001

From: Vojtech Trefny <vtrefny@redhat.com>

Date: Mon, 2 Nov 2020 14:30:37 +0100

Subject: [PATCH 06/17] Add support for creating LVM VDO pools and LVM VDO

 volumes

The pool and the volume are created by one call but these can have

different properties (like size) and are in fact two block devices

when created, we also need to create two devices and add them to

the devicetree. The pool device must be always created first and

the _create function for the VDO volume is a no-op.

---

 blivet/devices/lvm.py | 63 +++++++++++++++++++++++++++++++++++++------

 1 file changed, 55 insertions(+), 8 deletions(-)

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

index 2f93fa22..0802e2de 100644

--- a/blivet/devices/lvm.py

+++ b/blivet/devices/lvm.py

@@ -311,7 +311,7 @@ def _add_log_vol(self, lv):

         # verify we have the space, then add it

         # do not verify for growing vg (because of ks)

-        if not lv.exists and not self.growable and not lv.is_thin_lv and lv.size > self.free_space:

+        if not lv.exists and not self.growable and not (lv.is_thin_lv or lv.is_vdo_lv) and lv.size > self.free_space:

             raise errors.DeviceError("new lv is too large to fit in free space", self.name)

         log.debug("Adding %s/%s to %s", lv.name, lv.size, self.name)

@@ -639,7 +639,7 @@ def __init__(self, name, parents=None, size=None, uuid=None, seg_type=None,

                  percent=None, cache_request=None, pvs=None, from_lvs=None):

         if not exists:

-            if seg_type not in [None, "linear", "thin", "thin-pool", "cache"] + lvm.raid_seg_types:

+            if seg_type not in [None, "linear", "thin", "thin-pool", "cache", "vdo-pool", "vdo"] + lvm.raid_seg_types:

                 raise ValueError("Invalid or unsupported segment type: %s" % seg_type)

             if seg_type and seg_type in lvm.raid_seg_types and not pvs:

                 raise ValueError("List of PVs has to be given for every non-linear LV")

@@ -1793,7 +1793,11 @@ class LVMVDOPoolMixin(object):

     _external_dependencies = [availability.BLOCKDEV_LVM_PLUGIN, availability.BLOCKDEV_LVM_PLUGIN_VDO]

-    def __init__(self):

+    def __init__(self, compression=True, deduplication=True, index_memory=0, write_policy=None):

+        self.compression = compression

+        self.deduplication = deduplication

+        self.index_memory = index_memory

+        self.write_policy = write_policy

         self._lvs = []

     @property

@@ -1863,7 +1867,19 @@ def read_current_size(self):

     def _create(self):

         """ Create the device. """

-        raise NotImplementedError

+

+        if not self.vdo_lv:

+            raise errors.DeviceError("Cannot create new VDO pool without a VDO LV.")

+

+        if self.write_policy:

+            write_policy = blockdev.lvm_get_vdo_write_policy_str(self.write_policy)

+        else:

+            write_policy = blockdev.LVMVDOWritePolicy.AUTO

+

+        blockdev.lvm.vdo_pool_create(self.vg.name, self.vdo_lv.lvname, self.lvname,

+                                     self.size, self.vdo_lv.size, self.index_memory,

+                                     self.compression, self.deduplication,

+                                     write_policy)

 class LVMVDOLogicalVolumeMixin(object):

@@ -1915,9 +1931,26 @@ def resizable(self):

     def pool(self):

         return self.parents[0]

+    def _set_size(self, newsize):

+        if not isinstance(newsize, Size):

+            raise AttributeError("new size must of type Size")

+

+        newsize = self.vg.align(newsize)

+        newsize = self.vg.align(util.numeric_type(newsize))

+        # just make sure the size is set (no VG size/free space check needed for

+        # a VDO LV)

+        DMDevice._set_size(self, newsize)

+

+    def _pre_create(self):

+        # skip LVMLogicalVolumeDevice's _pre_create() method as it checks for a

+        # free space in a VG which doesn't make sense for a VDO LV and causes a

+        # bug by limitting the VDO LV's size to VG free space which is nonsense

+        super(LVMLogicalVolumeBase, self)._pre_create()  # pylint: disable=bad-super-call

+

     def _create(self):

-        """ Create the device. """

-        raise NotImplementedError

+        # nothing to do here, VDO LV is created automatically together with

+        # the VDO pool

+        pass

     def _destroy(self):

         # nothing to do here, VDO LV is destroyed automatically together with

@@ -1953,7 +1986,9 @@ def __init__(self, name, parents=None, size=None, uuid=None, seg_type=None,

                  fmt=None, exists=False, sysfs_path='', grow=None, maxsize=None,

                  percent=None, cache_request=None, pvs=None,

                  parent_lv=None, int_type=None, origin=None, vorigin=False,

-                 metadata_size=None, chunk_size=None, profile=None, from_lvs=None):

+                 metadata_size=None, chunk_size=None, profile=None, from_lvs=None,

+                 compression=False, deduplication=False, index_memory=0,

+                 write_policy=None):

         """

             :param name: the device name (generally a device node's basename)

             :type name: str

@@ -2012,6 +2047,17 @@ def __init__(self, name, parents=None, size=None, uuid=None, seg_type=None,

             :keyword from_lvs: LVs to create the new LV from (in the (data_lv, metadata_lv) order)

             :type from_lvs: tuple of :class:`LVMLogicalVolumeDevice`

+            For VDO pools only:

+

+            :keyword compression: whether to enable compression on the VDO pool

+            :type compression: bool

+            :keyword dudplication: whether to enable dudplication on the VDO pool

+            :type dudplication: bool

+            :keyword index_memory: amount of index memory (in bytes) or 0 for default

+            :type index_memory: int

+            :keyword write_policy: write policy for the volume or None for default

+            :type write_policy: str

+

         """

         if isinstance(parents, (list, ParentList)):

@@ -2032,7 +2078,8 @@ def __init__(self, name, parents=None, size=None, uuid=None, seg_type=None,

         LVMLogicalVolumeBase.__init__(self, name, parents, size, uuid, seg_type,

                                       fmt, exists, sysfs_path, grow, maxsize,

                                       percent, cache_request, pvs, from_lvs)

-        LVMVDOPoolMixin.__init__(self)

+        LVMVDOPoolMixin.__init__(self, compression, deduplication, index_memory,

+                                 write_policy)

         LVMVDOLogicalVolumeMixin.__init__(self)

         LVMInternalLogicalVolumeMixin._init_check(self)

From 2d1593b50dc6232e213b4df86dfbf5cf6d282dcd Mon Sep 17 00:00:00 2001

From: Vojtech Trefny <vtrefny@redhat.com>

Date: Mon, 2 Nov 2020 14:31:35 +0100

Subject: [PATCH 07/17] Allow creating LVM VDO pools and volumes using

 "blivet.new_lv"

The steps to create the VDO devices would typically look like:

pool = b.new_lv(vdo_pool=True, parents=[data], size=Size("8 GiB"))

vdolv = b.new_lv(vdo_lv=True, parents=[pool], size=Size("40 GiB"))

b.create_device(pool)

b.create_device(vdolv)

b.do_it()

---

 blivet/blivet.py               | 18 ++++++++++++++----

 tests/devices_test/lvm_test.py | 31 +++++++++++++++++++++++++++++++

 2 files changed, 45 insertions(+), 4 deletions(-)

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

index e7dbd37b..754eb152 100644

--- a/blivet/blivet.py

+++ b/blivet/blivet.py

@@ -573,6 +573,10 @@ def new_lv(self, *args, **kwargs):

             :type thin_pool: bool

             :keyword thin_volume: whether to create a thin volume

             :type thin_volume: bool

+            :keyword vdo_pool: whether to create a vdo pool

+            :type vdo_pool: bool

+            :keyword vdo_lv: whether to create a vdo lv

+            :type vdo_lv: bool

             :returns: the new device

             :rtype: :class:`~.devices.LVMLogicalVolumeDevice`

@@ -589,8 +593,10 @@ def new_lv(self, *args, **kwargs):

         """

         thin_volume = kwargs.pop("thin_volume", False)

         thin_pool = kwargs.pop("thin_pool", False)

+        vdo_pool = kwargs.pop("vdo_pool", False)

+        vdo_lv = kwargs.pop("vdo_lv", False)

         parent = kwargs.get("parents", [None])[0]

-        if thin_volume and parent:

+        if (thin_volume or vdo_lv) and parent:

             # kwargs["parents"] will contain the pool device, so...

             vg = parent.vg

         else:

@@ -600,6 +606,10 @@ def new_lv(self, *args, **kwargs):

             kwargs["seg_type"] = "thin"

         if thin_pool:

             kwargs["seg_type"] = "thin-pool"

+        if vdo_pool:

+            kwargs["seg_type"] = "vdo-pool"

+        if vdo_lv:

+            kwargs["seg_type"] = "vdo"

         mountpoint = kwargs.pop("mountpoint", None)

         if 'fmt_type' in kwargs:

@@ -625,7 +635,7 @@ def new_lv(self, *args, **kwargs):

                 swap = False

             prefix = ""

-            if thin_pool:

+            if thin_pool or vdo_pool:

                 prefix = "pool"

             name = self.suggest_device_name(parent=vg,

@@ -636,10 +646,10 @@ def new_lv(self, *args, **kwargs):

         if "%s-%s" % (vg.name, name) in self.names:

             raise ValueError("name already in use")

-        if thin_pool or thin_volume:

+        if thin_pool or thin_volume or vdo_pool or vdo_lv:

             cache_req = kwargs.pop("cache_request", None)

             if cache_req:

-                raise ValueError("Creating cached thin volumes and pools is not supported")

+                raise ValueError("Creating cached thin and VDO volumes and pools is not supported")

         return LVMLogicalVolumeDevice(name, *args, **kwargs)

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

index 204cb99a..493d3ba1 100644

--- a/tests/devices_test/lvm_test.py

+++ b/tests/devices_test/lvm_test.py

@@ -689,3 +689,34 @@ def test_new_lv_from_non_existing_lvs(self):

             with patch.object(pool, "_pre_create"):

                 pool.create()

                 self.assertTrue(lvm.thpool_convert.called)

+

+    def test_new_vdo_pool(self):

+        b = blivet.Blivet()

+        pv = StorageDevice("pv1", fmt=blivet.formats.get_format("lvmpv"),

+                           size=Size("10 GiB"), exists=True)

+        vg = LVMVolumeGroupDevice("testvg", parents=[pv], exists=True)

+

+        for dev in (pv, vg):

+            b.devicetree._add_device(dev)

+

+        # check that all the above devices are in the expected places

+        self.assertEqual(set(b.devices), {pv, vg})

+        self.assertEqual(set(b.vgs), {vg})

+

+        self.assertEqual(vg.size, Size("10236 MiB"))

+

+        vdopool = b.new_lv(name="vdopool", vdo_pool=True,

+                           parents=[vg], compression=True,

+                           deduplication=True,

+                           size=blivet.size.Size("8 GiB"))

+

+        vdolv = b.new_lv(name="vdolv", vdo_lv=True,

+                         parents=[vdopool],

+                         size=blivet.size.Size("40 GiB"))

+

+        b.create_device(vdopool)

+        b.create_device(vdolv)

+

+        self.assertEqual(vdopool.children[0], vdolv)

+        self.assertEqual(vdolv.parents[0], vdopool)

+        self.assertListEqual(vg.lvs, [vdopool, vdolv])

From 31ec429ad7bd0857a768e2dfebe1de088dafc144 Mon Sep 17 00:00:00 2001

From: Vojtech Trefny <vtrefny@redhat.com>

Date: Mon, 2 Nov 2020 14:32:47 +0100

Subject: [PATCH 08/17] Add LVM VDO device factory

---

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

 tests/devicefactory_test.py | 128 +++++++++++++++++++++++++++++++++---

 2 files changed, 218 insertions(+), 10 deletions(-)

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

index 9214ad54..c95037cc 100644

--- a/blivet/devicefactory.py

+++ b/blivet/devicefactory.py

@@ -27,7 +27,7 @@

 from .devices import BTRFSDevice, DiskDevice

 from .devices import LUKSDevice, LVMLogicalVolumeDevice

 from .devices import PartitionDevice, MDRaidArrayDevice

-from .devices.lvm import DEFAULT_THPOOL_RESERVE

+from .devices.lvm import LVMVDOPoolMixin, DEFAULT_THPOOL_RESERVE

 from .formats import get_format

 from .devicelibs import btrfs

 from .devicelibs import mdraid

@@ -58,6 +58,7 @@

 DEVICE_TYPE_BTRFS = 3

 DEVICE_TYPE_DISK = 4

 DEVICE_TYPE_LVM_THINP = 5

+DEVICE_TYPE_LVM_VDO = 6

 def is_supported_device_type(device_type):

@@ -69,6 +70,9 @@ def is_supported_device_type(device_type):

         :returns: True if this device type is supported

         :rtype: bool

     """

+    if device_type == DEVICE_TYPE_LVM_VDO:

+        return not any(e for e in LVMVDOPoolMixin._external_dependencies if not e.available)

+

     devices = []

     if device_type == DEVICE_TYPE_BTRFS:

         devices = [BTRFSDevice]

@@ -96,7 +100,7 @@ def get_supported_raid_levels(device_type):

     pkg = None

     if device_type == DEVICE_TYPE_BTRFS:

         pkg = btrfs

-    elif device_type in (DEVICE_TYPE_LVM, DEVICE_TYPE_LVM_THINP):

+    elif device_type in (DEVICE_TYPE_LVM, DEVICE_TYPE_LVM_THINP, DEVICE_TYPE_LVM_VDO):

         pkg = lvm

     elif device_type == DEVICE_TYPE_MD:

         pkg = mdraid

@@ -116,6 +120,8 @@ def get_device_type(device):

                     "lvmlv": DEVICE_TYPE_LVM,

                     "lvmthinlv": DEVICE_TYPE_LVM_THINP,

                     "lvmthinpool": DEVICE_TYPE_LVM,

+                    "lvmvdolv": DEVICE_TYPE_LVM_VDO,

+                    "lvmvdopool": DEVICE_TYPE_LVM,

                     "btrfs subvolume": DEVICE_TYPE_BTRFS,

                     "btrfs volume": DEVICE_TYPE_BTRFS,

                     "mdarray": DEVICE_TYPE_MD}

@@ -136,6 +142,7 @@ def get_device_factory(blivet, device_type=DEVICE_TYPE_LVM, **kwargs):

                    DEVICE_TYPE_PARTITION: PartitionFactory,

                    DEVICE_TYPE_MD: MDFactory,

                    DEVICE_TYPE_LVM_THINP: LVMThinPFactory,

+                   DEVICE_TYPE_LVM_VDO: LVMVDOFactory,

                    DEVICE_TYPE_DISK: DeviceFactory}

     factory_class = class_table[device_type]

@@ -1738,6 +1745,95 @@ def _get_new_device(self, *args, **kwargs):

         return super(LVMThinPFactory, self)._get_new_device(*args, **kwargs)

+class LVMVDOFactory(LVMFactory):

+

+    """ Factory for creating LVM VDO volumes.

+

+        :keyword pool_name: name for the VDO pool, if not specified unique name will be generated

+        :type pool_name: str

+        :keyword virtual_size: size for the VDO volume, usually bigger than pool size, if not

+                               specified physical size (pool size) will be used

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

+        :keyword compression: whether to enable compression (defaults to True)

+        :type compression: bool

+        :keyword deduplication: whether to enable deduplication (defaults to True)

+        :type deduplication: bool

+    """

+

+    def __init__(self, storage, **kwargs):

+        self.pool_name = kwargs.pop("pool_name", None)

+        self.virtual_size = kwargs.pop("virtual_size", None)

+        self.compression = kwargs.pop("compression", True)

+        self.deduplication = kwargs.pop("deduplication", True)

+        super(LVMVDOFactory, self).__init__(storage, **kwargs)

+

+    def _get_new_pool(self, *args, **kwargs):

+        kwargs["vdo_pool"] = True

+        return super(LVMVDOFactory, self)._get_new_device(*args, **kwargs)

+

+    def _set_device_size(self):

+        """ Set the size of the factory device. """

+        super(LVMVDOFactory, self)._set_device_size()

+

+        self.device.pool.size = self.size

+        self._reconfigure_container()

+

+        if not self.virtual_size or self.virtual_size < self.size:

+            # virtual_size is not set or smaller than current size --> it should be same as the pool size

+            self.device.size = self.size

+        else:

+            self.device.size = self.virtual_size

+

+    def _set_pool_name(self):

+        safe_new_name = self.storage.safe_device_name(self.pool_name)

+        if self.device.pool.name != safe_new_name:

+            if not safe_new_name:

+                log.error("not renaming '%s' to invalid name '%s'",

+                          self.device.pool.name, self.pool_name)

+                return

+            if safe_new_name in self.storage.names:

+                log.error("not renaming '%s' to in-use name '%s'",

+                          self.device.pool.name, safe_new_name)

+                return

+

+            log.debug("renaming device '%s' to '%s'",

+                      self.device.pool.name, safe_new_name)

+            self.device.pool.raw_device.name = safe_new_name

+

+    def _set_name(self):

+        super(LVMVDOFactory, self)._set_name()

+        if self.pool_name:

+            self._set_pool_name()

+

+    def _reconfigure_device(self):

+        super(LVMVDOFactory, self)._reconfigure_device()

+

+        self.device.pool.compression = self.compression

+        self.device.pool.deduplication = self.deduplication

+

+    #

+    # methods to configure the factory's device

+    #

+    def _get_new_device(self, *args, **kwargs):

+        """ Create and return the factory device as a StorageDevice. """

+        pool = self._get_new_pool(name=self.pool_name,

+                                  size=self.size,

+                                  parents=[self.vg],

+                                  compression=self.compression,

+                                  deduplication=self.deduplication)

+        self.storage.create_device(pool)

+

+        kwargs["parents"] = [pool]

+        kwargs["vdo_lv"] = True

+

+        if self.virtual_size:

+            vdolv_kwargs = kwargs.copy()

+            vdolv_kwargs["size"] = self.virtual_size

+        else:

+            vdolv_kwargs = kwargs

+        return super(LVMVDOFactory, self)._get_new_device(*args, **vdolv_kwargs)

+

+

 class MDFactory(DeviceFactory):

     """ Factory for creating MD RAID devices. """

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

index 08068779..7cdb51c5 100644

--- a/tests/devicefactory_test.py

+++ b/tests/devicefactory_test.py

@@ -4,6 +4,9 @@

 from decimal import Decimal

 import os

+import test_compat  # pylint: disable=unused-import

+from six.moves.mock import patch  # pylint: disable=no-name-in-module,import-error

+

 import blivet

 from blivet import devicefactory

@@ -93,10 +96,12 @@ def _validate_factory_device(self, *args, **kwargs):

             self.assertEqual(device.format.label,

                              kwargs.get('label'))

-        self.assertLessEqual(device.size, kwargs.get("size"))

-        self.assertGreaterEqual(device.size, device.format.min_size)

-        if device.format.max_size:

-            self.assertLessEqual(device.size, device.format.max_size)

+        # sizes with VDO are special, we have a special check in LVMVDOFactoryTestCase._validate_factory_device

+        if device_type != devicefactory.DEVICE_TYPE_LVM_VDO:

+            self.assertLessEqual(device.size, kwargs.get("size"))

+            self.assertGreaterEqual(device.size, device.format.min_size)

+            if device.format.max_size:

+                self.assertLessEqual(device.size, device.format.max_size)

         self.assertEqual(device.encrypted,

                          kwargs.get("encrypted", False) or

@@ -115,7 +120,11 @@ def test_device_factory(self):

                   "mountpoint": '/factorytest'}

         device = self._factory_device(device_type, **kwargs)

         self._validate_factory_device(device, device_type, **kwargs)

-        self.b.recursive_remove(device)

+

+        if device.type == "lvmvdolv":

+            self.b.recursive_remove(device.pool)

+        else:

+            self.b.recursive_remove(device)

         if self.encryption_supported:

             # Encrypt the leaf device

@@ -157,6 +166,12 @@ def test_device_factory(self):

         device = self._factory_device(device_type, **kwargs)

         self._validate_factory_device(device, device_type, **kwargs)

+        # change size up

+        kwargs["device"] = device

+        kwargs["size"] = Size("900 MiB")

+        device = self._factory_device(device_type, **kwargs)

+        self._validate_factory_device(device, device_type, **kwargs)

+

         # Change LUKS version

         kwargs["luks_version"] = "luks1"

         device = self._factory_device(device_type, **kwargs)

@@ -179,7 +194,7 @@ def _get_size_delta(self, devices=None):

         """

         return Size("1 MiB")

-    def test_get_free_disk_space(self):

+    def test_get_free_disk_space(self, *args):  # pylint: disable=unused-argument

         # get_free_disk_space should return the total free space on disks

         kwargs = self._get_test_factory_args()

         kwargs["size"] = Size("500 MiB")

@@ -206,7 +221,7 @@ def test_get_free_disk_space(self):

                                sum(d.size for d in self.b.disks) - device_space,

                                delta=self._get_size_delta(devices=[device]))

-    def test_normalize_size(self):

+    def test_normalize_size(self, *args):  # pylint: disable=unused-argument

         # _normalize_size should adjust target size to within the format limits

         fstype = "ext2"

         ext2 = get_format(fstype)

@@ -258,7 +273,7 @@ def test_default_factory_type(self):

         factory = devicefactory.get_device_factory(self.b)

         self.assertIsInstance(factory, devicefactory.LVMFactory)

-    def test_factory_defaults(self):

+    def test_factory_defaults(self, *args):  # pylint: disable=unused-argument

         ctor_kwargs = self._get_test_factory_args()

         factory = devicefactory.get_device_factory(self.b, self.device_type, **ctor_kwargs)

         for setting, value in factory._default_settings.items():

@@ -522,6 +537,103 @@ def _get_size_delta(self, devices=None):

         return delta

+class LVMVDOFactoryTestCase(LVMFactoryTestCase):

+    device_class = LVMLogicalVolumeDevice

+    device_type = devicefactory.DEVICE_TYPE_LVM_VDO

+    encryption_supported = False

+

+    def _validate_factory_device(self, *args, **kwargs):

+        super(LVMVDOFactoryTestCase, self)._validate_factory_device(*args,

+                                                                    **kwargs)

+        device = args[0]

+

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