Method send_migration

vmm/src/lib.rs:1395–1553

Performs a migration including all its phases.

(
        vm: &mut Vm,
        #[cfg(all(feature = "kvm", target_arch = "x86_64"))]
        hypervisor: &dyn hypervisor::Hypervisor,
        send_data_migration: &VmSendMigrationData,
        initial_

    /// Performs a migration including all its phases.
    fn send_migration(
        vm: &mut Vm,
        #[cfg(all(feature = "kvm", target_arch = "x86_64"))]
        hypervisor: &dyn hypervisor::Hypervisor,
        send_data_migration: &VmSendMigrationData,
        initial_vm_state: VmState,
    ) -> result::Result<(), MigratableError> {
        // State machine that is updated with more context as we progress.
        let mut ctx = OngoingMigrationContext::new();

        // Set up the socket connection
        let mut socket =
            migration_transport::send_migration_socket(&send_data_migration.destination_url)?;

        // Start the migration
        migration_transport::send_request_expect_ok(
            &mut socket,
            Request::start(),
            MigratableError::MigrateSend(anyhow!("Error starting migration")),
        )?;

        // Send config
        let vm_config = vm.get_config();
        #[cfg(all(feature = "kvm", target_arch = "x86_64"))]
        let common_cpuid = {
            #[cfg(feature = "tdx")]
            if vm_config.lock().unwrap().is_tdx_enabled() {
                return Err(MigratableError::MigrateSend(anyhow!(
                    "Live Migration is not supported when TDX is enabled"
                )));
            }

            let amx = vm_config.lock().unwrap().cpus.features.amx;
            let phys_bits =
                vm::physical_bits(hypervisor, vm_config.lock().unwrap().cpus.max_phys_bits);
            arch::generate_common_cpuid(
                hypervisor,
                &arch::CpuidConfig {
                    phys_bits,
                    kvm_hyperv: vm_config.lock().unwrap().cpus.kvm_hyperv,
                    #[cfg(feature = "tdx")]
                    tdx: false,
                    amx,
                },
            )
            .map_err(|e| {
                MigratableError::MigrateSend(anyhow!("Error generating common cpuid': {e:?}"))
            })?
        };

        if send_data_migration.local {
            match &mut socket {
                SocketStream::Unix(unix_socket) => {
                    // Proceed with sending memory file descriptors over UNIX socket
                    vm.send_memory_fds(unix_socket)?;
                }
                SocketStream::Tcp(_tcp_socket) => {
                    return Err(MigratableError::MigrateSend(anyhow!(