migration: Add destination VM backup and cleanup support

Add optional destination VM backup/cleanup functionality to MigrationBase:
- New parameter 'do_destination_vm_backup' (default: no) to enable feature
- Accept optional remote_virsh session for destination host operations
- Check if VM exists on destination before migration
- Fail test if destination VM is running (blocker condition)
- Backup and undefine pre-existing stopped VMs to avoid conflicts
- Use comprehensive undefine options (--nvram, --managed-save, etc.)
- Restore destination VM in cleanup_default()

Update migration_iommu_device test:
- Add setup_remote_virsh_session() helper function
- Create single remote virsh session shared across test operations
- Refactor check_iommu_xml() to reuse remote session (no duplication)
- Add cleanup_default() call in finally block
- Properly close remote session in finally block

This allows migration tests to run on non-clean environments without
depending on destination host state.

AI assisted code and commit. Human reviewed.

Signed-off-by: hholoubk <hholoubk@redhat.com>

Refactor MigrationBase to cache destination host credentials and reuse them across methods, and extract destination VM backup/undefine flow into a helper method.

When do_destination_vm_backup is enabled, include destination host info in logs, fail with clearer message if the destination VM is running, and restore a backed-up destination VM by copying its XML file to the destination host before defining it via remote virsh.

When destination VM backup is enabled, return early if the VM does not exist on the destination host, and enable debug logging for the existence/running-state checks.

Only call destination VM backup/undefine helper when do_destination_vm_backup is enabled, and drop the redundant guard from the helper.

AI assisted code and commit. Human reviewed.

Signed-off-by: hholoubk <hholoubk@redhat.com>

migration: Fix remote_virsh session resource leak in migration_iommu_device

Move remote_virsh session creation and migration_obj initialization
inside the try block to prevent resource leaks if MigrationBase.__init__
fails. Also remove redundant cleanup_default() call since it's already
called within cleanup_connection().

Changes:
- Initialize remote_virsh and migration_obj to None before try block
- Move session creation inside try block
- Add null checks before cleanup operations
- Remove duplicate cleanup_default() call

AI assisted code and commit. Human reviewed.

Signed-off-by: hholoubk <hholoubk@redhat.com>
Co-authored-by: Cursor <cursoragent@cursor.com>

migration: Check destination host libvirt version for checkpoints-metadata

Replace local version_compare() call with is_libvirt_feature_supported()
using a remote SSH session to the destination host. The previous code
incorrectly checked the local libvirt version when deciding whether to
pass --checkpoints-metadata to undefine on the remote host.

AI assisted code and commit. Human reviewed.

Signed-off-by: hholoubk <hholoubk@redhat.com>
Made-with: Cursor

dd

Author: hholoubk

libvirt/tests/cfg/sriov/vIOMMU/migration_iommu_device.cfg

@@ -25,6 +25,7 @@
     virsh_migrate_connect_uri = "qemu:///system"
     check_network_accessibility_after_mig = "yes"
     check_cont_ping = "yes"
+    do_destination_vm_backup = "yes"
     disk_driver = {'name': 'qemu', 'type': 'qcow2', 'iommu': 'on'}
     variants:
         - virtio:

libvirt/tests/src/sriov/vIOMMU/migration_iommu_device.py

@@ -13,27 +13,39 @@ def run(test, params, env):
     This case starts vm with different iommu device settings then migrate it
     to and back to check network works well.
     """
-    def check_iommu_xml(vm, params):
+    def setup_remote_virsh_session(params):
+        """
+        Setup remote virsh session for destination host operations
+
+        :param params: Dictionary with the test parameters
+        :return: VirshPersistent session
+        """
+        server_ip = params.get("server_ip")
+        server_user = params.get("server_user", "root")
+        server_pwd = params.get("server_pwd")
+
+        remote_virsh_dargs = {
+            'remote_ip': server_ip,
+            'remote_user': server_user,
+            'remote_pwd': server_pwd,
+            'unprivileged_user': None,
+            'ssh_remote_auth': True
+        }
+        return virsh.VirshPersistent(**remote_virsh_dargs)
+
+    def check_iommu_xml(vm, params, remote_virsh):
         """
         Check the iommu xml of the migrated vm
 
         :param vm: VM object
         :param params: Dictionary with the test parameters
+        :param remote_virsh: VirshPersistent session for destination host
         """
         iommu_dict = eval(params.get('iommu_dict', '{}'))
         if not iommu_dict:
             return
-        server_ip = params.get("server_ip")
-        server_user = params.get("server_user", "root")
-        server_pwd = params.get("server_pwd")
-        remote_virsh_dargs = {'remote_ip': server_ip,
-                              'remote_user': server_user,
-                              'remote_pwd': server_pwd,
-                              'unprivileged_user': None,
-                              'ssh_remote_auth': True}
-        virsh_session_remote = virsh.VirshPersistent(**remote_virsh_dargs)
         migrated_vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(
-                vm.name, virsh_instance=virsh_session_remote)
+                vm.name, virsh_instance=remote_virsh)
         vm_iommu = migrated_vmxml.devices.by_device_tag(
             'iommu')[0].fetch_attrs()
         for attr, value in iommu_dict.items():
@@ -71,14 +83,18 @@ def setup_test():
     vm_name = params.get("main_vm", "avocado-vt-vm1")
     vm = env.get_vm(vm_name)
     test_obj = viommu_base.VIOMMUTest(vm, test, params)
-    migration_obj = base_steps.MigrationBase(test, vm, params)
 
+    remote_virsh = None
+    migration_obj = None
     try:
+        # Setup remote virsh session for destination operations
+        remote_virsh = setup_remote_virsh_session(params)
+        migration_obj = base_steps.MigrationBase(test, vm, params, remote_virsh=remote_virsh)
         setup_test()
         test.log.info("TEST_STEP: Migrate the VM to the target host.")
         migration_obj.run_migration()
         migration_obj.verify_default()
-        check_iommu_xml(vm, params)
+        check_iommu_xml(vm, params, remote_virsh)
 
         migrate_vm_back = "yes" == params.get("migrate_vm_back", "yes")
         if migrate_vm_back:
@@ -87,5 +103,8 @@ def setup_test():
             migration_obj.migration_test.ping_vm(vm, params)
             migration_obj.check_vm_cont_ping(False)
     finally:
-        migration_obj.cleanup_connection()
+        if migration_obj:
+            migration_obj.cleanup_connection()
+        if remote_virsh:
+            remote_virsh.close_session()
         test_obj.teardown_iommu_test()

provider/migration/base_steps.py

@@ -8,6 +8,7 @@
 from virttest import migration
 from virttest import libvirt_remote
 from virttest import libvirt_vm
+from virttest import libvirt_version
 from virttest import remote
 from virttest import utils_config
 from virttest import utils_conn
@@ -38,10 +39,12 @@ class MigrationBase(object):
     :param remote_libvirtd_log: remote.RemoteFile object
     """
 
-    def __init__(self, test, vm, params):
+    def __init__(self, test, vm, params, remote_virsh=None):
         """
         Init params and other necessary variables
 
+        :param remote_virsh: Optional VirshPersistent session for destination host operations
+
         """
         self.test = test
         self.vm = vm
@@ -53,6 +56,12 @@ def __init__(self, test, vm, params):
         self.check_cont_ping = "yes" == self.params.get("check_cont_ping", "no")
         self.check_cont_ping_log = self.params.get("check_cont_ping_log", "/tmp/log_file")
         self.remote_libvirtd_log = None
+        self.server_ip = self.params.get("server_ip")
+        self.server_user = self.params.get("server_user", "root")
+        self.server_pwd = self.params.get("server_pwd")
+        self.do_destination_vm_backup = "yes" == self.params.get("do_destination_vm_backup", "no")
+        self.dest_backup_xml = None
+        self.remote_virsh = remote_virsh
 
         migration_test = migration.MigrationTest()
         migration_test.check_parameters(params)
@@ -63,6 +72,55 @@ def __init__(self, test, vm, params):
         new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
         self.orig_config_xml = new_xml.copy()
 
+        if self.do_destination_vm_backup:
+            self._backup_and_undefine_destination_vm_if_needed(vm_name)
+
+    def _backup_and_undefine_destination_vm_if_needed(self, vm_name):
+        """
+        If enabled, handle pre-existing destination VM with the same name:
+        - Fail if it is running (blocker)
+        - Backup its XML (optional / enabled via params)
+        - Undefine it on destination to avoid name conflict during migration
+
+        :param vm_name: VM name to check on destination host
+        """
+        if self.remote_virsh is None:
+            self.test.fail("Test setup error: Destination VM backup is enabled "
+                           "(do_destination_vm_backup=yes), but no remote_virsh "
+                           "session was provided to MigrationBase.__init__")
+
+        if not self.remote_virsh.domain_exists(vm_name, debug=True):
+            return
+
+        # Check if VM is running - we can only backup/undefine if it's not running
+        if not self.remote_virsh.is_dead(vm_name, debug=True):
+            self.test.fail(f"VM '{vm_name}' is running on destination host. {self.server_ip} "
+                           "Cannot proceed - VM must be stopped first.")
+
+        self.test.log.info(f"VM '{vm_name}' exists on destination host {self.server_ip}, "
+                           "backing it up")
+        dest_xml = vm_xml.VMXML.new_from_inactive_dumpxml(
+            vm_name,
+            virsh_instance=self.remote_virsh
+        )
+        self.dest_backup_xml = dest_xml.copy()
+
+        # Undefine the VM on destination to avoid conflicts during migration
+        self.test.log.info(f"Undefining VM '{vm_name}' on destination host {self.server_ip}")
+        undef_opts = "--managed-save --snapshots-metadata --nvram"
+        remote_session = remote.wait_for_login('ssh', self.server_ip, '22',
+                                               self.server_user, self.server_pwd,
+                                               r"[\#\$]\s*$")
+        try:
+            checkpoints_params = {"func_supported_since_libvirt_ver": "(7, 5, 0)"}
+            if libvirt_version.is_libvirt_feature_supported(
+                    checkpoints_params, ignore_error=True, session=remote_session):
+                undef_opts += " --checkpoints-metadata"
+        finally:
+            remote_session.close()
+
+        self.remote_virsh.undefine(vm_name, options=undef_opts)
+
     def setup_default(self, use_console=False):
         """
         Setup steps by default
@@ -253,19 +311,16 @@ def run_migration_back(self):
         options = self.params.get("virsh_migrate_options", "--live --verbose")
         dest_uri = self.params.get("virsh_migrate_desturi")
         self.vm.connect_uri = dest_uri
-        server_ip = self.params.get("server_ip")
-        server_user = self.params.get("server_user", "root")
-        server_pwd = self.params.get("server_pwd")
 
         client_ip = self.params.get("client_ip")
         client_pwd = self.params.get("client_pwd")
-        runner_on_target = remote.RemoteRunner(host=server_ip,
-                                               username=server_user,
-                                               password=server_pwd)
+        runner_on_target = remote.RemoteRunner(host=self.server_ip,
+                                               username=self.server_user,
+                                               password=self.server_pwd)
         ssh_connection = utils_conn.SSHConnection(server_ip=client_ip,
                                                   server_pwd=client_pwd,
-                                                  client_ip=server_ip,
-                                                  client_pwd=server_pwd)
+                                                  client_ip=self.server_ip,
+                                                  client_pwd=self.server_pwd)
         try:
             ssh_connection.conn_check()
         except utils_conn.ConnectionError:
@@ -343,6 +398,27 @@ def cleanup_default(self):
         # Clean VM on destination and source
         self.migration_test.cleanup_vm(self.vm, dest_uri)
         self.orig_config_xml.sync()
+        
+        # Restore destination VM if it was backed up
+        if self.dest_backup_xml:
+            vm_name = self.params.get("migrate_main_vm")
+            self.test.log.info(f"Restoring VM '{vm_name}' on destination host {self.server_ip}")
+            remote.scp_to_remote(
+                self.server_ip,
+                "22",
+                self.server_user,
+                self.server_pwd,
+                self.dest_backup_xml.xml,
+                self.dest_backup_xml.xml,
+                limit="",
+                log_filename=None,
+                timeout=60,
+                interface=None,
+            )
+            if not self.dest_backup_xml.define(virsh_instance=self.remote_virsh):
+                self.test.log.warning(f"Failed to restore VM '{vm_name}' on destination host {self.server_ip}")
+
+        self.orig_config_xml.sync()
 
     def setup_connection(self, use_console=False):
         """
@@ -390,9 +466,6 @@ def set_remote_log(self):
         log_file = self.params.get("libvirtd_debug_file", "/var/log/libvirt/virtqemud.log")
         log_filters = self.params.get("libvirtd_debug_filters", "1:*")
         remote_file_type = self.params.get("remote_file_type", "virtqemud")
-        server_ip = self.params.get("server_ip", self.params.get("migrate_dest_host"))
-        server_user = self.params.get("server_user", "root")
-        server_pwd = self.params.get("server_pwd", self.params.get("migrate_dest_pwd"))
 
         self.test.log.debug(f"Start setting {remote_file_type} log on remote host")
         service_name = utils_libvirtd.Libvirtd(remote_file_type).service_name
@@ -404,9 +477,9 @@ def set_remote_log(self):
                               '".*log_filters\s*=.*": \'log_filters="%s"\', '
                               '".*log_outputs\s*=.*": \'log_outputs="1:file:%s"\'}') % (log_level, log_filters, log_file)
         self.remote_libvirtd_log = libvirt_remote.update_remote_file(self.params, libvirtd_conf_dest, file_path)
-        remote_runner = remote.RemoteRunner(host=server_ip,
-                                            username=server_user,
-                                            password=server_pwd)
+        remote_runner = remote.RemoteRunner(host=self.server_ip,
+                                            username=self.server_user,
+                                            password=self.server_pwd)
         utils_libvirtd.Libvirtd(remote_file_type, session=remote_runner.session).restart()
         self.params.update({
             "remote_session": remote_runner.session
@@ -439,12 +512,9 @@ def check_local_and_remote_log(self, local_str_in_log=True, remote_str_in_log=Tr
                 local_str_in_log = False
                 libvirt.check_logfile(check_log, log_file, str_in_log=local_str_in_log)
         if check_str_remote_log or check_no_str_remote_log:
-            server_ip = self.params.get("server_ip")
-            server_user = self.params.get("server_user", "root")
-            server_pwd = self.params.get("server_pwd")
-            runner_on_target = remote.RemoteRunner(host=server_ip,
-                                                   username=server_user,
-                                                   password=server_pwd)
+            runner_on_target = remote.RemoteRunner(host=self.server_ip,
+                                                   username=self.server_user,
+                                                   password=self.server_pwd)
 
         if check_str_remote_log:
             for check_log in check_str_remote_log:
@@ -469,11 +539,8 @@ def remote_add_or_remove_port(self, port, add=True):
         :param port: port
         :param add: True for add port, False for remove port
         """
-        server_ip = self.params.get("server_ip")
-        server_user = self.params.get("server_user")
-        server_pwd = self.params.get("server_pwd")
-        remote_session = remote.wait_for_login('ssh', server_ip, '22',
-                                               server_user, server_pwd,
+        remote_session = remote.wait_for_login('ssh', self.server_ip, '22',
+                                               self.server_user, self.server_pwd,
                                                r"[\#\$]\s*$")
         firewall_cmd = utils_iptables.Firewall_cmd(remote_session)
         if add:
@@ -520,7 +587,7 @@ def prepare_disks_remote(params, vm):
     :param vm: vm object
     """
     server_ip = params.get("server_ip")
-    server_user = params.get("server_user")
+    server_user = params.get("server_user", "root")
     server_pwd = params.get("server_pwd")
 
     remote_session = remote.remote_login("ssh", server_ip, "22",
@@ -587,7 +654,7 @@ def check_cpu_for_mig(params):
     """
     dest_uri = params.get("virsh_migrate_desturi")
     remote_ip = params.get("server_ip")
-    remote_user = params.get("server_user")
+    remote_user = params.get("server_user", "root")
     remote_pwd = params.get("server_pwd")
 
     # aarch64 only supports migration tests between hosts with the same CPU, so