Merge pull request #340 from Dstack-TEE/qemu-version

dstack-mr: Add qemu_version in VmConfig

Author: kvinwang

dstack-mr/src/acpi.rs

@@ -85,7 +85,12 @@ impl Machine<'_> {
         } else {
             machine.push_str(",smm=off");
         }
-        if self.pic {
+
+        let vopt = self
+            .versioned_options()
+            .context("Failed to get versioned options")?;
+
+        if vopt.pic {
             machine.push_str(",pic=on");
         } else {
             machine.push_str(",pic=off");
@@ -148,8 +153,13 @@ impl Machine<'_> {
 
         debug!("qemu command: {cmd:?}");
 
+        let ver = vopt.version;
         // Execute the command and capture output
         let output = cmd
+            .env(
+                "QEMU_ACPI_COMPAT_VER",
+                format!("{}.{}.{}", ver.0, ver.1, ver.2),
+            )
             .output()
             .context("failed to execute dstack-acpi-tables")?;
 

dstack-mr/src/machine.rs

@@ -6,7 +6,7 @@ use crate::tdvf::Tdvf;
 use crate::util::debug_print_log;
 use crate::{kernel, TdxMeasurements};
 use crate::{measure_log, measure_sha384};
-use anyhow::{Context, Result};
+use anyhow::{bail, Context, Result};
 use fs_err as fs;
 use log::debug;
 
@@ -18,8 +18,9 @@ pub struct Machine<'a> {
     pub kernel: &'a str,
     pub initrd: &'a str,
     pub kernel_cmdline: &'a str,
-    pub two_pass_add_pages: bool,
-    pub pic: bool,
+    pub two_pass_add_pages: Option<bool>,
+    pub pic: Option<bool>,
+    pub qemu_version: Option<String>,
     #[builder(default = false)]
     pub smm: bool,
     pub pci_hole64_size: Option<u64>,
@@ -30,6 +31,53 @@ pub struct Machine<'a> {
     pub root_verity: bool,
 }
 
+fn parse_version_tuple(v: &str) -> Result<(u32, u32, u32)> {
+    let parts: Vec<u32> = v
+        .split('.')
+        .map(|p| p.parse::<u32>().context("Invalid version number"))
+        .collect::<Result<Vec<_>, _>>()?;
+    if parts.len() != 3 {
+        bail!(
+            "Version string must have exactly 3 parts (major.minor.patch), got {}",
+            parts.len()
+        );
+    }
+    Ok((parts[0], parts[1], parts[2]))
+}
+
+impl Machine<'_> {
+    pub fn versioned_options(&self) -> Result<VersionedOptions> {
+        let version = match &self.qemu_version {
+            Some(v) => Some(parse_version_tuple(v).context("Failed to parse QEMU version")?),
+            None => None,
+        };
+        let default_pic;
+        let default_two_pass;
+        let version = version.unwrap_or((9, 1, 0));
+        if version < (8, 0, 0) {
+            bail!("Unsupported QEMU version: {version:?}");
+        }
+        if ((8, 0, 0)..(9, 0, 0)).contains(&version) {
+            default_pic = true;
+            default_two_pass = true;
+        } else {
+            default_pic = false;
+            default_two_pass = false;
+        };
+        Ok(VersionedOptions {
+            version,
+            pic: self.pic.unwrap_or(default_pic),
+            two_pass_add_pages: self.two_pass_add_pages.unwrap_or(default_two_pass),
+        })
+    }
+}
+
+pub struct VersionedOptions {
+    pub version: (u32, u32, u32),
+    pub pic: bool,
+    pub two_pass_add_pages: bool,
+}
+
 impl Machine<'_> {
     pub fn measure(&self) -> Result<TdxMeasurements> {
         debug!("measuring machine: {self:#?}");

dstack-mr/src/tdvf.rs

@@ -223,7 +223,10 @@ impl<'a> Tdvf<'a> {
     }
 
     pub fn mrtd(&self, machine: &Machine) -> Result<Vec<u8>> {
-        self.compute_mrtd(if machine.two_pass_add_pages {
+        let opts = machine
+            .versioned_options()
+            .context("Failed to get versioned options")?;
+        self.compute_mrtd(if opts.two_pass_add_pages {
             PageAddOrder::TwoPass
         } else {
             PageAddOrder::SinglePass

dstack-types/src/lib.rs

@@ -138,10 +138,9 @@ pub struct VmConfig {
     pub cpu_count: u32,
     pub memory_size: u64,
     // https://github.com/intel-staging/qemu-tdx/issues/1
-    #[serde(default)]
-    pub qemu_single_pass_add_pages: bool,
-    #[serde(default)]
-    pub pic: bool,
+    pub qemu_single_pass_add_pages: Option<bool>,
+    pub pic: Option<bool>,
+    pub qemu_version: Option<String>,
     #[serde(default)]
     pub pci_hole64_size: u64,
     #[serde(default)]
@@ -152,6 +151,7 @@ pub struct VmConfig {
     pub num_nvswitches: u32,
     #[serde(default)]
     pub hotplug_off: bool,
+    pub image: Option<String>,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]

kms/src/main_service.rs

@@ -268,8 +268,9 @@ impl RpcHandler {
             .kernel_cmdline(&kernel_cmdline)
             .root_verity(true)
             .hotplug_off(vm_config.hotplug_off)
-            .two_pass_add_pages(vm_config.qemu_single_pass_add_pages)
-            .pic(vm_config.pic)
+            .maybe_two_pass_add_pages(vm_config.qemu_single_pass_add_pages)
+            .maybe_pic(vm_config.pic)
+            .maybe_qemu_version(vm_config.qemu_version.clone())
             .maybe_pci_hole64_size(if vm_config.pci_hole64_size > 0 {
                 Some(vm_config.pci_hole64_size)
             } else {

vmm/src/app.rs

@@ -513,11 +513,13 @@ impl App {
                 memory_size: manifest.memory as u64 * 1024 * 1024,
                 qemu_single_pass_add_pages: cfg.cvm.qemu_single_pass_add_pages,
                 pic: cfg.cvm.qemu_pic,
+                qemu_version: cfg.cvm.qemu_version.clone(),
                 pci_hole64_size: cfg.cvm.qemu_pci_hole64_size,
                 hugepages: manifest.hugepages,
                 num_gpus: gpus.gpus.len() as u32,
                 num_nvswitches: gpus.bridges.len() as u32,
                 hotplug_off: cfg.cvm.qemu_hotplug_off,
+                image: Some(manifest.image.clone()),
             })?;
             json!({
                 "kms_urls": kms_urls,

vmm/src/config.rs

@@ -2,7 +2,7 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-use std::{net::IpAddr, path::PathBuf, str::FromStr};
+use std::{net::IpAddr, path::PathBuf, process::Command, str::FromStr};
 
 use anyhow::{bail, Context, Result};
 use load_config::load_config;
@@ -11,9 +11,69 @@ use rocket::figment::Figment;
 use serde::{Deserialize, Serialize};
 
 use lspci::{lspci_filtered, Device};
-use tracing::info;
+use tracing::{info, warn};
 
 pub const DEFAULT_CONFIG: &str = include_str!("../vmm.toml");
+
+fn detect_qemu_version(qemu_path: &PathBuf) -> Result<String> {
+    let output = Command::new(qemu_path)
+        .arg("--version")
+        .output()
+        .context("Failed to execute qemu --version")?;
+
+    if !output.status.success() {
+        bail!("QEMU version command failed with status: {}", output.status);
+    }
+
+    let version_output =
+        String::from_utf8(output.stdout).context("QEMU version output is not valid UTF-8")?;
+
+    parse_qemu_version_from_output(&version_output)
+        .context("Could not parse QEMU version from output")
+}
+
+fn parse_qemu_version_from_output(output: &str) -> Result<String> {
+    // Parse version from output like:
+    // "QEMU emulator version 8.2.2 (Debian 2:8.2.2+ds-0ubuntu1.4+tdx1.0)"
+    // "QEMU emulator version 9.1.0"
+    let version = output
+        .lines()
+        .next()
+        .and_then(|line| {
+            let words: Vec<&str> = line.split_whitespace().collect();
+
+            // First try: Look for "version" keyword and get the next word (only if it looks like a version)
+            if let Some(version_idx) = words.iter().position(|&word| word == "version") {
+                if let Some(next_word) = words.get(version_idx + 1) {
+                    // Only use the word after "version" if it looks like a version number
+                    if next_word.chars().next().is_some_and(|c| c.is_ascii_digit())
+                        && (next_word.contains('.')
+                            || next_word.chars().all(|c| c.is_ascii_digit() || c == '-'))
+                    {
+                        return Some(*next_word);
+                    }
+                }
+            }
+
+            // Fallback: find first word that looks like a version number
+            words
+                .iter()
+                .find(|word| {
+                    // Check if word starts with digit and contains dots (version-like)
+                    word.chars().next().is_some_and(|c| c.is_ascii_digit())
+                        && (word.contains('.')
+                            || word.chars().all(|c| c.is_ascii_digit() || c == '-'))
+                })
+                .copied()
+        })
+        .context("Could not parse QEMU version from output")?;
+
+    // Extract just the version number (e.g., "8.2.2" from "8.2.2+ds-0ubuntu1.4+tdx1.0")
+    let clean_version = version.split('+').next().unwrap_or(version).to_string();
+
+    Ok(clean_version)
+}
+
 pub fn load_config_figment(config_file: Option<&str>) -> Figment {
     load_config("vmm", DEFAULT_CONFIG, config_file, false)
 }
@@ -127,9 +187,11 @@ pub struct CvmConfig {
     pub use_mrconfigid: bool,
 
     /// QEMU single pass add page
-    pub qemu_single_pass_add_pages: bool,
+    pub qemu_single_pass_add_pages: Option<bool>,
     /// QEMU pic
-    pub qemu_pic: bool,
+    pub qemu_pic: Option<bool>,
+    /// QEMU qemu_version
+    pub qemu_version: Option<String>,
     /// QEMU pci_hole64_size
     pub qemu_pci_hole64_size: u64,
     /// QEMU hotplug_off
@@ -361,7 +423,69 @@ impl Config {
                 }
             }
             info!("QEMU path: {}", me.cvm.qemu_path.display());
+
+            // Detect QEMU version if not already set
+            match &me.cvm.qemu_version {
+                None => match detect_qemu_version(&me.cvm.qemu_path) {
+                    Ok(version) => {
+                        info!("Detected QEMU version: {version}");
+                        me.cvm.qemu_version = Some(version);
+                    }
+                    Err(e) => {
+                        warn!("Failed to detect QEMU version: {e}");
+                        // Continue without version - the system will use defaults
+                    }
+                },
+                Some(version) => info!("Configured QEMU version: {version}"),
+            }
         }
         Ok(me)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_qemu_version_debian_format() {
+        let output = "QEMU emulator version 8.2.2 (Debian 2:8.2.2+ds-0ubuntu1.4+tdx1.0)\nCopyright (c) 2003-2023 Fabrice Bellard and the QEMU Project developers";
+        let version = parse_qemu_version_from_output(output).unwrap();
+        assert_eq!(version, "8.2.2");
+    }
+
+    #[test]
+    fn test_parse_qemu_version_simple_format() {
+        let output = "QEMU emulator version 9.1.0\nCopyright (c) 2003-2024 Fabrice Bellard and the QEMU Project developers";
+        let version = parse_qemu_version_from_output(output).unwrap();
+        assert_eq!(version, "9.1.0");
+    }
+
+    #[test]
+    fn test_parse_qemu_version_old_debian_format() {
+        let output = "QEMU emulator version 8.2.2 (Debian 1:8.2.2+ds-0ubuntu1.2)\nCopyright (c) 2003-2023 Fabrice Bellard and the QEMU Project developers";
+        let version = parse_qemu_version_from_output(output).unwrap();
+        assert_eq!(version, "8.2.2");
+    }
+
+    #[test]
+    fn test_parse_qemu_version_with_rc() {
+        let output = "QEMU emulator version 9.0.0-rc1\nCopyright (c) 2003-2024 Fabrice Bellard and the QEMU Project developers";
+        let version = parse_qemu_version_from_output(output).unwrap();
+        assert_eq!(version, "9.0.0-rc1");
+    }
+
+    #[test]
+    fn test_parse_qemu_version_fallback() {
+        let output = "Some unusual format 8.1.5 with version info";
+        let version = parse_qemu_version_from_output(output).unwrap();
+        assert_eq!(version, "8.1.5");
+    }
+
+    #[test]
+    fn test_parse_qemu_version_invalid() {
+        let output = "No version information here";
+        let result = parse_qemu_version_from_output(output);
+        assert!(result.is_err());
+    }
+}

vmm/src/one_shot.rs

@@ -261,11 +261,13 @@ Compose file content (first 200 chars):
             memory_size: manifest.memory as u64 * 1024 * 1024,
             qemu_single_pass_add_pages: config.cvm.qemu_single_pass_add_pages,
             pic: config.cvm.qemu_pic,
+            qemu_version: config.cvm.qemu_version.clone(),
             pci_hole64_size: config.cvm.qemu_pci_hole64_size,
             hugepages: manifest.hugepages,
             num_gpus: manifest.gpus.as_ref().map_or(0, |g| g.gpus.len() as u32),
             num_nvswitches: manifest.gpus.as_ref().map_or(0, |g| g.bridges.len() as u32),
             hotplug_off: config.cvm.qemu_hotplug_off,
+            image: Some(manifest.image.clone()),
         })?
     });
     let sys_config_path = vm_work_dir.shared_dir().join(".sys-config.json");

vmm/vmm.toml

@@ -30,8 +30,9 @@ user = ""
 use_mrconfigid = true
 
 # QEMU flags
-qemu_single_pass_add_pages = false
-qemu_pic = true
+#qemu_single_pass_add_pages = false
+#qemu_pic = true
+#qemu_version = ""
 qemu_pci_hole64_size = 0
 qemu_hotplug_off = false