sprout: version 0.0.15

Merge pull request #22 from edera-dev/dependabot/docker/docker-updates-d0b0844295
chore(deps): bump rustlang/rust from `7cba2ed` to `3453212` in the docker-updates group
2025-12-19 20:40:17 +00:00 · 2025-10-30 15:01:49 -04:00 · 2025-10-30 14:58:36 -04:00 · 2025-10-30 14:58:04 -04:00 · 2025-10-30 13:27:58 -04:00 · 2025-10-30 12:50:36 -04:00
48 changed files with 1439 additions and 278 deletions
--- a/.github/ISSUE_TEMPLATE/bug-report.yml
+++ b/.github/ISSUE_TEMPLATE/bug-report.yml
@@ -0,0 +1,42 @@
+name: Report a bug
+description: File a bug report.
+title: "bug: "
+labels: ["bug", "triage"]
+type: bug
+assignees:
+- edera-dev/engineering
+body:
+- type: markdown
+  attributes:
+    value: |
+      Thanks for taking the time to fill out this bug report!
+- type: input
+  id: version
+  attributes:
+    label: Version / Commit
+    description: What version of Sprout are you running?
+  validations:
+    required: true
+- type: textarea
+  id: what-happened
+  attributes:
+    label: What happened?
+    description: Tell us what you expected to happen.
+    placeholder: Tell us what you see!
+    value: "A bug happened!"
+  validations:
+    required: true
+- type: textarea
+  id: logs
+  attributes:
+    label: Log output
+    description: Please provide any relevant log output.
+    render: log
+- type: checkboxes
+  id: terms
+  attributes:
+    label: Code of Conduct
+    description: By submitting this report, you agree to follow our [Code of Conduct](https://github.com/edera-dev/sprout/blob/main/CODE_OF_CONDUCT.md).
+    options:
+    - label: I agree to follow the Sprout Code of Conduct.
+      required: true
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,6 @@
+blank_issues_enabled: false
+contact_links:
+- name: Ask a question
+  url: https://github.com/edera-dev/sprout/discussions
+  about: Please ask and answer questions here.
+# Note that GitHub will automatically display our security policy in the new issue form.
--- a/.github/ISSUE_TEMPLATE/feature-request.yml
+++ b/.github/ISSUE_TEMPLATE/feature-request.yml
@@ -0,0 +1,29 @@
+name: Request a feature
+description: Request a feature.
+title: "want: "
+labels: ["enhancement", "triage"]
+type: feature
+assignees:
+- edera-dev/engineering
+body:
+- type: markdown
+  attributes:
+    value: |
+      Thanks for taking the time to fill out a feature request!
+- type: textarea
+  id: description
+  attributes:
+    label: Description
+    description:
+    placeholder: Tell us what you want to see!
+    value: "Your hopes and dreams here!"
+  validations:
+    required: true
+- type: checkboxes
+  id: terms
+  attributes:
+    label: Code of Conduct
+    description: By submitting this report, you agree to follow our [Code of Conduct](https://github.com/edera-dev/sprout/blob/main/CODE_OF_CONDUCT.md).
+    options:
+    - label: I agree to follow the Sprout Code of Conduct.
+      required: true
--- a/.github/dependabot.yaml
+++ b/.github/dependabot.yaml
--- a/.github/workflows/ci-actions.yaml
+++ b/.github/workflows/ci-actions.yaml
@@ -10,7 +10,7 @@ permissions:
  contents: read # Needed to checkout the repository.

 concurrency:
-  group: "${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}"
+  group: "${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-${{ github.sha }}"
  cancel-in-progress: true

 jobs:
--- a/.github/workflows/ci-code.yaml
+++ b/.github/workflows/ci-code.yaml
@@ -12,7 +12,7 @@ permissions:
  contents: read # Needed to checkout the repository.

 concurrency:
-  group: "${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}"
+  group: "${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-${{ github.sha }}"
  cancel-in-progress: true

 jobs:
--- a/.github/workflows/codeql.yaml
+++ b/.github/workflows/codeql.yaml
@@ -12,7 +12,7 @@ permissions:
  contents: read # Needed to checkout the repository.

 concurrency:
-  group: "${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}"
+  group: "${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-${{ github.sha }}"
  cancel-in-progress: true

 jobs:
--- a/.github/workflows/publish.yaml
+++ b/.github/workflows/publish.yaml
@@ -19,7 +19,7 @@ permissions:
  contents: read # Needed to checkout the repository.

 concurrency:
-  group: "${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}"
+  group: "${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-${{ github.sha }}"
  cancel-in-progress: true

 jobs:
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14,6 +14,17 @@ version = "1.0.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61"

+[[package]]
+name = "async-trait"
+version = "0.1.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "autocfg"
 version = "1.5.0"
@@ -32,6 +43,15 @@ version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"

+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
 [[package]]
 name = "bytemuck"
 version = "1.24.0"
@@ -44,12 +64,27 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"

+[[package]]
+name = "bytes"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
+
 [[package]]
 name = "cfg-if"
 version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"

+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "crc32fast"
 version = "1.5.0"
@@ -59,14 +94,35 @@ dependencies = [
 "cfg-if",
 ]

+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
 [[package]]
 name = "edera-sprout"
-version = "0.0.11"
+version = "0.0.15"
 dependencies = [
 "anyhow",
 "image",
 "log",
 "serde",
+ "sha256",
 "toml",
 "uefi",
 "uefi-raw",
@@ -97,12 +153,28 @@ dependencies = [
 "miniz_oxide",
 ]

+[[package]]
+name = "generic-array"
+version = "0.14.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bb6743198531e02858aeaea5398fcc883e71851fcbcb5a2f773e2fb6cb1edf2"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
 [[package]]
 name = "hashbrown"
 version = "0.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5419bdc4f6a9207fbeba6d11b604d481addf78ecd10c11ad51e76c2f6482748d"

+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
 [[package]]
 name = "image"
 version = "0.25.8"
@@ -126,6 +198,12 @@ dependencies = [
 "hashbrown",
 ]

+[[package]]
+name = "libc"
+version = "0.2.177"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976"
+
 [[package]]
 name = "log"
 version = "0.4.28"
@@ -259,6 +337,29 @@ dependencies = [
 "serde_core",
 ]

+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sha256"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f880fc8562bdeb709793f00eb42a2ad0e672c4f883bbe59122b926eca935c8f6"
+dependencies = [
+ "async-trait",
+ "bytes",
+ "hex",
+ "sha2",
+]
+
 [[package]]
 name = "simd-adler32"
 version = "0.3.7"
@@ -314,6 +415,12 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df8b2b54733674ad286d16267dcfc7a71ed5c776e4ac7aa3c3e2561f7c637bf2"

+[[package]]
+name = "typenum"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
+
 [[package]]
 name = "ucs2"
 version = "0.3.3"
@@ -372,6 +479,12 @@ version = "1.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "462eeb75aeb73aea900253ce739c8e18a67423fadf006037cd3ff27e82748a06"

+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
 [[package]]
 name = "winnow"
 version = "0.7.13"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,7 +2,7 @@
 name = "edera-sprout"
 description = "Modern UEFI bootloader"
 license = "Apache-2.0"
-version = "0.0.11"
+version = "0.0.15"
 homepage = "https://sprout.edera.dev"
 repository = "https://github.com/edera-dev/sprout"
 edition = "2024"
@@ -13,7 +13,7 @@ toml = "0.9.8"
 log = "0.4.28"

 [dependencies.image]
-version = "0.25.6"
+version = "0.25.8"
 default-features = false
 features = ["png"]
 optional = true
@@ -22,6 +22,10 @@ optional = true
 version = "1.0.228"
 features = ["derive"]

+[dependencies.sha256]
+version = "1.6.0"
+default-features = false
+
 [dependencies.uefi]
 version = "0.36.0"
 features = ["alloc", "logger"]
@@ -33,6 +37,11 @@ version = "0.12.0"
 default = ["splash"]
 splash = ["dep:image"]

+[profile.dev]
+# We have to compile for opt-level = 2 due to optimization passes
+# which don't handle the UEFI target properly.
+opt-level = 2
+
 [profile.release]
 lto = "thin"
 strip = "symbols"
@@ -46,6 +55,7 @@ debug = 1
 inherits = "dev"
 strip = "debuginfo"
 debug = 0
+opt-level = 2

 [patch.crates-io.simd-adler32]
 git = "https://github.com/edera-dev/sprout-patched-deps.git"
--- a/2
+++ b/2
@@ -2,7 +2,7 @@
 ARG RUST_PROFILE=release
 ARG RUST_TARGET_SUBDIR=release

-FROM --platform=$BUILDPLATFORM rustlang/rust:nightly-alpine@sha256:141e9a7f13f77237dd4d462364c3a1b21cb8a6791d8924c409573e77b788af5e AS build
+FROM --platform=$BUILDPLATFORM rustlang/rust:nightly-alpine@sha256:34532121803db17008af0cdc4e2e1210466cb257cc9d3840dac42d706640fee5 AS build
 RUN apk --no-cache add musl-dev busybox-static
 ARG RUST_PROFILE
 RUN adduser -S -s /bin/sh build
--- a/README.md
+++ b/README.md
@@ -18,6 +18,9 @@ existing UEFI bootloader or booted by the hardware directly.

 Sprout is licensed under Apache 2.0 and is open to modifications and contributions.

+**IMPORTANT WARNING**: Sprout does not support UEFI Secure Boot yet.
+See [this issue](https://github.com/edera-dev/sprout/issues/20) for updates.
+
 ## Background

 At [Edera] we make compute isolation technology for a wide variety of environments, often ones we do not fully control.
@@ -55,7 +58,7 @@ The boot menu mechanism is very rudimentary.
 ### Current

 - [x] Loadable driver support
- [x] [Bootloader specification (BLS)](https://uapi-group.org/specifications/specs/boot_loader_specification/) support
+- [x] Basic [Bootloader specification (BLS)](https://uapi-group.org/specifications/specs/boot_loader_specification/) support
 - [x] Chainload support
 - [x] Linux boot support via EFI stub
 - [x] Windows boot support via chainload
@@ -65,15 +68,18 @@ The boot menu mechanism is very rudimentary.

 ### Roadmap

- [ ] Full-featured boot menu
- [ ] Secure Boot support: work in progress
- [ ] UKI support: partial
- [ ] multiboot2 support
- [ ] Linux boot protocol (boot without EFI stub)
+- [ ] [Bootloader interface support](https://github.com/edera-dev/sprout/issues/21)
+- [ ] [BLS specification conformance](https://github.com/edera-dev/sprout/issues/2)
+- [ ] [Full-featured boot menu](https://github.com/edera-dev/sprout/issues/1)
+- [ ] [Secure Boot support](https://github.com/edera-dev/sprout/issues/20): work in progress
+- [ ] [UKI support](https://github.com/edera-dev/sprout/issues/6): partial
+- [ ] [multiboot2 support](https://github.com/edera-dev/sprout/issues/7)
+- [ ] [Linux boot protocol (boot without EFI stub)](https://github.com/edera-dev/sprout/issues/7)

 ## Concepts

 - drivers: loadable EFI modules that can add functionality to the EFI system.
+- autoconfiguration: code that can automatically generate sprout.toml based on the EFI environment.
 - actions: executable code with a configuration that can be run by various other sprout concepts.
 - generators: code that can generate boot entries based on inputs or runtime code.
 - extractors: code that can extract values from the EFI environment.
@@ -138,7 +144,7 @@ version = 1
 path = "\\sprout\\drivers\\ext4.efi"

 # global options.
-[defaults]
+[options]
 # enable autoconfiguration by detecting bls enabled
 # filesystems and generating boot entries for them.
 autoconfigure = true
--- a/docs/fedora-setup.md
+++ b/docs/fedora-setup.md
@@ -40,7 +40,7 @@ version = 1
 path = "\\sprout\\drivers\\ext4.efi"

 # global options.
-[defaults]
+[options]
 # enable autoconfiguration by detecting bls enabled
 # filesystems and generating boot entries for them.
 autoconfigure = true
--- a/docs/windows-setup.md
+++ b/docs/windows-setup.md
@@ -33,15 +33,10 @@ Write the following file to `X:\sprout.toml`:
 # sprout configuration: version 1
 version = 1

-# add a boot entry for booting Windows
-# which will run the boot-windows action.
-[entries.windows]
-title = "Windows"
-actions = ["boot-windows"]
-
-# use the chainload action to boot the Windows bootloader.
-[actions.boot-windows]
-chainload.path = "\\EFI\\Microsoft\\Boot\\bootmgfw.efi"
+# global options.
+[options]
+# enable autoconfiguration to detect Windows.
+autoconfigure = true
 ```

 ## Step 4: Configure EFI Firmware to boot Sprout
--- a/hack/dev/configs/all.sprout.toml
+++ b/hack/dev/configs/all.sprout.toml
@@ -1,7 +1,7 @@
 version = 1

-[defaults]
-entry = "kernel"
+[options]
+default-entry = "kernel"

 [extractors.boot.filesystem-device-match]
 has-item = "\\EFI\\BOOT\\kernel.efi"
--- a/hack/dev/configs/autoconfigure.sprout.toml
+++ b/hack/dev/configs/autoconfigure.sprout.toml
@@ -1,4 +1,4 @@
 version = 1

-[defaults]
+[options]
 autoconfigure = true
--- a/hack/dev/configs/edera.sprout.toml
+++ b/hack/dev/configs/edera.sprout.toml
@@ -1,7 +1,7 @@
 version = 1

-[defaults]
-entry = "edera"
+[options]
+default-entry = "edera"
 menu-timeout = 0

 [extractors.boot.filesystem-device-match]
--- a/hack/dev/configs/kernel.sprout.toml
+++ b/hack/dev/configs/kernel.sprout.toml
@@ -1,7 +1,7 @@
 version = 1

-[defaults]
-entry = "kernel"
+[options]
+default-entry = "kernel"
 menu-timeout = 0

 [extractors.boot.filesystem-device-match]
--- a/hack/dev/configs/shell.sprout.toml
+++ b/hack/dev/configs/shell.sprout.toml
@@ -1,7 +1,7 @@
 version = 1

-[defaults]
-entry = "shell"
+[options]
+default-entry = "shell"
 menu-timeout = 0

 [extractors.boot.filesystem-device-match]
--- a/hack/dev/configs/xen.sprout.toml
+++ b/hack/dev/configs/xen.sprout.toml
@@ -1,7 +1,7 @@
 version = 1

-[defaults]
-entry = "xen"
+[options]
+default-entry = "xen"
 menu-timeout = 0

 [extractors.boot.filesystem-device-match]
--- a/src/actions/chainload.rs
+++ b/src/actions/chainload.rs
@@ -1,9 +1,10 @@
 use crate::context::SproutContext;
+use crate::integrations::bootloader_interface::BootloaderInterface;
 use crate::utils;
 use crate::utils::media_loader::MediaLoaderHandle;
 use crate::utils::media_loader::constants::linux::LINUX_EFI_INITRD_MEDIA_GUID;
 use anyhow::{Context, Result, bail};
-use log::{error, info};
+use log::error;
 use serde::{Deserialize, Serialize};
 use std::rc::Rc;
 use uefi::CString16;
@@ -53,18 +54,15 @@ pub fn chainload(context: Rc<SproutContext>, configuration: &ChainloadConfigurat
    let mut loaded_image_protocol = uefi::boot::open_protocol_exclusive::<LoadedImage>(image)
        .context("unable to open loaded image protocol")?;

-    // Stamp and concatenate the options to pass to the image.
-    let options = configuration
-        .options
-        .iter()
-        .map(|item| context.stamp(item))
-        .collect::<Vec<_>>()
-        .join(" ");
+    // 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 options to the image, if any are provided.
    // The holder must drop at the end of this function to ensure the options are not leaked,
    // and the holder here ensures it outlives the if block here, as a pointer has to be
-    // passed to the image. This has been hand-validated to be safe.
+    // passed to the image.
+    // SAFETY: The options outlive the usage of the image, and the image is not used after this.
    let mut options_holder: Option<Box<CString16>> = None;
    if !options.is_empty() {
        let options = Box::new(
@@ -72,8 +70,6 @@ pub fn chainload(context: Rc<SproutContext>, configuration: &ChainloadConfigurat
                .context("unable to convert chainloader options to CString16")?,
        );

-        info!("options: {}", options);
-
        if options.num_bytes() > u32::MAX as usize {
            bail!("chainloader options too large");
        }
@@ -88,10 +84,18 @@ pub fn chainload(context: Rc<SproutContext>, configuration: &ChainloadConfigurat
        options_holder = Some(options);
    }

+    // 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(ref linux_initrd) = configuration.linux_initrd {
-        let initrd_path = context.stamp(linux_initrd);
-        let content = utils::read_file_contents(context.root().loaded_image_path()?, &initrd_path)
+    if let Some(linux_initrd) = initrd {
+        let content = utils::read_file_contents(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())
@@ -99,11 +103,15 @@ pub fn chainload(context: Rc<SproutContext>, configuration: &ChainloadConfigurat
        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).context("unable to start image");
+    let result = uefi::boot::start_image(image);

    // Unregister the initrd if it was registered.
    if let Some(initrd_handle) = initrd_handle
--- a/src/actions/edera.rs
+++ b/src/actions/edera.rs
@@ -40,7 +40,23 @@ pub struct EderaConfiguration {
 }

 /// Builds a configuration string for the Xen EFI stub using the specified `configuration`.
-fn build_xen_config(configuration: &EderaConfiguration) -> String {
+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
@@ -50,10 +66,10 @@ fn build_xen_config(configuration: &EderaConfiguration) -> String {
        // configuration section for sprout
        "[sprout]".to_string(),
        // xen options
-        format!("options={}", configuration.xen_options.join(" ")),
+        format!("options={}", xen_options),
        // kernel options, stub replaces the kernel path
        // the kernel is provided via media loader
-        format!("kernel=stub {}", configuration.kernel_options.join(" ")),
+        format!("kernel=stub {}", kernel_options),
        // required or else the last line will be ignored
        "".to_string(),
    ]
@@ -94,7 +110,7 @@ fn register_media_loader_file(
 /// `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(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)
@@ -113,7 +129,7 @@ pub fn edera(context: Rc<SproutContext>, configuration: &EderaConfiguration) ->
    let mut media_loaders = vec![config, kernel];

    // Register the initrd if it is provided.
-    if let Some(ref initrd) = configuration.initrd {
+    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")?;
@@ -131,7 +147,7 @@ pub fn edera(context: Rc<SproutContext>, configuration: &EderaConfiguration) ->
    )
    .context("unable to chainload to xen");

-    // Unregister the media loaders on error.
+    // 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);
--- a/src/autoconfigure.rs
+++ b/src/autoconfigure.rs
@@ -1,101 +1,19 @@
-use crate::actions::ActionDeclaration;
-use crate::actions::chainload::ChainloadConfiguration;
 use crate::config::RootConfiguration;
-use crate::entries::EntryDeclaration;
-use crate::generators::GeneratorDeclaration;
-use crate::generators::bls::BlsConfiguration;
 use anyhow::{Context, Result};
-use uefi::cstr16;
-use uefi::fs::{FileSystem, Path};
+use uefi::fs::FileSystem;
 use uefi::proto::device_path::DevicePath;
-use uefi::proto::device_path::text::{AllowShortcuts, DisplayOnly};
 use uefi::proto::media::fs::SimpleFileSystem;

-/// The name prefix of the BLS chainload action that will be used
-/// by the BLS generator to chainload entries.
-const BLS_CHAINLOAD_ACTION_PREFIX: &str = "bls-chainload-";
+/// bls: autodetect and configure BLS-enabled filesystems.
+pub mod bls;

-/// Scan the specified `filesystem` for BLS configurations.
-fn scan_for_bls(
-    filesystem: &mut FileSystem,
-    root: &DevicePath,
-    config: &mut RootConfiguration,
-) -> Result<bool> {
-    // BLS has a loader.conf file that can specify its own auto-entries mechanism.
-    let bls_loader_conf_path = Path::new(cstr16!("\\loader\\loader.conf"));
-    // BLS also has an entries directory that can specify explicit entries.
-    let bls_entries_path = Path::new(cstr16!("\\loader\\entries"));
+/// linux: autodetect and configure Linux kernels.
+/// This autoconfiguration module should not be activated
+/// on BLS-enabled filesystems as it may make duplicate entries.
+pub mod linux;

-    // Convert the device path root to a string we can use in the configuration.
-    let mut root = root
-        .to_string(DisplayOnly(false), AllowShortcuts(false))
-        .context("unable to convert device root to string")?
-        .to_string();
-    // Add a trailing slash to the root to ensure the path is valid.
-    root.push('/');
-
-    // Whether we have a loader.conf file.
-    let has_loader_conf = filesystem
-        .try_exists(bls_loader_conf_path)
-        .context("unable to check for BLS loader.conf file")?;
-
-    // Whether we have an entries directory.
-    // We actually iterate the entries to see if there are any.
-    let has_entries_dir = filesystem
-        .read_dir(bls_entries_path)
-        .ok()
-        .and_then(|mut iterator| iterator.next())
-        .map(|entry| entry.is_ok())
-        .unwrap_or(false);
-
-    // Detect if a BLS supported configuration is on this filesystem.
-    // We check both loader.conf and entries directory as only one of them is required.
-    if !(has_loader_conf || has_entries_dir) {
-        return Ok(false);
-    }
-
-    // Generate a unique name for the BLS chainload action.
-    let chainload_action_name = format!("{}{}", BLS_CHAINLOAD_ACTION_PREFIX, root);
-
-    // BLS is now detected, generate a configuration for it.
-    let generator = BlsConfiguration {
-        entry: EntryDeclaration {
-            title: "$title".to_string(),
-            actions: vec![chainload_action_name.clone()],
-            ..Default::default()
-        },
-        path: format!("{}\\loader", root),
-    };
-
-    // Generate a unique name for the BLS generator and insert the generator into the configuration.
-    config.generators.insert(
-        format!("autoconfigure-bls-{}", root),
-        GeneratorDeclaration {
-            bls: Some(generator),
-            ..Default::default()
-        },
-    );
-
-    // Generate a chainload configuration for BLS.
-    // BLS will provide these values to us.
-    let chainload = ChainloadConfiguration {
-        path: format!("{}\\$chainload", root),
-        options: vec!["$options".to_string()],
-        linux_initrd: Some(format!("{}\\$initrd", root)),
-    };
-
-    // Insert the chainload action into the configuration.
-    config.actions.insert(
-        chainload_action_name,
-        ActionDeclaration {
-            chainload: Some(chainload),
-            ..Default::default()
-        },
-    );
-
-    // We had a BLS supported configuration, so return true.
-    Ok(true)
-}
+/// windows: autodetect and configure Windows boot configurations.
+pub mod windows;

 /// Generate a [RootConfiguration] based on the environment.
 /// Intakes a `config` to use as the basis of the autoconfiguration.
@@ -121,8 +39,18 @@ pub fn autoconfigure(config: &mut RootConfiguration) -> Result<()> {
        let mut filesystem = FileSystem::new(filesystem);

        // Scan the filesystem for BLS supported configurations.
-        // If we find any, we will add a BLS generator to the configuration.
-        scan_for_bls(&mut filesystem, &root, config).context("unable to scan filesystem")?;
+        let bls_found = bls::scan(&mut filesystem, &root, config)
+            .context("unable to scan for bls configurations")?;
+
+        // If BLS was not found, scan for Linux configurations.
+        if !bls_found {
+            linux::scan(&mut filesystem, &root, config)
+                .context("unable to scan for linux configurations")?;
+        }
+
+        // Always look for Windows configurations.
+        windows::scan(&mut filesystem, &root, config)
+            .context("unable to scan for windows configurations")?;
    }

    Ok(())
--- a/src/autoconfigure/bls.rs
+++ b/src/autoconfigure/bls.rs
@@ -0,0 +1,101 @@
+use crate::actions::ActionDeclaration;
+use crate::actions::chainload::ChainloadConfiguration;
+use crate::config::RootConfiguration;
+use crate::entries::EntryDeclaration;
+use crate::generators::GeneratorDeclaration;
+use crate::generators::bls::BlsConfiguration;
+use crate::utils;
+use anyhow::{Context, Result};
+use uefi::cstr16;
+use uefi::fs::{FileSystem, Path};
+use uefi::proto::device_path::DevicePath;
+use uefi::proto::device_path::text::{AllowShortcuts, DisplayOnly};
+
+/// The name prefix of the BLS chainload action that will be used
+/// by the BLS generator to chainload entries.
+const BLS_CHAINLOAD_ACTION_PREFIX: &str = "bls-chainload-";
+
+/// Scan the specified `filesystem` for BLS configurations.
+pub fn scan(
+    filesystem: &mut FileSystem,
+    root: &DevicePath,
+    config: &mut RootConfiguration,
+) -> Result<bool> {
+    // BLS has a loader.conf file that can specify its own auto-entries mechanism.
+    let bls_loader_conf_path = Path::new(cstr16!("\\loader\\loader.conf"));
+    // BLS also has an entries directory that can specify explicit entries.
+    let bls_entries_path = Path::new(cstr16!("\\loader\\entries"));
+
+    // Convert the device path root to a string we can use in the configuration.
+    let mut root = root
+        .to_string(DisplayOnly(false), AllowShortcuts(false))
+        .context("unable to convert device root to string")?
+        .to_string();
+    // Add a trailing forward-slash to the root to ensure the device root is completed.
+    root.push('/');
+
+    // Generate a unique hash of the root path.
+    let root_unique_hash = utils::unique_hash(&root);
+
+    // Whether we have a loader.conf file.
+    let has_loader_conf = filesystem
+        .try_exists(bls_loader_conf_path)
+        .context("unable to check for BLS loader.conf file")?;
+
+    // Whether we have an entries directory.
+    // We actually iterate the entries to see if there are any.
+    let has_entries_dir = filesystem
+        .read_dir(bls_entries_path)
+        .ok()
+        .and_then(|mut iterator| iterator.next())
+        .map(|entry| entry.is_ok())
+        .unwrap_or(false);
+
+    // Detect if a BLS supported configuration is on this filesystem.
+    // We check both loader.conf and entries directory as only one of them is required.
+    if !(has_loader_conf || has_entries_dir) {
+        return Ok(false);
+    }
+
+    // Generate a unique name for the BLS chainload action.
+    let chainload_action_name = format!("{}{}", BLS_CHAINLOAD_ACTION_PREFIX, root_unique_hash,);
+
+    // BLS is now detected, generate a configuration for it.
+    let generator = BlsConfiguration {
+        entry: EntryDeclaration {
+            title: "$title".to_string(),
+            actions: vec![chainload_action_name.clone()],
+            ..Default::default()
+        },
+        path: format!("{}\\loader", root),
+    };
+
+    // Generate a unique name for the BLS generator and insert the generator into the configuration.
+    config.generators.insert(
+        format!("autoconfigure-bls-{}", root_unique_hash),
+        GeneratorDeclaration {
+            bls: Some(generator),
+            ..Default::default()
+        },
+    );
+
+    // Generate a chainload configuration for BLS.
+    // BLS will provide these values to us.
+    let chainload = ChainloadConfiguration {
+        path: format!("{}\\$chainload", root),
+        options: vec!["$options".to_string()],
+        linux_initrd: Some(format!("{}\\$initrd", root)),
+    };
+
+    // Insert the chainload action into the configuration.
+    config.actions.insert(
+        chainload_action_name,
+        ActionDeclaration {
+            chainload: Some(chainload),
+            ..Default::default()
+        },
+    );
+
+    // We had a BLS supported configuration, so return true.
+    Ok(true)
+}
--- a/src/autoconfigure/linux.rs
+++ b/src/autoconfigure/linux.rs
@@ -0,0 +1,219 @@
+use crate::actions::ActionDeclaration;
+use crate::actions::chainload::ChainloadConfiguration;
+use crate::config::RootConfiguration;
+use crate::entries::EntryDeclaration;
+use crate::generators::GeneratorDeclaration;
+use crate::generators::list::ListConfiguration;
+use crate::utils;
+use anyhow::{Context, Result};
+use std::collections::BTreeMap;
+use uefi::CString16;
+use uefi::fs::{FileSystem, Path};
+use uefi::proto::device_path::DevicePath;
+use uefi::proto::device_path::text::{AllowShortcuts, DisplayOnly};
+
+/// The name prefix of the Linux chainload action that will be used to boot Linux.
+const LINUX_CHAINLOAD_ACTION_PREFIX: &str = "linux-chainload-";
+
+/// The locations to scan for kernel pairs.
+/// We will check for symlinks and if this directory is a symlink, we will skip it.
+const SCAN_LOCATIONS: &[&str] = &["/boot", "/"];
+
+/// Prefixes of kernel files to scan for.
+const KERNEL_PREFIXES: &[&str] = &["vmlinuz"];
+
+/// Prefixes of initramfs files to match to.
+const INITRAMFS_PREFIXES: &[&str] = &["initramfs", "initrd", "initrd.img"];
+
+/// Pair of kernel and initramfs.
+/// This is what scanning a directory is meant to find.
+struct KernelPair {
+    /// The path to a kernel.
+    kernel: String,
+    /// The path to an initramfs, if any.
+    initramfs: Option<String>,
+}
+
+/// Scan the specified `filesystem` at `path` for [KernelPair] results.
+fn scan_directory(filesystem: &mut FileSystem, path: &str) -> Result<Vec<KernelPair>> {
+    // All the discovered kernel pairs.
+    let mut pairs = Vec::new();
+
+    // Construct a filesystem path from the path string.
+    let path = CString16::try_from(path).context("unable to convert path to CString16")?;
+    let path = Path::new(&path);
+    let path = path.to_path_buf();
+
+    // Check if the path exists and is a directory.
+    let exists = filesystem
+        .metadata(&path)
+        .ok()
+        .map(|metadata| metadata.is_directory())
+        .unwrap_or(false);
+
+    // If the path does not exist, return an empty list.
+    if !exists {
+        return Ok(pairs);
+    }
+
+    // Open a directory iterator on the path to scan.
+    // Ignore errors here as in some scenarios this might fail due to symlinks.
+    let Some(directory) = filesystem.read_dir(&path).ok() else {
+        return Ok(pairs);
+    };
+
+    // For each item in the directory, find a kernel.
+    for item in directory {
+        let item = item.context("unable to read directory item")?;
+
+        // Skip over any items that are not regular files.
+        if !item.is_regular_file() {
+            continue;
+        }
+
+        // Convert the name from a CString16 to a String.
+        let name = item.file_name().to_string();
+
+        // Find a kernel prefix that matches, if any.
+        let Some(prefix) = KERNEL_PREFIXES
+            .iter()
+            .find(|prefix| name == **prefix || name.starts_with(&format!("{}-", prefix)))
+        else {
+            // Skip over anything that doesn't match a kernel prefix.
+            continue;
+        };
+
+        // Acquire the suffix of the name, this will be used to match an initramfs.
+        let suffix = &name[prefix.len()..];
+
+        // Find a matching initramfs, if any.
+        let mut initramfs_prefix_iter = INITRAMFS_PREFIXES.iter();
+        let matched_initramfs_path = loop {
+            let Some(prefix) = initramfs_prefix_iter.next() else {
+                break None;
+            };
+            // Construct an initramfs path.
+            let initramfs = format!("{}{}", prefix, suffix);
+            let initramfs = CString16::try_from(initramfs.as_str())
+                .context("unable to convert initramfs name to CString16")?;
+            let mut initramfs_path = path.clone();
+            initramfs_path.push(Path::new(&initramfs));
+            // Check if the initramfs path exists, if it does, break out of the loop.
+            if filesystem
+                .try_exists(&initramfs_path)
+                .context("unable to check if initramfs path exists")?
+            {
+                break Some(initramfs_path);
+            }
+        };
+
+        // Construct a kernel path from the kernel name.
+        let mut kernel = path.clone();
+        kernel.push(Path::new(&item.file_name()));
+        let kernel = kernel.to_string();
+        let initramfs = matched_initramfs_path.map(|initramfs_path| initramfs_path.to_string());
+
+        // Produce a kernel pair.
+        let pair = KernelPair { kernel, initramfs };
+        pairs.push(pair);
+    }
+
+    Ok(pairs)
+}
+
+/// Scan the specified `filesystem` for Linux kernels and matching initramfs.
+pub fn scan(
+    filesystem: &mut FileSystem,
+    root: &DevicePath,
+    config: &mut RootConfiguration,
+) -> Result<bool> {
+    let mut pairs = Vec::new();
+
+    // Convert the device path root to a string we can use in the configuration.
+    let mut root = root
+        .to_string(DisplayOnly(false), AllowShortcuts(false))
+        .context("unable to convert device root to string")?
+        .to_string();
+    // Add a trailing forward-slash to the root to ensure the device root is completed.
+    root.push('/');
+
+    // Generate a unique hash of the root path.
+    let root_unique_hash = utils::unique_hash(&root);
+
+    // Scan all locations for kernel pairs, adding them to the list.
+    for location in SCAN_LOCATIONS {
+        let scanned = scan_directory(filesystem, location)
+            .with_context(|| format!("unable to scan directory {}", location))?;
+        pairs.extend(scanned);
+    }
+
+    // If no kernel pairs were found, return false.
+    if pairs.is_empty() {
+        return Ok(false);
+    }
+
+    // Generate a unique name for the linux chainload action.
+    let chainload_action_name = format!("{}{}", LINUX_CHAINLOAD_ACTION_PREFIX, root_unique_hash,);
+
+    // Kernel pairs are detected, generate a list configuration for it.
+    let generator = ListConfiguration {
+        entry: EntryDeclaration {
+            title: "Boot Linux $name".to_string(),
+            actions: vec![chainload_action_name.clone()],
+            ..Default::default()
+        },
+        values: pairs
+            .into_iter()
+            .map(|pair| {
+                BTreeMap::from_iter(vec![
+                    ("name".to_string(), pair.kernel.clone()),
+                    ("kernel".to_string(), format!("{}{}", root, pair.kernel)),
+                    (
+                        "initrd".to_string(),
+                        pair.initramfs
+                            .map(|initramfs| format!("{}{}", root, initramfs))
+                            .unwrap_or_default(),
+                    ),
+                ])
+            })
+            .collect(),
+    };
+
+    // Generate a unique name for the Linux generator and insert the generator into the configuration.
+    config.generators.insert(
+        format!("autoconfigure-linux-{}", root_unique_hash),
+        GeneratorDeclaration {
+            list: Some(generator),
+            ..Default::default()
+        },
+    );
+
+    // Insert a default value for the linux-options if it doesn't exist.
+    if !config.values.contains_key("linux-options") {
+        config
+            .values
+            .insert("linux-options".to_string(), "".to_string());
+    }
+
+    // Generate a chainload configuration for the list generator.
+    // The list will provide these values to us.
+    // Note that we don't need an extra \\ in the paths here.
+    // The root already contains a trailing slash.
+    let chainload = ChainloadConfiguration {
+        path: "$kernel".to_string(),
+        options: vec!["$linux-options".to_string()],
+        linux_initrd: Some("$initrd".to_string()),
+    };
+
+    // Insert the chainload action into the configuration.
+    config.actions.insert(
+        chainload_action_name,
+        ActionDeclaration {
+            chainload: Some(chainload),
+            ..Default::default()
+        },
+    );
+
+    // We had a Linux kernel, so return true to indicate something was found.
+    Ok(true)
+}
--- a/src/autoconfigure/windows.rs
+++ b/src/autoconfigure/windows.rs
@@ -0,0 +1,80 @@
+use crate::actions::ActionDeclaration;
+use crate::actions::chainload::ChainloadConfiguration;
+use crate::config::RootConfiguration;
+use crate::entries::EntryDeclaration;
+use crate::utils;
+use anyhow::{Context, Result};
+use uefi::CString16;
+use uefi::fs::{FileSystem, Path};
+use uefi::proto::device_path::DevicePath;
+use uefi::proto::device_path::text::{AllowShortcuts, DisplayOnly};
+
+/// The name prefix of the Windows chainload action that will be used to boot Windows.
+const WINDOWS_CHAINLOAD_ACTION_PREFIX: &str = "windows-chainload-";
+
+/// Windows boot manager path.
+const BOOTMGR_FW_PATH: &str = "\\EFI\\Microsoft\\Boot\\bootmgfw.efi";
+
+/// Scan the specified `filesystem` for Windows configurations.
+pub fn scan(
+    filesystem: &mut FileSystem,
+    root: &DevicePath,
+    config: &mut RootConfiguration,
+) -> Result<bool> {
+    // Convert the boot manager firmware path to a path.
+    let bootmgr_fw_path =
+        CString16::try_from(BOOTMGR_FW_PATH).context("unable to convert path to CString16")?;
+    let bootmgr_fw_path = Path::new(&bootmgr_fw_path);
+
+    // Check if the boot manager firmware path exists, if it doesn't, return false.
+    if !filesystem
+        .try_exists(bootmgr_fw_path)
+        .context("unable to check if bootmgr firmware path exists")?
+    {
+        return Ok(false);
+    }
+
+    // Convert the device path root to a string we can use in the configuration.
+    let mut root = root
+        .to_string(DisplayOnly(false), AllowShortcuts(false))
+        .context("unable to convert device root to string")?
+        .to_string();
+    // Add a trailing forward-slash to the root to ensure the device root is completed.
+    root.push('/');
+
+    // Generate a unique hash of the root path.
+    let root_unique_hash = utils::unique_hash(&root);
+
+    // Generate a unique name for the Windows chainload action.
+    let chainload_action_name = format!("{}{}", WINDOWS_CHAINLOAD_ACTION_PREFIX, root_unique_hash,);
+
+    // Generate an entry name for Windows.
+    let entry_name = format!("autoconfigure-windows-{}", root_unique_hash,);
+
+    // Create an entry for Windows and insert it into the configuration.
+    let entry = EntryDeclaration {
+        title: "Boot Windows".to_string(),
+        actions: vec![chainload_action_name.clone()],
+        values: Default::default(),
+    };
+    config.entries.insert(entry_name, entry);
+
+    // Generate a chainload configuration for Windows.
+    let chainload = ChainloadConfiguration {
+        path: format!("{}{}", root, bootmgr_fw_path),
+        options: vec![],
+        ..Default::default()
+    };
+
+    // Insert the chainload action into the configuration.
+    config.actions.insert(
+        chainload_action_name,
+        ActionDeclaration {
+            chainload: Some(chainload),
+            ..Default::default()
+        },
+    );
+
+    // We have a Windows boot entry, so return true to indicate something was found.
+    Ok(true)
+}
--- a/src/config.rs
+++ b/src/config.rs
@@ -27,7 +27,7 @@ pub struct RootConfiguration {
    pub version: u32,
    /// Default options for Sprout.
    #[serde(default)]
-    pub defaults: DefaultsConfiguration,
+    pub options: OptionsConfiguration,
    /// Values to be inserted into the root sprout context.
    #[serde(default)]
    pub values: BTreeMap<String, String>,
@@ -65,16 +65,18 @@ pub struct RootConfiguration {
    pub phases: PhasesConfiguration,
 }

-/// Default configuration for Sprout, used when the corresponding options are not specified.
+/// Options configuration for Sprout, used when the corresponding options are not specified.
 #[derive(Serialize, Deserialize, Debug, Default, Clone)]
-pub struct DefaultsConfiguration {
+pub struct OptionsConfiguration {
    /// The entry to boot without showing the boot menu.
    /// If not specified, a boot menu is shown.
-    pub entry: Option<String>,
+    #[serde(rename = "default-entry", default)]
+    pub default_entry: Option<String>,
    /// The timeout of the boot menu.
    #[serde(rename = "menu-timeout", default = "default_menu_timeout")]
    pub menu_timeout: u64,
    /// Enables autoconfiguration of Sprout based on the environment.
+    #[serde(default)]
    pub autoconfigure: bool,
 }

--- a/src/context.rs
+++ b/src/context.rs
@@ -1,5 +1,6 @@
 use crate::actions::ActionDeclaration;
 use crate::options::SproutOptions;
+use crate::platform::timer::PlatformTimer;
 use anyhow::anyhow;
 use anyhow::{Result, bail};
 use std::cmp::Reverse;
@@ -12,22 +13,29 @@ const CONTEXT_FINALIZE_ITERATION_LIMIT: usize = 100;

 /// Declares a root context for Sprout.
 /// This contains data that needs to be shared across Sprout.
-#[derive(Default)]
 pub struct RootContext {
    /// The actions that are available in Sprout.
    actions: BTreeMap<String, ActionDeclaration>,
    /// The device path of the loaded Sprout image.
    loaded_image_path: Option<Box<DevicePath>>,
+    /// Platform timer started at the beginning of the boot process.
+    timer: PlatformTimer,
    /// The global options of Sprout.
    options: SproutOptions,
 }

 impl RootContext {
    /// Creates a new root context with the `loaded_image_device_path` which will be stored
-    /// in the context for easy access.
-    pub fn new(loaded_image_device_path: Box<DevicePath>, options: SproutOptions) -> Self {
+    /// in the context for easy access. We also provide a `timer` which is used to measure elapsed
+    /// time for the bootloader.
+    pub fn new(
+        loaded_image_device_path: Box<DevicePath>,
+        timer: PlatformTimer,
+        options: SproutOptions,
+    ) -> Self {
        Self {
            actions: BTreeMap::new(),
+            timer,
            loaded_image_path: Some(loaded_image_device_path),
            options,
        }
@@ -43,6 +51,11 @@ impl RootContext {
        &mut self.actions
    }

+    /// Access the platform timer that is started at the beginning of the boot process.
+    pub fn timer(&self) -> &PlatformTimer {
+        &self.timer
+    }
+
    /// Access the device path of the loaded Sprout image.
    pub fn loaded_image_path(&self) -> Result<&DevicePath> {
        self.loaded_image_path
@@ -118,7 +131,10 @@ impl SproutContext {
    pub fn all_values(&self) -> BTreeMap<String, String> {
        let mut values = BTreeMap::new();
        for key in self.all_keys() {
-            values.insert(key.clone(), self.get(key).cloned().unwrap_or_default());
+            // Acquire the value from the context. Since retrieving all the keys will give us
+            // a full view of the context, we can be sure that the key exists.
+            let value = self.get(&key).cloned().unwrap_or_default();
+            values.insert(key.clone(), value);
        }
        values
    }
@@ -165,13 +181,13 @@ impl SproutContext {
        let mut current_values = self.all_values();

        // To ensure that there is no possible infinite loop, we need to check
-        // the number of iterations. If it exceeds 100, we bail.
+        // the number of iterations. If it exceeds CONTEXT_FINALIZE_ITERATION_LIMIT, we bail.
        let mut iterations: usize = 0;
        loop {
            iterations += 1;

            if iterations > CONTEXT_FINALIZE_ITERATION_LIMIT {
-                bail!("infinite loop detected in context finalization");
+                bail!("maximum number of replacement iterations reached while finalizing context");
            }

            let mut did_change = false;
--- a/src/drivers.rs
+++ b/src/drivers.rs
@@ -33,8 +33,6 @@ fn load_driver(context: Rc<SproutContext>, driver: &DriverDeclaration) -> Result
    // Push the path of the driver from the root.
    full_path.push_str(&context.stamp(&driver.path));

-    info!("driver path: {}", full_path);
-
    // Convert the path to a device path.
    let device_path = utils::text_to_device_path(&full_path)?;

--- a/src/entries.rs
+++ b/src/entries.rs
@@ -28,6 +28,7 @@ pub struct BootableEntry {
    context: Rc<SproutContext>,
    declaration: EntryDeclaration,
    default: bool,
+    pin_name: bool,
 }

 impl BootableEntry {
@@ -44,6 +45,7 @@ impl BootableEntry {
            context,
            declaration,
            default: false,
+            pin_name: false,
        }
    }

@@ -72,6 +74,11 @@ impl BootableEntry {
        self.default
    }

+    /// Fetch whether the entry is pinned, which prevents prefixing.
+    pub fn is_pin_name(&self) -> bool {
+        self.pin_name
+    }
+
    /// Swap out the context of the entry.
    pub fn swap_context(&mut self, context: Rc<SproutContext>) {
        self.context = context;
@@ -87,6 +94,11 @@ impl BootableEntry {
        self.default = true;
    }

+    /// Mark this entry as being pinned, which prevents prefixing.
+    pub fn mark_pin_name(&mut self) {
+        self.pin_name = true;
+    }
+
    /// Prepend the name of the entry with `prefix`.
    pub fn prepend_name_prefix(&mut self, prefix: &str) {
        self.name.insert_str(0, prefix);
--- a/src/extractors/filesystem_device_match.rs
+++ b/src/extractors/filesystem_device_match.rs
@@ -9,17 +9,16 @@ use uefi::fs::{FileSystem, Path};
 use uefi::proto::device_path::DevicePath;
 use uefi::proto::media::file::{File, FileSystemVolumeLabel};
 use uefi::proto::media::fs::SimpleFileSystem;
-use uefi::proto::media::partition::PartitionInfo;
 use uefi::{CString16, Guid};
-use uefi_raw::Status;

 /// The filesystem device match extractor.
 /// This extractor finds a filesystem using some search criteria and returns
 /// the device root path that can concatenated with subpaths to access files
 /// on a particular filesystem.
+/// The fallback value can be used to provide a value if no match is found.
 ///
-/// This function only requires one of the criteria to match.
-/// The fallback value can be used to provide a value if none is found.
+/// This extractor requires all the criteria to match. If no criteria is provided,
+/// an error is returned.
 #[derive(Serialize, Deserialize, Debug, Default, Clone)]
 pub struct FilesystemDeviceMatchExtractor {
    /// Matches a filesystem that has the specified label.
@@ -45,6 +44,15 @@ pub fn extract(
    context: Rc<SproutContext>,
    extractor: &FilesystemDeviceMatchExtractor,
 ) -> Result<String> {
+    // If no criteria are provided, bail with an error.
+    if extractor.has_label.is_none()
+        && extractor.has_item.is_none()
+        && extractor.has_partition_uuid.is_none()
+        && extractor.has_partition_type_uuid.is_none()
+    {
+        bail!("at least one criteria is required for filesystem-device-match");
+    }
+
    // Find all the filesystems inside the UEFI stack.
    let handles = uefi::boot::find_handles::<SimpleFileSystem>()
        .context("unable to find filesystem handles")?;
@@ -54,58 +62,49 @@ pub fn extract(
        // This defines whether a match has been found.
        let mut has_match = false;

-        // Extract the partition info for this filesystem.
-        // There is no guarantee that the filesystem has a partition.
-        let partition_info = {
-            // Open the partition info protocol for this handle.
-            let partition_info = uefi::boot::open_protocol_exclusive::<PartitionInfo>(handle);
-
-            match partition_info {
-                Ok(partition_info) => {
-                    // GPT partitions have a unique partition GUID.
-                    // MBR does not.
-                    if let Some(gpt) = partition_info.gpt_partition_entry() {
-                        let uuid = gpt.unique_partition_guid;
-                        let type_uuid = gpt.partition_type_guid;
-                        Some((uuid, type_uuid.0))
-                    } else {
-                        None
-                    }
-                }
-
-                Err(error) => {
-                    // If the filesystem does not have a partition, that is okay.
-                    if error.status() == Status::NOT_FOUND || error.status() == Status::UNSUPPORTED
-                    {
-                        None
-                    } else {
-                        // We should still handle other errors gracefully.
-                        Err(error).context("unable to open filesystem partition info")?;
-                        unreachable!()
-                    }
-                }
-            }
-        };
-
        // Check if the partition info matches partition uuid criteria.
-        if let Some((partition_uuid, _partition_type_guid)) = partition_info
-            && let Some(ref has_partition_uuid) = extractor.has_partition_uuid
-        {
+        if let Some(ref has_partition_uuid) = extractor.has_partition_uuid {
+            // Parse the partition uuid from the extractor.
            let parsed_uuid = Guid::from_str(has_partition_uuid)
                .map_err(|e| anyhow!("unable to parse has-partition-uuid: {}", e))?;
-            if partition_uuid != parsed_uuid {
+
+            // Fetch the root of the device.
+            let root = uefi::boot::open_protocol_exclusive::<DevicePath>(handle)
+                .context("unable to fetch the device path of the filesystem")?
+                .deref()
+                .to_boxed();
+
+            // Fetch the partition uuid for this filesystem.
+            let partition_uuid = utils::partition_guid(&root, utils::PartitionGuidForm::Partition)
+                .context("unable to fetch the partition uuid of the filesystem")?;
+
+            // Compare the partition uuid to the parsed uuid.
+            // If it does not match, continue to the next filesystem.
+            if partition_uuid != Some(parsed_uuid) {
                continue;
            }
            has_match = true;
        }

        // Check if the partition info matches partition type uuid criteria.
-        if let Some((_partition_uuid, partition_type_guid)) = partition_info
-            && let Some(ref has_partition_type_uuid) = extractor.has_partition_type_uuid
-        {
+        if let Some(ref has_partition_type_uuid) = extractor.has_partition_type_uuid {
+            // Parse the partition type uuid from the extractor.
            let parsed_uuid = Guid::from_str(has_partition_type_uuid)
                .map_err(|e| anyhow!("unable to parse has-partition-type-uuid: {}", e))?;
-            if partition_type_guid != parsed_uuid {
+
+            // Fetch the root of the device.
+            let root = uefi::boot::open_protocol_exclusive::<DevicePath>(handle)
+                .context("unable to fetch the device path of the filesystem")?
+                .deref()
+                .to_boxed();
+
+            // Fetch the partition uuid for this filesystem.
+            let partition_type_uuid =
+                utils::partition_guid(&root, utils::PartitionGuidForm::Partition)
+                    .context("unable to fetch the partition uuid of the filesystem")?;
+            // Compare the partition type uuid to the parsed uuid.
+            // If it does not match, continue to the next filesystem.
+            if partition_type_uuid != Some(parsed_uuid) {
                continue;
            }
            has_match = true;
--- a/src/generators.rs
+++ b/src/generators.rs
@@ -1,6 +1,7 @@
 use crate::context::SproutContext;
 use crate::entries::BootableEntry;
 use crate::generators::bls::BlsConfiguration;
+use crate::generators::list::ListConfiguration;
 use crate::generators::matrix::MatrixConfiguration;
 use anyhow::Result;
 use anyhow::bail;
@@ -8,6 +9,7 @@ use serde::{Deserialize, Serialize};
 use std::rc::Rc;

 pub mod bls;
+pub mod list;
 pub mod matrix;

 /// Declares a generator configuration.
@@ -32,6 +34,9 @@ pub struct GeneratorDeclaration {
    /// It will generate a sprout entry for every supported BLS entry.
    #[serde(default)]
    pub bls: Option<BlsConfiguration>,
+    /// List generator configuration.
+    /// Allows you to specify a list of values to generate an entry from.
+    pub list: Option<ListConfiguration>,
 }

 /// Runs the generator specified by the `generator` option.
@@ -45,6 +50,8 @@ pub fn generate(
        matrix::generate(context, matrix)
    } else if let Some(bls) = &generator.bls {
        bls::generate(context, bls)
+    } else if let Some(list) = &generator.list {
+        list::generate(context, list)
    } else {
        bail!("unknown generator configuration");
    }
--- a/src/generators/bls.rs
+++ b/src/generators/bls.rs
@@ -83,13 +83,16 @@ pub fn generate(context: Rc<SproutContext>, bls: &BlsConfiguration) -> Result<Ve
        }

        // Get the file name of the filesystem item.
-        let name = entry.file_name().to_string();
+        let mut name = entry.file_name().to_string();

        // Ignore files that are not .conf files.
        if !name.to_lowercase().ends_with(".conf") {
            continue;
        }

+        // Remove the .conf extension.
+        name.truncate(name.len() - 5);
+
        // Create a mutable path so we can append the file name to produce the full path.
        let mut full_entry_path = entries_path.to_path_buf();
        full_entry_path.push(entry.file_name());
@@ -125,13 +128,21 @@ pub fn generate(context: Rc<SproutContext>, bls: &BlsConfiguration) -> Result<Ve
        context.set("options", options);
        context.set("initrd", initrd);

-        // Add the entry to the list with a frozen context.
-        entries.push(BootableEntry::new(
+        // Produce a new bootable entry.
+        let mut entry = BootableEntry::new(
            name,
            bls.entry.title.clone(),
            context.freeze(),
            bls.entry.clone(),
-        ));
+        );
+
+        // Pin the entry name to prevent prefixing.
+        // This is needed as the bootloader interface requires the name to be
+        // the same as the entry file name, minus the .conf extension.
+        entry.mark_pin_name();
+
+        // Add the entry to the list with a frozen context.
+        entries.push(entry);
    }

    Ok(entries)
--- a/src/generators/bls/entry.rs
+++ b/src/generators/bls/entry.rs
@@ -41,7 +41,8 @@ impl FromStr for BlsEntry {
                continue;
            }

-            // Split the line once by whitespace.
+            // Split the line once by whitespace. This technically includes newlines but since
+            // the lines iterator is used, there should never be a newline here.
            let Some((key, value)) = line.split_once(char::is_whitespace) else {
                continue;
            };
--- a/src/generators/list.rs
+++ b/src/generators/list.rs
@@ -0,0 +1,52 @@
+use crate::context::SproutContext;
+use crate::entries::{BootableEntry, EntryDeclaration};
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+use std::rc::Rc;
+
+/// List generator configuration.
+/// The list generator produces multiple entries based
+/// on a set of input maps.
+#[derive(Serialize, Deserialize, Debug, Default, Clone)]
+pub struct ListConfiguration {
+    /// The template entry to use for each generated entry.
+    #[serde(default)]
+    pub entry: EntryDeclaration,
+    /// The values to use as the input for the matrix.
+    #[serde(default)]
+    pub values: Vec<BTreeMap<String, String>>,
+}
+
+/// Generates a set of entries using the specified `matrix` configuration in the `context`.
+pub fn generate(
+    context: Rc<SproutContext>,
+    list: &ListConfiguration,
+) -> Result<Vec<BootableEntry>> {
+    let mut entries = Vec::new();
+
+    // For each combination, create a new context and entry.
+    for (index, combination) in list.values.iter().enumerate() {
+        let mut context = context.fork();
+        // Insert the combination into the context.
+        context.insert(combination);
+        let context = context.freeze();
+
+        // Stamp the entry title and actions from the template.
+        let mut entry = list.entry.clone();
+        entry.actions = entry
+            .actions
+            .into_iter()
+            .map(|action| context.stamp(action))
+            .collect();
+        // Push the entry into the list with the new context.
+        entries.push(BootableEntry::new(
+            index.to_string(),
+            entry.title.clone(),
+            context,
+            entry,
+        ));
+    }
+
+    Ok(entries)
+}
--- a/src/generators/matrix.rs
+++ b/src/generators/matrix.rs
@@ -1,5 +1,6 @@
 use crate::context::SproutContext;
 use crate::entries::{BootableEntry, EntryDeclaration};
+use crate::generators::list;
 use anyhow::Result;
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
@@ -57,30 +58,12 @@ pub fn generate(
 ) -> Result<Vec<BootableEntry>> {
    // Produce all the combinations of the input values.
    let combinations = build_matrix(&matrix.values);
-    let mut entries = Vec::new();
-
-    // For each combination, create a new context and entry.
-    for (index, combination) in combinations.into_iter().enumerate() {
-        let mut context = context.fork();
-        // Insert the combination into the context.
-        context.insert(&combination);
-        let context = context.freeze();
-
-        // Stamp the entry title and actions from the template.
-        let mut entry = matrix.entry.clone();
-        entry.actions = entry
-            .actions
-            .into_iter()
-            .map(|action| context.stamp(action))
-            .collect();
-        // Push the entry into the list with the new context.
-        entries.push(BootableEntry::new(
-            index.to_string(),
-            entry.title.clone(),
+    // Use the list generator to generate entries for each combination.
+    list::generate(
        context,
-            entry,
-        ));
-    }
-
-    Ok(entries)
+        &list::ListConfiguration {
+            entry: matrix.entry.clone(),
+            values: combinations,
+        },
+    )
 }
--- a/src/integrations.rs
+++ b/src/integrations.rs
@@ -0,0 +1,2 @@
+/// Implements support for the bootloader interface specification.
+pub mod bootloader_interface;
--- a/src/integrations/bootloader_interface.rs
+++ b/src/integrations/bootloader_interface.rs
@@ -0,0 +1,125 @@
+use crate::platform::timer::PlatformTimer;
+use crate::utils::device_path_subpath;
+use anyhow::{Context, Result};
+use uefi::proto::device_path::DevicePath;
+use uefi::{CString16, Guid, guid};
+use uefi_raw::table::runtime::{VariableAttributes, VariableVendor};
+
+/// The name of the bootloader to tell the system.
+const LOADER_NAME: &str = "Sprout";
+
+/// Bootloader Interface support.
+pub struct BootloaderInterface;
+
+impl BootloaderInterface {
+    /// Bootloader Interface GUID from https://systemd.io/BOOT_LOADER_INTERFACE
+    const VENDOR: VariableVendor = VariableVendor(guid!("4a67b082-0a4c-41cf-b6c7-440b29bb8c4f"));
+
+    /// Tell the system that Sprout was initialized at the current time.
+    pub fn mark_init(timer: &PlatformTimer) -> Result<()> {
+        Self::mark_time("LoaderTimeInitUSec", timer)
+    }
+
+    /// Tell the system that Sprout is about to execute the boot entry.
+    pub fn mark_exec(timer: &PlatformTimer) -> Result<()> {
+        Self::mark_time("LoaderTimeExecUSec", timer)
+    }
+
+    /// Tell the system that Sprout is about to display the menu.
+    pub fn mark_menu(timer: &PlatformTimer) -> Result<()> {
+        Self::mark_time("LoaderTimeMenuUsec", timer)
+    }
+
+    /// Tell the system about the current time as measured by the platform timer.
+    /// Sets the variable specified by `key` to the number of microseconds.
+    fn mark_time(key: &str, timer: &PlatformTimer) -> Result<()> {
+        // Measure the elapsed time since the hardware timer was started.
+        let elapsed = timer.elapsed_since_lifetime();
+        Self::set_cstr16(key, &elapsed.as_micros().to_string())
+    }
+
+    /// Tell the system what loader is being used.
+    pub fn set_loader_info() -> Result<()> {
+        Self::set_cstr16("LoaderInfo", LOADER_NAME)
+    }
+
+    /// Tell the system the relative path to the partition root of the current bootloader.
+    pub fn set_loader_path(path: &DevicePath) -> Result<()> {
+        let subpath = device_path_subpath(path).context("unable to get loader path subpath")?;
+        Self::set_cstr16("LoaderImageIdentifier", &subpath)
+    }
+
+    /// Tell the system what the partition GUID of the ESP Sprout was booted from is.
+    pub fn set_partition_guid(guid: &Guid) -> Result<()> {
+        Self::set_cstr16("LoaderDevicePartUUID", &guid.to_string())
+    }
+
+    /// Tell the system what boot entries are available.
+    pub fn set_entries<N: AsRef<str>>(entries: impl Iterator<Item = N>) -> Result<()> {
+        // Entries are stored as a null-terminated list of CString16 strings back to back.
+        // Iterate over the entries and convert them to CString16 placing them into data.
+        let mut data = Vec::new();
+        for entry in entries {
+            // Convert the entry to CString16 little endian.
+            let encoded = entry
+                .as_ref()
+                .encode_utf16()
+                .flat_map(|c| c.to_le_bytes())
+                .collect::<Vec<u8>>();
+            // Write the bytes (including the null terminator) into the data buffer.
+            data.extend_from_slice(&encoded);
+        }
+        Self::set("LoaderEntries", &data)
+    }
+
+    /// Tell the system what the default boot entry is.
+    pub fn set_default_entry(entry: String) -> Result<()> {
+        Self::set_cstr16("LoaderEntryDefault", &entry)
+    }
+
+    /// Tell the system what the selected boot entry is.
+    pub fn set_selected_entry(entry: String) -> Result<()> {
+        Self::set_cstr16("LoaderEntrySelected", &entry)
+    }
+
+    /// Tell the system about the UEFI firmware we are running on.
+    pub fn set_firmware_info() -> Result<()> {
+        // Format the firmware information string into something human-readable.
+        let firmware_info = format!(
+            "{} {}.{:02}",
+            uefi::system::firmware_vendor(),
+            uefi::system::firmware_revision() >> 16,
+            uefi::system::firmware_revision() & 0xFFFFF,
+        );
+        Self::set_cstr16("LoaderFirmwareInfo", &firmware_info)?;
+
+        // Format the firmware revision into something human-readable.
+        let firmware_type = format!("UEFI {:02}", uefi::system::firmware_revision());
+        Self::set_cstr16("LoaderFirmwareType", &firmware_type)
+    }
+
+    /// The [VariableAttributes] for bootloader interface variables.
+    fn attributes() -> VariableAttributes {
+        VariableAttributes::BOOTSERVICE_ACCESS | VariableAttributes::RUNTIME_ACCESS
+    }
+
+    /// Set a bootloader interface variable specified by `key` to `value`.
+    fn set(key: &str, value: &[u8]) -> Result<()> {
+        let name =
+            CString16::try_from(key).context("unable to convert variable name to CString16")?;
+        uefi::runtime::set_variable(&name, &Self::VENDOR, Self::attributes(), value)
+            .with_context(|| format!("unable to set efi variable {}", key))?;
+        Ok(())
+    }
+
+    /// Set a bootloader interface variable specified by `key` to `value`, converting the value to
+    /// a [CString16].
+    fn set_cstr16(key: &str, value: &str) -> Result<()> {
+        // Encode the value as a CString16 little endian.
+        let encoded = value
+            .encode_utf16()
+            .flat_map(|c| c.to_le_bytes())
+            .collect::<Vec<u8>>();
+        Self::set(key, &encoded)
+    }
+}
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,19 +1,22 @@
 #![doc = include_str!("../README.md")]
 #![feature(uefi_std)]
+extern crate core;

 use crate::config::RootConfiguration;
 use crate::context::{RootContext, SproutContext};
 use crate::entries::BootableEntry;
+use crate::integrations::bootloader_interface::BootloaderInterface;
 use crate::options::SproutOptions;
 use crate::options::parser::OptionsRepresentable;
 use crate::phases::phase;
+use crate::platform::timer::PlatformTimer;
+use crate::utils::PartitionGuidForm;
 use anyhow::{Context, Result, bail};
-use log::info;
+use log::{error, info};
 use std::collections::BTreeMap;
 use std::ops::Deref;
 use std::time::Duration;
 use uefi::proto::device_path::LoadedImageDevicePath;
-use uefi::proto::device_path::text::{AllowShortcuts, DisplayOnly};

 /// actions: Code that can be configured and executed by Sprout.
 pub mod actions;
@@ -39,9 +42,15 @@ pub mod extractors;
 /// generators: Runtime code that can generate entries with specific values.
 pub mod generators;

+/// platform: Integration or support code for specific hardware platforms.
+pub mod platform;
+
 /// menu: Display a boot menu to select an entry to boot.
 pub mod menu;

+/// integrations: Code that interacts with other systems.
+pub mod integrations;
+
 /// phases: Hooks into specific parts of the boot process.
 pub mod phases;

@@ -54,12 +63,22 @@ pub mod options;
 /// utils: Utility functions that are used by other parts of Sprout.
 pub mod utils;

-/// The main entrypoint of sprout.
-/// It is possible this function will not return if actions that are executed
-/// exit boot services or do not return control to sprout.
-fn main() -> Result<()> {
-    // Initialize the basic UEFI environment.
-    setup::init()?;
+/// Run Sprout, returning an error if one occurs.
+fn run() -> Result<()> {
+    // Start the platform timer.
+    let timer = PlatformTimer::start();
+
+    // Mark the initialization of Sprout in the bootloader interface.
+    BootloaderInterface::mark_init(&timer)
+        .context("unable to mark initialization in bootloader interface")?;
+
+    // Tell the bootloader interface what firmware we are running on.
+    BootloaderInterface::set_firmware_info()
+        .context("unable to set firmware info in bootloader interface")?;
+
+    // Tell the bootloader interface what loader is being used.
+    BootloaderInterface::set_loader_info()
+        .context("unable to set loader info in bootloader interface")?;

    // Parse the options to the sprout executable.
    let options = SproutOptions::parse().context("unable to parse options")?;
@@ -75,21 +94,35 @@ fn main() -> Result<()> {
        config::loader::load(&options)?
    };

-    // Load the root context.
+    // Grab the sprout.efi loaded image path.
    // This is done in a block to ensure the release of the LoadedImageDevicePath protocol.
-    let mut root = {
+    let loaded_image_path = {
        let current_image_device_path_protocol = uefi::boot::open_protocol_exclusive::<
            LoadedImageDevicePath,
        >(uefi::boot::image_handle())
        .context("unable to get loaded image device path")?;
-        let loaded_image_path = current_image_device_path_protocol.deref().to_boxed();
-        info!(
-            "loaded image path: {}",
-            loaded_image_path.to_string(DisplayOnly(false), AllowShortcuts(false))?
-        );
-        RootContext::new(loaded_image_path, options)
+        current_image_device_path_protocol.deref().to_boxed()
    };

+    // Grab the partition GUID of the ESP that sprout was loaded from.
+    let loaded_image_partition_guid =
+        utils::partition_guid(&loaded_image_path, PartitionGuidForm::Partition)
+            .context("unable to retrieve loaded image partition guid")?;
+
+    // Set the partition GUID of the ESP that sprout was loaded from in the bootloader interface.
+    if let Some(loaded_image_partition_guid) = loaded_image_partition_guid {
+        // Tell the system about the partition GUID.
+        BootloaderInterface::set_partition_guid(&loaded_image_partition_guid)
+            .context("unable to set partition guid in bootloader interface")?;
+    }
+
+    // Tell the bootloader interface what the loaded image path is.
+    BootloaderInterface::set_loader_path(&loaded_image_path)
+        .context("unable to set loader path in bootloader interface")?;
+
+    // Create the root context.
+    let mut root = RootContext::new(loaded_image_path, timer, options);
+
    // Insert the configuration actions into the root context.
    root.actions_mut().extend(config.actions.clone());

@@ -110,7 +143,7 @@ fn main() -> Result<()> {

    // If --autoconfigure is specified or the loaded configuration has autoconfigure enabled,
    // trigger the autoconfiguration mechanism.
-    if context.root().options().autoconfigure || config.defaults.autoconfigure {
+    if context.root().options().autoconfigure || config.options.autoconfigure {
        autoconfigure::autoconfigure(&mut config).context("unable to autoconfigure")?;
    }

@@ -128,6 +161,9 @@ fn main() -> Result<()> {

        // Extend the root context with the autoconfigured actions.
        root.actions_mut().extend(config.actions);
+
+        // Insert any modified root values.
+        context.insert(&config.values);
    }

    // Refreeze the context to ensure that further operations can share the context.
@@ -166,13 +202,17 @@ fn main() -> Result<()> {
    for (name, generator) in config.generators {
        let context = context.fork().freeze();

-        // We will prefix all entries with [name]-.
+        // We will prefix all entries with [name]-, provided the name is not pinned.
        let prefix = format!("{}-", name);

        // Add all the entries generated by the generator to the entry list.
        // The generator specifies the context associated with the entry.
        for mut entry in generators::generate(context.clone(), &generator)? {
+            // If the entry name is not pinned, prepend the name prefix.
+            if !entry.is_pin_name() {
                entry.prepend_name_prefix(&prefix);
+            }
+
            entries.push(entry);
        }
    }
@@ -192,7 +232,7 @@ fn main() -> Result<()> {
        entry.restamp_title();

        // Mark this entry as the default entry if it is declared as such.
-        if let Some(ref default_entry) = config.defaults.entry {
+        if let Some(ref default_entry) = config.options.default_entry {
            // If the entry matches the default entry, mark it as the default entry.
            if entry.is_match(default_entry) {
                entry.mark_default();
@@ -207,6 +247,21 @@ fn main() -> Result<()> {
        entry.mark_default();
    }

+    // Iterate over all the entries and tell the bootloader interface what the entries are.
+    for entry in &entries {
+        // If the entry is the default entry, tell the bootloader interface it is the default.
+        if entry.is_default() {
+            // Tell the bootloader interface what the default entry is.
+            BootloaderInterface::set_default_entry(entry.name().to_string())
+                .context("unable to set default entry in bootloader interface")?;
+            break;
+        }
+    }
+
+    // Tell the bootloader interface what entries are available.
+    BootloaderInterface::set_entries(entries.iter().map(|entry| entry.name()))
+        .context("unable to set entries in bootloader interface")?;
+
    // Execute the late phase.
    phase(context.clone(), &config.phases.late).context("unable to execute late phase")?;

@@ -221,7 +276,7 @@ fn main() -> Result<()> {
        .root()
        .options()
        .menu_timeout
-        .unwrap_or(config.defaults.menu_timeout);
+        .unwrap_or(config.options.menu_timeout);
    let menu_timeout = Duration::from_secs(menu_timeout);

    // Use the forced boot entry if possible, otherwise pick the first entry using a boot menu.
@@ -230,9 +285,14 @@ fn main() -> Result<()> {
            .context(format!("unable to find entry: {force_boot_entry}"))?
    } else {
        // Delegate to the menu to select an entry to boot.
-        menu::select(menu_timeout, &entries).context("unable to select entry via boot menu")?
+        menu::select(&timer, menu_timeout, &entries)
+            .context("unable to select entry via boot menu")?
    };

+    // Tell the bootloader interface what the selected entry is.
+    BootloaderInterface::set_selected_entry(entry.name().to_string())
+        .context("unable to set selected entry in bootloader interface")?;
+
    // Execute all the actions for the selected entry.
    for action in &entry.declaration().actions {
        let action = entry.context().stamp(action);
@@ -240,6 +300,28 @@ fn main() -> Result<()> {
            .context(format!("unable to execute action '{}'", action))?;
    }

+    Ok(())
+}
+
+/// The main entrypoint of sprout.
+/// It is possible this function will not return if actions that are executed
+/// exit boot services or do not return control to sprout.
+fn main() -> Result<()> {
+    // Initialize the basic UEFI environment.
+    setup::init()?;
+
+    // Run Sprout, then handle the error.
+    let result = run();
+    if let Err(ref error) = result {
+        // Print an error trace.
+        error!("sprout encountered an error");
+        for (index, stack) in error.chain().enumerate() {
+            error!("[{}]: {}", index, stack);
+        }
+        // Sleep for 10 seconds to allow the user to read the error.
+        uefi::boot::stall(Duration::from_secs(10));
+    }
+
    // Sprout doesn't necessarily guarantee anything was booted.
    // If we reach here, we will exit back to whoever called us.
    Ok(())
--- a/src/menu.rs
+++ b/src/menu.rs
@@ -1,4 +1,6 @@
 use crate::entries::BootableEntry;
+use crate::integrations::bootloader_interface::BootloaderInterface;
+use crate::platform::timer::PlatformTimer;
 use anyhow::{Context, Result, bail};
 use log::info;
 use std::time::Duration;
@@ -40,15 +42,30 @@ fn read(input: &mut Input, timeout: &Duration) -> Result<MenuOperation> {
        uefi::boot::create_event_ex(EventType::TIMER, Tpl::CALLBACK, None, None, None)
            .context("unable to create timer event")?
    };
+
    // The timeout is in increments of 100 nanoseconds.
-    let trigger = TimerTrigger::Relative(timeout.as_nanos() as u64 / 100);
+    let timeout_hundred_nanos = timeout.as_nanos() / 100;
+
+    // Check if the timeout is too large to fit into an u64.
+    if timeout_hundred_nanos > u64::MAX as u128 {
+        bail!("timeout duration overflow");
+    }
+
+    // Set a timer to trigger after the specified duration.
+    let trigger = TimerTrigger::Relative(timeout_hundred_nanos as u64);
    uefi::boot::set_timer(&timer_event, trigger).context("unable to set timeout timer")?;

-    let mut events = [timer_event, key_event];
+    let mut events = vec![timer_event, key_event];
    let event = uefi::boot::wait_for_event(&mut events)
        .discard_errdata()
        .context("unable to wait for event")?;

+    // Close the timer event that we acquired.
+    // We don't need to close the key event because it is owned globally.
+    if let Some(timer_event) = events.into_iter().next() {
+        uefi::boot::close_event(timer_event).context("unable to close timer event")?;
+    }
+
    // The first event is the timer event.
    // If it has triggered, the user did not select a numbered entry.
    if event == 0 {
@@ -121,7 +138,7 @@ fn select_with_input<'a>(
            // Entry was selected by number. If the number is invalid, we continue.
            MenuOperation::Number(index) => {
                let Some(entry) = entries.get(index) else {
-                    println!("invalid entry number");
+                    info!("invalid entry number");
                    continue;
                };
                return Ok(entry);
@@ -147,7 +164,15 @@ fn select_with_input<'a>(
 /// Shows a boot menu to select a bootable entry to boot.
 /// The actual work is done internally in [select_with_input] which is called
 /// within the context of the standard input device.
-pub fn select(timeout: Duration, entries: &[BootableEntry]) -> Result<&BootableEntry> {
+pub fn select<'live>(
+    timer: &'live PlatformTimer,
+    timeout: Duration,
+    entries: &'live [BootableEntry],
+) -> Result<&'live BootableEntry> {
+    // Notify the bootloader interface that we are about to display the menu.
+    BootloaderInterface::mark_menu(timer)
+        .context("unable to mark menu display in bootloader interface")?;
+
    // Acquire the standard input device and run the boot menu.
    uefi::system::with_stdin(move |input| select_with_input(input, timeout, entries))
 }
--- a/src/options/parser.rs
+++ b/src/options/parser.rs
@@ -1,4 +1,5 @@
 use anyhow::{Context, Result, bail};
+use log::info;
 use std::collections::BTreeMap;

 /// The type of option. This disambiguates different behavior
@@ -113,9 +114,9 @@ pub trait OptionsRepresentable {
            // Handle the --help flag case.
            if description.form == OptionForm::Help {
                // Generic configured options output.
-                println!("Configured Options:");
+                info!("Configured Options:");
                for (name, description) in &configured {
-                    println!(
+                    info!(
                        "  --{}{}: {}",
                        name,
                        if description.form == OptionForm::Value {
--- a/src/platform.rs
+++ b/src/platform.rs
@@ -0,0 +1,2 @@
+/// timer: Platform timer support.
+pub mod timer;
--- a/src/platform/timer.rs
+++ b/src/platform/timer.rs
@@ -0,0 +1,89 @@
+// Referenced https://github.com/sheroz/tick_counter (MIT license) as a baseline.
+// Architecturally modified to support UEFI and remove x86 (32-bit) support.
+
+use std::time::Duration;
+
+/// Support for aarch64 timers.
+#[cfg(target_arch = "aarch64")]
+pub mod aarch64;
+
+/// Support for x86_64 timers.
+#[cfg(target_arch = "x86_64")]
+pub mod x86_64;
+
+/// The tick frequency of the platform.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum TickFrequency {
+    /// The platform provides the tick frequency.
+    Hardware(u64),
+    /// The tick frequency is measured internally.
+    Measured(u64, Duration),
+}
+
+impl TickFrequency {
+    /// Acquire the tick frequency reported by the platform.
+    fn ticks(&self) -> u64 {
+        match self {
+            TickFrequency::Hardware(frequency) => *frequency,
+            TickFrequency::Measured(frequency, _) => *frequency,
+        }
+    }
+
+    /// Calculate the nanoseconds represented by a tick.
+    fn nanos(&self) -> f64 {
+        1.0e9_f64 / (self.ticks() as f64)
+    }
+
+    /// Produce a duration from the provided elapsed `ticks` value.
+    fn duration(&self, ticks: u64) -> Duration {
+        let accuracy = self.nanos();
+        let nanos = ticks as f64 * accuracy;
+        Duration::from_nanos(nanos as u64)
+    }
+}
+
+/// Acquire the tick value reported by the platform.
+fn arch_ticks() -> u64 {
+    #[cfg(target_arch = "aarch64")]
+    return aarch64::ticks();
+    #[cfg(target_arch = "x86_64")]
+    return x86_64::ticks();
+}
+
+/// Acquire the tick frequency reported by the platform.
+fn arch_frequency() -> TickFrequency {
+    #[cfg(target_arch = "aarch64")]
+    return aarch64::frequency();
+    #[cfg(target_arch = "x86_64")]
+    return x86_64::frequency();
+}
+
+/// Platform timer that allows measurement of the elapsed time.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct PlatformTimer {
+    /// The start tick value.
+    start: u64,
+    /// The tick frequency of the platform.
+    frequency: TickFrequency,
+}
+
+impl PlatformTimer {
+    /// Start a platform timer at the current instant.
+    pub fn start() -> Self {
+        Self {
+            start: arch_ticks(),
+            frequency: arch_frequency(),
+        }
+    }
+
+    /// Measure the elapsed duration since the hardware started ticking upwards.
+    pub fn elapsed_since_lifetime(&self) -> Duration {
+        self.frequency.duration(arch_ticks())
+    }
+
+    /// Measure the elapsed duration since the timer was started.
+    pub fn elapsed_since_start(&self) -> Duration {
+        let duration = arch_ticks() - self.start;
+        self.frequency.duration(duration)
+    }
+}
--- a/src/platform/timer/aarch64.rs
+++ b/src/platform/timer/aarch64.rs
@@ -0,0 +1,33 @@
+use crate::platform::timer::TickFrequency;
+use std::arch::asm;
+
+/// Reads the cntvct_el0 counter and returns the value.
+pub fn ticks() -> u64 {
+    let counter: u64;
+    unsafe {
+        asm!("mrs x0, cntvct_el0", out("x0") counter);
+    }
+    counter
+}
+
+/// We can use the actual ticks value as our start value.
+pub fn start() -> u64 {
+    ticks()
+}
+
+/// We can use the actual ticks value as our stop value.
+pub fn stop() -> u64 {
+    ticks()
+}
+
+/// Our frequency is provided by cntfrq_el0 on the platform.
+pub fn frequency() -> TickFrequency {
+    let frequency: u64;
+    unsafe {
+        asm!(
+            "mrs x0, cntfrq_el0",
+            out("x0") frequency
+        );
+    }
+    TickFrequency::Hardware(frequency)
+}
--- a/src/platform/timer/x86_64.rs
+++ b/src/platform/timer/x86_64.rs
@@ -0,0 +1,66 @@
+use crate::platform::timer::TickFrequency;
+use core::arch::asm;
+use std::time::Duration;
+
+/// We will measure the frequency of the timer based on 1000 microseconds.
+/// This will result in a call to BS->Stall(1000) in the end.
+const MEASURE_FREQUENCY_DURATION: Duration = Duration::from_micros(1000);
+
+/// Read the number of ticks from the platform timer.
+pub fn ticks() -> u64 {
+    let mut eax: u32;
+    let mut edx: u32;
+
+    unsafe {
+        asm!("rdtsc", out("eax") eax, out("edx") edx);
+    }
+
+    (edx as u64) << 32 | eax as u64
+}
+
+/// Read the starting number of ticks from the platform timer.
+pub fn start() -> u64 {
+    let rax: u64;
+    unsafe {
+        asm!(
+            "mfence",
+            "lfence",
+            "rdtsc",
+            "shl rdx, 32",
+            "or rax, rdx",
+            out("rax") rax
+        );
+    }
+    rax
+}
+
+/// Read the ending number of ticks from the platform timer.
+pub fn stop() -> u64 {
+    let rax: u64;
+    unsafe {
+        asm!(
+        "rdtsc",
+        "lfence",
+        "shl rdx, 32",
+        "or rax, rdx",
+        out("rax") rax
+        );
+    }
+    rax
+}
+
+/// Measure the frequency of the platform timer.
+fn measure_frequency(duration: &Duration) -> u64 {
+    let start = start();
+    uefi::boot::stall(*duration);
+    let stop = stop();
+    let elapsed = (stop - start) as f64;
+    (elapsed / duration.as_secs_f64()) as u64
+}
+
+/// Acquire the platform timer frequency.
+/// On x86_64, this is slightly expensive, so it should be done once.
+pub fn frequency() -> TickFrequency {
+    let frequency = measure_frequency(&MEASURE_FREQUENCY_DURATION);
+    TickFrequency::Measured(frequency, MEASURE_FREQUENCY_DURATION)
+}
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -4,7 +4,9 @@ use uefi::fs::{FileSystem, Path};
 use uefi::proto::device_path::text::{AllowShortcuts, DevicePathFromText, DisplayOnly};
 use uefi::proto::device_path::{DevicePath, PoolDevicePath};
 use uefi::proto::media::fs::SimpleFileSystem;
-use uefi::{CString16, Handle};
+use uefi::proto::media::partition::PartitionInfo;
+use uefi::{CString16, Guid, Handle};
+use uefi_raw::Status;

 /// Support code for the EFI framebuffer.
 pub mod framebuffer;
@@ -161,3 +163,69 @@ pub fn read_file_contents(default_root_path: &DevicePath, input: &str) -> Result
    let content = fs.read(Path::new(&path));
    content.context("unable to read file contents")
 }
+
+/// Filter a string-like Option `input` such that an empty string is [None].
+pub fn empty_is_none<T: AsRef<str>>(input: Option<T>) -> Option<T> {
+    input.filter(|input| !input.as_ref().is_empty())
+}
+
+/// Combine a sequence of strings into a single string, separated by spaces, ignoring empty strings.
+pub fn combine_options<T: AsRef<str>>(options: impl Iterator<Item = T>) -> String {
+    options
+        .flat_map(|item| empty_is_none(Some(item)))
+        .map(|item| item.as_ref().to_string())
+        .collect::<Vec<_>>()
+        .join(" ")
+}
+
+/// Produce a unique hash for the input.
+/// This uses SHA-256, which is unique enough but relatively short.
+pub fn unique_hash(input: &str) -> String {
+    sha256::digest(input.as_bytes())
+}
+
+/// Represents the type of partition GUID that can be retrieved.
+#[derive(PartialEq, Eq)]
+pub enum PartitionGuidForm {
+    Partition,
+    PartitionType,
+}
+
+/// Retrieve the partition / partition type GUID of the device root `path`.
+/// This only works on GPT partitions. If the root is not a GPT partition, None is returned.
+pub fn partition_guid(path: &DevicePath, form: PartitionGuidForm) -> Result<Option<Guid>> {
+    // Clone the path so we can pass it to the UEFI stack.
+    let path = path.to_boxed();
+    let result = uefi::boot::locate_device_path::<PartitionInfo>(&mut &*path);
+    let handle = match result {
+        Ok(handle) => Ok(Some(handle)),
+        Err(error) => {
+            // If the error is NOT_FOUND or UNSUPPORTED, we can return None.
+            // These are non-fatal errors.
+            if error.status() == Status::NOT_FOUND || error.status() == Status::UNSUPPORTED {
+                Ok(None)
+            } else {
+                Err(error)
+            }
+        }
+    }
+    .context("unable to locate device path")?;
+
+    // If we have the handle, we can try to open the partition info protocol.
+    if let Some(handle) = handle {
+        // Open the partition info protocol.
+        let partition_info = uefi::boot::open_protocol_exclusive::<PartitionInfo>(handle)
+            .context("unable to open partition info protocol")?;
+        // Find the unique partition GUID.
+        // If this is not a GPT partition, this will produce None.
+        Ok(partition_info
+            .gpt_partition_entry()
+            .map(|entry| match form {
+                // Match the form of the partition GUID.
+                PartitionGuidForm::Partition => entry.unique_partition_guid,
+                PartitionGuidForm::PartitionType => entry.partition_type_guid.0,
+            }))
+    } else {
+        Ok(None)
+    }
+}
--- a/src/utils/media_loader.rs
+++ b/src/utils/media_loader.rs
@@ -51,6 +51,11 @@ impl MediaLoaderHandle {
    /// The next call will pass a buffer of the right size, and we should copy
    /// data into that buffer, checking whether it is safe to copy based on
    /// the buffer size.
+    ///
+    /// SAFETY: `this.address` and `this.length` are set by leaking a Box<[u8]>, so we can
+    /// be sure their pointers are valid when this is called. The caller must call this function
+    /// while inside UEFI boot services to ensure pointers are valid. Copying to `buffer` is
+    /// assumed valid because the caller must ensure `buffer` is valid by function contract.
    unsafe extern "efiapi" fn load_file(
        this: *mut MediaLoaderProtocol,
        file_path: *const DevicePathProtocol,
@@ -155,7 +160,7 @@ impl MediaLoaderHandle {

        // Install a protocol interface for the device path.
        // This ensures it can be located by other EFI programs.
-        let mut handle = unsafe {
+        let primary_handle = unsafe {
            uefi::boot::install_protocol_interface(
                None,
                &DevicePathProtocol::GUID,
@@ -178,25 +183,54 @@ impl MediaLoaderHandle {
        let protocol = Box::leak(protocol);

        // Install a protocol interface for the load file protocol for the media loader protocol.
-        handle = unsafe {
+        let secondary_handle = unsafe {
            uefi::boot::install_protocol_interface(
-                Some(handle),
+                Some(primary_handle),
                &LoadFile2Protocol::GUID,
-                protocol as *mut _ as *mut c_void,
+                // The UEFI API expects an opaque pointer here.
+                protocol as *mut MediaLoaderProtocol as *mut c_void,
            )
-        }
-        .context("unable to install media loader load file handle")?;
+        };

-        // Check if the media loader is registered.
-        // If it is not, we can't continue safely because something went wrong.
-        if !Self::already_registered(guid)? {
-            bail!("media loader not registered when expected to be registered");
+        // If installing the second protocol interface failed, we need to clean up after ourselves.
+        if secondary_handle.is_err() {
+            // Uninstall the protocol interface for the device path protocol.
+            // SAFETY: If we have reached this point, we know that the protocol is registered.
+            // If this fails, we have no choice but to leak memory. The error will be shown
+            // to the user, so at least they can see it. In most cases, catching this error
+            // will exit, so leaking is safe.
+            unsafe {
+                uefi::boot::uninstall_protocol_interface(
+                    primary_handle,
+                    &DevicePathProtocol::GUID,
+                    path.as_ffi_ptr() as *mut c_void,
+                )
+                .context(
+                    "unable to uninstall media loader device path handle, this will leak memory",
+                )?;
            }

+            // SAFETY: We know that the protocol is leaked, so we can safely take a reference to it.
+            let protocol = unsafe { Box::from_raw(protocol) };
+            // SAFETY: We know that the data is leaked, so we can safely take a reference to it.
+            let data = unsafe { Box::from_raw(data) };
+            // SAFETY: We know that the path is leaked, so we can safely take a reference to it.
+            let path = unsafe { Box::from_raw(path) };
+
+            // Drop all the allocations explicitly to clarify the lifetime.
+            drop(protocol);
+            drop(data);
+            drop(path);
+        }
+
+        // If installing the second protocol interface failed, this will return the error.
+        // We should have already cleaned up after ourselves, so this is safe.
+        secondary_handle.context("unable to install media loader load file handle")?;
+
        // Return a handle to the media loader.
        Ok(Self {
            guid,
-            handle,
+            handle: primary_handle,
            protocol,
            path,
        })
Author	SHA1	Message	Date
Alex Zenla	b9b34394cd	sprout: version 0.0.15	2025-10-30 15:01:49 -04:00
Alex Zenla	3c467fef65	Merge pull request #22 from edera-dev/dependabot/docker/docker-updates-d0b0844295 chore(deps): bump rustlang/rust from `7cba2ed` to `3453212` in the docker-updates group	2025-10-30 14:58:36 -04:00
Alex Zenla	cfe7088970	Merge pull request #23 from edera-dev/azenla/bootloader-interface feat(integrations): basic bootloader interface support	2025-10-30 14:58:04 -04:00
Alex Zenla	9d3a022e08	feat(bootloader-interface): add support for marking when the menu is being display	2025-10-30 13:27:58 -04:00
Alex Zenla	cc90199d61	feat(bootloader-interface): identify ourselves as sprout	2025-10-30 12:50:36 -04:00
Alex Zenla	cff55322fc	feat(bootloader-interface): implement support for LoaderImageIdentifier	2025-10-30 12:44:07 -04:00
Alex Zenla	d2bef03437	fix(platform/timer): add back note of platform timer reference	2025-10-30 12:30:08 -04:00
Alex Zenla	37ab0406bb	feat(bootloader-interface): implement support for UEFI firmware information	2025-10-30 11:47:35 -04:00
Alex Zenla	a77be3c282	feat(bootloader-interface): measure time in firmware as well	2025-10-30 02:51:52 -04:00
Alex Zenla	87d608366f	feat(bootloader-interface): add support for loader boot times	2025-10-30 02:36:14 -04:00
Alex Zenla	e7d2438e5f	feat(bls): basic support for boot loader interface	2025-10-28 23:23:12 -04:00
Alex Zenla	f82d24a206	feat(integrations): implement initial bootloader interface touchpoints	2025-10-28 21:05:22 -04:00
Alex Zenla	fe714cc411	fix(filesystem-device-match): bail early if no criteria is provided	2025-10-28 17:10:28 -04:00
Alex Zenla	000e3ea6c7	chore(github): disable blank issues	2025-10-28 16:56:56 -04:00
Alex Zenla	44de1bebd3	chore(github): add a feature request template	2025-10-28 16:56:06 -04:00
Alex Zenla	4d62ac2ce2	chore(github): show an ask a question link when creating an issue	2025-10-28 16:52:22 -04:00
dependabot[bot]	8d87fcfd2d	chore(deps): bump rustlang/rust in the docker-updates group Bumps the docker-updates group with 1 update: rustlang/rust. Updates `rustlang/rust` from `7cba2ed` to `3453212` --- updated-dependencies: - dependency-name: rustlang/rust dependency-version: nightly-alpine dependency-type: direct:production dependency-group: docker-updates ... Signed-off-by: dependabot[bot] <support@github.com>	2025-10-28 20:50:21 +00:00
Alex Zenla	1a2b103675	chore(github): make all workflows (except release) concurrent by sha	2025-10-28 16:49:26 -04:00
Alex Zenla	5e1bc4659b	chore(github): rename all files from yaml => yml	2025-10-28 16:47:25 -04:00
Alex Zenla	27c82d24d0	chore(github): update bug report issue template	2025-10-28 16:44:54 -04:00
Alex Zenla	e2aa19174e	chore(github): update bug report template to reorder items	2025-10-28 16:43:41 -04:00
Alex Zenla	fb342e12cb	chore(github): initial issue templates	2025-10-28 16:35:12 -04:00
Alex Zenla	6f60a279c3	sprout: version 0.0.14	2025-10-28 01:47:15 -04:00
Alex Zenla	2e66d8c72e	chore(docs): update readme with secure boot notes and roadmap items	2025-10-28 01:43:07 -04:00
Alex Zenla	86e08c2400	fix(doc/extractors/filesystem-device-match): the extractor will error if no criteria is provided	2025-10-28 00:19:38 -04:00
Alex Zenla	852823e2eb	chore(doc/bls/entry): clarify why char::is_whitespace is used despite newline matching	2025-10-28 00:12:16 -04:00
Alex Zenla	734ab84054	chore(doc/context): clarify context finalization limit error message	2025-10-28 00:10:22 -04:00
Alex Zenla	c8a3408fdd	fix(extractors/filesystem-device-match): clarify when to use fallback for empty criteria	2025-10-28 00:09:11 -04:00
Alex Zenla	deeda650a7	fix(autoconfigure/linux): remove debug line	2025-10-28 00:06:02 -04:00
Alex Zenla	268a2cb28b	fix(media-loader): improve safety in the event protocol interface install fails	2025-10-27 23:56:12 -04:00
Alex Zenla	0b6523906d	fix(doc): filesystem-device-match will not return a filesystem when criteria is not provided	2025-10-27 23:39:55 -04:00
Alex Zenla	3acd0ec7d8	chore(doc): document media loader safety	2025-10-27 23:24:35 -04:00
Alex Zenla	fe593efa8c	chore(autoconfigure/docs): clarify why we append / to a device root	2025-10-27 23:15:14 -04:00
Alex Zenla	3058abab23	fix(menu): check for timeout duration overflow	2025-10-27 23:10:05 -04:00
Alex Zenla	5df717de6d	chore(filesystem-device-match): extract partition uuid fetch to function	2025-10-27 23:05:57 -04:00
Alex Zenla	011e133455	chore(autoconfigure-linux): clarify variable shadowing for initramfs matching	2025-10-27 23:00:55 -04:00
Alex Zenla	ccd1a8f498	chore(menu): clarify that we do not need to free the key event	2025-10-27 22:59:00 -04:00
Alex Zenla	527ce4b1b4	sprout: version 0.0.13	2025-10-27 22:44:21 -04:00
Alex Zenla	ebd3c07bf5	fix(autoconfigure): reinject values after configuration changes	2025-10-27 22:43:37 -04:00
Alex Zenla	e8b7b967fa	chore(docs): change windows setup guide to use autoconfiguration	2025-10-27 21:36:48 -04:00
Alex Zenla	2bf4013938	feat(autoconfigure): improved linux support and windows support	2025-10-27 19:47:21 -04:00
Alex Zenla	6819e55e23	Merge pull request #19 from edera-dev/dependabot/docker/docker-updates-d0b0844295 chore(deps): bump rustlang/rust from `141e9a7` to `7cba2ed` in the docker-updates group	2025-10-27 19:03:00 -04:00
Alex Zenla	50f7bc11aa	sprout: version 0.0.12	2025-10-27 18:41:32 -04:00
Alex Zenla	2200ba74f6	fix(cargo): force dev profiles to use opt-level = 2 to workaround hardware acceleration	2025-10-27 18:35:18 -04:00
Alex Zenla	7a3db08e1d	fix(cargo): remove transitive dependency on tokio	2025-10-27 18:26:53 -04:00
Alex Zenla	e7f5be30dd	feat(autoconfigure): generate names using a unique hash	2025-10-27 18:21:28 -04:00
Alex Zenla	3bbe6561ef	fix(docs): fedora setup guide should use [options]	2025-10-27 17:57:29 -04:00
Alex Zenla	3b5e110d1e	feat(config): rename [defaults] to [options]	2025-10-27 17:56:38 -04:00
Alex Zenla	26315fb4c4	fix(options): stamp initrd and combine options safely by ignoring empty strings	2025-10-27 17:44:30 -04:00
Alex Zenla	a76f9770dc	fix(chainload): support an empty initrd path, which will result in no initrd	2025-10-27 16:27:39 -04:00
Alex Zenla	59edd63a12	fix(doc): list generator is not the matrix generator	2025-10-27 16:17:33 -04:00
Alex Zenla	8a2e8c8127	fix(sprout): correct rustdoc and clarify safety in some places	2025-10-27 16:16:09 -04:00
Alex Zenla	6086778dc0	fix(menu): free timer event to avoid leak	2025-10-27 16:03:25 -04:00
Alex Zenla	e729d6a60b	feat(sprout): cleanup default logging	2025-10-27 15:44:29 -04:00
Alex Zenla	d6e8fe0245	feat(autoconfigure): find vmlinuz and initramfs pairs with linux autoconfigure module	2025-10-27 15:41:29 -04:00
Alex Zenla	99653b5192	fix(menu): hide the entry name from the menu since it can be long with autoconfigure	2025-10-27 12:25:22 -04:00
dependabot[bot]	3ffda86544	chore(deps): bump rustlang/rust in the docker-updates group Bumps the docker-updates group with 1 update: rustlang/rust. Updates `rustlang/rust` from `141e9a7` to `7cba2ed` --- updated-dependencies: - dependency-name: rustlang/rust dependency-version: nightly-alpine dependency-type: direct:production dependency-group: docker-updates ... Signed-off-by: dependabot[bot] <support@github.com>	2025-10-27 12:48:29 +00:00
Alex Zenla	2a76e4f798	chore(code): move bls autoconfigure to separate module	2025-10-27 04:28:25 -04:00