vmm: api: temporarily make VmSendMigration call blocking again

phip1611 · phip1611 · commit 7d1e566368ce · 2025-11-18T12:46:15.000+01:00
Once we have a mechanism to query the progress of an ongoing
live-migration, we can remove this workaround.

Signed-off-by: Philipp Schuster &lt;philipp.schuster@cyberus-technology.de&gt;
On-behalf-of: SAP philipp.schuster@sap.com
diff --git a/vmm/src/api/http/http_endpoint.rs b/vmm/src/api/http/http_endpoint.rs
@@ -32,11 +32,22 @@
 
 use std::fs::File;
 use std::os::unix::io::IntoRawFd;
-use std::sync::mpsc::Sender;
+use std::sync::mpsc::{Receiver, Sender, SyncSender};
+use std::sync::{LazyLock, Mutex};
 
 use micro_http::{Body, Method, Request, Response, StatusCode, Version};
 use vmm_sys_util::eventfd::EventFd;
 
+/// Helper to make the VmSendMigration call blocking as long as a migration is ongoing.
+#[allow(clippy::type_complexity)]
+pub static ONGOING_LIVEMIGRATION: LazyLock<(
+    SyncSender<Result<(), vm_migration::MigratableError>>,
+    Mutex<Receiver<Result<(), vm_migration::MigratableError>>>,
+)> = LazyLock::new(|| {
+    let (sender, receiver) = std::sync::mpsc::sync_channel(0);
+    (sender, Mutex::new(receiver))
+});
+
 #[cfg(all(target_arch = "x86_64", feature = "guest_debug"))]
 use crate::api::VmCoredump;
 use crate::api::http::{EndpointHandler, HttpError, error_response};
@@ -230,7 +241,6 @@ vm_action_put_handler_body!(VmRemoveDevice);
 vm_action_put_handler_body!(VmResizeDisk);
 vm_action_put_handler_body!(VmResizeZone);
 vm_action_put_handler_body!(VmSnapshot);
-vm_action_put_handler_body!(VmSendMigration);
 
 #[cfg(all(target_arch = "x86_64", feature = "guest_debug"))]
 vm_action_put_handler_body!(VmCoredump);
@@ -382,6 +392,46 @@ impl PutHandler for VmReceiveMigration {
 
 impl GetHandler for VmReceiveMigration {}
 
+// Special Handling for virtio-net Devices Backed by Network File Descriptors
+//
+// See above.
+impl PutHandler for VmSendMigration {
+    fn handle_request(
+        &'static self,
+        api_notifier: EventFd,
+        api_sender: Sender<ApiRequest>,
+        body: &Option<Body>,
+        _files: Vec<File>,
+    ) -> std::result::Result<Option<Body>, HttpError> {
+        if let Some(body) = body {
+            let res = self
+                .send(
+                    api_notifier,
+                    api_sender,
+                    serde_json::from_slice(body.raw())?,
+                )
+                .map_err(HttpError::ApiError)?;
+
+            info!("live migration started");
+
+            let (_, receiver) = &*ONGOING_LIVEMIGRATION;
+
+            info!("waiting for live migration result");
+            let mig_res = receiver.lock().unwrap().recv().unwrap();
+            info!("received live migration result");
+
+            // We forward the migration error here to the guest
+            mig_res
+                .map(|_| res)
+                .map_err(|e| HttpError::ApiError(ApiError::VmSendMigration(e)))
+        } else {
+            Err(HttpError::BadRequest)
+        }
+    }
+}
+
+impl GetHandler for VmSendMigration {}
+
 impl PutHandler for VmResize {
     fn handle_request(
         &'static self,
diff --git a/vmm/src/lib.rs b/vmm/src/lib.rs
@@ -30,7 +30,7 @@ use std::path::PathBuf;
 use std::rc::Rc;
 use std::sync::mpsc::{Receiver, RecvError, SendError, Sender, TrySendError};
 use std::sync::{Arc, Barrier, Mutex};
-use std::thread::JoinHandle;
+use std::thread::{JoinHandle, sleep};
 #[cfg(not(target_arch = "riscv64"))]
 use std::time::{Duration, Instant};
 use std::{io, mem, result, thread};
@@ -64,6 +64,7 @@ use vmm_sys_util::eventfd::EventFd;
 use vmm_sys_util::signal::unblock_signal;
 use vmm_sys_util::sock_ctrl_msg::ScmSocket;
 
+use crate::api::http::http_endpoint::ONGOING_LIVEMIGRATION;
 use crate::api::{
     ApiRequest, ApiResponse, RequestHandler, VmInfoResponse, VmReceiveMigrationData,
     VmSendMigrationData, VmmPingResponse,
@@ -2375,8 +2376,9 @@ impl Vmm {
 
     /// Checks the migration result.
     ///
-    /// This should be called when the migration thread indicated is stopped.
-    // TODO return Result
+    /// This should be called when the migration thread indicated a state#
+    /// change. The function parses the callback and either shuts down the VMM
+    /// on success or keeps the VM and the VMM running on migration failure.
     fn check_migration_result(&mut self) {
         let receiver = self
             .migration_state_receiver
@@ -2393,13 +2395,28 @@ impl Vmm {
 
         match res {
             Ok(()) => {
+                {
+                    info!("Sending Receiver in HTTP thread that migration succeeded");
+                    let (sender, _) = &*ONGOING_LIVEMIGRATION;
+                    // unblock API call; propagate migration result
+                    sender.send(Ok(())).unwrap();
+                }
+
                 // Shutdown the VM after the migration succeeded
                 if let Err(e) = self.exit_evt.write(1) {
                     error!("Failed shutting down the VM after migration: {}", e);
                 }
             }
             Err(e) => {
-                panic!("Migration failed: {}", e);
+                error!("Migration failed: {}", e);
+                {
+                    info!("Sending Receiver in HTTP thread that migration failed");
+                    let (sender, _) = &*ONGOING_LIVEMIGRATION;
+                    // unblock API call; propagate migration result
+                    sender.send(Err(e)).unwrap();
+                    sleep(Duration::from_millis(1));
+                }
+                // we don't fail the VMM here, it just continues running its VM
             }
         }
     }
@@ -2930,10 +2947,18 @@ impl RequestHandler for Vmm {
     }
 
     fn vm_resize_disk(&mut self, id: String, desired_size: u64) -> result::Result<(), VmError> {
+        info!("request to resize disk: id={id}");
         self.vm_config.as_ref().ok_or(VmError::VmNotCreated)?;
 
         match self.vm {
-            MaybeVmOwnership::Vmm(ref mut vm) => vm.resize_disk(id, desired_size),
+            MaybeVmOwnership::Vmm(ref mut vm) => {
+                if let Err(e) = vm.resize_disk(id, desired_size) {
+                    error!("Error when resizing disk: {:?}", e);
+                    Err(e)
+                } else {
+                    Ok(())
+                }
+            }
             MaybeVmOwnership::Migration => Err(VmError::VmMigrating),
             MaybeVmOwnership::None => Err(VmError::ResizeDisk),
         }
diff --git a/vmm/src/seccomp_filters.rs b/vmm/src/seccomp_filters.rs
@@ -865,6 +865,7 @@ fn http_api_thread_rules() -> Result<Vec<(i64, Vec<SeccompRule>)>, BackendError>
         (libc::SYS_write, vec![]),
         (libc::SYS_rt_sigprocmask, vec![]),
         (libc::SYS_getcwd, vec![]),
+        (libc::SYS_clock_nanosleep, vec![]),
     ])
 }
 

Original file line number	Diff line number	Diff line change
`@@ -865,6 +865,7 @@ fn http_api_thread_rules() -> Result<Vec<(i64, Vec<SeccompRule>)>, BackendError>`
`865`	`865`	`(libc::SYS_write, vec![]),`
`866`	`866`	`(libc::SYS_rt_sigprocmask, vec![]),`
`867`	`867`	`(libc::SYS_getcwd, vec![]),`
	`868`	`+ (libc::SYS_clock_nanosleep, vec![]),`
`868`	`869`	`])`
`869`	`870`	`}`
`870`	`871`