in progress

Signed-off-by: Ronan Abhamon <ronan.abhamon@vates.tech>

Author: Wescoeur

drivers/LinstorSR.py

@@ -559,23 +559,19 @@ def create(self, uuid, size) -> None:
                 opterr='Redundancy greater than host count'
             )
 
-        xenapi = self.session.xenapi
-        srs = xenapi.SR.get_all_records_where(
-            'field "type" = "{}"'.format(self.DRIVER_TYPE)
-        )
-        srs = dict([e for e in srs.items() if e[1]['uuid'] != self.uuid])
+        srs = util.get_linstor_srs(self.session)
+        try:
+            srs.pop(self.uuid)
+        except KeyError:
+            # We cannot guarantee that the new SR key will be there even it should be the case.
+            pass
 
-        for sr in srs.values():
-            for pbd in sr['PBDs']:
-                device_config = xenapi.PBD.get_device_config(pbd)
-                group_name = device_config.get('group-name')
-                if group_name and group_name == self._group_name:
-                    raise xs_errors.XenError(
-                        'LinstorSRCreate',
-                        opterr='group name must be unique, already used by PBD {}'.format(
-                            xenapi.PBD.get_uuid(pbd)
-                        )
-                    )
+        pbd_uuid = util.find_pbd_uuid_from_dconf_value(self.session, srs, "group-name", self._group_name)
+        if pbd_uuid:
+            raise xs_errors.XenError(
+                'LinstorSRCreate',
+                opterr=f"group name must be unique, already used by PBD {pbd_uuid}"
+            )
 
         if srs:
             raise xs_errors.XenError(
@@ -1838,7 +1834,8 @@ def attach(self, sr_uuid, vdi_uuid) -> str:
             return self._attach_using_http_nbd()
 
         # Ensure we have a path...
-        self.sr._vhdutil.create_chain_paths(self.uuid, readonly=not writable)
+        chain = self.sr._vhdutil.create_chain_paths(self.uuid, not writable, cleanup.LinstorSR.abort_gc_from_openers_vdi)
+        chain.close()
 
         self.attached = True
         return VDI.VDI.attach(self, self.sr.uuid, self.uuid)
@@ -2375,7 +2372,8 @@ def _snapshot(self, snap_type, cbtlog=None, cbt_consistency=None):
             raise xs_errors.XenError('SnapshotChainTooLong')
 
         # Ensure we have a valid path if we don't have a local diskful.
-        self.sr._vhdutil.create_chain_paths(self.uuid, readonly=True)
+        chain = self.sr._vhdutil.create_chain_paths(self.uuid, True, cleanup.LinstorSR.abort_gc_from_openers_vdi)
+        chain.close()
 
         volume_path = self.path
         if not util.pathexists(volume_path):

drivers/VDI.py

@@ -123,14 +123,8 @@ def __init__(self, sr, uuid):
 
     @staticmethod
     def from_uuid(session, vdi_uuid):
-
-        _VDI = session.xenapi.VDI
-        vdi_ref = _VDI.get_by_uuid(vdi_uuid)
-        sr_ref = _VDI.get_SR(vdi_ref)
-
-        _SR = session.xenapi.SR
-        sr_uuid = _SR.get_uuid(sr_ref)
-
+        vdi_ref = session.xenapi.VDI.get_by_uuid(vdi_uuid)
+        sr_uuid = util.get_sr_from_vdi_ref(session, vdi_ref)
         sr = SR.SR.from_uuid(session, sr_uuid)
 
         sr.srcmd.params['vdi_ref'] = vdi_ref

drivers/blktap2.py

@@ -55,7 +55,7 @@
 from socket import socket, AF_UNIX, SOCK_STREAM
 
 try:
-    from linstorvolumemanager import log_drbd_openers
+    from linstorvolumemanager import get_controller_uri, get_all_volume_openers, LinstorVolumeManager
     LINSTOR_AVAILABLE = True
 except ImportError:
     LINSTOR_AVAILABLE = False
@@ -424,6 +424,8 @@ def unpause(cls, pid, minor, _type=None, _file=None, mirror=None,
             args += ["-a", str(params)]
         if cbtlog:
             args.extend(["-c", cbtlog])
+
+        # TODO: Handle issue.
         cls._pread(args)
 
     @classmethod
@@ -820,6 +822,38 @@ def cgclassify(pid):
         except util.CommandException as e:
             util.logException(e)
 
+    @staticmethod
+    def abort_linstor_gc(drbd_path: str) -> bool:
+        if not LINSTOR_AVAILABLE or not drbd_path.startswith("/dev/drbd/by-res/xcp-volume-"):
+            return False
+
+        _, volume_name, _ = drbd_path.rsplit("/", 2)
+        group_name = LinstorVolumeManager.get_volume_group_name(volume_name)
+
+        openers = get_all_volume_openers(volume_name, "0")
+
+        session = XenAPI.xapi_local()
+        session.xenapi.login_with_password("root", "", "", "SM")
+        try:
+            srs = util.get_linstor_srs(session)
+            pbd_uuid = util.find_pbd_uuid_from_dconf_value(session, srs, "group-name", group_name)
+
+            pbd_ref = session.xenapi.PBD.get_by_uuid(pbd_uuid)
+            pbd_rec = session.xenapi.PBD.get_record(pbd_ref)
+
+            sr_ref = pbd_rec["SR"]
+            sr_uuid = session.xenapi.SR.get_uuid(sr_ref)
+
+            import cleanup # pylint: disable=C0415
+            if cleanup.LinstorSR.abort_gc_from_openers_sr(sr_uuid, openers):
+                return True
+
+            util.SMlog(f"Unable to run tapdisk, openers of DRBD resource `{drbd_path}`: {openers}")
+        finally:
+            session.xenapi.session.logout()
+
+        return False
+
     @classmethod
     def launch_on_tap(cls, blktap, path, _type, options):
 
@@ -844,13 +878,13 @@ def launch_on_tap(cls, blktap, path, _type, options):
                             err = (
                                 'status' in e.info and e.info['status']
                             ) or None
-                            if err in (errno.EIO, errno.EROFS, errno.EAGAIN):
-                                if retry_open < 5:
-                                    retry_open += 1
-                                    time.sleep(1)
-                                    continue
-                                if LINSTOR_AVAILABLE and err == errno.EROFS:
-                                    log_drbd_openers(path)
+                            if err in (errno.EROFS, errno.EMEDIUMTYPE) and cls.abort_linstor_gc(path):
+                                continue
+
+                            if err in (errno.EIO, errno.EAGAIN, errno.EROFS, errno.EMEDIUMTYPE) and retry_open < 5:
+                                retry_open += 1
+                                time.sleep(1)
+                                continue
                             raise
                     try:
                         tapdisk = cls.__from_blktap(blktap)

drivers/cleanup.py

@@ -18,7 +18,7 @@
 # Script to coalesce and garbage collect VHD-based SR's in the background
 #
 
-from sm_typing import Optional, override
+from sm_typing import Dict, Optional, override
 
 import os
 import os.path
@@ -56,8 +56,7 @@
     from linstorjournaler import LinstorJournaler
     from linstorvhdutil import LinstorVhdUtil
     from linstorvolumemanager import get_controller_uri
-    from linstorvolumemanager import LinstorVolumeManager
-    from linstorvolumemanager import LinstorVolumeManagerError
+    from linstorvolumemanager import LinstorVolumeManager, LinstorVolumeManagerError, LinstorVolumeOpeners
     from linstorvolumemanager import PERSISTENT_PREFIX as LINSTOR_PERSISTENT_PREFIX
 
     LINSTOR_AVAILABLE = True
@@ -3656,17 +3655,55 @@ def _finishInterruptedCoalesceLeaf(self, childUuid, parentUuid):
 
     def _checkSlaves(self, vdi):
         try:
-            all_openers = self._linstor.get_volume_openers(vdi.uuid)
-            for openers in all_openers.values():
-                for opener in openers.values():
+            openers = self._linstor.get_volume_openers(vdi.uuid)
+            for host_openers in openers.values():
+                for opener in host_openers.values():
                     if opener['process-name'] != 'tapdisk':
                         raise util.SMException(
-                            'VDI {} is in use: {}'.format(vdi.uuid, all_openers)
+                            'VDI {} is in use: {}'.format(vdi.uuid, openers)
                         )
         except LinstorVolumeManagerError as e:
             if e.code != LinstorVolumeManagerError.ERR_VOLUME_NOT_EXISTS:
                 raise
 
+    @classmethod
+    def abort_gc_from_openers_vdi(cls, vdi_uuid: str, openers: 'LinstorVolumeOpeners') -> bool:
+        return cls._abort_gc_from_openers(vdi_uuid, True, openers)
+
+    @classmethod
+    def abort_gc_from_openers_sr(cls, sr_uuid: str, openers: 'LinstorVolumeOpeners') -> bool:
+        return cls._abort_gc_from_openers(sr_uuid, False, openers)
+
+    @staticmethod
+    def _abort_gc_from_openers(uuid: str, is_vdi_uuid: bool, openers: 'LinstorVolumeOpeners') -> bool:
+        from linstorvhdutil import MANAGER_PLUGIN
+
+        node_name = None
+
+        for host_openers in openers.values():
+            for hostname, opener in host_openers.items():
+                if opener['process-name'] != 'vhd-util' or 'coalesce' not in opener['cmdline']:
+                    continue
+
+                if not node_name:
+                    import socket
+                    node_name = socket.gethostname()
+
+                if node_name == hostname:
+                    continue
+
+                session = XAPI.getSession()
+                try:
+                    sr_uuid = util.get_sr_from_vdi_uuid(session, uuid) if is_vdi_uuid else uuid
+                    util.SMlog(f"LINSTOR volume is coalescing on `{sr_uuid}`. We're going to interrupt the GC...")
+                    return bool(session.xenapi.host.call_plugin(
+                        util.get_master_ref(session), MANAGER_PLUGIN, "abortGc", {"srUuid": sr_uuid}
+                    ))
+                finally:
+                    session.xenapi.session.logout()
+        return False
+
+
 
 ################################################################################
 #

drivers/linstor-manager

@@ -385,6 +385,19 @@ def destroy(session, args):
     return str(False)
 
 
+def abort_gc(session, args):
+    try:
+        sr_uuid = args['srUuid']
+
+        import cleanup
+        cleanup.abort(sr_uuid)
+
+        return str(True)
+    except Exception as e:
+        util.SMlog('linstor-manager:abort_gc error: {}'.format(e))
+    return str(False)
+
+
 def check(session, args):
     try:
         device_path = args['devicePath']
@@ -1231,6 +1244,7 @@ if __name__ == '__main__':
         'attach': attach,
         'detach': detach,
         'destroy': destroy,
+        'abortGc': abort_gc,
 
         # vhdutil wrappers called by linstorvhdutil.
         # Note: When a VHD is open in RO mode (so for all vhdutil getters),

drivers/linstorvhdutil.py

@@ -14,10 +14,10 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-from sm_typing import override
+from sm_typing import Any, Callable, Dict, IO, List, Optional, override
 
 from linstorjournaler import LinstorJournaler
-from linstorvolumemanager import LinstorVolumeManager
+from linstorvolumemanager import LinstorVolumeManager, LinstorVolumeOpeners
 import base64
 import errno
 import json
@@ -165,47 +165,74 @@ def wrapper(*args, **kwargs):
 class LinstorVhdUtil:
     MAX_SIZE = 2 * 1024 * 1024 * 1024 * 1024  # Max VHD size.
 
+    class Chain(object):
+        def __init__(self, files: List[IO], leaf_path: str):
+            self._files = files
+            self._leaf_path = leaf_path
+
+        @property
+        def leaf_path(self) -> str:
+            return self._leaf_path
+
+        def close(self) -> None:
+            for file in self._files:
+                try:
+                    file.close()
+                except Exception: # pylint: disable = W0718
+                    pass
+
     def __init__(self, session, linstor):
         self._session = session
         self._linstor = linstor
 
-    def create_chain_paths(self, vdi_uuid, readonly=False):
+    def create_chain_paths(
+        self,
+        vdi_uuid: str,
+        readonly=False,
+        cb_openers: Optional[Callable[[str, LinstorVolumeOpeners], Any]] = None
+    ) -> Chain:
         # OPTIMIZE: Add a limit_to_first_allocated_block param to limit vhdutil calls.
         # Useful for the snapshot code algorithm.
 
-        leaf_vdi_path = self._linstor.get_device_path(vdi_uuid)
-        path = leaf_vdi_path
-        while True:
-            if not util.pathexists(path):
-                raise xs_errors.XenError(
-                    'VDIUnavailable', opterr='Could not find: {}'.format(path)
-                )
+        files = []
 
-            # Diskless path can be created on the fly, ensure we can open it.
-            def check_volume_usable():
-                while True:
-                    try:
-                        with open(path, 'r' if readonly else 'r+'):
-                            pass
-                    except IOError as e:
-                        if e.errno == errno.ENODATA:
-                            time.sleep(2)
-                            continue
-                        if e.errno == errno.EROFS or e.errno == errno.EMEDIUMTYPE:
-                            util.SMlog('Volume not attachable because used. Openers: {}'.format(
-                                self._linstor.get_volume_openers(vdi_uuid)
-                            ))
-                        raise
+        leaf_path = self._linstor.get_device_path(vdi_uuid)
+        path = leaf_path
+        try:
+            while True:
+                if not util.pathexists(path):
+                    raise xs_errors.XenError(
+                        'VDIUnavailable', opterr='Could not find: {}'.format(path)
+                    )
+
+                # Diskless path can be created on the fly, ensure we can open it.
+                def check_volume_usable():
+                    while True:
+                        try:
+                            files.append(open(path, 'r' if readonly else 'r+'))
+                        except OSError as e:
+                            if e.errno == errno.ENODATA:
+                                time.sleep(2)
+                                continue
+                            if e.errno in (errno.EROFS, errno.EMEDIUMTYPE):
+                                openers = self._linstor.get_volume_openers(vdi_uuid)
+                                util.SMlog(f'Volume not attachable because used. Openers: {openers}')
+                                if cb_openers:
+                                    cb_openers(vdi_uuid, openers)
+                            raise
+                        break
+                util.retry(check_volume_usable, 15, 2)
+
+                vdi_uuid = self.get_vhd_info(vdi_uuid).parentUuid
+                if not vdi_uuid:
                     break
-            util.retry(check_volume_usable, 15, 2)
-
-            vdi_uuid = self.get_vhd_info(vdi_uuid).parentUuid
-            if not vdi_uuid:
-                break
-            path = self._linstor.get_device_path(vdi_uuid)
-            readonly = True  # Non-leaf is always readonly.
+                path = self._linstor.get_device_path(vdi_uuid)
+                readonly = True  # Non-leaf is always readonly.
+        except Exception as e:
+            self.Chain(files, leaf_path).close()
+            raise e
 
-        return leaf_vdi_path
+        return self.Chain(files, leaf_path)
 
     # --------------------------------------------------------------------------
     # Getters: read locally and try on another host in case of failure.
@@ -554,7 +581,7 @@ def _call_method(self, local_method, remote_method, device_path, use_parent, *ar
         # B.3. Call!
         def remote_call():
             try:
-                all_openers = self._linstor.get_volume_openers(openers_uuid)
+                openers = self._linstor.get_volume_openers(openers_uuid)
             except Exception as e:
                 raise xs_errors.XenError(
                     'VDIUnavailable',
@@ -563,8 +590,8 @@ def remote_call():
                 )
 
             no_host_found = True
-            for hostname, openers in all_openers.items():
-                if not openers:
+            for hostname, host_openers in openers.items():
+                if not host_openers:
                     continue
 
                 host_ref = self._find_host_ref_from_hostname(hosts, hostname)