Add a new bootimage runner subcommand for use as target.runner

Author: phil-opp

Cargo.lock

@@ -15,6 +15,7 @@ wait-timeout = "0.2"
 xmas-elf = "0.6.2"
 llvm-tools = "0.1.1"
 locate-cargo-manifest = "0.1.0"
+tempdir = "0.3.7"
 
 [dependencies.cargo_metadata]
 version = "0.7.4"

Cargo.toml

@@ -23,6 +23,7 @@ pub(crate) fn parse_args() -> Command {
             Command::BuildHelp => Command::TestHelp,
             cmd => cmd,
         },
+        Some("runner") => parse_runner_args(args),
         Some("--help") | Some("-h") => Command::Help,
         Some("--version") => Command::Version,
         _ => Command::NoSubcommand,
@@ -194,3 +195,41 @@ impl Args {
         }
     }
 }
+
+fn parse_runner_args<A>(args: A) -> Command
+where
+    A: Iterator<Item = String>,
+{
+    let mut arg_iter = args.into_iter().fuse();
+    let executable = PathBuf::from(arg_iter.next().expect("excepted path to kernel executable as first argument")).canonicalize().expect("Failed to canonicalize executable path");
+    let mut run_command = 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()));
+                assert!(old.is_none(), "multiple `--command` arguments");
+                break;
+            }
+            Some("--help") | Some("-h") => {
+                return Command::RunnerHelp;
+            }
+            Some("--version") => {
+                return Command::Version;
+            }
+            None => break,
+            Some(arg) => panic!("unexpected argument `{}`", arg),
+        }
+    }
+
+    Command::Runner(RunnerArgs {
+        executable,
+        run_command,
+    })
+}
+
+#[derive(Debug, Clone)]
+pub struct RunnerArgs {
+    pub executable: PathBuf,
+    pub run_command: Option<Vec<String>>,
+}

src/args.rs

@@ -1,4 +1,4 @@
-use args::Args;
+use args::{Args, RunnerArgs};
 use std::{fmt, process};
 
 mod args;
@@ -12,17 +12,19 @@ enum Command {
     Build(Args),
     Run(Args),
     Test(Args),
+    Runner(RunnerArgs),
     Help,
     BuildHelp,
     RunHelp,
     TestHelp,
+    RunnerHelp,
     Version,
 }
 
 pub fn main() {
     if let Err(err) = run() {
-        eprintln!("Error: {}", err.display());
-        process::exit(1);
+        eprintln!("Error: {}", err.message);
+        process::exit(err.exit_code);
     }
 }
 
@@ -32,26 +34,25 @@ fn run() -> Result<(), ErrorString> {
         Command::Build(args) => subcommand::build::build(args),
         Command::Run(args) => subcommand::run::run(args),
         Command::Test(args) => subcommand::test::test(args),
+        Command::Runner(args) => subcommand::runner::runner(args),
         Command::NoSubcommand => help::no_subcommand(),
         Command::Help => Ok(help::help()),
         Command::BuildHelp => Ok(help::build_help()),
         Command::RunHelp => Ok(help::run_help()),
         Command::TestHelp => Ok(help::test_help()),
+        Command::RunnerHelp => unimplemented!(),
         Command::Version => Ok(println!("bootimage {}", env!("CARGO_PKG_VERSION"))),
     }
 }
 
-struct ErrorString(Box<dyn fmt::Display + Send>);
-
-impl ErrorString {
-    fn display(&self) -> &dyn fmt::Display {
-        &self.0
-    }
+struct ErrorString {
+    pub message: Box<dyn fmt::Display + Send>,
+    pub exit_code: i32,
 }
 
 impl fmt::Debug for ErrorString {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.display().fmt(f)
+        self.message.fmt(f)
     }
 }
 
@@ -60,6 +61,9 @@ where
     T: fmt::Display + Send + 'static,
 {
     fn from(err: T) -> Self {
-        ErrorString(Box::new(err))
+        ErrorString {
+            message: Box::new(err),
+            exit_code: 1,
+        }
     }
 }

src/main.rs

@@ -1,3 +1,4 @@
 pub mod build;
 pub mod run;
+pub mod runner;
 pub mod test;

src/subcommand.rs

@@ -0,0 +1,42 @@
+use crate::{args::RunnerArgs, ErrorString};
+use std::process;
+
+pub(crate) fn runner(args: RunnerArgs) -> Result<(), ErrorString> {
+    let out_dir = tempdir::TempDir::new("bootimage-runner")?;
+    let bootimage_bin = out_dir.path().join("bootimage.bin");
+
+    let builder = bootimage::Builder::new(None)?;
+    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(),
+    ]);
+
+    println!("Running {:?}", run_cmd);
+
+    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 output = command
+        .output()
+        .map_err(|e| format!("Failed to execute `{:?}`: {}", command, e))?;
+
+    if !output.status.success() {
+        return Err(ErrorString {
+            exit_code: output.status.code().unwrap_or(1),
+            message: Box::new(format!(
+                "Command `{:?}` failed:\n{}",
+                command,
+                String::from_utf8_lossy(&output.stderr)
+            )),
+        });
+    }
+
+    drop(bootimage_bin);
+    out_dir.close()?;
+
+    Ok(())
+}