in progress

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

Author: Wescoeur

drivers/LinstorSR.py

@@ -559,23 +559,21 @@ 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, LinstorVolumeManager.build_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 +1836,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 +2374,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,42 @@ 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, LinstorVolumeManager.build_group_name
+            )
+            if pbd_uuid:
+                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
+            else:
+                util.SMlog(f"Unable to find PBD of LINSTOR group `{group_name}`...")
+
+            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 +882,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,57 @@ 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():
+                # Not the most accurate check but it works...
+                # `vhd-util` is probably prefixed with a "+" which is ignored here.
+                if not opener["process-name"].endswith("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 util.strtobool(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/linstorjournaler.py

@@ -153,7 +153,7 @@ def connect(uri):
                         'Unable to find controller uri...'
                     )
             return linstor.KV(
-                LinstorVolumeManager._build_group_name(group_name),
+                LinstorVolumeManager.build_group_name(group_name),
                 uri=uri,
                 namespace=namespace
             )