[PATCH 2/3] Recognize and process cached logical volumes

Vratislav Podzimek vpodzime at redhat.com
Mon Jun 22 18:27:08 UTC 2015


When there's an existing cached LV we need to gather some basic information
about the cache and ammend it to base/data LV so that it can report such
information when queried.

Related: rhbz#1120421
Signed-off-by: Vratislav Podzimek <vpodzime at redhat.com>
---
 blivet/devicelibs/lvm.py   |  5 ++++
 blivet/devices/__init__.py |  2 +-
 blivet/devices/lvm.py      | 57 +++++++++++++++++++++++++++++++++++++++++++++-
 blivet/devicetree.py       |  9 +++++++-
 4 files changed, 70 insertions(+), 3 deletions(-)

diff --git a/blivet/devicelibs/lvm.py b/blivet/devicelibs/lvm.py
index 6568d14..c1fbe90 100644
--- a/blivet/devicelibs/lvm.py
+++ b/blivet/devicelibs/lvm.py
@@ -634,3 +634,8 @@ def thinlvpoolname(vg_name, lv_name):
         pool = ''
 
     return pool
+
+def cachepoolname(vg_name, lv_name):
+    # exactly the same as thin pool name
+    return thinlvpoolname(vg_name, lv_name)
+
diff --git a/blivet/devices/__init__.py b/blivet/devices/__init__.py
index 0b2eef2..85e9827 100644
--- a/blivet/devices/__init__.py
+++ b/blivet/devices/__init__.py
@@ -26,7 +26,7 @@ from .disk import DiskDevice, DiskFile, DMRaidArrayDevice, MultipathDevice, iScs
 from .partition import PartitionDevice
 from .dm import DMDevice, DMLinearDevice, DMCryptDevice
 from .luks import LUKSDevice
-from .lvm import LVMVolumeGroupDevice, LVMLogicalVolumeDevice, LVMSnapShotDevice, LVMThinPoolDevice, LVMThinLogicalVolumeDevice, LVMThinSnapShotDevice
+from .lvm import LVMVolumeGroupDevice, LVMLogicalVolumeDevice, LVMSnapShotDevice, LVMThinPoolDevice, LVMThinLogicalVolumeDevice, LVMThinSnapShotDevice, LVMCache
 from .md import MDRaidArrayDevice
 from .btrfs import BTRFSDevice, BTRFSVolumeDevice, BTRFSSubVolumeDevice, BTRFSSnapShotDevice
 from .file import FileDevice, DirectoryDevice, SparseFileDevice
diff --git a/blivet/devices/lvm.py b/blivet/devices/lvm.py
index 61e8e26..356446c 100644
--- a/blivet/devices/lvm.py
+++ b/blivet/devices/lvm.py
@@ -515,6 +515,7 @@ class LVMLogicalVolumeDevice(DMDevice):
         self.metaDataSize = 0
         self.segType = segType or "linear"
         self.snapshots = []
+        self._cache = None
 
         self.req_grow = None
         self.req_max_size = Size(0)
@@ -582,8 +583,11 @@ class LVMLogicalVolumeDevice(DMDevice):
     @property
     def vgSpaceUsed(self):
         """ Space occupied by this LV, not including snapshots. """
+        cache_size = Size(0)
+        if self.cached:
+            cache_size = self.cache.size
         return (self.vg.align(self.size, roundup=True) * self.copies
-                + self.logSize + self.metaDataSize)
+                + self.logSize + self.metaDataSize + cache_size)
 
     @property
     def vg(self):
@@ -802,6 +806,18 @@ class LVMLogicalVolumeDevice(DMDevice):
 
         return True
 
+    @property
+    def cached(self):
+        return bool(self._cache)
+
+    @property
+    def cache(self):
+        return self._cache
+
+    @cache.setter
+    def cache(self, val):
+        self._cache = val
+
 class LVMSnapShotBase(object):
     """ Abstract base class for lvm snapshots
 
@@ -1243,3 +1259,42 @@ class LVMThinSnapShotDevice(LVMSnapShotBase, LVMThinLogicalVolumeDevice):
         # once a thin snapshot exists it no longer depends on its origin
         return ((self.origin == dep and not self.exists) or
                 super(LVMThinSnapShotDevice, self).dependsOn(dep))
+
+class LVMCache(object):
+    """Class providing the cache-related functionality of a cached LV"""
+
+    def __init__(self, cached_lv, size=None, exists=False, fast_pv_names=None, mode=None):
+        """
+        :param cached_lv: the LV the cache functionality of which to provide
+        :type cached_lv: :class:`LVMLogicalVolumeDevice`
+        :param size: size of the cache (useful mainly for non-existing caches
+                     that cannot determine their size dynamically)
+        :type size: :class:`~.size.Size`
+        :param bool exists: whether the cache exists or not
+        :param fast_pv_names: PVs to allocate the cache on/from (ignored for existing)
+        :type fast_pv_names: list of str
+        :param str mode: desired mode for non-existing cache (ignored for existing)
+
+        """
+        self._cached_lv = cached_lv
+        self._size = size
+        self._exists = exists
+        self._fast_pvs = fast_pv_names
+        self._mode = mode
+
+    @property
+    def size(self):
+        return self._size
+
+    @property
+    def exists(self):
+        return self._exists
+
+    @property
+    def fast_pv_names(self):
+        return self._fast_pvs
+
+    @property
+    def mode(self):
+        return self._mode
+
diff --git a/blivet/devicetree.py b/blivet/devicetree.py
index e691a2c..23f0721 100644
--- a/blivet/devicetree.py
+++ b/blivet/devicetree.py
@@ -33,7 +33,7 @@ from .devices import DASDDevice, DMDevice, DMLinearDevice, DMRaidArrayDevice, Di
 from .devices import FcoeDiskDevice, FileDevice, LoopDevice, LUKSDevice
 from .devices import LVMLogicalVolumeDevice, LVMVolumeGroupDevice
 from .devices import LVMThinPoolDevice, LVMThinLogicalVolumeDevice
-from .devices import LVMSnapShotDevice, LVMThinSnapShotDevice
+from .devices import LVMSnapShotDevice, LVMThinSnapShotDevice, LVMCache
 from .devices import MDRaidArrayDevice, MultipathDevice, NoDevice, OpticalDevice
 from .devices import PartitionDevice, ZFCPDiskDevice, iScsiDiskDevice
 from .devices import devicePathToName
@@ -1504,6 +1504,13 @@ class DeviceTree(object):
                 lv_device = lv_class(lv_name, parents=lv_parents,
                                      uuid=lv_uuid, size=lv_size,segType=lv_type,
                                      exists=True, **lv_kwargs)
+                if lv_attr[0] == "C":
+                    cache_pool_name = lvm.cachepoolname(vg_name, lv_name)
+                    if cache_pool_name:
+                        cache_pool_info = self.lvInfo["%s-%s" % (vg_name, cache_pool_name)]
+                        cache_size = udev.device_get_lv_size(cache_pool_info)
+                        cache = LVMCache(lv_dev, cache_size, exists=True)
+                        lv_device.cache = cache
                 self._addDevice(lv_device)
                 if flags.installer_mode:
                     lv_device.setup()
-- 
2.1.0



More information about the anaconda-patches mailing list