Bootimage

https://docs.rs/bootimage
Admin
Bootimage is a Rust crate that provides functions to create a bootable OS image from a kernel...
Tokens:16,701
Snippets:213
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Create Disk Image using llvm-objcopy

Source: https://docs.rs/bootimage/latest/src/bootimage/builder/disk_image.rs.html

Converts a bootloader ELF file to a binary format using `llvm-objcopy` and pads it to a nearest block size. Requires `llvm-tools` to be installed.

```rust
use super::error::DiskImageError;
use std::{path::Path, process::Command};

pub fn create_disk_image(
    bootloader_elf_path: &Path,
    output_bin_path: &Path,
) -> Result<(), DiskImageError> {
    let llvm_tools = llvm_tools::LlvmTools::new()?;
    let objcopy = llvm_tools
        .tool(&llvm_tools::exe("llvm-objcopy"))
        .ok_or(DiskImageError::LlvmObjcopyNotFound)?;

    // convert bootloader to binary
    let mut cmd = Command::new(objcopy);
    cmd.arg("-I").arg("elf64-x86-64");
    cmd.arg("-O").arg("binary");
    cmd.arg("--binary-architecture=i386:x86-64");
    cmd.arg(bootloader_elf_path);
    cmd.arg(output_bin_path);
    let output = cmd.output().map_err(|err| DiskImageError::Io {
        message: "failed to execute llvm-objcopy command",
        error: err,
    })?;
    if !output.status.success() {
        return Err(DiskImageError::ObjcopyFailed {
            stderr: output.stderr,
        });
    }

    pad_to_nearest_block_size(output_bin_path)?;
    Ok(())
}
```

--------------------------------

### print_version

Source: https://docs.rs/bootimage/latest/src/bootimage/help/mod.rs.html

Prints the current version of the bootimage crate to the console. This is useful for debugging and verifying the installed version.

```APIDOC
## print_version

### Description
Prints the version of this crate.

### Signature
`pub fn print_version()`
```

--------------------------------

### Get manifest path from BuildArgs

Source: https://docs.rs/bootimage/latest/src/bootimage/args/build.rs.html

Returns the value of the `--manifest-path` argument, if it was provided.

```rust
pub fn manifest_path(&self) -> Option<&Path> {
    self.manifest_path.as_deref()
}
```

--------------------------------

### Get Manifest Path

Source: https://docs.rs/bootimage/latest/bootimage/builder/struct.Builder.html

Retrieves the path to the Cargo.toml file of the project associated with the builder.

```rust
pub fn manifest_path(&self) -> &Path
```

--------------------------------

### Get Manifest Path

Source: https://docs.rs/bootimage/latest/bootimage/args/struct.BuildArgs.html

Retrieves the value of the `--manifest-path` argument, if it was provided.

```rust
pub fn manifest_path(&self) -> Option<&Path>
```

--------------------------------

### Get Cargo Arguments

Source: https://docs.rs/bootimage/latest/bootimage/args/struct.BuildArgs.html

Returns a slice of strings representing arguments to be forwarded to `cargo build`.

```rust
pub fn cargo_args(&self) -> &[String]
```

--------------------------------

### Get Project Metadata

Source: https://docs.rs/bootimage/latest/src/bootimage/builder/mod.rs.html

Retrieves the cargo metadata for the project. If not already loaded, it executes `cargo metadata` and caches the result.

```rust
fn project_metadata(&mut self) -> Result<&Metadata, cargo_metadata::Error> {
        if let Some(ref metadata) = self.project_metadata {
            return Ok(metadata);
        }
        let metadata = cargo_metadata::MetadataCommand::new()
            .manifest_path(&self.manifest_path)
            .exec()?;
        Ok(self.project_metadata.get_or_insert(metadata))
    }
```

--------------------------------

### Get Kernel Package Metadata

Source: https://docs.rs/bootimage/latest/bootimage/builder/struct.Builder.html

Finds and returns the cargo metadata package corresponding to the specified kernel binary name.

```rust
pub fn kernel_package_for_bin( &mut self, kernel_bin_name: &str, ) -> Result<Option<&Package>, Error>
```

--------------------------------

### Error::description Implementation for BuilderError (Deprecated)

Source: https://docs.rs/bootimage/latest/bootimage/builder/error/enum.BuilderError.html

Provides a deprecated method for getting a string description of the error.

```rust
fn description(&self) -> &str
```

--------------------------------

### Error::cause Implementation for BuilderError (Deprecated)

Source: https://docs.rs/bootimage/latest/bootimage/builder/error/enum.BuilderError.html

Provides a deprecated method for getting the cause of the error.

```rust
fn cause(&self) -> Option<&dyn Error>
```

--------------------------------

### Get Type ID

Source: https://docs.rs/bootimage/latest/bootimage/args/struct.BuildArgs.html

Gets the `TypeId` of the BuildArgs instance.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### run

Source: https://docs.rs/bootimage/latest/bootimage/run/index.html

Run the given disk image in QEMU.

```APIDOC
## run

### Description
Run the given disk image in QEMU.

### Parameters

This function does not explicitly list parameters in the provided documentation. However, based on its purpose, it likely accepts a disk image or configuration related to it.

### Returns

This function returns a `Result<(), RunError>` which indicates success or failure during the execution of the disk image in QEMU. The `RunError` enum provides context for potential failures.
```

--------------------------------

### run

Source: https://docs.rs/bootimage/latest/bootimage/run/fn.run.html

Runs the specified disk image in QEMU, applying configurations and arguments. It differentiates between regular runs and test executions.

```APIDOC
## run

### Description

Run the given disk image in QEMU. Automatically takes into account the runner arguments and the run/test commands defined in the given `Config`. Since test executables are treated differently (run with a timeout and match exit status), the caller needs to specify whether the given disk image is a test or not.

### Function Signature

```rust
pub fn run(
    config: Config,
    args: RunnerArgs,
    image_path: &Path,
    is_test: bool,
) -> Result<i32, RunError>
```

### Parameters

* `config` (Config) - The configuration for running the image.
* `args` (RunnerArgs) - The arguments for the runner.
* `image_path` (&Path) - The path to the disk image to run.
* `is_test` (bool) - A flag indicating if the image is for testing.

### Returns

* `Result<i32, RunError>` - Ok(0) on success, or a `RunError` on failure.
```

--------------------------------

### create_bootimage

Source: https://docs.rs/bootimage/latest/src/bootimage/builder/mod.rs.html

Creates a bootable disk image at the specified output path. It builds the bootloader, integrates it with the kernel, and places the final image.

```APIDOC
## create_bootimage

### Description
Places the resulting bootable disk image at the given `output_bin_path`. If the `quiet` argument is set to true, all output to stdout is suppressed.

### Method
`pub fn create_bootimage(&mut self, kernel_manifest_path: &Path, bin_path: &Path, output_bin_path: &Path, quiet: bool) -> Result<(), CreateBootimageError>`

### Parameters
#### Path Parameters
- **kernel_manifest_path** (`&Path`) - Description: Path to the kernel manifest.
- **bin_path** (`&Path`) - Description: Path to the binary.
- **output_bin_path** (`&Path`) - Description: Path where the output bootable disk image will be placed.

#### Query Parameters
- **quiet** (`bool`) - Description: If true, suppresses all output to stdout.

### Return Value
- `Result<(), CreateBootimageError>` - Ok(()) on success, or a `CreateBootimageError` on failure.
```

--------------------------------

### Create Bootable Disk Image

Source: https://docs.rs/bootimage/latest/src/bootimage/builder/mod.rs.html

Builds a bootable disk image. It first compiles the bootloader, then retrieves its ELF path, and finally creates the disk image. Suppresses stdout output if `quiet` is true.

```rust
pub fn create_bootimage(
        &mut self,
        kernel_manifest_path: &Path,
        bin_path: &Path,
        output_bin_path: &Path,
        quiet: bool,
    ) -> Result<(), CreateBootimageError> {
        let bootloader_build_config = bootloader::BuildConfig::from_metadata(
            self.project_metadata()?,
            kernel_manifest_path,
            bin_path,
        )?;

        // build bootloader
        if !quiet {
            println!("Building bootloader");
        }
        let mut cmd = bootloader_build_config.build_command();
        if !quiet {
            cmd.stdout(process::Stdio::inherit());
            cmd.stderr(process::Stdio::inherit());
        }
        let output = cmd.output().map_err(|err| CreateBootimageError::Io {
            message: "failed to execute bootloader build command",
            error: err,
        })?;
        if !output.status.success() {
            return Err(CreateBootimageError::BootloaderBuildFailed {
                stderr: output.stderr,
            });
        }

        // Retrieve binary path
        let mut cmd = bootloader_build_config.build_command();
        cmd.arg("--message-format").arg("json");
        let output = cmd.output().map_err(|err| CreateBootimageError::Io {
            message: "failed to execute bootloader build command with json output",
            error: err,
        })?;
        if !output.status.success() {
            return Err(CreateBootimageError::BootloaderBuildFailed {
                stderr: output.stderr,
            });
        }
        let mut bootloader_elf_path = None;
        for line in String::from_utf8(output.stdout)
            .map_err(CreateBootimageError::BuildJsonOutputInvalidUtf8)?
            .lines() {
            let mut artifact =
                json::parse(line).map_err(CreateBootimageError::BuildJsonOutputInvalidJson)?;
            if let Some(executable) = artifact["executable"].take_string() {
                if bootloader_elf_path
                    .replace(PathBuf::from(executable))
                    .is_some() {
                    return Err(BootloaderError::BootloaderInvalid(
                        "bootloader has multiple executables".into(),
                    )
                    .into());
                }
            }
        }
        let bootloader_elf_path = bootloader_elf_path.ok_or_else(|| {
            BootloaderError::BootloaderInvalid("bootloader has no executable".into())
        })?;

        disk_image::create_disk_image(&bootloader_elf_path, output_bin_path)?;

        Ok(())
    }
```

--------------------------------

### print_runner_help

Source: https://docs.rs/bootimage/latest/bootimage/help/fn.print_runner_help.html

Prints the help for the `bootimage runner` command.

```APIDOC
## print_runner_help

### Description
Prints the help for the `bootimage runner` command.

### Function Signature
```rust
pub fn print_runner_help()
```
```

--------------------------------

### print_help

Source: https://docs.rs/bootimage/latest/src/bootimage/help/mod.rs.html

Prints a general help text to the console. This function is useful for providing users with an overview of the bootimage crate's capabilities.

```APIDOC
## print_help

### Description
Prints a general help text.

### Signature
`pub fn print_help()`
```

--------------------------------

### Into<Config> Implementation for ConfigBuilder

Source: https://docs.rs/bootimage/latest/src/bootimage/config.rs.html

Converts a `ConfigBuilder` into a `Config` struct, applying default values for `build_command`, `run_command`, `test_timeout`, and `test_no_reboot` if they are not explicitly set. The `run_command` defaults to a QEMU system command with a placeholder for the drive file.

```rust
impl Into<Config> for ConfigBuilder {
    fn into(self) -> Config {
        Config {
            build_command: self.build_command.unwrap_or_else(|| vec!["build".into()])
            run_command: self.run_command.unwrap_or_else(|| {
                vec![
                    "qemu-system-x86_64".into(),
                    "-drive".into(),
                    "format=raw,file={}".into(),
                ]
            }),
            run_args: self.run_args,
            test_args: self.test_args,
            test_timeout: self.test_timeout.unwrap_or(60 * 5),
            test_success_exit_code: self.test_success_exit_code,
            test_no_reboot: self.test_no_reboot.unwrap_or(true),
        }
    }
}
```

--------------------------------

### Create Bootimage

Source: https://docs.rs/bootimage/latest/bootimage/builder/struct.Builder.html

Combines the kernel binary with the bootloader to create a bootable disk image. The output image is placed at the specified path. Suppresses stdout if `quiet` is true.

```rust
pub fn create_bootimage( &mut self, kernel_manifest_path: &Path, bin_path: &Path, output_bin_path: &Path, quiet: bool, ) -> Result<(), CreateBootimageError>
```

--------------------------------

### Run Disk Image in QEMU

Source: https://docs.rs/bootimage/latest/bootimage/run/fn.run.html

Use this function to run a disk image in QEMU. Specify whether it's a test to handle exit status and timeouts appropriately.

```rust
pub fn run(
    config: Config,
    args: RunnerArgs,
    image_path: &Path,
    is_test: bool,
) -> Result<i32, RunError>
```

--------------------------------

### Print General Help Text

Source: https://docs.rs/bootimage/latest/bootimage/help/fn.print_help.html

Call this function to display a general help message to the user.

```rust
pub fn print_help()
```

--------------------------------

### Builder::create_bootimage

Source: https://docs.rs/bootimage/latest/bootimage/builder/struct.Builder.html

Creates a bootimage by combining the given kernel binary with the bootloader. Places the resulting bootable disk image at the given `output_bin_path`. If the quiet argument is set to true, all output to stdout is suppressed.

```APIDOC
## Builder::create_bootimage

### Description
Creates a bootimage by combining the given kernel binary with the bootloader. Places the resulting bootable disk image at the given `output_bin_path`. If the quiet argument is set to true, all output to stdout is suppressed.

### Signature
`pub fn create_bootimage(&mut self, kernel_manifest_path: &Path, bin_path: &Path, output_bin_path: &Path, quiet: bool) -> Result<(), CreateBootimageError>`
```

--------------------------------

### print_cargo_bootimage_help

Source: https://docs.rs/bootimage/latest/src/bootimage/help/mod.rs.html

Prints the help text specifically for the `cargo bootimage` command. This is helpful for users interacting with the bootimage functionality through Cargo.

```APIDOC
## print_cargo_bootimage_help

### Description
Prints the help for the `cargo bootimage` command.

### Signature
`pub fn print_cargo_bootimage_help()`
```

--------------------------------

### Crate Documentation and Modules

Source: https://docs.rs/bootimage/latest/src/bootimage/lib.rs.html

This snippet shows the main crate-level documentation and the public modules provided by the lib.rs file. It includes warnings for missing documentation.

```rust
1//! Provides functions to create a bootable OS image from a kernel binary.
2//! 
3//! This crate is mainly built as a binary tool. Run `cargo install bootimage` to install it.
4
5#![warn(missing_docs)]
6
7pub mod args;
8pub mod builder;
9pub mod config;
10pub mod run;
11
12/// Contains help messages for the command line application.
13pub mod help;

```

--------------------------------

### Create a new builder

Source: https://docs.rs/bootimage/latest/src/bootimage/builder/mod.rs.html

Creates a new builder for the project at the given manifest path. If None is passed for `manifest_path`, it is automatically searched.

```rust
pub fn new(manifest_path: Option<PathBuf>) -> Result<Self, BuilderError> {
        let manifest_path = match manifest_path.or_else(|| {
            std::env::var("CARGO_MANIFEST_DIR")
                .ok()
                .map(|dir| Path::new(&dir).join("Cargo.toml"))
        }) {
            Some(path) => path,
            None => {
                println!("WARNING: `CARGO_MANIFEST_DIR` env variable not set");
                locate_cargo_manifest::locate_manifest()? 
            }
        };

        Ok(Builder {
            manifest_path,
            project_metadata: None,
        })
    }
```

--------------------------------

### Builder::new

Source: https://docs.rs/bootimage/latest/bootimage/builder/struct.Builder.html

Creates a new builder for the project at the given manifest path. If None is passed for `manifest_path`, it is automatically searched.

```APIDOC
## Builder::new

### Description
Creates a new builder for the project at the given manifest path. If None is passed for `manifest_path`, it is automatically searched.

### Signature
`pub fn new(manifest_path: Option<PathBuf>) -> Result<Self, BuilderError>`
```

--------------------------------

### Help Text Constants and Print Functions

Source: https://docs.rs/bootimage/latest/src/bootimage/help/mod.rs.html

Defines constants for help text loaded from files and provides functions to print them. Also includes a function to print the crate's version.

```rust
const HELP: &str = include_str!("help.txt");
const CARGO_BOOTIMAGE_HELP: &str = include_str!("cargo_bootimage_help.txt");
const RUNNER_HELP: &str = include_str!("runner_help.txt");

/// Prints a general help text.
pub fn print_help() {
    print!("{}", HELP);
}

/// Prints the help for the `cargo bootimage` command.
pub fn print_cargo_bootimage_help() {
    print!("{}", CARGO_BOOTIMAGE_HELP);
}
/// Prints the help for the `bootimage runner` command.
pub fn print_runner_help() {
    print!("{}", RUNNER_HELP);
}

/// Prints the version of this crate.
pub fn print_version() {
    println!("bootimage {}", env!("CARGO_PKG_VERSION"));
}
```

--------------------------------

### Create New Builder

Source: https://docs.rs/bootimage/latest/bootimage/builder/struct.Builder.html

Initializes a new Builder instance. If no manifest path is provided, it searches for Cargo.toml automatically. This method returns a Result, which can be Ok(Self) or Err(BuilderError).

```rust
pub fn new(manifest_path: Option<PathBuf>) -> Result<Self, BuilderError>
```

--------------------------------

### Pad Binary File to Block Size

Source: https://docs.rs/bootimage/latest/src/bootimage/builder/disk_image.rs.html

Pads a given binary file with zeros to the nearest 512-byte block size. This ensures the disk image meets certain alignment requirements.

```rust
fn pad_to_nearest_block_size(output_bin_path: &Path) -> Result<(), DiskImageError> {
    const BLOCK_SIZE: u64 = 512;
    use std::fs::OpenOptions;
    let file = OpenOptions::new()
        .write(true)
        .open(&output_bin_path)
        .map_err(|err| DiskImageError::Io {
            message: "failed to open boot image",
            error: err,
        })?;
    let file_size = file
        .metadata()
        .map_err(|err| DiskImageError::Io {
            message: "failed to get size of boot image",
            error: err,
        })?;
        .len();
    let remainder = file_size % BLOCK_SIZE;
    let padding = if remainder > 0 {
        BLOCK_SIZE - remainder
    } else {
        0
    };
    file.set_len(file_size + padding)
        .map_err(|err| DiskImageError::Io {
            message: "failed to pad boot image to a multiple of the block size",
            error: err,
        })
}
```

--------------------------------

### Builder::manifest_path

Source: https://docs.rs/bootimage/latest/bootimage/builder/struct.Builder.html

Returns the path to the Cargo.toml file of the project.

```APIDOC
## Builder::manifest_path

### Description
Returns the path to the Cargo.toml file of the project.

### Signature
`pub fn manifest_path(&self) -> &Path`
```

--------------------------------

### Construct Cargo Command for Bootloader Build

Source: https://docs.rs/bootimage/latest/src/bootimage/builder/bootloader.rs.html

Builds a Cargo command to compile the bootloader with specified features, target, and environment variables. Includes kernel path and manifest path.

```rust
cmd.arg("--bin").arg(&self.bootloader_name);
cmd.arg("--target-dir").arg(&self.target_dir);
cmd.arg("--features")
    .arg(self.features.as_slice().join(" "));
cmd.arg("--target").arg(&self.target);
cmd.arg("-Zjson-target-spec");
cmd.arg("--release");
cmd.env("KERNEL", &self.kernel_bin_path);
cmd.env("KERNEL_MANIFEST", &self.kernel_manifest_path);
cmd.env("RUSTFLAGS", "");
cmd.env("XBUILD_SYSROOT_PATH", self.target_dir.join("bootloader-sysroot")); // for cargo-xbuild
```

--------------------------------

### Builder::new

Source: https://docs.rs/bootimage/latest/src/bootimage/builder/mod.rs.html

Creates a new builder instance for the project. It can automatically locate the Cargo.toml if not provided.

```APIDOC
## Builder::new

### Description
Creates a new builder for the project at the given manifest path. If `None` is passed for `manifest_path`, it is automatically searched.

### Signature
`pub fn new(manifest_path: Option<PathBuf>) -> Result<Self, BuilderError>`

### Parameters
* `manifest_path` (Option<PathBuf>) - The path to the Cargo.toml file. If `None`, it will be auto-detected.
```

--------------------------------

### Read Bootimage Configuration

Source: https://docs.rs/bootimage/latest/src/bootimage/config.rs.html

The `read_config` function serves as the public entry point for reading the bootimage configuration from a specified `Cargo.toml` manifest path. It wraps the internal parsing logic and provides context for potential errors.

```rust
/// Reads the configuration from a `package.metadata.bootimage` in the given Cargo.toml.
pub fn read_config(manifest_path: &Path) -> Result<Config> {
    read_config_inner(manifest_path).context("Failed to read bootimage configuration")
}

```

--------------------------------

### Builder::kernel_package_for_bin

Source: https://docs.rs/bootimage/latest/bootimage/builder/struct.Builder.html

Returns the cargo metadata package that contains the given binary.

```APIDOC
## Builder::kernel_package_for_bin

### Description
Returns the cargo metadata package that contains the given binary.

### Signature
`pub fn kernel_package_for_bin(&mut self, kernel_bin_name: &str) -> Result<Option<&Package>, Error>`
```

--------------------------------

### Derive Bootloader Build Configuration

Source: https://docs.rs/bootimage/latest/src/bootimage/builder/bootloader.rs.html

Creates a BuildConfig from project metadata, kernel manifest path, and kernel binary path. It parses the bootloader's Cargo.toml to extract build-related information.

```rust
use super::error::BootloaderError;
use cargo_metadata::{Metadata, Package};
use std::{
    fs,
    path::{Path, PathBuf},
    process::Command,
};

pub struct BuildConfig {
    manifest_path: PathBuf,
    bootloader_name: String,
    target: PathBuf,
    features: Vec<String>,
    target_dir: PathBuf,
    kernel_bin_path: PathBuf,
    kernel_manifest_path: PathBuf,
    build_std: Option<String>,
}

impl BuildConfig {
    /// Derives the bootloader build config from the project's metadata.
    pub fn from_metadata(
        project_metadata: &Metadata,
        kernel_manifest_path: &Path,
        kernel_bin_path: &Path,
    ) -> Result<Self, BootloaderError> {
        let kernel_pkg = project_metadata
            .packages
            .iter()
            .find(|p| p.manifest_path == kernel_manifest_path)
            .ok_or_else(|| BootloaderError::KernelPackageNotFound {
                manifest_path: kernel_manifest_path.to_owned(),
            })?;

        let bootloader_pkg = bootloader_package(project_metadata, kernel_pkg)?;
        let bootloader_root = bootloader_pkg.manifest_path.parent().ok_or_else(|| {
            BootloaderError::BootloaderInvalid("bootloader manifest has no target directory".into())
        })?;

        let cargo_toml_content = fs::read_to_string(&bootloader_pkg.manifest_path)
            .map_err(|err| format!(
```

--------------------------------

### read_config

Source: https://docs.rs/bootimage/latest/bootimage/config/fn.read_config.html

Reads the bootimage configuration from the specified Cargo.toml manifest path. It looks for the `package.metadata.bootimage` section.

```APIDOC
## read_config

### Description
Reads the configuration from a `package.metadata.bootimage` in the given Cargo.toml.

### Function Signature
```rust
pub fn read_config(manifest_path: &Path) -> Result<Config>
```

### Parameters
#### Path Parameters
- **manifest_path** (*&Path*) - Required - The path to the Cargo.toml manifest file.
```

--------------------------------

### Construct Cargo Build Command

Source: https://docs.rs/bootimage/latest/src/bootimage/builder/bootloader.rs.html

Generates a `cargo` command to build the bootloader. It supports building with `build-std` if specified, otherwise uses `xbuild`.

```rust
"bootloader has no valid Cargo.toml: {}".format(err))
            .map_err(BootloaderError::BootloaderInvalid)?;
        let cargo_toml = cargo_toml_content
            .parse::<toml::Value>()
            .map_err(|e| format!(
```

--------------------------------

### BuildCommand Enum Definition

Source: https://docs.rs/bootimage/latest/bootimage/args/enum.BuildCommand.html

Defines the possible commands for the `cargo bootimage` tool: Build, Version, and Help.

```rust
pub enum BuildCommand {
    Build(BuildArgs),
    Version,
    Help,
}
```

--------------------------------

### Define Bootimage Configuration Structure

Source: https://docs.rs/bootimage/latest/src/bootimage/config.rs.html

Defines the `Config` struct which represents the parsed configuration options from `package.metadata.bootimage` in `Cargo.toml`. This struct holds settings like build commands, run commands, and test-related arguments.

```rust
/// Represents the `package.metadata.bootimage` configuration table
///
/// The bootimage crate can be configured through a `package.metadata.bootimage` table
/// in the `Cargo.toml` file of the kernel. This struct represents the parsed configuration
/// options.
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct Config {
    /// The cargo subcommand that is used for building the kernel for `cargo bootimage`.
    ///
    /// Defaults to `build`.
    pub build_command: Vec<String>,
    /// The run command that is invoked on `bootimage run` or `bootimage runner`
    ///
    /// The substring "{}" will be replaced with the path to the bootable disk image.
    pub run_command: Vec<String>,
    /// Additional arguments passed to the runner for not-test binaries
    ///
    /// Applies to `bootimage run` and `bootimage runner`.
    pub run_args: Option<Vec<String>>,
    /// Additional arguments passed to the runner for test binaries
    ///
    /// Applies to `bootimage runner`.
    pub test_args: Option<Vec<String>>,
    /// The timeout for running an test through `bootimage test` or `bootimage runner` in seconds
    pub test_timeout: u32,
    /// An exit code that should be considered as success for test executables (applies to
    /// `bootimage runner`)
    pub test_success_exit_code: Option<i32>,
    /// Whether the `-no-reboot` flag should be passed to test executables
    ///
    /// Defaults to `true`
    pub test_no_reboot: bool,
}

```

--------------------------------

### Print Cargo Bootimage Help

Source: https://docs.rs/bootimage/latest/bootimage/help/fn.print_cargo_bootimage_help.html

This function prints the help message for the `cargo bootimage` command. It is part of the bootimage crate's help module.

```rust
pub fn print_cargo_bootimage_help()

```

--------------------------------

### ConfigBuilder Struct Definition

Source: https://docs.rs/bootimage/latest/src/bootimage/config.rs.html

Defines the structure for building bootimage configurations, including build and run commands, arguments, and test-related settings. Uses `Option` for fields that can be omitted.

```rust
#[derive(Default)]
struct ConfigBuilder {
    build_command: Option<Vec<String>>,
    run_command: Option<Vec<String>>,
    run_args: Option<Vec<String>>,
    test_args: Option<Vec<String>>,
    test_timeout: Option<u32>,
    test_success_exit_code: Option<i32>,
    test_no_reboot: Option<bool>,
}
```

--------------------------------

### BuildArgs struct for cargo bootimage arguments

Source: https://docs.rs/bootimage/latest/src/bootimage/args/build.rs.html

Represents the arguments passed to `cargo bootimage`. It stores the manifest path, arguments for `cargo build`, and a flag indicating if `--quiet` was used.

```rust
pub struct BuildArgs {
    /// The manifest path (also present in `cargo_args`).
    manifest_path: Option<PathBuf>,
    /// All arguments that are passed to cargo.
    cargo_args: Vec<String>,
    /// Suppress any output to stdout.
    quiet: bool,
}
```

--------------------------------

### Print Crate Version

Source: https://docs.rs/bootimage/latest/bootimage/help/fn.print_version.html

This function prints the version of the bootimage crate. It requires no arguments.

```rust
pub fn print_version()
```

--------------------------------

### Clone to Uninit (Nightly)

Source: https://docs.rs/bootimage/latest/bootimage/args/struct.BuildArgs.html

Nightly-only experimental API. Performs copy-assignment from self to an uninitialized memory location.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### Try From BuildArgs

Source: https://docs.rs/bootimage/latest/bootimage/args/struct.BuildArgs.html

Attempts to convert a value into BuildArgs, returning an error if the conversion fails.

```rust
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

--------------------------------

### print_runner_help Function Signature

Source: https://docs.rs/bootimage/latest/bootimage/help/fn.print_runner_help.html

This is the function signature for print_runner_help. It does not take any arguments and returns nothing.

```rust
pub fn print_runner_help()

```

--------------------------------

### Config Struct Definition

Source: https://docs.rs/bootimage/latest/bootimage/config/struct.Config.html

Defines the structure of the configuration for the bootimage crate, including build and run commands, arguments, and test-related settings.

```rust
#[non_exhaustive]
pub struct Config {
    pub build_command: Vec<String>,
    pub run_command: Vec<String>,
    pub run_args: Option<Vec<String>>,
    pub test_args: Option<Vec<String>>,
    pub test_timeout: u32,
    pub test_success_exit_code: Option<i32>,
    pub test_no_reboot: bool,
}

```

--------------------------------

### Builder::build_kernel

Source: https://docs.rs/bootimage/latest/bootimage/builder/struct.Builder.html

Builds the kernel by executing `cargo build` with the given arguments. Returns a list of paths to all built executables. If the quiet argument is set to true, all output to stdout is suppressed.

```APIDOC
## Builder::build_kernel

### Description
Builds the kernel by executing `cargo build` with the given arguments. Returns a list of paths to all built executables. For crates with only a single binary, the returned list contains only a single element. If the quiet argument is set to true, all output to stdout is suppressed.

### Signature
`pub fn build_kernel(&mut self, args: &[String], config: &Config, quiet: bool) -> Result<Vec<PathBuf>, BuildKernelError>`
```

--------------------------------

### Function Signature for read_config

Source: https://docs.rs/bootimage/latest/bootimage/config/fn.read_config.html

This is the function signature for reading the bootimage configuration. It takes a path to the manifest file and returns a Result containing the Config object.

```rust
pub fn read_config(manifest_path: &Path) -> Result<Config>
```

--------------------------------

### From<llvm_tools::Error> for DiskImageError Implementation

Source: https://docs.rs/bootimage/latest/src/bootimage/builder/error.rs.html

Implements the `From` trait to convert `llvm_tools::Error` into `DiskImageError`, handling the `NotFound` variant specifically.

```rust
impl From<llvm_tools::Error> for DiskImageError {
    fn from(err: llvm_tools::Error) -> Self {
        match err {
            llvm_tools::Error::NotFound => DiskImageError::LlvmToolsNotFound,
            other => DiskImageError::LlvmTools(other),
        }
    }
}
```

--------------------------------

### BuildCommand Enum Variants

Source: https://docs.rs/bootimage/latest/bootimage/args/enum.BuildCommand.html

This enum defines the possible commands for the `cargo bootimage` CLI. Each variant corresponds to a specific user action.

```APIDOC
## Enum BuildCommand

### Variants

*   **Build(BuildArgs)**: Represents a normal build invocation.
*   **Version**: Represents the `--version` command.
*   **Help**: Represents the `--help` command.
```

--------------------------------

### Parse Cargo.toml for Bootimage Config

Source: https://docs.rs/bootimage/latest/src/bootimage/config.rs.html

The `read_config_inner` function handles the core logic of reading and parsing the `package.metadata.bootimage` section from a `Cargo.toml` file. It gracefully handles cases where the configuration table is missing, defaulting to a default `Config`.

```rust
fn read_config_inner(manifest_path: &Path) -> Result<Config> {
    use std::{fs::File, io::Read};
    let cargo_toml: Value = {
        let mut content = String::new();
        File::open(manifest_path)
            .context("Failed to open Cargo.toml")? 
            .read_to_string(&mut content)
            .context("Failed to read Cargo.toml")?;
        content
            .parse::<Value>()
            .context("Failed to parse Cargo.toml")? 
    };

    let metadata = cargo_toml
        .get("package")
        .and_then(|table| table.get("metadata"))
        .and_then(|table| table.get("bootimage"));
    let metadata = match metadata {
        None => {
            return Ok(ConfigBuilder::default().into());
        }
        Some(metadata) => metadata
            .as_table()
            .ok_or_else(|| anyhow!("Bootimage configuration invalid: {:?}", metadata))?,
    };

    let mut config = ConfigBuilder::default();

    for (key, value) in metadata {
        match (key.as_str(), value.clone()) {
            ("test-timeout", Value::Integer(timeout)) if timeout.is_negative() => {
                return Err(anyhow!("test-timeout must not be negative"))
            }
            ("test-timeout", Value::Integer(timeout)) => {
                config.test_timeout = Some(timeout as u32);
            }
            ("test-success-exit-code", Value::Integer(exit_code)) => {
                config.test_success_exit_code = Some(exit_code as i32);
            }
            ("build-command", Value::Array(array)) => {
                config.build_command = Some(parse_string_array(array, "build-command")?);
            }
            ("run-command", Value::Array(array)) => {
                config.run_command = Some(parse_string_array(array, "run-command")?);
            }
            ("run-args", Value::Array(array)) => {
                config.run_args = Some(parse_string_array(array, "run-args")?);
            }
            ("test-args", Value::Array(array)) => {
                config.test_args = Some(parse_string_array(array, "test-args")?);
            }
            ("test-no-reboot", Value::Boolean(no_reboot)) => {
                config.test_no_reboot = Some(no_reboot);
            }
            (key, value) => {
                return Err(anyhow!(
                    "unexpected `package.metadata.bootimage` \ 
                 key `{}` with value `{}`",
                    key,
                    value
                ))
            }
        }
    }
    Ok(config.into())
}

```

--------------------------------

### Build Kernel

Source: https://docs.rs/bootimage/latest/bootimage/builder/struct.Builder.html

Compiles the kernel using `cargo build` with specified arguments and configuration. It can suppress stdout output if `quiet` is true. Returns a list of paths to all built executables.

```rust
pub fn build_kernel( &mut self, args: &[String], config: &Config, quiet: bool, ) -> Result<Vec<PathBuf>, BuildKernelError>
```

--------------------------------

### Find Kernel Package for Binary

Source: https://docs.rs/bootimage/latest/src/bootimage/builder/mod.rs.html

Searches for a cargo metadata package that contains a binary with the specified name. Returns `None` if no such package is found.

```rust
pub fn kernel_package_for_bin(
        &mut self,
        kernel_bin_name: &str,
    ) -> Result<Option<&cargo_metadata::Package>, cargo_metadata::Error> {
        Ok(self.project_metadata()?.packages.iter().find(|p| {
            p.targets
                .iter()
                .any(|t| t.name == kernel_bin_name && t.kind.iter().any(|k| k == "bin"))
        }))
    }
```

--------------------------------

### IoErrorContext Enum for I/O Operations

Source: https://docs.rs/bootimage/latest/src/bootimage/run.rs.html

Provides context for I/O errors encountered during QEMU execution, specifying the operation that failed.

```rust
/// An I/O error occurred while trying to run the disk image.
#[derive(Debug, Error)]
pub enum IoErrorContext {
    /// QEMU command for non-test failed
    #[error("Failed to execute QEMU run command `{command}`")]
    QemuRunCommand {
        /// The QEMU command that was executed
        command: String,
    },

    /// QEMU command for test failed
    #[error("Failed to execute QEMU test command `{command}`")]
    QemuTestCommand {
        /// The QEMU command that was executed
        command: String,
    },

    /// Waiting for test with timeout failed
    #[error("Failed to wait with timeout")]
    WaitWithTimeout,

    /// Failed to kill QEMU
    #[error("Failed to kill QEMU")]
    KillQemu,

    /// Failed to wait for QEMU process
    #[error("Failed to wait for QEMU process")]
    WaitForQemu,
}

```

--------------------------------

### Try Into BuildArgs

Source: https://docs.rs/bootimage/latest/bootimage/args/struct.BuildArgs.html

Attempts to convert BuildArgs into another type `U`, returning an error if the conversion fails.

```rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

--------------------------------

### Parse command line arguments into BuildCommand

Source: https://docs.rs/bootimage/latest/src/bootimage/args/build.rs.html

Parses an iterator of strings into a `BuildCommand` enum. It recognizes `--help`, `--version`, `--quiet`, and `--manifest-path` arguments. Other arguments are collected for `cargo build`.

```rust
pub fn parse_args<A>(args: A) -> Result<Self>
where
    A: Iterator<Item = String>,
{
    let mut manifest_path: Option<PathBuf> = None;
    let mut cargo_args = Vec::new();
    let mut quiet = false;
    {
        fn set<T>(arg: &mut Option<T>, value: Option<T>) -> Result<()> {
            let previous = mem::replace(arg, value);
            if previous.is_some() {
                return Err(anyhow!("multiple arguments of same type provided"));
            }
            Ok(())
        }

        let mut arg_iter = args;
        while let Some(arg) = arg_iter.next() {
            match arg.as_ref() {
                "--help" | "-h" => {
                    return Ok(BuildCommand::Help);
                }
                "--version" => {
                    return Ok(BuildCommand::Version);
                }
                "--quiet" => {
                    quiet = true;
                }
                "--manifest-path" => {
                    let next = arg_iter.next();
                    set(
                        &mut manifest_path,
                        next.as_ref()
                            .map(|p| Path::new(&p).canonicalize())
                            .transpose()
                            .context("--manifest-path invalid")?,
                    )?;
                    cargo_args.push(arg);
                    if let Some(next) = next {
                        cargo_args.push(next);
                    }
                }
                _ if arg.starts_with("--manifest-path=") => {
                    let path = Path::new(arg.trim_start_matches("--manifest-path="))
                        .canonicalize()
                        .context("--manifest-path invalid")?;
                    set(&mut manifest_path, Some(path)?);
                    cargo_args.push(arg);
                }
                _ => {
                    cargo_args.push(arg);
                }
            };
        }
    }

    Ok(BuildCommand::Build(BuildArgs {
        manifest_path,
        cargo_args,
        quiet,
    }))
}
```

--------------------------------

### Builder Struct Definition

Source: https://docs.rs/bootimage/latest/bootimage/builder/struct.Builder.html

Defines the Builder struct used for creating bootable disk images. It contains private fields.

```rust
pub struct Builder { /* private fields */ }
```

--------------------------------

### Into BuildArgs

Source: https://docs.rs/bootimage/latest/bootimage/args/struct.BuildArgs.html

Converts BuildArgs into another type `U` if `U` implements `From<T>`.

```rust
fn into(self) -> U
```

--------------------------------

### From BuildArgs

Source: https://docs.rs/bootimage/latest/bootimage/args/struct.BuildArgs.html

Returns the BuildArgs value unchanged. Used for `From<T> for T` trait.

```rust
fn from(t: T) -> T
```

--------------------------------

### Retrieve Bootloader Package Metadata

Source: https://docs.rs/bootimage/latest/src/bootimage/builder/bootloader.rs.html

Finds the bootloader package metadata from the project's Cargo metadata. It searches for a dependency named 'bootloader' within the kernel package.

```rust
let bootloader_name = {
    let mut dependencies = kernel_package.dependencies.iter();
    let bootloader_package = dependencies
        .find(|p| p.rename.as_ref().unwrap_or(&p.name) == "bootloader")
        .ok_or(BootloaderError::BootloaderNotFound)?;
    bootloader_package.name.clone()
};

project_metadata
    .packages
    .iter()
    .find(|p| p.name == bootloader_name)
    .ok_or(BootloaderError::CargoMetadataIncomplete {
        key: format!("packages[name = `{}`", &bootloader_name),
    })
```

--------------------------------

### Error::provide Implementation for BuilderError (Nightly-only)

Source: https://docs.rs/bootimage/latest/bootimage/builder/error/enum.BuilderError.html

Implements the nightly-only experimental API for providing type-based access to error context.

```rust
fn provide<'a>(&'a self, request: &mut Request<'a>)
```

--------------------------------

### Module Declaration and Re-exports

Source: https://docs.rs/bootimage/latest/src/bootimage/args/mod.rs.html

Declares the `args` module and re-exports public items from its submodules, `build` and `runner`.

```rust
1//! Parses command line arguments.
2
3pub use build::*;
4pub use runner::*;
5
6mod build;
7mod runner;

```

--------------------------------

### CreateBootimageError Enum

Source: https://docs.rs/bootimage/latest/src/bootimage/builder/error.rs.html

Encompasses errors encountered during the creation of a bootimage. It covers bootloader building, cargo metadata issues, disk image creation, I/O operations, and problems with JSON output parsing.

```rust
/// Represents an error that occurred when creating a bootimage.
#[derive(Debug, Error)]
#[non_exhaustive]
pub enum CreateBootimageError {
    /// Failed to build the bootloader.
    #[error("An error occurred while trying to build the bootloader: {0}")]
    Bootloader(#[from] BootloaderError),

    /// Error while running `cargo metadata`
    #[error("Error while running `cargo metadata` for current project: {0:?}")]
    CargoMetadata(#[from] cargo_metadata::Error),

    /// Building the bootloader failed
    #[error("Bootloader build failed.\nStderr: {}", String::from_utf8_lossy(.stderr))]
    BootloaderBuildFailed {
        /// The `cargo build` output to standard error
        stderr: Vec<u8>,
    },

    /// Disk image creation failed
    #[error("An error occurred while trying to create the disk image: {0}")]
    DiskImage(#[from] DiskImageError),

    /// An unexpected I/O error occurred
    #[error("I/O error: {message}:\n{error}")]
    Io {
        /// Desciption of the failed I/O operation
        message: &'static str,
        /// The I/O error that occurred
        error: io::Error,
    },

    /// The output of `cargo build --message-format=json` was not valid UTF-8
    #[error("Output of bootloader build with --message-format=json is not valid UTF-8:\n{0}")]
    BuildJsonOutputInvalidUtf8(std::string::FromUtf8Error),
    /// The output of `cargo build --message-format=json` was not valid JSON
    #[error("Output of bootloader build with --message-format=json is not valid JSON:\n{0}")]
    BuildJsonOutputInvalidJson(json::Error),
}
```

--------------------------------

### kernel_package_for_bin

Source: https://docs.rs/bootimage/latest/src/bootimage/builder/mod.rs.html

Finds the cargo metadata package that contains the specified kernel binary name.

```APIDOC
## kernel_package_for_bin

### Description
Returns the cargo metadata package that contains the given binary. This is useful for identifying the package associated with a specific kernel binary.

### Method
`pub fn kernel_package_for_bin(&mut self, kernel_bin_name: &str) -> Result<Option<&cargo_metadata::Package>, cargo_metadata::Error>`

### Parameters
#### Path Parameters
- **kernel_bin_name** (`&str`) - Description: The name of the kernel binary to search for.

### Return Value
- `Result<Option<&cargo_metadata::Package>, cargo_metadata::Error>` - Returns `Ok(Some(package))` if the package is found, `Ok(None)` if not found, or a `cargo_metadata::Error` if an error occurs during metadata retrieval.
```

--------------------------------

### Clone From BuildArgs

Source: https://docs.rs/bootimage/latest/bootimage/args/struct.BuildArgs.html

Performs copy-assignment from a source BuildArgs value.

```rust
fn clone_from(&mut self, source: &Self)
```

--------------------------------

### To Owned BuildArgs

Source: https://docs.rs/bootimage/latest/bootimage/args/struct.BuildArgs.html

Creates owned data from borrowed data, usually by cloning.

```rust
fn to_owned(&self) -> T
```

--------------------------------

### Clone Into BuildArgs

Source: https://docs.rs/bootimage/latest/bootimage/args/struct.BuildArgs.html

Uses borrowed data to replace owned data, usually by cloning.

```rust
fn clone_into(&self, target: &mut T)
```

--------------------------------

### BuildArgs Struct Definition

Source: https://docs.rs/bootimage/latest/bootimage/args/struct.BuildArgs.html

Defines the structure for arguments passed to `cargo bootimage`. It contains private fields.

```rust
pub struct BuildArgs { /* private fields */ }
```

--------------------------------

### Display Implementation for BuilderError

Source: https://docs.rs/bootimage/latest/bootimage/builder/error/enum.BuilderError.html

Formats the BuilderError for display, allowing it to be converted to a string.

```rust
fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result
```

--------------------------------

### From and Into Trait Implementations

Source: https://docs.rs/bootimage/latest/bootimage/args/struct.RunnerArgs.html

Facilitates conversions between types where one type can be created from another.

```rust
fn from(t: T) -> T
```

```rust
fn into(self) -> U
```

--------------------------------

### CreateBootimageError Enum Definition

Source: https://docs.rs/bootimage/latest/bootimage/builder/error/enum.CreateBootimageError.html

Defines the CreateBootimageError enum, which enumerates potential errors during bootimage creation. This enum is marked as non-exhaustive, meaning new variants may be added in the future.

```rust
#[non_exhaustive]
pub enum CreateBootimageError {
    Bootloader(BootloaderError),
    CargoMetadata(Error),
    BootloaderBuildFailed {
        stderr: Vec<u8>,
    },
    DiskImage(DiskImageError),
    Io {
        message: &'static str,
        error: Error,
    },
    BuildJsonOutputInvalidUtf8(FromUtf8Error),
    BuildJsonOutputInvalidJson(Error),
}
```

--------------------------------

### DiskImageError Enum

Source: https://docs.rs/bootimage/latest/src/bootimage/builder/error.rs.html

Defines errors that can occur during disk image creation. It specifically includes an error for when the `llvm-tools-preview` rustup component is not found.

```rust
/// Creating the disk image failed.
#[derive(Debug, Error)]
pub enum DiskImageError {
    /// The `llvm-tools-preview` rustup component was not found
    #[error(
        "Could not find the `llvm-tools-preview` rustup component.\n\n    You can install by executing `rustup component add llvm-tools-preview`."
    )]
    LlvmToolsNotFound,
}
```

--------------------------------

### CreateBootimageError Enum

Source: https://docs.rs/bootimage/latest/bootimage/builder/error/enum.CreateBootimageError.html

Represents an error that occurred when creating a bootimage. This enum is marked as non-exhaustive, meaning additional variants may be added in the future.

```APIDOC
## Enum CreateBootimageError

**Description:** Represents an error that occurred when creating a bootimage.

**Variants:**

*   **Bootloader(BootloaderError):** Failed to build the bootloader.
*   **CargoMetadata(Error):** Error while running `cargo metadata`.
*   **BootloaderBuildFailed:** Building the bootloader failed.
    *   **Fields:**
        *   `stderr: Vec<u8>` - The `cargo build` output to standard error.
*   **DiskImage(DiskImageError):** Disk image creation failed.
*   **Io:** An unexpected I/O error occurred.
    *   **Fields:**
        *   `message: &'static str` - Description of the failed I/O operation.
        *   `error: Error` - The I/O error that occurred.
*   **BuildJsonOutputInvalidUtf8(FromUtf8Error):** The output of `cargo build --message-format=json` was not valid UTF-8.
*   **BuildJsonOutputInvalidJson(Error):** The output of `cargo build --message-format=json` was not valid JSON.

**Note:** This enum is non-exhaustive. When matching against its variants, include a wildcard arm (`_ => {}`) to handle potential future variants.
```

--------------------------------

### IoErrorContext Function

Source: https://docs.rs/bootimage/latest/src/bootimage/run.rs.html

Defines a context for I/O errors within the bootimage execution. This closure is used to wrap `io::Error` into a `RunError`.

```rust
fn context(context: IoErrorContext) -> impl FnOnce(io::Error) -> RunError {
    |error| RunError::Io { context, error }
}
```

--------------------------------

### RunnerCommand Enum

Source: https://docs.rs/bootimage/latest/bootimage/args/enum.RunnerCommand.html

The RunnerCommand enum defines the different commands that can be executed by the bootimage runner, including running a boot image, displaying version information, or showing help.

```APIDOC
## Enum RunnerCommand

Internal representation of the `bootimage runner` command.

### Variants

*   **Runner(RunnerArgs)**: Represents a normal invocation of `bootimage runner`.
*   **Version**: Represents a command containing the `--version` flag.
*   **Help**: Represents a command containing the `--help` flag.

## Methods

### pub fn parse_args<A>(args: A) -> Result<Self>

Parses the given argument set into the internal `RunnerCommand` representation. This function is generic over any iterator that yields strings.
```

--------------------------------

### Debug Implementation for BuilderError

Source: https://docs.rs/bootimage/latest/bootimage/builder/error/enum.BuilderError.html

Formats the BuilderError for debugging purposes.

```rust
fn fmt(&self, f: &mut Formatter<'_>) -> Result
```

--------------------------------

### RunnerArgs Struct Definition

Source: https://docs.rs/bootimage/latest/bootimage/args/struct.RunnerArgs.html

Defines the structure for arguments passed to the `bootimage runner` command. Includes the executable path, a quiet flag, and optional runner arguments.

```rust
pub struct RunnerArgs {
    pub executable: PathBuf,
    pub quiet: bool,
    pub runner_args: Option<Vec<String>>,
}
```

--------------------------------

### Borrow BuildArgs

Source: https://docs.rs/bootimage/latest/bootimage/args/struct.BuildArgs.html

Immutably borrows from an owned BuildArgs value.

```rust
fn borrow(&self) -> &T
```

--------------------------------

### TryFrom and TryInto Trait Implementations

Source: https://docs.rs/bootimage/latest/bootimage/args/struct.RunnerArgs.html

Allows for fallible conversions between types, returning a Result to indicate success or failure.

```rust
type Error = Infallible
```

```rust
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

```rust
type Error = <U as TryFrom<T>>::Error
```

```rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

--------------------------------

### Clone BuildArgs

Source: https://docs.rs/bootimage/latest/bootimage/args/struct.BuildArgs.html

Creates a duplicate of the BuildArgs value.

```rust
fn clone(&self) -> BuildArgs
```
Tokens:
Raw