vmm: actually populate migration progress

The first version has the limitation that we populate the latest
snapshot once per memory iteration, although this is the most
interesting part by far. In a follow-up, we can make this more
fine-grained.

Signed-off-by: Philipp Schuster <[email protected]>
On-behalf-of: SAP [email protected]

Author: phip1611

vmm/src/lib.rs

@@ -54,7 +54,9 @@ use vm_memory::{
     GuestAddress, GuestAddressSpace, GuestMemory, GuestMemoryAtomic, ReadVolatile,
     VolatileMemoryError, VolatileSlice, WriteVolatile,
 };
-use vm_migration::progress::MigrationProgressAndStatus;
+use vm_migration::progress::{
+    MemoryTransmissionInfo, MigrationPhase, MigrationProgressAndStatus, TransportationMode,
+};
 use vm_migration::protocol::*;
 use vm_migration::tls::{TlsConnectionWrapper, TlsStream, TlsStreamWrapper};
 use vm_migration::{
@@ -278,6 +280,9 @@ impl From<u64> for EpollDispatch {
     }
 }
 
+// TODO make this a member of Vmm
+static MIGRATION_PROGRESS_SNAPSHOT: Mutex<Option<MigrationProgressAndStatus>> = Mutex::new(None);
+
 enum SocketStream {
     Unix(UnixStream),
     Tcp(TcpStream),
@@ -2039,6 +2044,12 @@ impl Vmm {
     ) -> result::Result<MemoryRangeTable, MigratableError> {
         let mut bandwidth = 0.0;
         let mut iteration_table;
+        let total_memory_size_bytes = vm
+            .memory_range_table()?
+            .regions()
+            .iter()
+            .map(|range| range.length)
+            .sum::<u64>();
 
         loop {
             // todo: check if auto-converge is enabled at all?
@@ -2095,6 +2106,30 @@ impl Vmm {
             s.current_dirty_pages = s.pending_size.div_ceil(PAGE_SIZE as u64);
             s.total_transferred_dirty_pages += s.current_dirty_pages;
 
+            // Update migration progress snapshot
+            // TODO the first version alters this at the beginning of each iteration.
+            // We should do this continuously instead.
+            {
+                let mut lock = MIGRATION_PROGRESS_SNAPSHOT.lock().unwrap();
+                lock.as_mut()
+                    .expect("live migration should be ongoing")
+                    .update_ongoing_migration_state(
+                        MigrationPhase::MemoryPrecopy,
+                        Some(MemoryTransmissionInfo {
+                            memory_iteration: s.iteration,
+                            memory_transmission_bps: s.mb_per_sec as u64 * 1024 * 1024,
+                            memory_bytes_total: total_memory_size_bytes,
+                            memory_bytes_transmitted: s.total_transferred_bytes,
+                            memory_pages_4k_transmitted: s.total_transferred_dirty_pages,
+                            memory_pages_4k_remaining_iteration: s.current_dirty_pages,
+                            memory_bytes_remaining_iteration: s.pending_size,
+                            memory_dirty_rate_pps: 0, /* TODO */
+                            memory_pages_constant_count: 0,
+                        }),
+                        Some(vm.throttle_percent()),
+                    );
+            }
+
             // Send the current dirty pages
             let transfer_start = Instant::now();
             mem_send.send_memory(&iteration_table, socket)?;
@@ -2207,6 +2242,25 @@ impl Vmm {
         hypervisor: &dyn hypervisor::Hypervisor,
         send_data_migration: &VmSendMigrationData,
     ) -> result::Result<(), MigratableError> {
+        // Update migration progress snapshot
+        {
+            let mut lock = MIGRATION_PROGRESS_SNAPSHOT.lock().unwrap();
+            // if this fails, we made a programming error in our state handling
+            assert!(lock.is_none());
+            let transportation_mode = if send_data_migration.local {
+                TransportationMode::Local
+            } else {
+                TransportationMode::Tcp {
+                    connections: send_data_migration.connections,
+                    tls: send_data_migration.tls_dir.is_some(),
+                }
+            };
+            lock.replace(MigrationProgressAndStatus::new(
+                transportation_mode,
+                Duration::from_millis(send_data_migration.downtime),
+            ));
+        }
+
         let mut s = MigrationState::new();
 
         // Set up the socket connection
@@ -2251,6 +2305,11 @@ impl Vmm {
         if send_data_migration.local {
             match &mut socket {
                 SocketStream::Unix(unix_socket) => {
+                    let mut lock = MIGRATION_PROGRESS_SNAPSHOT.lock().unwrap();
+                    lock.as_mut()
+                        .expect("live migration should be ongoing")
+                        .update_ongoing_migration_state(MigrationPhase::MemoryFds, None, None);
+
                     // Proceed with sending memory file descriptors over UNIX socket
                     vm.send_memory_fds(unix_socket)?;
                 }
@@ -2291,6 +2350,14 @@ impl Vmm {
             vm.pause()?;
         } else {
             Self::do_memory_migration(vm, &mut socket, &mut s, send_data_migration)?;
+
+            // Update migration progress snapshot
+            {
+                let mut lock = MIGRATION_PROGRESS_SNAPSHOT.lock().unwrap();
+                lock.as_mut()
+                    .expect("live migration should be ongoing")
+                    .update_ongoing_migration_state(MigrationPhase::Completing, None, None);
+            }
         }
 
         // We release the locks early to enable locking them on the destination host.
@@ -2336,10 +2403,26 @@ impl Vmm {
         // Record total migration time
         s.total_time = s.start_time.elapsed();
 
-        info!("Migration complete");
+        info!("Migration complete: {}s", s.total_time.as_secs_f32());
+
+        // Update migration progress snapshot
+        {
+            let mut lock = MIGRATION_PROGRESS_SNAPSHOT.lock().unwrap();
+            lock.as_mut()
+                .expect("live migration should be ongoing")
+                .mark_as_finished();
+        }
 
         // Let every Migratable object know about the migration being complete
-        vm.complete_migration()
+        vm.complete_migration()?;
+
+        // Give management software a chance to fetch the migration state.
+        info!("Sleeping five seconds before shutting off.");
+        // TODO right now, the http-server is single-threaded and the blocking
+        // start-migration API call will block other requests here.
+        thread::sleep(Duration::from_secs(5));
+
+        Ok(())
     }
 
     #[cfg(all(feature = "kvm", target_arch = "x86_64"))]
@@ -2488,6 +2571,14 @@ impl Vmm {
                 }
             }
             Err(e) => {
+                // Update migration progress snapshot
+                {
+                    let mut lock = MIGRATION_PROGRESS_SNAPSHOT.lock().unwrap();
+                    lock.as_mut()
+                        .expect("live migration should be ongoing")
+                        .mark_as_failed(&e);
+                }
+
                 error!("Migration failed: {e}");
                 {
                     info!("Sending Receiver in HTTP thread that migration failed");