Method start_vm

vmm/src/app.rs:221–275

(&self, id: &str)

    }

    pub async fn start_vm(&self, id: &str) -> Result<()> {
        {
            let state = self.lock();
            if let Some(vm) = state.get(id) {
                if vm.state.removing {
                    bail!("VM is being removed");
                }
            }
        }
        self.sync_dynamic_config(id)?;
        let is_running = self
            .supervisor
            .info(id)
            .await?
            .is_some_and(|info| info.state.status.is_running());
        self.set_started(id, true)?;
        let vm_config = {
            let mut state = self.lock();
            let vm_state = state.get_mut(id).context("VM not found")?;
            // Older images does not support for progress reporting
            if vm_state.config.image.info.shared_ro {
                vm_state.state.start(is_running);
            } else {
                vm_state.state.reset_na();
            }
            vm_state.config.clone()
        };
        if !is_running {
            let work_dir = self.work_dir(id);
            for path in [work_dir.serial_pty(), work_dir.qmp_socket()] {
                if path.symlink_metadata().is_ok() {
                    fs::remove_file(path)?;
                }
            }
            // Append current serial.log to serial.history.log before QEMU truncates it.
            rotate_serial_log(&work_dir, self.config.cvm.serial_history_max_bytes);
            // Add boot separator to stdout/stderr (they are opened in append mode).
            append_boot_separator(&work_dir.stdout_file());
            append_boot_separator(&work_dir.stderr_file());

            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 mut state = self.lock();
            let vm_state = state.get_mut(id).context("VM not found")?;
            vm_state.state.devices = devices;
        }
        Ok(())
    }

    fn set_started(&self, id: &str, started: bool) -> Result<()> {
        let work_dir = self.work_dir(id);