Rewrite for new bootloader build system

Cargo.toml

@@ -5,19 +5,16 @@ license = "MIT/Apache-2.0"
 name = "bootimage"
 version = "0.6.6"
 repository = "https://github.com/rust-osdev/bootimage"
+edition = "2018"
 
 [dependencies]
-byteorder = "1.3.1"
 rayon = "1.0"
 toml = "0.5.0"
 wait-timeout = "0.2"
-xmas-elf = "0.6.2"
+llvm-tools = "0.1.1"
+locate-cargo-manifest = "0.1.0"
+json = "0.11.13"
 
 [dependencies.cargo_metadata]
 version = "0.7.4"
 default-features = false
-
-[dependencies.failure]
-version = "0.1.5"
-default-features = false
-features = ["std"]

Changelog.md

@@ -1,3 +1,29 @@
+
+## Breaking
+
+- Rewrite for new bootloader build system
+  - Compatible with bootloader 0.5.0+
+- Remove the following config options: `output`, `bootloader.*`, `minimum_image_size`, and `package_filepath`
+  - The bootloader is now fully controlled through cargo dependencies.
+  - For using a bootloader crate with name different than `bootloader` use [cargo's rename feature](https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html#renaming-dependencies-in-cargotoml).
+- Remove support for `bootloader_precompiled`
+  - The `bootloader` crate compiles fine on all architectures for some time and should be prefered
+- Require the `llvm-tools-preview` rustup component
+- Pass the QEMU exit code in `bootimage run`
+
+## Other
+
+- Add support for default targets declared in `.cargo/config` files
+- Add a `cargo-bootimage` executable that is equivalent to `bootimage build` and can be used as cargo subcommand (`cargo bootimage`)
+- Add a new `bootimage runner` subcommand that can be used as `target.[…].runner` in `.cargo/config` files
+- Make test timeout configurable and increase default to 5 minutes
+- Move crate to 2018 edition
+- Refactor and cleanup the code
+- Remove the dependency on `failure`
+    - Use a custom `ErrorMessage` type instead
+- Add a new `run-args` config key
+- Add a new `--quiet` argument to suppress output
+
 # 0.6.6
 
 - Update dependencies

Readme.md

@@ -10,40 +10,83 @@ Creates a bootable disk image from a Rust OS kernel.
 
 ## Usage
 
-First you need to add a dependency on the `bootloader` crate:
+First you need to add a dependency on the [`bootloader`](https://github.com/rust-osdev/bootloader) crate:
 
 ```toml
 # in your Cargo.toml
 
 [dependencies]
-bootloader = "0.2.0-alpha"
+bootloader = "0.5.0"
 ```
 
+**Note**: At least bootloader version `0.5.0` is required.
+
+If you want to use a custom bootloader with a different name, you can use Cargo's [rename functionality](https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html#renaming-dependencies-in-cargotoml).
+
+### Building
+
 Now you can build the kernel project and create a bootable disk image from it by running:
 
 ```
-> bootimage build --target your_custom_target.json [other_args]
+bootimage build --target your_custom_target.json [other_args]
+```
+
+The command will invoke [`cargo xbuild`](https://github.com/rust-osdev/cargo-xbuild), forwarding all passed options. Then it will build the specified bootloader together with the kernel to create a bootable disk image.
+
+If you prefer a cargo subcommand, you can use the equivalent `cargo bootimage` command:
+
+```
+cargo bootimage --target your_custom_target.json [other_args]
+```
+
+### Running
+
+To run your kernel in QEMU, you can use `bootimage run`:
+
+```
+bootimage run --target your_custom_target.json [other_args] -- [qemu args]
+```
+
+All arguments after `--` are passed to QEMU. If you want to use a custom run command, see the _Configuration_ section below.
+
+If you prefer working directly with cargo, you can use `bootimage runner` as a custom runner in your `.cargo/config`:
+
+```toml
+[target.'cfg(target_os = "none")']
+runner = "bootimage runner"
 ```
 
-The command will invoke [`cargo xbuild`](https://github.com/rust-osdev/cargo-xbuild), forwarding all passed options. Then it will download and build a bootloader, by default the [rust-osdev/bootloader](https://github.com/rust-osdev/bootloader). Finally, it combines the kernel and the bootloader into a bootable disk image.
+Now you can run your kernel through `cargo xrun --target […]`.
 
 ## Configuration
 
-Configuration is done through a through a `[package.metadata.bootimage]` table in the `Cargo.toml`. The following options are available:
+Configuration is done through a through a `[package.metadata.bootimage]` table in the `Cargo.toml` of your kernel. The following options are available:
 
 ```toml
     [package.metadata.bootimage]
-    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`
+    # This target is used if no `--target` is passed
+    default-target = ""
+
+    # The command invoked on `bootimage run` or `bootimage runner`
     # (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
-    target = "x86_64-bootloader.json"   # Target triple for compiling the bootloader
+    # Additional arguments passed to the runner on `bootimage run` or `bootimage runner`
+    # (this is useful when you want to add some arguments to the default QEMU command)
+    run-args = []
+
+    # The timeout for running an integration test through `bootimage test` in seconds
+    test-timeout = 300
 ```
 
 ## License
-Dual-licensed under MIT or the Apache License (Version 2.0).
+
+Licensed under either of
+
+- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or
+  http://www.apache.org/licenses/LICENSE-2.0)
+- MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
+
+at your option.
+
+Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.