Handle generate metadata and Bootloader Updates

For `bootupd generate-update-metadata` we now generate metadata for all
found bootloaders. The final json will look like

```json
{
  "timestamp": "2026-06-10T09:52:58.107743026Z",
  "version": "grub-cc-1:2.12-59.fc45,grub2-1:2.12-58.fc44,shim-16.1-5",
  "versions": [
    { "name": "grub-cc", "rpm_evr": "1:2.12-59.fc45" },
    { "name": "grub2", "rpm_evr": "1:2.12-58.fc44" },
    { "name": "shim", "rpm_evr": "16.1-5" }
  ]
}
```

This allows us to have multiple bootloaders in a single image and
install/update based on preference.

During install/update, we check to bootloader and filter out any and all
entries from the update metadata that do not match or are not required
for the bootloader

Signed-off-by: Pragyan Poudyal <pragyanpoudyal41999@gmail.com>

Author: Johan-Liebert1

src/bios.rs

@@ -116,14 +116,14 @@ impl Component for Bios {
         bootloader: Bootloader,
     ) -> Result<InstalledContent> {
         if !self.is_bootloader_supported(bootloader) {
-            anyhow::bail!("{bootloader} cannot be installed for bios");
+            anyhow::bail!("{bootloader} cannot be installed for {}", self.name());
         }
 
         let device =
             device.ok_or_else(|| anyhow::anyhow!("BIOS component requires a target device"))?;
         let src_dir = Dir::open_ambient_dir(src_root, ambient_authority())
             .with_context(|| format!("opening source directory {src_root}"))?;
-        let Some(meta) = get_component_update(&src_dir, self)? else {
+        let Some(meta) = get_component_update(&src_dir, self, Some(bootloader))? else {
             anyhow::bail!("No update metadata for component {} found", self.name());
         };
 
@@ -137,15 +137,7 @@ impl Component for Bios {
         })
     }
 
-    fn generate_update_metadata(
-        &self,
-        sysroot_path: &str,
-        bootloader: Bootloader,
-    ) -> Result<Option<ContentMetadata>> {
-        if !self.is_bootloader_supported(bootloader) {
-            anyhow::bail!("{bootloader} cannot be installed for bios");
-        }
-
+    fn generate_update_metadata(&self, sysroot_path: &str) -> Result<Option<ContentMetadata>> {
         let grub_install = Path::new(sysroot_path).join(GRUB_BIN);
         if !grub_install.exists() {
             println!("Failed to find {:?}", grub_install);
@@ -263,8 +255,16 @@ impl Component for Bios {
         }))
     }
 
-    fn query_update(&self, sysroot: &Dir) -> Result<Option<ContentMetadata>> {
-        get_component_update(sysroot, self)
+    fn query_update(
+        &self,
+        sysroot: &Dir,
+        bootloader: Bootloader,
+    ) -> Result<Option<ContentMetadata>> {
+        if !self.is_bootloader_supported(bootloader) {
+            return Ok(None);
+        }
+
+        get_component_update(sysroot, self, Some(bootloader))
     }
 
     fn query_requires_update(&self, sysroot: &Dir) -> Result<()> {
@@ -277,7 +277,7 @@ impl Component for Bios {
 
     fn run_update(&self, rootcxt: &RootContext, _: &InstalledContent) -> Result<InstalledContent> {
         let updatemeta = self
-            .query_update(&rootcxt.sysroot)?
+            .query_update(&rootcxt.sysroot, Bootloader::Grub)?
             .expect("update available");
 
         for parent in rootcxt.device.find_all_roots()? {

src/bootupd.rs

@@ -19,7 +19,6 @@ use crate::freezethaw::fsfreeze_thaw_cycle;
 ))]
 use crate::grubconfigs::{ensure_grub_permissions, GRUB2DIR};
 use crate::model::{ComponentStatus, ComponentUpdatable, ContentMetadata, SavedState, Status};
-use crate::util::running_in_container;
 use crate::{ostreeutil, util};
 use anyhow::{anyhow, Context, Result};
 use camino::{Utf8Path, Utf8PathBuf};
@@ -54,6 +53,7 @@ impl ConfigMode {
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 pub(crate) fn install(
     source_root: &str,
     dest_root: &str,
@@ -105,18 +105,21 @@ pub(crate) fn install(
             continue;
         }
 
-        // skip components that don't have an update metadata
-        if component.query_update(&source_root_dir)?.is_none() {
+        if !component.is_bootloader_supported(bootloader) {
             println!(
-                "Skip installing component {} without update metadata",
+                "Skip installing component {} as it does not support bootloader {bootloader}",
                 component.name()
             );
             continue;
         }
 
-        if !component.is_bootloader_supported(bootloader) {
+        // skip components that don't have an update metadata
+        if component
+            .query_update(&source_root_dir, bootloader)?
+            .is_none()
+        {
             println!(
-                "Skip installing component {} as it does not support bootloader {bootloader}",
+                "Skip installing component {} without update metadata",
                 component.name()
             );
             continue;
@@ -283,22 +286,15 @@ pub(crate) fn get_components() -> Components {
     get_components_impl(false)
 }
 
-pub(crate) fn generate_update_metadata(sysroot_path: &str, bootloader: Bootloader) -> Result<()> {
+pub(crate) fn generate_update_metadata(sysroot_path: &str) -> Result<()> {
     // create bootupd update dir which will save component metadata files for both components
     let updates_dir = Path::new(sysroot_path).join(crate::model::BOOTUPD_UPDATES_DIR);
+
     std::fs::create_dir_all(&updates_dir)
         .with_context(|| format!("Failed to create updates dir {:?}", &updates_dir))?;
-    for component in get_components().values() {
-        if !component.is_bootloader_supported(bootloader) {
-            println!(
-                "Bootloader {bootloader} not supported for {}. Skipping metadata generation",
-                component.name(),
-            );
-
-            continue;
-        }
 
-        if let Some(v) = component.generate_update_metadata(sysroot_path, bootloader)? {
+    for component in get_components().values() {
+        if let Some(v) = component.generate_update_metadata(sysroot_path)? {
             println!(
                 "Generated update layout for {}: {}",
                 component.name(),
@@ -343,7 +339,7 @@ pub(crate) fn update(name: &str, rootcxt: &RootContext) -> Result<ComponentUpdat
         anyhow::bail!("Component {} is not installed", name);
     };
     let sysroot = &rootcxt.sysroot;
-    let update = component.query_update(sysroot)?;
+    let update = component.query_update(sysroot, bootloader)?;
     let update = match update.as_ref() {
         Some(p) => match inst.meta.can_upgrade_to(p) {
             std::cmp::Ordering::Less => p, // current < available -> upgrade
@@ -364,10 +360,12 @@ pub(crate) fn update(name: &str, rootcxt: &RootContext) -> Result<ComponentUpdat
         target_arch = "riscv64"
     ))]
     {
-        let grub2dir = &sysroot
-            .open_dir(format!("boot/{GRUB2DIR}"))
-            .context("Opening /boot/grub2")?;
-        ensure_grub_permissions(grub2dir)?;
+        if bootloader == Bootloader::Grub {
+            let grub2dir = &sysroot
+                .open_dir(format!("boot/{GRUB2DIR}"))
+                .context("Opening /boot/grub2")?;
+            ensure_grub_permissions(grub2dir)?;
+        }
     }
 
     let mut pending_container = state.pending.take().unwrap_or_default();
@@ -417,13 +415,15 @@ pub(crate) fn adopt_and_update(
         target_arch = "riscv64"
     ))]
     {
-        let grub2dir = &sysroot
-            .open_dir(format!("boot/{GRUB2DIR}"))
-            .context("Opening /boot/grub2")?;
-        ensure_grub_permissions(grub2dir)?;
+        if bootloader == Bootloader::Grub {
+            let grub2dir = &sysroot
+                .open_dir(format!("boot/{GRUB2DIR}"))
+                .context("Opening /boot/grub2")?;
+            ensure_grub_permissions(grub2dir)?;
+        }
     }
 
-    let Some(update) = component.query_update(sysroot)? else {
+    let Some(update) = component.query_update(sysroot, bootloader)? else {
         anyhow::bail!("Component {} has no available update", name);
     };
 
@@ -486,7 +486,7 @@ pub(crate) fn validate(name: &str) -> Result<ValidationResult> {
 pub(crate) fn status() -> Result<Status> {
     let mut ret: Status = Default::default();
     let mut known_components = get_components();
-    let sysroot = Dir::open_ambient_dir("/", ambient_authority())?;
+    let root = Dir::open_ambient_dir("/", ambient_authority())?;
 
     let bootloader = get_bootloader()?;
     let state = SavedState::load_from_disk("/", Some(bootloader))?;
@@ -499,7 +499,7 @@ pub(crate) fn status() -> Result<Status> {
                 .ok_or_else(|| anyhow!("Unknown component installed: {}", name))?;
             let component = component.as_ref();
             let interrupted = state.pending.as_ref().and_then(|p| p.get(name.as_str()));
-            let update = component.query_update(&sysroot)?;
+            let update = component.query_update(&root, bootloader)?;
             let updatable = ComponentUpdatable::from_metadata(&ic.meta, update.as_ref());
             let adopted_from = ic.adopted_from.clone();
             ret.components.insert(
@@ -538,7 +538,7 @@ pub(crate) fn status() -> Result<Status> {
         if let Some(adopt_ver) = component::query_adopt_state()? {
             let component = component::new_from_name(&name)?;
             // Skip if the update metadata could not be found
-            if component.query_update(&sysroot)?.is_none() {
+            if component.query_update(&root, bootloader)?.is_none() {
                 continue;
             };
             ret.adoptable.insert(name.to_string(), adopt_ver);

src/cli/bootupd.rs

@@ -96,12 +96,6 @@ pub struct GenerateOpts {
     /// Physical root mountpoint
     #[clap(value_parser)]
     sysroot: Option<String>,
-
-    /// The bootloader to generate metadata for
-    //
-    // We have a default to not break older systems
-    #[clap(long, default_value_t = Bootloader::Grub)]
-    bootloader: Bootloader,
 }
 
 impl DCommand {
@@ -119,8 +113,7 @@ impl DCommand {
         if sysroot != "/" {
             anyhow::bail!("Using a non-default sysroot is not supported: {}", sysroot);
         }
-        bootupd::generate_update_metadata(sysroot, opts.bootloader)
-            .context("generating metadata failed")?;
+        bootupd::generate_update_metadata(sysroot).context("generating metadata failed")?;
         Ok(())
     }
 

src/component.rs

@@ -71,15 +71,15 @@ pub(crate) trait Component {
     /// this is an `rpm-ostree compose tree` for example.  For a dual-partition
     /// style updater, this would be run as part of a postprocessing step
     /// while the filesystem for the partition is mounted.
-    fn generate_update_metadata(
+    fn generate_update_metadata(&self, sysroot: &str) -> Result<Option<ContentMetadata>>;
+
+    /// Used on the client to query for an update cached in the current booted OS.
+    fn query_update(
         &self,
-        sysroot: &str,
+        sysroot: &Dir,
         bootloader: Bootloader,
     ) -> Result<Option<ContentMetadata>>;
 
-    /// Used on the client to query for an update cached in the current booted OS.
-    fn query_update(&self, sysroot: &Dir) -> Result<Option<ContentMetadata>>;
-
     /// This is called in the update code if query_update() returned no metadata.
     /// It should return an error if the current booted system should expect some
     /// metadata for this component.
@@ -167,21 +167,37 @@ pub(crate) fn write_update_metadata(
 }
 
 /// Given a component, return metadata on the available update (if any)
+//
+/// If bootloader is Some, all metadata not pertaining to the specified bootloader
+/// is filtered
+///
+/// If bootloader is None, no filtering is performed
 #[context("Loading update for component {}", component.name())]
 pub(crate) fn get_component_update(
     sysroot: &Dir,
     component: &dyn Component,
+    bootloader: Option<Bootloader>,
 ) -> Result<Option<ContentMetadata>> {
     let name = component_update_data_name(component);
-    let path = Path::new(BOOTUPD_UPDATES_DIR).join(name);
-    if let Some(f) = sysroot.open_optional(&path)? {
-        let mut f = std::io::BufReader::new(f);
-        let u = serde_json::from_reader(&mut f)
-            .with_context(|| format!("failed to parse {:?}", &path))?;
-        Ok(Some(u))
-    } else {
-        Ok(None)
-    }
+    let path = Path::new(BOOTUPD_UPDATES_DIR).join(&name);
+
+    let Some(f) = sysroot.open_optional(&path)? else {
+        return Ok(None);
+    };
+
+    let mut f = std::io::BufReader::new(f);
+    let mut u =
+        serde_json::from_reader(&mut f).with_context(|| format!("failed to parse {:?}", &path))?;
+
+    let Some(bootloader) = bootloader else {
+        return Ok(Some(u));
+    };
+
+    // We store metadata of all bootloaders present in the image
+    // So here, we will now filter out the bootloaders
+    u.filter_bootloader(bootloader);
+
+    Ok(Some(u))
 }
 
 #[context("Querying adoptable state")]

src/efi.rs

@@ -24,7 +24,7 @@ use widestring::U16CString;
 
 use bootc_internal_blockdev::Device;
 
-use crate::bootloader::Bootloader;
+use crate::bootloader::{get_bootloader, Bootloader};
 use crate::bootupd::RootContext;
 use crate::freezethaw::fsfreeze_thaw_cycle;
 use crate::model::*;
@@ -449,7 +449,7 @@ impl Component for Efi {
     ) -> Result<InstalledContent> {
         let src_dir = Dir::open_ambient_dir(src_root, ambient_authority())
             .with_context(|| format!("opening source directory {src_root}"))?;
-        let Some(meta) = get_component_update(&src_dir, self)? else {
+        let Some(meta) = get_component_update(&src_dir, self, Some(bootloader))? else {
             anyhow::bail!("No update metadata for component {} found", self.name());
         };
         log::debug!("Found metadata {}", meta.version);
@@ -533,7 +533,9 @@ impl Component for Efi {
             .as_ref()
             .ok_or_else(|| anyhow::anyhow!("No filetree for installed EFI found!"))?;
         let sysroot_dir = &rootcxt.sysroot;
-        let updatemeta = self.query_update(sysroot_dir)?.expect("update available");
+        let updatemeta = self
+            .query_update(sysroot_dir, get_bootloader()?)?
+            .expect("update available");
         let updated_path = {
             let efilib_path = rootcxt.path.join(EFILIB);
             if efilib_path.exists()
@@ -580,11 +582,7 @@ impl Component for Efi {
         })
     }
 
-    fn generate_update_metadata(
-        &self,
-        sysroot: &str,
-        bootloader: Bootloader,
-    ) -> Result<Option<ContentMetadata>> {
+    fn generate_update_metadata(&self, sysroot: &str) -> Result<Option<ContentMetadata>> {
         let sysroot_path = Utf8Path::new(sysroot);
         let sysroot_dir = Dir::open_ambient_dir(sysroot_path, cap_std::ambient_authority())?;
 
@@ -596,7 +594,7 @@ impl Component for Efi {
         // have them in /usr/lib/ostree-boot, which we move to /usr/lib/bootupd/updates/EFI
         let metadata = if sysroot_path.join(EFILIB).exists() {
             println!("Generating metadata from {EFILIB}");
-            generate_meta_from_usr_efi(sysroot_path, bootloader)?
+            generate_meta_from_usr_efi(sysroot_path)?
         } else {
             match &ostreeboot {
                 Some(..) => {
@@ -630,8 +628,12 @@ impl Component for Efi {
         Ok(Some(metadata))
     }
 
-    fn query_update(&self, sysroot: &Dir) -> Result<Option<ContentMetadata>> {
-        get_component_update(sysroot, self)
+    fn query_update(
+        &self,
+        sysroot: &Dir,
+        bootloader: Bootloader,
+    ) -> Result<Option<ContentMetadata>> {
+        get_component_update(sysroot, self, Some(bootloader))
     }
 
     fn query_requires_update(&self, _sysroot: &Dir) -> Result<()> {
@@ -826,12 +828,11 @@ fn find_file_recursive<P: AsRef<Path>>(dir: P, target_file: &str) -> Result<Vec<
 }
 
 #[context("Generating metadata from usr/lib/efi")]
-fn generate_meta_from_usr_efi(
-    sysroot_path: &Utf8Path,
-    bootloader: Bootloader,
-) -> Result<ContentMetadata> {
-    let Some(efi_components) = get_efi_component_from_usr(sysroot_path, EFILIB, Some(bootloader))?
-    else {
+fn generate_meta_from_usr_efi(sysroot_path: &Utf8Path) -> Result<ContentMetadata> {
+    // We DO NOT want to filter while generating metadata
+    // We want to have metadata for multiple bootloaders
+    // Later on, while installing, we'll filter out the stuff we don't need
+    let Some(efi_components) = get_efi_component_from_usr(sysroot_path, EFILIB, None)? else {
         anyhow::bail!("Failed to find EFI components");
     };