chore(code): move crates/sprout to crates/boot and name it edera-sprout-boot

crates/boot/src/actions/chainload.rs

@@ -0,0 +1,107 @@
+use crate::context::SproutContext;
+use crate::utils;
+use alloc::boxed::Box;
+use alloc::rc::Rc;
+use anyhow::{Context, Result, bail};
+use edera_sprout_config::actions::chainload::ChainloadConfiguration;
+use eficore::bootloader_interface::BootloaderInterface;
+use eficore::media_loader::MediaLoaderHandle;
+use eficore::media_loader::constants::linux::LINUX_EFI_INITRD_MEDIA_GUID;
+use eficore::shim::{ShimInput, ShimSupport};
+use log::error;
+use uefi::CString16;
+use uefi::proto::loaded_image::LoadedImage;
+
+/// Executes the chainload action using the specified `configuration` inside the provided `context`.
+pub fn chainload(context: Rc<SproutContext>, configuration: &ChainloadConfiguration) -> Result<()> {
+    // Retrieve the current image handle of sprout.
+    let sprout_image = uefi::boot::image_handle();
+
+    // Resolve the path to the image to chainload.
+    let resolved = eficore::path::resolve_path(
+        Some(context.root().loaded_image_path()?),
+        &context.stamp(&configuration.path),
+    )
+    .context("unable to resolve chainload path")?;
+
+    // Load the image to chainload using the shim support integration.
+    // It will determine if the image needs to be loaded via the shim or can be loaded directly.
+    let image = ShimSupport::load(sprout_image, ShimInput::ResolvedPath(&resolved))?;
+
+    // Open the LoadedImage protocol of the image to chainload.
+    let mut loaded_image_protocol = uefi::boot::open_protocol_exclusive::<LoadedImage>(image)
+        .context("unable to open loaded image protocol")?;
+
+    // Stamp and combine the options to pass to the image.
+    let options =
+        utils::combine_options(configuration.options.iter().map(|item| context.stamp(item)));
+
+    // Pass the load options to the image.
+    // If no options are provided, the resulting string will be empty.
+    // The options are pinned and boxed to ensure that they are valid for the lifetime of this
+    // function, which ensures the lifetime of the options for the image runtime.
+    let options = Box::pin(
+        CString16::try_from(&options[..])
+            .context("unable to convert chainloader options to CString16")?,
+    );
+
+    if options.num_bytes() > u32::MAX as usize {
+        bail!("chainloader options too large");
+    }
+
+    // SAFETY: option size is checked to validate it is safe to pass.
+    // Additionally, the pointer is allocated and retained on heap, which makes
+    // passing the `options` pointer safe to the next image.
+    unsafe {
+        loaded_image_protocol
+            .set_load_options(options.as_ptr() as *const u8, options.num_bytes() as u32);
+    }
+
+    // Stamp the initrd path, if provided.
+    let initrd = configuration
+        .linux_initrd
+        .as_ref()
+        .map(|item| context.stamp(item));
+    // The initrd can be None or empty, so we need to collapse that into a single Option.
+    let initrd = utils::empty_is_none(initrd);
+
+    // If an initrd is provided, register it with the EFI stack.
+    let mut initrd_handle = None;
+    if let Some(linux_initrd) = initrd {
+        let content = eficore::path::read_file_contents(
+            Some(context.root().loaded_image_path()?),
+            &linux_initrd,
+        )
+        .context("unable to read linux initrd")?;
+        let handle =
+            MediaLoaderHandle::register(LINUX_EFI_INITRD_MEDIA_GUID, content.into_boxed_slice())
+                .context("unable to register linux initrd")?;
+        initrd_handle = Some(handle);
+    }
+
+    // Mark execution of an entry in the bootloader interface.
+    BootloaderInterface::mark_exec(context.root().timer())
+        .context("unable to mark execution of boot entry in bootloader interface")?;
+
+    // Start the loaded image.
+    // This call might return, or it may pass full control to another image that will never return.
+    // Capture the result to ensure we can return an error if the image fails to start, but only
+    // after the optional initrd has been unregistered.
+    let result = uefi::boot::start_image(image);
+
+    // Unregister the initrd if it was registered.
+    if let Some(initrd_handle) = initrd_handle
+        && let Err(error) = initrd_handle.unregister()
+    {
+        error!("unable to unregister linux initrd: {}", error);
+    }
+
+    // Assert there was no error starting the image.
+    result.context("unable to start image")?;
+
+    // Explicitly drop the options to clarify the lifetime.
+    drop(options);
+
+    // Return control to sprout.
+    Ok(())
+}

crates/boot/src/actions/edera.rs

@@ -0,0 +1,138 @@
+use crate::{
+    actions,
+    context::SproutContext,
+    utils::{self},
+};
+use alloc::rc::Rc;
+use alloc::string::{String, ToString};
+use alloc::{format, vec};
+use anyhow::{Context, Result};
+use edera_sprout_config::actions::chainload::ChainloadConfiguration;
+use edera_sprout_config::actions::edera::EderaConfiguration;
+use eficore::media_loader::{
+    MediaLoaderHandle,
+    constants::xen::{
+        XEN_EFI_CONFIG_MEDIA_GUID, XEN_EFI_KERNEL_MEDIA_GUID, XEN_EFI_RAMDISK_MEDIA_GUID,
+    },
+};
+use log::error;
+use uefi::Guid;
+
+/// Builds a configuration string for the Xen EFI stub using the specified `configuration`.
+fn build_xen_config(context: Rc<SproutContext>, configuration: &EderaConfiguration) -> String {
+    // Stamp xen options and combine them.
+    let xen_options = utils::combine_options(
+        configuration
+            .xen_options
+            .iter()
+            .map(|item| context.stamp(item)),
+    );
+
+    // Stamp kernel options and combine them.
+    let kernel_options = utils::combine_options(
+        configuration
+            .kernel_options
+            .iter()
+            .map(|item| context.stamp(item)),
+    );
+
+    // xen config file format is ini-like
+    [
+        // global section
+        "[global]".to_string(),
+        // default configuration section
+        "default=sprout".to_string(),
+        // configuration section for sprout
+        "[sprout]".to_string(),
+        // xen options
+        format!("options={}", xen_options),
+        // kernel options, stub replaces the kernel path
+        // the kernel is provided via media loader
+        format!("kernel=stub {}", kernel_options),
+        // required or else the last line will be ignored
+        "".to_string(),
+    ]
+    .join("\n")
+}
+
+/// Register a media loader for some `text` with the vendor `guid`.
+/// `what` should indicate some identifying value for error messages
+/// like `config` or `kernel`.
+/// Provides a [MediaLoaderHandle] that can be used to unregister the media loader.
+fn register_media_loader_text(guid: Guid, what: &str, text: String) -> Result<MediaLoaderHandle> {
+    MediaLoaderHandle::register(guid, text.as_bytes().to_vec().into_boxed_slice())
+        .context(format!("unable to register {} media loader", what)) /*  */
+}
+
+/// Register a media loader for the file `path` with the vendor `guid`.
+/// `what` should indicate some identifying value for error messages
+/// like `config` or `kernel`.
+/// Provides a [MediaLoaderHandle] that can be used to unregister the media loader.
+fn register_media_loader_file(
+    context: &Rc<SproutContext>,
+    guid: Guid,
+    what: &str,
+    path: &str,
+) -> Result<MediaLoaderHandle> {
+    // Stamp the path to the file.
+    let path = context.stamp(path);
+    // Read the file contents.
+    let content =
+        eficore::path::read_file_contents(Some(context.root().loaded_image_path()?), &path)
+            .context(format!("unable to read {} file", what))?;
+    // Register the media loader.
+    let handle = MediaLoaderHandle::register(guid, content.into_boxed_slice())
+        .context(format!("unable to register {} media loader", what))?;
+    Ok(handle)
+}
+
+/// Executes the edera action which will boot the Edera hypervisor with the specified
+/// `configuration` and `context`. This action uses Edera-specific Xen EFI stub functionality.
+pub fn edera(context: Rc<SproutContext>, configuration: &EderaConfiguration) -> Result<()> {
+    // Build the Xen config file content for this configuration.
+    let config = build_xen_config(context.clone(), configuration);
+
+    // Register the media loader for the config.
+    let config = register_media_loader_text(XEN_EFI_CONFIG_MEDIA_GUID, "config", config)
+        .context("unable to register config media loader")?;
+
+    // Register the media loaders for the kernel.
+    let kernel = register_media_loader_file(
+        &context,
+        XEN_EFI_KERNEL_MEDIA_GUID,
+        "kernel",
+        &configuration.kernel,
+    )
+    .context("unable to register kernel media loader")?;
+
+    // Create a vector of media loaders to unregister on error.
+    let mut media_loaders = vec![config, kernel];
+
+    // Register the initrd if it is provided.
+    if let Some(initrd) = utils::empty_is_none(configuration.initrd.as_ref()) {
+        let initrd =
+            register_media_loader_file(&context, XEN_EFI_RAMDISK_MEDIA_GUID, "initrd", initrd)
+                .context("unable to register initrd media loader")?;
+        media_loaders.push(initrd);
+    }
+
+    // Chainload to the Xen EFI stub.
+    let result = actions::chainload::chainload(
+        context.clone(),
+        &ChainloadConfiguration {
+            path: configuration.xen.clone(),
+            options: vec![],
+            linux_initrd: None,
+        },
+    )
+    .context("unable to chainload to xen");
+
+    // Unregister the media loaders when an error happens.
+    for media_loader in media_loaders {
+        if let Err(error) = media_loader.unregister() {
+            error!("unable to unregister media loader: {}", error);
+        }
+    }
+
+    result
+}

crates/boot/src/actions/print.rs

@@ -0,0 +1,11 @@
+use crate::context::SproutContext;
+use alloc::rc::Rc;
+use anyhow::Result;
+use edera_sprout_config::actions::print::PrintConfiguration;
+use log::info;
+
+/// Executes the print action with the specified `configuration` inside the provided `context`.
+pub fn print(context: Rc<SproutContext>, configuration: &PrintConfiguration) -> Result<()> {
+    info!("{}", context.stamp(&configuration.text));
+    Ok(())
+}