fix(vmm): make runtime networking state consistent

Reject configurations with multiple forwarding-enabled bridges so DHCP lease updates cannot redirect the VM-wide forwarding target between interfaces.\n\nPersist runtime network snapshots atomically before launching QEMU, publish the snapshot to in-memory state before DHCP can arrive, and clear both copies when process startup fails. Add regression coverage for forwarding validation and atomic snapshot replacement.

Author: Leechael

vmm/src/app.rs

@@ -378,20 +378,33 @@ impl App {
 
             let devices = self.try_allocate_gpus(&vm_config.manifest)?;
             let processes = vm_config.config_qemu(&work_dir, &self.config.cvm, &devices)?;
-            for process in processes {
-                self.supervisor
-                    .deploy(&process)
-                    .await
-                    .with_context(|| format!("Failed to start process {}", process.id))?;
-            }
-
             let runtime_networks =
                 crate::app::qemu::resolved_networks(&vm_config.manifest, &self.config.cvm);
             work_dir.set_runtime_networks(&runtime_networks)?;
+            {
+                let mut state = self.lock();
+                let vm_state = state.get_mut(id).context("VM not found")?;
+                vm_state.state.runtime_networks = runtime_networks;
+            }
+            for process in processes {
+                if let Err(err) = self.supervisor.deploy(&process).await {
+                    if let Err(clear_err) = work_dir.clear_runtime_networks() {
+                        warn!(
+                            id,
+                            "failed to clear runtime networks after start failure: {clear_err}"
+                        );
+                    }
+                    if let Some(vm_state) = self.lock().get_mut(id) {
+                        vm_state.state.runtime_networks.clear();
+                    }
+                    return Err(err)
+                        .with_context(|| format!("failed to start process {}", process.id));
+                }
+            }
+
             let mut state = self.lock();
             let vm_state = state.get_mut(id).context("VM not found")?;
             vm_state.state.devices = devices;
-            vm_state.state.runtime_networks = runtime_networks;
         }
         Ok(())
     }

vmm/src/app/qemu.rs

@@ -152,6 +152,13 @@ pub(crate) fn validate_resolved_network(networking: &Networking) -> Result<()> {
 }
 
 pub(crate) fn validate_resolved_networks(networks: &[Networking]) -> Result<()> {
+    let forwarding_bridges = networks
+        .iter()
+        .filter(|networking| networking.is_bridge() && networking.forward_service_enabled)
+        .count();
+    if forwarding_bridges > 1 {
+        bail!("built-in port forwarding supports only one bridge");
+    }
     for networking in networks {
         validate_resolved_network(networking)?;
     }
@@ -599,7 +606,12 @@ impl VmState {
 mod tests {
     use super::{
         amd_sev_snp_memory_backend_arg, mac_address_for_vm, mac_address_for_vm_index,
-        parse_amd_sev_snp_qmp_capabilities, sanitize_optional, virtio_pci_device,
+        parse_amd_sev_snp_qmp_capabilities, sanitize_optional, virtio_pci_device, VmWorkDir,
+    };
+    use std::{
+        fs,
+        os::unix::fs::symlink,
+        time::{SystemTime, UNIX_EPOCH},
     };
 
     #[test]
@@ -635,6 +647,27 @@ mod tests {
         );
     }
 
+    #[test]
+    fn runtime_networks_snapshot_replaces_target_instead_of_following_it() -> anyhow::Result<()> {
+        let temp = std::env::temp_dir().join(format!(
+            "dstack-vmm-runtime-networks-test-{}",
+            SystemTime::now().duration_since(UNIX_EPOCH)?.as_nanos()
+        ));
+        fs::create_dir_all(&temp)?;
+        let external = temp.join("external.json");
+        fs::write(&external, "sentinel")?;
+        let workdir = VmWorkDir::new(temp.join("vm"));
+        fs::create_dir_all(workdir.path())?;
+        symlink(&external, workdir.runtime_networks_path())?;
+
+        workdir.set_runtime_networks(&[])?;
+
+        assert_eq!(fs::read_to_string(&external)?, "sentinel");
+        assert_eq!(fs::read_to_string(workdir.runtime_networks_path())?, "[]");
+        fs::remove_dir_all(temp)?;
+        Ok(())
+    }
+
     #[test]
     fn amd_sev_snp_memory_backend_arg_uses_passed_final_memory_size() {
         assert_eq!(
@@ -1431,11 +1464,9 @@ impl VmWorkDir {
     }
 
     pub fn set_runtime_networks(&self, networks: &[Networking]) -> Result<()> {
-        fs::write(
-            self.runtime_networks_path(),
-            serde_json::to_string(networks)?,
-        )
-        .context("failed to write runtime networks")
+        let serialized = serde_json::to_vec(networks)?;
+        safe_write::safe_write(self.runtime_networks_path(), serialized)
+            .context("failed to write runtime networks")
     }
 
     pub fn clear_runtime_networks(&self) -> Result<()> {

vmm/src/main_service.rs

@@ -919,6 +919,29 @@ mod tests {
 
         assert!(err.to_string().contains("custom networking mode"));
     }
+
+    #[test]
+    fn multiple_bridges_are_rejected_when_builtin_forwarding_is_enabled() {
+        let mut cvm_config = test_cvm_config();
+        cvm_config.networking.forward_service_enabled = true;
+        let mut request = test_vm_configuration();
+        request.networks = vec![
+            rpc::NetworkingConfig {
+                mode: "bridge".to_string(),
+                bridge_name: "lo".to_string(),
+            },
+            rpc::NetworkingConfig {
+                mode: "bridge".to_string(),
+                bridge_name: "lo".to_string(),
+            },
+        ];
+
+        let err = create_manifest_from_vm_config(request, &cvm_config).unwrap_err();
+
+        assert!(err
+            .to_string()
+            .contains("built-in port forwarding supports only one bridge"));
+    }
 }
 
 impl RpcCall<App> for RpcHandler {