bootloader: Introduce BootloaderKind enum

The two variants in this enum distinguish between Grub classic and BLS
compatible bootloader (GrubCC and SystemdBoot). This cleans up the
match statements where we perform the same op for GrubCC and SystemdBoot

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

Author: Johan-Liebert1

crates/lib/src/bootc_composefs/backwards_compat/bcompat_boot.rs

@@ -17,7 +17,7 @@ use crate::{
         TYPE1_ENT_PATH_STAGED, UKI_NAME_PREFIX, USER_CFG_STAGED,
     },
     parsers::bls_config::{BLSConfig, BLSConfigType},
-    spec::Bootloader,
+    spec::BootloaderKind,
     store::Storage,
 };
 use anyhow::{Context, Result};
@@ -323,8 +323,8 @@ pub(crate) async fn prepend_custom_prefix(
             handle_bls_conf(storage, cfs_cmdline, boot_dir, false)?;
         }
 
-        BootType::Uki => match bootloader {
-            Bootloader::Grub => {
+        BootType::Uki => match bootloader.kind()? {
+            BootloaderKind::GRUBClassic => {
                 let esp = storage.require_esp()?;
 
                 let mut buf = String::new();
@@ -384,11 +384,9 @@ pub(crate) async fn prepend_custom_prefix(
                 rename_exchange_user_cfg(&grub_dir)?;
             }
 
-            Bootloader::Systemd | Bootloader::GrubCC => {
+            BootloaderKind::BLSCompatible => {
                 handle_bls_conf(storage, cfs_cmdline, boot_dir, true)?;
             }
-
-            Bootloader::None => unreachable!("Checked at install time"),
         },
     };
 

crates/lib/src/bootc_composefs/boot.rs

@@ -96,6 +96,7 @@ use crate::bootc_composefs::status::ComposefsCmdline;
 use crate::bootc_kargs::compute_new_kargs;
 use crate::composefs_consts::{TYPE1_BOOT_DIR_PREFIX, TYPE1_ENT_PATH, TYPE1_ENT_PATH_STAGED};
 use crate::parsers::bls_config::{BLSConfig, BLSConfigType};
+use crate::spec::BootloaderKind;
 use crate::task::Task;
 use crate::{bootc_composefs::repo::open_composefs_repo, store::Storage};
 use crate::{bootc_composefs::status::get_sorted_grub_uki_boot_entries, install::PostFetchState};
@@ -582,8 +583,8 @@ pub(crate) fn setup_composefs_bls_boot(
 
     compute_new_kargs(mounted_erofs, current_root, &mut cmdline_refs)?;
 
-    let (entry_paths, _tmpdir_guard) = match bootloader {
-        Bootloader::Grub => {
+    let (entry_paths, _tmpdir_guard) = match bootloader.kind()? {
+        BootloaderKind::GRUBClassic => {
             let root = Dir::open_ambient_dir(&root_path, ambient_authority())
                 .context("Opening root path")?;
 
@@ -607,7 +608,7 @@ pub(crate) fn setup_composefs_bls_boot(
             )
         }
 
-        Bootloader::Systemd | Bootloader::GrubCC => {
+        BootloaderKind::BLSCompatible => {
             let efi_mount = mount_esp(&esp_device).context("Mounting ESP")?;
 
             let mounted_efi = Utf8PathBuf::from(efi_mount.dir.path().as_str()?);
@@ -622,8 +623,6 @@ pub(crate) fn setup_composefs_bls_boot(
                 Some(efi_mount),
             )
         }
-
-        Bootloader::None => unreachable!("Checked at install time"),
     };
 
     let (bls_config, boot_digest, os_id) = match &entry {
@@ -1164,16 +1163,14 @@ pub(crate) fn setup_composefs_uki_boot(
 
     let boot_digest = uki_info.boot_digest.clone();
 
-    match bootloader {
-        Bootloader::Grub => {
+    match bootloader.kind()? {
+        BootloaderKind::GRUBClassic => {
             write_grub_uki_menuentry(root_path, &setup_type, uki_info.boot_label, id, &esp_device)?
         }
 
-        Bootloader::Systemd | Bootloader::GrubCC => {
+        BootloaderKind::BLSCompatible => {
             write_systemd_uki_config(&esp_mount.fd, &setup_type, uki_info, id)?
         }
-
-        Bootloader::None => unreachable!("Checked at install time"),
     };
 
     Ok(boot_digest)

crates/lib/src/bootc_composefs/delete.rs

@@ -15,7 +15,7 @@ use crate::{
         TYPE1_ENT_PATH, TYPE1_ENT_PATH_STAGED, USER_CFG_STAGED,
     },
     parsers::bls_config::{BLSConfigType, parse_bls_config},
-    spec::{BootEntry, Bootloader, DeploymentEntry},
+    spec::{BootEntry, BootloaderKind, DeploymentEntry},
     status::Slot,
     store::{BootedComposefs, Storage},
 };
@@ -145,20 +145,18 @@ fn delete_depl_boot_entries(
 ) -> Result<()> {
     let boot_dir = storage.require_boot_dir()?;
 
-    match deployment.deployment.bootloader {
-        Bootloader::Grub => match deployment.deployment.boot_type {
+    match deployment.deployment.bootloader.kind()? {
+        BootloaderKind::GRUBClassic => match deployment.deployment.boot_type {
             BootType::Bls => delete_type1_conf_file(deployment, boot_dir, deleting_staged),
             BootType::Uki => {
                 remove_grub_menucfg_entry(&deployment.deployment.verity, boot_dir, deleting_staged)
             }
         },
 
-        Bootloader::Systemd | Bootloader::GrubCC => {
+        BootloaderKind::BLSCompatible => {
             // For Systemd UKI as well, we use .conf files
             delete_type1_conf_file(deployment, boot_dir, deleting_staged)
         }
-
-        Bootloader::None => unreachable!("Checked at install time"),
     }
 }
 

crates/lib/src/bootc_composefs/finalize.rs

@@ -5,7 +5,7 @@ use crate::bootc_composefs::gc::{GCOpts, composefs_gc};
 use crate::bootc_composefs::rollback::{rename_exchange_bls_entries, rename_exchange_user_cfg};
 use crate::bootc_composefs::status::get_composefs_status;
 use crate::composefs_consts::STATE_DIR_ABS;
-use crate::spec::Bootloader;
+use crate::spec::BootloaderKind;
 use crate::store::{BootedComposefs, Storage};
 use anyhow::{Context, Result};
 use bootc_initramfs_setup::mount_composefs_image;
@@ -131,21 +131,19 @@ pub(crate) async fn composefs_backend_finalize(
 
     let boot_dir = storage.require_boot_dir()?;
 
-    match booted_composefs.bootloader {
-        Bootloader::Grub => match staged_composefs.boot_type {
+    match booted_composefs.bootloader.kind()? {
+        BootloaderKind::GRUBClassic => match staged_composefs.boot_type {
             BootType::Bls => {
                 let entries_dir = boot_dir.open_dir("loader")?;
                 rename_exchange_bls_entries(&entries_dir)?;
             }
             BootType::Uki => finalize_staged_grub_uki(boot_dir)?,
         },
 
-        Bootloader::Systemd | Bootloader::GrubCC => {
+        BootloaderKind::BLSCompatible => {
             let entries_dir = boot_dir.open_dir("loader")?;
             rename_exchange_bls_entries(&entries_dir)?;
         }
-
-        Bootloader::None => unreachable!("Checked at install time"),
     };
 
     // Now that we have successfully updated bootloader entires, we can GC the unreferenced ones

crates/lib/src/bootc_composefs/rollback.rs

@@ -12,7 +12,7 @@ use crate::bootc_composefs::boot::{
 };
 use crate::bootc_composefs::status::{get_composefs_status, get_sorted_type1_boot_entries};
 use crate::composefs_consts::TYPE1_ENT_PATH_STAGED;
-use crate::spec::Bootloader;
+use crate::spec::{Bootloader, BootloaderKind};
 use crate::store::{BootedComposefs, Storage};
 use crate::{
     bootc_composefs::{boot::get_efi_uuid_source, status::get_sorted_grub_uki_boot_entries},
@@ -224,8 +224,8 @@ pub(crate) async fn composefs_rollback(
 
     let boot_dir = storage.require_boot_dir()?;
 
-    match &rollback_entry.bootloader {
-        Bootloader::Grub => match rollback_entry.boot_type {
+    match &rollback_entry.bootloader.kind()? {
+        BootloaderKind::GRUBClassic => match rollback_entry.boot_type {
             BootType::Bls => {
                 rollback_composefs_entries(boot_dir, rollback_entry.bootloader.clone())?;
             }
@@ -234,12 +234,10 @@ pub(crate) async fn composefs_rollback(
             }
         },
 
-        Bootloader::Systemd | Bootloader::GrubCC => {
+        BootloaderKind::BLSCompatible => {
             // We use BLS entries for systemd UKI as well
             rollback_composefs_entries(boot_dir, rollback_entry.bootloader.clone())?;
         }
-
-        Bootloader::None => unreachable!("Checked at install time"),
     }
 
     if reverting {

crates/lib/src/bootc_composefs/status.rs

@@ -25,7 +25,7 @@ use crate::{
         bls_config::{BLSConfig, BLSConfigType, parse_bls_config},
         grub_menuconfig::{MenuEntry, parse_grub_menuentry_file},
     },
-    spec::{BootEntry, BootOrder, Host, HostSpec, ImageStatus},
+    spec::{BootEntry, BootOrder, BootloaderKind, Host, HostSpec, ImageStatus},
     store::Storage,
     utils::{EfiError, read_uefi_var},
 };
@@ -339,8 +339,8 @@ pub(crate) fn list_bootloader_entries(storage: &Storage) -> Result<Vec<Bootloade
     let bootloader = get_bootloader()?;
     let boot_dir = storage.require_boot_dir()?;
 
-    let entries = match bootloader {
-        Bootloader::Grub => {
+    let entries = match bootloader.kind()? {
+        BootloaderKind::GRUBClassic => {
             // Grub entries are always in boot
             let grub_dir = boot_dir.open_dir("grub2").context("Opening grub dir")?;
 
@@ -368,9 +368,7 @@ pub(crate) fn list_bootloader_entries(storage: &Storage) -> Result<Vec<Bootloade
             }
         }
 
-        Bootloader::Systemd | Bootloader::GrubCC => list_type1_entries(boot_dir)?,
-
-        Bootloader::None => unreachable!("Checked at install time"),
+        BootloaderKind::BLSCompatible => list_type1_entries(boot_dir)?,
     };
 
     Ok(entries)
@@ -873,8 +871,11 @@ async fn composefs_deployment_status_from(
     let booted_cfs = host.require_composefs_booted()?;
 
     let mut grub_menu_string = String::new();
-    let (is_rollback_queued, sorted_bls_config, grub_menu_entries) = match booted_cfs.bootloader {
-        Bootloader::Grub => match boot_type {
+    let (is_rollback_queued, sorted_bls_config, grub_menu_entries) = match booted_cfs
+        .bootloader
+        .kind()?
+    {
+        BootloaderKind::GRUBClassic => match boot_type {
             BootType::Bls => {
                 let bls_configs = get_sorted_type1_boot_entries(boot_dir, false)?;
                 let bls_config = bls_configs
@@ -915,7 +916,7 @@ async fn composefs_deployment_status_from(
         },
 
         // We will have BLS stuff and the UKI stuff in the same DIR
-        Bootloader::Systemd | Bootloader::GrubCC => {
+        BootloaderKind::BLSCompatible => {
             let bls_configs = get_sorted_type1_boot_entries(boot_dir, true)?;
             let bls_config = bls_configs
                 .first()
@@ -938,8 +939,6 @@ async fn composefs_deployment_status_from(
 
             (is_rollback_queued, Some(bls_configs), None)
         }
-
-        Bootloader::None => unreachable!("Checked at install time"),
     };
 
     // Determine rollback deployment by matching extra deployment boot entries against entires read from /boot

crates/lib/src/bootc_composefs/update.rs

@@ -12,6 +12,7 @@ use ocidir::cap_std::ambient_authority;
 use ostree_ext::container::ManifestDiff;
 
 use crate::bootc_composefs::gc::GCOpts;
+use crate::spec::BootloaderKind;
 use crate::{
     bootc_composefs::{
         boot::{BootSetupType, BootType, setup_composefs_bls_boot, setup_composefs_uki_boot},
@@ -30,7 +31,7 @@ use crate::{
         COMPOSEFS_STAGED_DEPLOYMENT_FNAME, COMPOSEFS_TRANSIENT_STATE_DIR, STATE_DIR_RELATIVE,
         TYPE1_ENT_PATH_STAGED, USER_CFG_STAGED,
     },
-    spec::{Bootloader, Host, ImageReference},
+    spec::{Host, ImageReference},
     store::{BootedComposefs, ComposefsRepository, Storage},
 };
 
@@ -170,8 +171,8 @@ pub(crate) fn validate_update(
 
     // Remove staged bootloader entries, if any
     // GC should take care of the UKI PEs and other binaries
-    match get_bootloader()? {
-        Bootloader::Grub => match booted.boot_type {
+    match get_bootloader()?.kind()? {
+        BootloaderKind::GRUBClassic => match booted.boot_type {
             BootType::Bls => rm_staged_type1_ent(boot_dir)?,
 
             BootType::Uki => {
@@ -184,9 +185,7 @@ pub(crate) fn validate_update(
             }
         },
 
-        Bootloader::Systemd | Bootloader::GrubCC => rm_staged_type1_ent(boot_dir)?,
-
-        Bootloader::None => unreachable!("Checked at install time"),
+        BootloaderKind::BLSCompatible => rm_staged_type1_ent(boot_dir)?,
     }
 
     // Remove state directory

crates/lib/src/spec.rs

@@ -245,6 +245,15 @@ pub enum Bootloader {
     None,
 }
 
+#[derive(Debug)]
+pub enum BootloaderKind {
+    /// Bootloader that support Bootloader Specification
+    /// GrubCC and SystemdBoot
+    BLSCompatible,
+    /// Classic Grub
+    GRUBClassic,
+}
+
 impl Display for Bootloader {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let string = match self {
@@ -272,6 +281,18 @@ impl FromStr for Bootloader {
     }
 }
 
+impl Bootloader {
+    /// Returns whether the Bootloader is BLSCompatible
+    /// Throws and error if Bootloader is None
+    pub(crate) fn kind(&self) -> Result<BootloaderKind> {
+        match self {
+            Bootloader::Grub => Ok(BootloaderKind::GRUBClassic),
+            Bootloader::Systemd | Bootloader::GrubCC => Ok(BootloaderKind::BLSCompatible),
+            Bootloader::None => anyhow::bail!("Bootloader was None"),
+        }
+    }
+}
+
 /// A bootable entry
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
 #[serde(rename_all = "camelCase")]

crates/lib/src/store/mod.rs

@@ -92,7 +92,6 @@
 
 use std::cell::OnceCell;
 use std::ops::Deref;
-use std::os::fd::{AsFd, AsRawFd};
 use std::sync::Arc;
 
 use anyhow::{Context, Result};
@@ -119,7 +118,7 @@ use crate::bootc_composefs::boot::{EFI_LINUX, mount_esp};
 use crate::bootc_composefs::status::{ComposefsCmdline, composefs_booted, get_bootloader};
 use crate::lsm;
 use crate::podstorage::CStorage;
-use crate::spec::{Bootloader, ImageStatus};
+use crate::spec::{BootloaderKind, ImageStatus};
 use crate::utils::{deployment_fd, open_dir_remount_rw};
 
 /// See <https://github.com/containers/composefs-rs/issues/159>
@@ -333,13 +332,14 @@ impl BootedStorage {
                 let esp_dev = root_dev.find_first_colocated_esp()?;
                 let esp_mount = mount_esp(&esp_dev.path())?;
 
-                let boot_dir = match get_bootloader()? {
-                    Bootloader::Grub => physical_root.open_dir("boot").context("Opening boot")?,
+                let boot_dir = match get_bootloader()?.kind()? {
+                    BootloaderKind::GRUBClassic => {
+                        physical_root.open_dir("boot").context("Opening boot")?
+                    }
                     // NOTE: Handle XBOOTLDR partitions here if and when we use it
-                    Bootloader::Systemd | Bootloader::GrubCC => {
+                    BootloaderKind::BLSCompatible => {
                         esp_mount.fd.try_clone().context("Cloning fd")?
                     }
-                    Bootloader::None => unreachable!("Checked at install time"),
                 };
 
                 let storage = Storage {
@@ -527,16 +527,15 @@ impl Storage {
 
         // boot dir in case of systemd-boot points to the ESP, but we store
         // the actual binaries inside ESP/EFI/Linux
-        let boot_dir = match get_bootloader()? {
-            Bootloader::Grub => boot_dir.try_clone()?,
-            Bootloader::Systemd | Bootloader::GrubCC => {
+        let boot_dir = match get_bootloader()?.kind()? {
+            BootloaderKind::GRUBClassic => boot_dir.try_clone()?,
+            BootloaderKind::BLSCompatible => {
                 let boot_dir = boot_dir
                     .open_dir(EFI_LINUX)
                     .with_context(|| format!("Opening {EFI_LINUX}"))?;
 
                 boot_dir
             }
-            Bootloader::None => anyhow::bail!("Unknown bootloader"),
         };
 
         Ok(boot_dir)