Convert runner args to config keys

Variable length args are not possible since the executable name is appended at the end

Author: phil-opp

example-kernels/runner/.cargo/config

@@ -2,4 +2,4 @@
 target = "../x86_64-bootimage-example-kernels.json"
 
 [target.'cfg(target_os = "none")']
-runner = "bootimage runner --args -device isa-debug-exit,iobase=0xf4,iosize=0x04 -display none"
+runner = "bootimage runner"

example-kernels/runner/Cargo.toml

@@ -7,3 +7,6 @@ edition = "2018"
 [dependencies]
 bootloader = "0.5.0"
 x86_64 = "0.5.3"
+
+[package.metadata.bootimage]
+run-args = ["-device", "isa-debug-exit,iobase=0xf4,iosize=0x04", "-display", "none"]

src/args.rs

@@ -207,56 +207,41 @@ fn parse_runner_args<A>(args: A) -> Result<Command, ErrorString>
 where
     A: Iterator<Item = String>,
 {
+    let mut executable = None;
     let mut arg_iter = args.into_iter().fuse();
-    let executable = PathBuf::from(
-        arg_iter
-            .next()
-            .ok_or("excepted path to kernel executable as first argument")?,
-    )
-    .canonicalize()
-    .map_err(|err| format!("Failed to canonicalize executable path: {}", err))?;
-    let mut run_command = None;
-    let mut run_args = None;
 
     loop {
         match arg_iter.next().as_ref().map(|s| s.as_str()) {
-            Some("--command") => {
-                let old = mem::replace(&mut run_command, Some(arg_iter.collect()));
-                if !old.is_none() {
-                    Err("multiple `--command` arguments")?;
-                }
-                break;
-            }
-            Some("--args") => {
-                let old = mem::replace(&mut run_args, Some(arg_iter.collect()));
-                if !old.is_none() {
-                    Err("multiple `--args` arguments")?;
-                }
-                break;
-            }
             Some("--help") | Some("-h") => {
                 return Ok(Command::RunnerHelp);
             }
             Some("--version") => {
                 return Ok(Command::Version);
             }
-            None => break,
+            Some(exe) if executable.is_none() => {
+                let path = Path::new(exe);
+                let path_canonicalized = path.canonicalize().map_err(|err| {
+                    format!(
+                        "Failed to canonicalize executable path `{}`: {}",
+                        path.display(),
+                        err
+                    )
+                })?;
+                executable = Some(path_canonicalized);
+            }
             Some(arg) => Err(format!("unexpected argument `{}`", arg))?,
+            None => break,
         }
     }
 
     Ok(Command::Runner(RunnerArgs {
-        executable,
-        run_command,
-        run_args,
+        executable: executable.ok_or("excepted path to kernel executable as first argument")?,
     }))
 }
 
 #[derive(Debug, Clone)]
 pub struct RunnerArgs {
     pub executable: PathBuf,
-    pub run_command: Option<Vec<String>>,
-    pub run_args: Option<Vec<String>>,
 }
 
 fn parse_tester_args<A>(args: A) -> Result<Command, ErrorString>

src/config.rs

@@ -7,6 +7,7 @@ pub struct Config {
     pub manifest_path: PathBuf,
     pub default_target: Option<String>,
     pub run_command: Vec<String>,
+    pub run_args: Option<Vec<String>>,
     pub test_timeout: u32,
 }
 
@@ -70,6 +71,16 @@ pub(crate) fn read_config_inner(manifest_path: PathBuf) -> Result<Config, ErrorS
                 }
                 config.run_command = Some(command);
             }
+            ("run-args", Value::Array(array)) => {
+                let mut args = Vec::new();
+                for value in array {
+                    match value {
+                        Value::String(s) => args.push(s),
+                        _ => Err(format!("run-args must be a list of strings"))?,
+                    }
+                }
+                config.run_args = Some(args);
+            }
             (key, value) => Err(format!(
                 "unexpected `package.metadata.bootimage` \
                  key `{}` with value `{}`",
@@ -85,6 +96,7 @@ struct ConfigBuilder {
     manifest_path: Option<PathBuf>,
     default_target: Option<String>,
     run_command: Option<Vec<String>>,
+    run_args: Option<Vec<String>>,
     test_timeout: Option<u32>,
 }
 
@@ -98,6 +110,7 @@ impl Into<Config> for ConfigBuilder {
                 "-drive".into(),
                 "format=raw,file={}".into(),
             ]),
+            run_args: self.run_args,
             test_timeout: self.test_timeout.unwrap_or(60 * 5),
         }
     }

src/subcommand/runner.rs

@@ -1,8 +1,9 @@
-use crate::{args::RunnerArgs, builder::Builder, ErrorString};
+use crate::{args::RunnerArgs, builder::Builder, config, ErrorString};
 use std::{fs, process};
 
 pub(crate) fn runner(args: RunnerArgs) -> Result<i32, ErrorString> {
     let builder = Builder::new(None)?;
+    let config = config::read_config(builder.kernel_manifest_path().to_owned())?;
 
     let bootimage_bin = {
         let kernel_target_dir = &builder.kernel_metadata().target_directory;
@@ -38,17 +39,11 @@ pub(crate) fn runner(args: RunnerArgs) -> Result<i32, ErrorString> {
 
     builder.create_bootimage(&args.executable, &bootimage_bin, false)?;
 
-    let run_cmd = args.run_command.unwrap_or(vec![
-        "qemu-system-x86_64".into(),
-        "-drive".into(),
-        "format=raw,file={bootimage}".into(),
-    ]);
-
-    let mut command = process::Command::new(&run_cmd[0]);
-    for arg in &run_cmd[1..] {
-        command.arg(arg.replace("{bootimage}", &format!("{}", bootimage_bin.display())));
+    let mut command = process::Command::new(&config.run_command[0]);
+    for arg in &config.run_command[1..] {
+        command.arg(arg.replace("{}", &format!("{}", bootimage_bin.display())));
     }
-    if let Some(run_args) = args.run_args {
+    if let Some(run_args) = config.run_args {
         command.args(run_args);
     }