feat: 支持从 Cargo 包目录解析 QEMU 配置文件

Author: ZR233

ostool/src/build/mod.rs

@@ -26,7 +26,10 @@ use crate::{
         cargo_builder::CargoBuilder,
         config::{Cargo, Custom},
     },
-    run::{qemu::RunQemuArgs, uboot::RunUbootArgs},
+    run::{
+        qemu::{RunQemuArgs, resolve_qemu_config_path_in_dir},
+        uboot::RunUbootArgs,
+    },
 };
 
 /// Cargo builder implementation for building projects.
@@ -50,6 +53,12 @@ pub enum CargoRunnerKind {
         debug: bool,
         /// Whether to dump the device tree blob.
         dtb_dump: bool,
+        /// Extra default QEMU command-line arguments.
+        args: Vec<String>,
+        /// Regex patterns that indicate successful execution.
+        success_regex: Vec<String>,
+        /// Regex patterns that indicate failed execution.
+        fail_regex: Vec<String>,
     },
     /// Run the built artifact on real hardware via U-Boot.
     Uboot {
@@ -157,13 +166,28 @@ impl Tool {
             CargoRunnerKind::Qemu {
                 qemu_config,
                 dtb_dump,
+                args,
+                success_regex,
+                fail_regex,
                 ..
             } => {
-                self.run_qemu(RunQemuArgs {
-                    qemu_config: qemu_config.clone(),
-                    dtb_dump: *dtb_dump,
-                    show_output: true,
-                })
+                let package_dir = self.resolve_package_manifest_dir(&config.package)?;
+                let resolved_qemu_config = resolve_qemu_config_path_in_dir(
+                    &package_dir,
+                    self.ctx.arch,
+                    qemu_config.clone(),
+                )?;
+
+                self.run_qemu_with_more_default_args(
+                    RunQemuArgs {
+                        qemu_config: Some(resolved_qemu_config),
+                        dtb_dump: *dtb_dump,
+                        show_output: true,
+                    },
+                    args.clone(),
+                    success_regex.clone(),
+                    fail_regex.clone(),
+                )
                 .await?;
             }
             CargoRunnerKind::Uboot { uboot_config } => {

ostool/src/main.rs

@@ -60,6 +60,8 @@ pub struct QemuArgs {
     /// Path to the qemu configuration file
     ///
     /// Default behavior when not specified:
+    /// - Cargo build system: use the target package directory
+    /// - Custom build system: use the workspace directory
     /// - With architecture detected: .qemu-{arch}.toml (e.g., .qemu-aarch64.toml)
     /// - Without architecture: .qemu.toml
     #[arg(short, long)]
@@ -118,6 +120,9 @@ async fn try_main() -> Result<()> {
                             qemu_config: qemu_args.qemu_config,
                             debug: qemu_args.debug,
                             dtb_dump: qemu_args.dtb_dump,
+                            args: vec![],
+                            success_regex: vec![],
+                            fail_regex: vec![],
                         },
                         RunSubCommands::Uboot(uboot_args) => CargoRunnerKind::Uboot {
                             uboot_config: uboot_args.uboot_config,

ostool/src/run/qemu.rs

@@ -677,12 +677,20 @@ impl QemuRunner<'_> {
 pub(crate) fn resolve_qemu_config_path(
     tool: &Tool,
     explicit_path: Option<PathBuf>,
+) -> anyhow::Result<PathBuf> {
+    resolve_qemu_config_path_in_dir(tool.workspace_dir(), tool.ctx.arch, explicit_path)
+}
+
+pub(crate) fn resolve_qemu_config_path_in_dir(
+    search_dir: &Path,
+    arch: Option<Architecture>,
+    explicit_path: Option<PathBuf>,
 ) -> anyhow::Result<PathBuf> {
     if let Some(path) = explicit_path {
         return Ok(path);
     }
 
-    let arch_str = tool.ctx.arch.map(|arch| format!("{arch:?}").to_lowercase());
+    let arch_str = arch.map(|arch| format!("{arch:?}").to_lowercase());
 
     // 文件名优先级顺序
     let candidates: Vec<String> = if let Some(ref arch) = arch_str {
@@ -697,7 +705,7 @@ pub(crate) fn resolve_qemu_config_path(
     };
 
     for filename in &candidates {
-        let path = tool.workspace_dir().join(filename);
+        let path = search_dir.join(filename);
         if path.exists() {
             return Ok(path);
         }
@@ -709,14 +717,14 @@ pub(crate) fn resolve_qemu_config_path(
         ".qemu.toml".to_string()
     };
 
-    Ok(tool.workspace_dir().join(default_filename))
+    Ok(search_dir.join(default_filename))
 }
 
 #[cfg(test)]
 mod tests {
     use super::{
         QemuConfig, QemuDefaultOverrides, QemuRunner, build_default_qemu_config,
-        resolve_qemu_config_path,
+        resolve_qemu_config_path, resolve_qemu_config_path_in_dir,
     };
     use object::Architecture;
     use std::path::PathBuf;
@@ -939,6 +947,50 @@ mod tests {
         assert_eq!(result, tmp.path().join("qemu.toml"));
     }
 
+    #[test]
+    fn qemu_config_search_dir_prefers_arch_specific_files() {
+        let tmp = TempDir::new().unwrap();
+        std::fs::write(tmp.path().join("qemu-aarch64.toml"), "").unwrap();
+        std::fs::write(tmp.path().join("qemu.toml"), "").unwrap();
+
+        let result = resolve_qemu_config_path_in_dir(
+            tmp.path(),
+            Some(Architecture::Aarch64),
+            None,
+        )
+        .unwrap();
+        assert_eq!(result, tmp.path().join("qemu-aarch64.toml"));
+    }
+
+    #[test]
+    fn qemu_config_search_dir_uses_hidden_generic_before_hidden_default_creation() {
+        let tmp = TempDir::new().unwrap();
+        std::fs::write(tmp.path().join(".qemu.toml"), "").unwrap();
+
+        let result =
+            resolve_qemu_config_path_in_dir(tmp.path(), Some(Architecture::Aarch64), None)
+                .unwrap();
+        assert_eq!(result, tmp.path().join(".qemu.toml"));
+    }
+
+    #[test]
+    fn qemu_config_search_dir_defaults_to_arch_specific_hidden_file() {
+        let tmp = TempDir::new().unwrap();
+
+        let result =
+            resolve_qemu_config_path_in_dir(tmp.path(), Some(Architecture::Aarch64), None)
+                .unwrap();
+        assert_eq!(result, tmp.path().join(".qemu-aarch64.toml"));
+    }
+
+    #[test]
+    fn qemu_config_search_dir_defaults_without_arch() {
+        let tmp = TempDir::new().unwrap();
+
+        let result = resolve_qemu_config_path_in_dir(tmp.path(), None, None).unwrap();
+        assert_eq!(result, tmp.path().join(".qemu.toml"));
+    }
+
     #[test]
     fn build_config_explicit_path_wins() {
         let tmp = TempDir::new().unwrap();

ostool/src/tool.rs

@@ -171,6 +171,28 @@ impl Tool {
             })
     }
 
+    pub(crate) fn resolve_package_manifest_dir(&self, package: &str) -> anyhow::Result<PathBuf> {
+        let metadata = self.metadata()?;
+        let Some(pkg) = metadata.packages.iter().find(|pkg| pkg.name == package) else {
+            bail!(
+                "package '{}' not found in cargo metadata under {}",
+                package,
+                self.manifest_dir().display()
+            );
+        };
+
+        pkg.manifest_path
+            .parent()
+            .map(|path| path.as_std_path().to_path_buf())
+            .ok_or_else(|| {
+                anyhow!(
+                    "package '{}' manifest has no parent: {}",
+                    package,
+                    pkg.manifest_path
+                )
+            })
+    }
+
     /// Sets the ELF artifact path and synchronizes derived runtime metadata.
     pub async fn set_elf_artifact_path(&mut self, path: PathBuf) -> anyhow::Result<()> {
         let path = path
@@ -485,6 +507,8 @@ fn resolve_manifest_path(input: Option<PathBuf>) -> anyhow::Result<PathBuf> {
 #[cfg(test)]
 mod tests {
     use super::{Tool, ToolConfig, resolve_manifest_context};
+    use crate::run::qemu::resolve_qemu_config_path_in_dir;
+    use object::Architecture;
 
     #[tokio::test]
     async fn set_elf_artifact_path_updates_dirs_and_arch() {
@@ -548,4 +572,87 @@ mod tests {
         assert_eq!(manifest.manifest_dir, app_dir);
         assert_eq!(manifest.workspace_dir, temp.path());
     }
+
+    #[test]
+    fn resolve_package_manifest_dir_uses_selected_package() {
+        let temp = tempfile::tempdir().unwrap();
+        std::fs::write(
+            temp.path().join("Cargo.toml"),
+            "[workspace]\nmembers = [\"app\", \"kernel\"]\nresolver = \"3\"\n",
+        )
+        .unwrap();
+
+        let app_dir = temp.path().join("app");
+        std::fs::create_dir_all(app_dir.join("src")).unwrap();
+        std::fs::write(
+            app_dir.join("Cargo.toml"),
+            "[package]\nname = \"app\"\nversion = \"0.1.0\"\nedition = \"2024\"\n",
+        )
+        .unwrap();
+        std::fs::write(app_dir.join("src/main.rs"), "fn main() {}\n").unwrap();
+
+        let kernel_dir = temp.path().join("kernel");
+        std::fs::create_dir_all(kernel_dir.join("src")).unwrap();
+        std::fs::write(
+            kernel_dir.join("Cargo.toml"),
+            "[package]\nname = \"kernel\"\nversion = \"0.1.0\"\nedition = \"2024\"\n",
+        )
+        .unwrap();
+        std::fs::write(kernel_dir.join("src/main.rs"), "fn main() {}\n").unwrap();
+
+        let tool = Tool::new(ToolConfig {
+            manifest: Some(app_dir.clone()),
+            ..Default::default()
+        })
+        .unwrap();
+
+        let resolved = tool.resolve_package_manifest_dir("kernel").unwrap();
+        assert_eq!(resolved, kernel_dir);
+    }
+
+    #[test]
+    fn cargo_qemu_config_resolution_prefers_package_dir_over_workspace_root() {
+        let temp = tempfile::tempdir().unwrap();
+        std::fs::write(
+            temp.path().join("Cargo.toml"),
+            "[workspace]\nmembers = [\"app\", \"kernel\"]\nresolver = \"3\"\n",
+        )
+        .unwrap();
+        std::fs::write(temp.path().join("qemu-aarch64.toml"), "").unwrap();
+
+        let app_dir = temp.path().join("app");
+        std::fs::create_dir_all(app_dir.join("src")).unwrap();
+        std::fs::write(
+            app_dir.join("Cargo.toml"),
+            "[package]\nname = \"app\"\nversion = \"0.1.0\"\nedition = \"2024\"\n",
+        )
+        .unwrap();
+        std::fs::write(app_dir.join("src/main.rs"), "fn main() {}\n").unwrap();
+
+        let kernel_dir = temp.path().join("kernel");
+        std::fs::create_dir_all(kernel_dir.join("src")).unwrap();
+        std::fs::write(
+            kernel_dir.join("Cargo.toml"),
+            "[package]\nname = \"kernel\"\nversion = \"0.1.0\"\nedition = \"2024\"\n",
+        )
+        .unwrap();
+        std::fs::write(kernel_dir.join("src/main.rs"), "fn main() {}\n").unwrap();
+        std::fs::write(kernel_dir.join(".qemu-aarch64.toml"), "").unwrap();
+
+        let tool = Tool::new(ToolConfig {
+            manifest: Some(app_dir),
+            ..Default::default()
+        })
+        .unwrap();
+
+        let package_dir = tool.resolve_package_manifest_dir("kernel").unwrap();
+        let resolved = resolve_qemu_config_path_in_dir(
+            &package_dir,
+            Some(Architecture::Aarch64),
+            None,
+        )
+        .unwrap();
+
+        assert_eq!(resolved, kernel_dir.join(".qemu-aarch64.toml"));
+    }
 }