Add a run subcommand (builds and invokes QEMU by default)

Author: phil-opp

Readme.md

@@ -27,6 +27,9 @@ Configuration is done through a through a `[package.metadata.bootimage]` table i
     default-target = ""         # This target is used if no `--target` is passed
     output = "bootimage.bin"    # The output file name
     minimum-image-size = 0      # The minimum output file size (in MiB)
+    # The command invoked on `bootimage run`
+    # (the "{}" will be replaced with the path to the bootable disk image)
+    run-command = ["qemu-system-x86_64", "-drive", "format=raw,file={}"]
 
     [package.metadata.bootimage.bootloader]
     name = "bootloader"             # The bootloader crate name

src/args.rs

@@ -7,18 +7,28 @@ pub(crate) fn parse_args() -> Command {
     let first = args.next();
     match first.as_ref().map(|s| s.as_str()) {
         Some("build") => parse_build_args(args),
+        Some("run") => match parse_build_args(args) {
+            Command::Build(args) => Command::Run(args),
+            Command::BuildHelp => Command::RunHelp,
+            cmd => cmd,
+        },
         Some("--help") | Some("-h") => Command::Help,
         Some("--version") => Command::Version,
         _ => Command::NoSubcommand,
     }
 }
 
-fn parse_build_args<A>(args: A) -> Command where A: Iterator<Item=String>{
+fn parse_build_args<A>(args: A) -> Command
+where
+    A: Iterator<Item = String>,
+{
     let mut manifest_path: Option<PathBuf> = None;
     let mut target: Option<String> = None;
     let mut release: Option<bool> = None;
     let mut update_bootloader: Option<bool> = None;
     let mut cargo_args = Vec::new();
+    let mut run_args = Vec::new();
+    let mut run_args_started = false;
     {
         fn set<T>(arg: &mut Option<T>, value: Option<T>) {
             let previous = mem::replace(arg, value);
@@ -30,6 +40,10 @@ fn parse_build_args<A>(args: A) -> Command where A: Iterator<Item=String>{
 
         let mut arg_iter = args.into_iter();
         while let Some(arg) = arg_iter.next() {
+            if run_args_started {
+                run_args.push(arg);
+                continue;
+            }
             match arg.as_ref() {
                 "--help" | "-h" => {
                     return Command::BuildHelp;
@@ -54,10 +68,7 @@ fn parse_build_args<A>(args: A) -> Command where A: Iterator<Item=String>{
                 }
                 "--manifest-path" => {
                     let next = arg_iter.next();
-                    set(
-                        &mut manifest_path,
-                        next.as_ref().map(|p| PathBuf::from(&p)),
-                    );
+                    set(&mut manifest_path, next.as_ref().map(|p| PathBuf::from(&p)));
                     cargo_args.push(arg);
                     if let Some(next) = next {
                         cargo_args.push(next);
@@ -71,10 +82,13 @@ fn parse_build_args<A>(args: A) -> Command where A: Iterator<Item=String>{
                 "--release" => {
                     set(&mut release, Some(true));
                     cargo_args.push(arg);
-                },
+                }
                 "--update-bootloader" => {
                     set(&mut update_bootloader, Some(true));
                 }
+                "--" => {
+                    run_args_started = true;
+                }
                 _ => {
                     cargo_args.push(arg);
                 }
@@ -83,7 +97,8 @@ fn parse_build_args<A>(args: A) -> Command where A: Iterator<Item=String>{
     }
 
     Command::Build(Args {
-        all_cargo: cargo_args,
+        cargo_args,
+        run_args,
         target,
         manifest_path,
         release: release.unwrap_or(false),
@@ -93,14 +108,16 @@ fn parse_build_args<A>(args: A) -> Command where A: Iterator<Item=String>{
 
 pub struct Args {
     /// All arguments that are passed to cargo.
-    pub all_cargo: Vec<String>,
-    /// The manifest path (also present in `all_cargo`).
+    pub cargo_args: Vec<String>,
+    /// All arguments that are passed to the runner.
+    pub run_args: Vec<String>,
+    /// The manifest path (also present in `cargo_args`).
     manifest_path: Option<PathBuf>,
-    /// The target triple (also present in `all_cargo`).
+    /// The target triple (also present in `cargo_args`).
     target: Option<String>,
-    /// The release flag (also present in `all_cargo`).
+    /// The release flag (also present in `cargo_args`).
     release: bool,
-    /// Whether the bootloader should be updated (not present in `all_cargo`).
+    /// Whether the bootloader should be updated (not present in `cargo_args`).
     update_bootloader: bool,
 }
 
@@ -124,7 +141,7 @@ impl Args {
     pub fn set_target(&mut self, target: String) {
         assert!(self.target.is_none());
         self.target = Some(target.clone());
-        self.all_cargo.push("--target".into());
-        self.all_cargo.push(target);
+        self.cargo_args.push("--target".into());
+        self.cargo_args.push(target);
     }
 }

src/build.rs

@@ -11,7 +11,20 @@ use xmas_elf;
 const BLOCK_SIZE: usize = 512;
 type KernelInfoBlock = [u8; BLOCK_SIZE];
 
-pub(crate) fn build(mut args: Args) -> Result<(), Error> {
+pub(crate) fn build(args: Args) -> Result<(), Error> {
+    let (args, config, metadata, out_dir) = common_setup(args)?;
+
+    build_impl(&args, &config, &metadata, &out_dir)
+}
+
+pub(crate) fn run(args: Args) -> Result<(), Error> {
+    let (args, config, metadata, out_dir) = common_setup(args)?;
+
+    build_impl(&args, &config, &metadata, &out_dir)?;
+    run_impl(&args, &config)
+}
+
+fn common_setup(mut args: Args) -> Result<(Args, Config, CargoMetadata, PathBuf), Error> {
     fn out_dir(args: &Args, metadata: &CargoMetadata) -> PathBuf {
         let target_dir = PathBuf::from(&metadata.target_directory);
         let mut out_dir = target_dir;
@@ -43,13 +56,22 @@ pub(crate) fn build(mut args: Args) -> Result<(), Error> {
 
     let out_dir = out_dir(&args, &metadata);
 
+    Ok((args, config, metadata, out_dir))
+}
+
+fn build_impl(
+    args: &Args,
+    config: &Config,
+    metadata: &CargoMetadata,
+    out_dir: &Path,
+) -> Result<(), Error> {
     let kernel = build_kernel(&out_dir, &args, &config, &metadata)?;
 
     let kernel_size = kernel.metadata()?.len();
     let kernel_info_block = create_kernel_info_block(kernel_size);
 
     if args.update_bootloader() {
-        let mut bootloader_cargo_lock = out_dir.clone();
+        let mut bootloader_cargo_lock = PathBuf::from(out_dir);
         bootloader_cargo_lock.push("bootloader");
         bootloader_cargo_lock.push("Cargo.lock");
 
@@ -63,6 +85,25 @@ pub(crate) fn build(mut args: Args) -> Result<(), Error> {
     Ok(())
 }
 
+fn run_impl(args: &Args, config: &Config) -> Result<(), Error> {
+    let command = &config.run_command[0];
+    let mut command = process::Command::new(command);
+    for arg in &config.run_command[1..] {
+        command.arg(
+            arg.replace(
+                "{}",
+                config
+                    .output
+                    .to_str()
+                    .expect("output must be valid unicode"),
+            ),
+        );
+    }
+    command.args(&args.run_args);
+    command.status()?;
+    Ok(())
+}
+
 fn read_cargo_metadata(args: &Args) -> Result<CargoMetadata, cargo_metadata::Error> {
     cargo_metadata::metadata(args.manifest_path().as_ref().map(PathBuf::as_path))
 }
@@ -82,7 +123,7 @@ fn build_kernel(
 
     // compile kernel
     println!("Building kernel");
-    let exit_status = run_xargo_build(&env::current_dir()?, &args.all_cargo)?;
+    let exit_status = run_xargo_build(&env::current_dir()?, &args.cargo_args)?;
     if !exit_status.success() {
         process::exit(1)
     }

src/config.rs

@@ -8,6 +8,7 @@ pub struct Config {
     pub output: PathBuf,
     pub bootloader: BootloaderConfig,
     pub minimum_image_size: Option<u64>,
+    pub run_command: Vec<String>,
 }
 
 pub struct BootloaderConfig {
@@ -89,6 +90,18 @@ pub(crate) fn read_config(manifest_path: PathBuf) -> Result<Config, Error> {
                     )))?
                 }
             }
+            ("run-command", Value::Array(array)) => {
+                let mut command = Vec::new();
+                for value in array {
+                    match value {
+                        Value::String(s) => command.push(s),
+                        _ => Err(Error::Config(format!(
+                            "run-command must be a list of strings"
+                        )))?,
+                    }
+                }
+                config.run_command = Some(command);
+            }
             (key, value) => Err(Error::Config(format!(
                 "unexpected `package.metadata.bootimage` \
                  key `{}` with value `{}`",
@@ -106,6 +119,7 @@ struct ConfigBuilder {
     output: Option<PathBuf>,
     bootloader: Option<BootloaderConfigBuilder>,
     minimum_image_size: Option<u64>,
+    run_command: Option<Vec<String>>,
 }
 
 #[derive(Default)]
@@ -131,6 +145,11 @@ impl Into<Config> for ConfigBuilder {
             output: self.output.unwrap_or(PathBuf::from("bootimage.bin")),
             bootloader: self.bootloader.unwrap_or(default_bootloader_config).into(),
             minimum_image_size: self.minimum_image_size,
+            run_command: self.run_command.unwrap_or(vec![
+                "qemu-system-x86_64".into(),
+                "-drive".into(),
+                "format=raw,file={}".into(),
+            ]),
         }
     }
 }

src/help/build_help.txt

@@ -1,11 +1,11 @@
 Creates a bootable disk image from a Rust kernel
 
 USAGE:
-    bootimage build [BUILD_OPTIONS]     Create a bootable disk image (see below)
+    bootimage build [BUILD_OPTS]        Create a bootable disk image
 
     (for other forms of usage see `bootimage --help`)
 
-BUILD_OPTIONS:
+BUILD_OPTS:
     --update-bootloader     Update the bootloader dependency.
 
     Any additional options are directly passed to `cargo build` (see
@@ -16,7 +16,7 @@ BUILD_OPTIONS:
 CONFIGURATION:
     The bootloader and the behavior of `bootimage build` can be configured
     through a `[package.metadata.bootimage]` table in the `Cargo.toml`. The
-    following options are available:
+    following options are available to configure the build:
 
     [package.metadata.bootimage]
     default-target = ""         This target is used if no `--target` is passed

src/help/help.txt

@@ -1,14 +1,15 @@
 Creates a bootable disk image from a Rust kernel
 
 USAGE:
-    bootimage [OPTIONS]                 Display help and version information
-    bootimage build [BUILD_OPTIONS]     Create a bootable disk image (see below)
+    bootimage [OPTIONS]                         Help and version information
+    bootimage build [BUILD_OPTS]                Create a bootable disk image
+    bootimage run [BUILD_OPTS] -- [RUN_OPTS]    Build and run a disk image
 
 OPTIONS:
     -h, --help      Prints help information and exit
     ---version      Prints version information and exit
 
-BUILD_OPTIONS:
+BUILD_OPTS:
     --update-bootloader     Update the bootloader dependency.
 
     Any additional options are directly passed to `cargo build` (see
@@ -17,3 +18,9 @@ BUILD_OPTIONS:
     disk image.
 
     For configuration options see `bootimage build --help`.
+
+RUN_OPTS:
+    Any options are directly passed to the run command. Note that the run
+    options must be separated from the build options by a "--".
+
+    For configuration options see `bootimage run --help`.

src/help/mod.rs

@@ -2,6 +2,7 @@ use std::process;
 
 const HELP: &str = include_str!("help.txt");
 const BUILD_HELP: &str = include_str!("build_help.txt");
+const RUN_HELP: &str = include_str!("run_help.txt");
 
 pub(crate) fn help() {
     print!("{}", HELP);
@@ -11,6 +12,10 @@ pub(crate) fn build_help() {
     print!("{}", BUILD_HELP);
 }
 
+pub(crate) fn run_help() {
+    print!("{}", RUN_HELP);
+}
+
 pub(crate) fn no_subcommand() -> ! {
     println!("Please invoke `bootimage` with a subcommand (e.g. `bootimage build`).");
     println!();

src/help/run_help.txt

@@ -0,0 +1,21 @@
+Creates a bootable disk image from a Rust kernel
+
+USAGE:
+    bootimage run [BUILD_OPTS] -- [RUN_OPTS]        Build and run a disk image
+
+    (for other forms of usage see `bootimage --help`)
+    (for BUILD_OPTS see `bootimage build --help`)
+
+RUN_OPTS:
+    Any options are directly passed to the run command. Note that the run
+    options must be separated from the build options by a "--".
+
+CONFIGURATION:
+    The behavior of `bootimage run` can be configured through a
+    `[package.metadata.bootimage]` table in the `Cargo.toml`. The
+    following options are available to configure run behavior:
+
+    [package.metadata.bootimage]
+    # The command invoked on `bootimage run`
+    # (the "{}" will be replaced with the path to the bootable disk image)
+    run-command = ["qemu-system-x86_64", "-drive", "format=raw,file={}"]

src/main.rs

@@ -14,8 +14,10 @@ mod help;
 enum Command {
     NoSubcommand,
     Build(Args),
+    Run(Args),
     Help,
     BuildHelp,
+    RunHelp,
     Version,
 }
 
@@ -59,8 +61,10 @@ fn run() -> Result<(), Error> {
     match command {
         Command::NoSubcommand => help::no_subcommand(),
         Command::Build(args) => build::build(args),
+        Command::Run(args) => build::run(args),
         Command::Help => Ok(help::help()),
         Command::BuildHelp => Ok(help::build_help()),
+        Command::RunHelp => Ok(help::run_help()),
         Command::Version => Ok(println!("bootimage {}", env!("CARGO_PKG_VERSION"))),
     }
 }