storage: Add boot_dir and esp fields

We have a lot of places where we mount the ESP temporarily and a lot of
switch cases for Grub's vs SystemdBoot's 'boot' directory.

We add a `boot_dir` field in Storage which points to `/sysroot/boot` for
systems with Grub as the bootloader and points to the ESP for systems
with SystemdBoot as the bootloader.

Also we mount the ESP temporarily while creating the storage struct,
which cleans up the code quite a bit.

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

Author: Johan-Liebert1

crates/lib/src/bootc_composefs/boot.rs

@@ -408,23 +408,11 @@ pub(crate) fn setup_composefs_bls_boot(
             let sysroot_parent = get_sysroot_parent_dev(&storage.physical_root)?;
             let bootloader = host.require_composefs_booted()?.bootloader.clone();
 
-            let current_cfg = match bootloader {
-                Bootloader::Grub => {
-                    let boot_dir = storage
-                        .physical_root
-                        .open_dir("boot")
-                        .context("Opening boot")?;
-
-                    get_booted_bls(&boot_dir)?
-                }
-
-                Bootloader::Systemd => {
-                    let esp = get_esp_partition(&sysroot_parent)?.0;
-                    let esp_mnt = mount_esp(&esp)?;
-
-                    get_booted_bls(&esp_mnt.fd)?
-                }
-            };
+            let boot_dir = storage
+                .boot_dir
+                .as_ref()
+                .ok_or_else(|| anyhow::anyhow!("Boot dir not found"))?;
+            let current_cfg = get_booted_bls(&boot_dir)?;
 
             let mut cmdline = match current_cfg.cfg_type {
                 BLSConfigType::NonEFI { options, .. } => {

crates/lib/src/bootc_composefs/delete.rs

@@ -7,10 +7,7 @@ use composefs_boot::bootloader::{EFI_ADDON_DIR_EXT, EFI_EXT};
 
 use crate::{
     bootc_composefs::{
-        boot::{
-            find_vmlinuz_initrd_duplicates, get_efi_uuid_source, get_esp_partition,
-            get_sysroot_parent_dev, mount_esp, BootType, SYSTEMD_UKI_DIR,
-        },
+        boot::{find_vmlinuz_initrd_duplicates, get_efi_uuid_source, BootType, SYSTEMD_UKI_DIR},
         gc::composefs_gc,
         repo::open_composefs_repo,
         rollback::{composefs_rollback, rename_exchange_user_cfg},
@@ -215,40 +212,37 @@ fn remove_grub_menucfg_entry(id: &str, boot_dir: &Dir, deleting_staged: bool) ->
 #[fn_error_context::context("Deleting boot entries for deployment {}", deployment.deployment.verity)]
 fn delete_depl_boot_entries(
     deployment: &DeploymentEntry,
-    physical_root: &Dir,
+    storage: &Storage,
     deleting_staged: bool,
 ) -> Result<()> {
-    match deployment.deployment.bootloader {
-        Bootloader::Grub => {
-            let boot_dir = physical_root.open_dir("boot").context("Opening boot dir")?;
+    let boot_dir = storage
+        .boot_dir
+        .as_ref()
+        .ok_or_else(|| anyhow::anyhow!("Boot dir not found"))?;
 
-            match deployment.deployment.boot_type {
-                BootType::Bls => delete_type1_entry(deployment, &boot_dir, deleting_staged),
+    match deployment.deployment.bootloader {
+        Bootloader::Grub => match deployment.deployment.boot_type {
+            BootType::Bls => delete_type1_entry(deployment, boot_dir, deleting_staged),
 
-                BootType::Uki => {
-                    let device = get_sysroot_parent_dev(physical_root)?;
-                    let (esp_part, ..) = get_esp_partition(&device)?;
-                    let esp_mount = mount_esp(&esp_part)?;
+            BootType::Uki => {
+                let esp = storage
+                    .esp
+                    .as_ref()
+                    .ok_or_else(|| anyhow::anyhow!("ESP not found"))?;
 
-                    remove_grub_menucfg_entry(
-                        &deployment.deployment.verity,
-                        &boot_dir,
-                        deleting_staged,
-                    )?;
+                remove_grub_menucfg_entry(
+                    &deployment.deployment.verity,
+                    boot_dir,
+                    deleting_staged,
+                )?;
 
-                    delete_uki(&deployment.deployment.verity, &esp_mount.fd)
-                }
+                delete_uki(&deployment.deployment.verity, &esp.fd)
             }
-        }
+        },
 
         Bootloader::Systemd => {
-            let device = get_sysroot_parent_dev(physical_root)?;
-            let (esp_part, ..) = get_esp_partition(&device)?;
-
-            let esp_mount = mount_esp(&esp_part)?;
-
             // For Systemd UKI as well, we use .conf files
-            delete_type1_entry(deployment, &esp_mount.fd, deleting_staged)
+            delete_type1_entry(deployment, boot_dir, deleting_staged)
         }
     }
 }
@@ -362,7 +356,7 @@ pub(crate) async fn delete_composefs_deployment(
 
     tracing::info!("Deleting {kind}deployment '{deployment_id}'");
 
-    delete_depl_boot_entries(&depl_to_del, &storage.physical_root, deleting_staged)?;
+    delete_depl_boot_entries(&depl_to_del, &storage, deleting_staged)?;
 
     composefs_gc(storage, booted_cfs).await?;
 

crates/lib/src/bootc_composefs/finalize.rs

@@ -1,8 +1,6 @@
 use std::path::Path;
 
-use crate::bootc_composefs::boot::{
-    get_esp_partition, get_sysroot_parent_dev, mount_esp, BootType,
-};
+use crate::bootc_composefs::boot::BootType;
 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;
@@ -86,15 +84,15 @@ pub(crate) async fn composefs_backend_finalize(
     // Unmount EROFS
     drop(erofs_tmp_mnt);
 
-    let sysroot_parent = get_sysroot_parent_dev(&storage.physical_root)?;
-    // NOTE: Assumption here that ESP will always be present
-    let (esp_part, ..) = get_esp_partition(&sysroot_parent)?;
-
-    let esp_mount = mount_esp(&esp_part)?;
     let boot_dir = storage
-        .physical_root
-        .open_dir("boot")
-        .context("Opening boot")?;
+        .boot_dir
+        .as_ref()
+        .ok_or_else(|| anyhow::anyhow!("Boot dir not found"))?;
+
+    let esp_mount = storage
+        .esp
+        .as_ref()
+        .ok_or_else(|| anyhow::anyhow!("ESP not found"))?;
 
     // NOTE: Assuming here we won't have two bootloaders at the same time
     match booted_composefs.bootloader {
@@ -103,21 +101,17 @@ pub(crate) async fn composefs_backend_finalize(
                 let entries_dir = boot_dir.open_dir("loader")?;
                 rename_exchange_bls_entries(&entries_dir)?;
             }
-            BootType::Uki => finalize_staged_grub_uki(&esp_mount.fd, &boot_dir)?,
+            BootType::Uki => finalize_staged_grub_uki(&esp_mount.fd, boot_dir)?,
         },
 
-        Bootloader::Systemd => match staged_composefs.boot_type {
-            BootType::Bls => {
-                let entries_dir = esp_mount.fd.open_dir("loader")?;
-                rename_exchange_bls_entries(&entries_dir)?;
-            }
-            BootType::Uki => {
+        Bootloader::Systemd => {
+            if matches!(staged_composefs.boot_type, BootType::Uki) {
                 rename_staged_uki_entries(&esp_mount.fd)?;
-
-                let entries_dir = esp_mount.fd.open_dir("loader")?;
-                rename_exchange_bls_entries(&entries_dir)?;
             }
-        },
+
+            let entries_dir = boot_dir.open_dir("loader")?;
+            rename_exchange_bls_entries(&entries_dir)?;
+        }
     };
 
     Ok(())

crates/lib/src/bootc_composefs/gc.rs

@@ -10,7 +10,6 @@ use composefs::fsverity::{FsVerityHashValue, Sha512HashValue};
 
 use crate::{
     bootc_composefs::{
-        boot::{get_esp_partition, get_sysroot_parent_dev, mount_esp},
         delete::{delete_image, delete_staged, delete_state_dir, get_image_objects},
         status::{
             get_bootloader, get_composefs_status, get_sorted_grub_uki_boot_entries,
@@ -44,28 +43,30 @@ fn list_erofs_images(sysroot: &Dir) -> Result<Vec<String>> {
 /// # Returns
 /// The fsverity of EROFS images corresponding to boot entries
 #[fn_error_context::context("Listing bootloader entries")]
-fn list_bootloader_entries(physical_root: &Dir) -> Result<Vec<String>> {
+fn list_bootloader_entries(storage: &Storage) -> Result<Vec<String>> {
     let bootloader = get_bootloader()?;
+    let boot_dir = storage
+        .boot_dir
+        .as_ref()
+        .ok_or_else(|| anyhow::anyhow!("Boot dir not found"))?;
 
     let entries = match bootloader {
         Bootloader::Grub => {
-            let boot_dir = physical_root.open_dir("boot").context("Opening boot dir")?;
-
             // Grub entries are always in boot
             let grub_dir = boot_dir.open_dir("grub2").context("Opening grub dir")?;
 
             if grub_dir.exists(USER_CFG) {
                 // Grub UKI
                 let mut s = String::new();
-                let boot_entries = get_sorted_grub_uki_boot_entries(&boot_dir, &mut s)?;
+                let boot_entries = get_sorted_grub_uki_boot_entries(boot_dir, &mut s)?;
 
                 boot_entries
                     .into_iter()
                     .map(|entry| entry.get_verity())
                     .collect::<Result<Vec<_>, _>>()?
             } else {
                 // Type1 Entry
-                let boot_entries = get_sorted_type1_boot_entries(&boot_dir, true)?;
+                let boot_entries = get_sorted_type1_boot_entries(boot_dir, true)?;
 
                 boot_entries
                     .into_iter()
@@ -75,11 +76,7 @@ fn list_bootloader_entries(physical_root: &Dir) -> Result<Vec<String>> {
         }
 
         Bootloader::Systemd => {
-            let device = get_sysroot_parent_dev(physical_root)?;
-            let (esp_part, ..) = get_esp_partition(&device)?;
-            let esp_mount = mount_esp(&esp_part)?;
-
-            let boot_entries = get_sorted_type1_boot_entries(&esp_mount.fd, true)?;
+            let boot_entries = get_sorted_type1_boot_entries(boot_dir, true)?;
 
             boot_entries
                 .into_iter()
@@ -175,7 +172,7 @@ pub(crate) async fn composefs_gc(storage: &Storage, booted_cfs: &BootedComposefs
 
     let sysroot = &storage.physical_root;
 
-    let bootloader_entries = list_bootloader_entries(&storage.physical_root)?;
+    let bootloader_entries = list_bootloader_entries(&storage)?;
     let images = list_erofs_images(&sysroot)?;
 
     // Collect the deployments that have an image but no bootloader entry

crates/lib/src/bootc_composefs/rollback.rs

@@ -6,9 +6,7 @@ use cap_std_ext::dirext::CapStdExtDirExt;
 use fn_error_context::context;
 use rustix::fs::{fsync, renameat_with, AtFlags, RenameFlags};
 
-use crate::bootc_composefs::boot::{
-    get_esp_partition, get_sysroot_parent_dev, mount_esp, type1_entry_conf_file_name, BootType,
-};
+use crate::bootc_composefs::boot::{type1_entry_conf_file_name, BootType};
 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;
@@ -196,31 +194,24 @@ pub(crate) async fn composefs_rollback(
         anyhow::bail!("Rollback deployment not a composefs deployment")
     };
 
+    let boot_dir = storage
+        .boot_dir
+        .as_ref()
+        .ok_or_else(|| anyhow::anyhow!("Boot dir not found"))?;
+
     match &rollback_entry.bootloader {
-        Bootloader::Grub => {
-            let boot_dir = storage
-                .physical_root
-                .open_dir("boot")
-                .context("Opening boot dir")?;
-
-            match rollback_entry.boot_type {
-                BootType::Bls => {
-                    rollback_composefs_entries(&boot_dir, rollback_entry.bootloader.clone())?;
-                }
-
-                BootType::Uki => {
-                    rollback_grub_uki_entries(&boot_dir)?;
-                }
+        Bootloader::Grub => match rollback_entry.boot_type {
+            BootType::Bls => {
+                rollback_composefs_entries(boot_dir, rollback_entry.bootloader.clone())?;
             }
-        }
+            BootType::Uki => {
+                rollback_grub_uki_entries(boot_dir)?;
+            }
+        },
 
         Bootloader::Systemd => {
-            let parent = get_sysroot_parent_dev(&storage.physical_root)?;
-            let (esp_part, ..) = get_esp_partition(&parent)?;
-            let esp_mount = mount_esp(&esp_part)?;
-
             // We use BLS entries for systemd UKI as well
-            rollback_composefs_entries(&esp_mount.fd, rollback_entry.bootloader.clone())?;
+            rollback_composefs_entries(boot_dir, rollback_entry.bootloader.clone())?;
         }
     }
 

crates/lib/src/bootc_composefs/status.rs

@@ -5,14 +5,15 @@ use bootc_kernel_cmdline::utf8::Cmdline;
 use fn_error_context::context;
 
 use crate::{
-    bootc_composefs::boot::{get_esp_partition, get_sysroot_parent_dev, mount_esp, BootType},
+    bootc_composefs::boot::BootType,
     composefs_consts::{COMPOSEFS_CMDLINE, ORIGIN_KEY_BOOT_DIGEST, TYPE1_ENT_PATH, USER_CFG},
     install::EFI_LOADER_INFO,
     parsers::{
         bls_config::{parse_bls_config, BLSConfig, BLSConfigType},
         grub_menuconfig::{parse_grub_menuentry_file, MenuEntry},
     },
     spec::{BootEntry, BootOrder, Host, HostSpec, ImageReference, ImageStatus},
+    store::Storage,
     utils::{read_uefi_var, EfiError},
 };
 
@@ -254,17 +255,23 @@ pub(crate) async fn get_composefs_status(
     storage: &crate::store::Storage,
     booted_cfs: &crate::store::BootedComposefs,
 ) -> Result<Host> {
-    composefs_deployment_status_from(&storage.physical_root, booted_cfs.cmdline).await
+    composefs_deployment_status_from(&storage, booted_cfs.cmdline).await
 }
 
 #[context("Getting composefs deployment status")]
 pub(crate) async fn composefs_deployment_status_from(
-    sysroot: &Dir,
+    storage: &Storage,
     cmdline: &ComposefsCmdline,
 ) -> Result<Host> {
     let composefs_digest = &cmdline.digest;
 
-    let deployments = sysroot
+    let boot_dir = storage
+        .boot_dir
+        .as_ref()
+        .ok_or_else(|| anyhow::anyhow!("Boot dir not found"))?;
+
+    let deployments = storage
+        .physical_root
         .read_dir(STATE_DIR_RELATIVE)
         .with_context(|| format!("Reading sysroot {STATE_DIR_RELATIVE}"))?;
 
@@ -348,30 +355,10 @@ pub(crate) async fn composefs_deployment_status_from(
 
     let booted = host.require_composefs_booted()?;
 
-    let (boot_dir, _temp_guard) = match booted.bootloader {
-        Bootloader::Grub => (sysroot.open_dir("boot").context("Opening boot dir")?, None),
-
-        // TODO: This is redundant as we should already have ESP mounted at `/efi/` accoding to
-        // spec; currently we do not
-        //
-        // See: https://uapi-group.org/specifications/specs/boot_loader_specification/#mount-points
-        Bootloader::Systemd => {
-            let parent = get_sysroot_parent_dev(sysroot)?;
-            let (esp_part, ..) = get_esp_partition(&parent)?;
-
-            let esp_mount = mount_esp(&esp_part)?;
-
-            let dir = esp_mount.fd.try_clone().context("Cloning fd")?;
-            let guard = Some(esp_mount);
-
-            (dir, guard)
-        }
-    };
-
     let is_rollback_queued = match booted.bootloader {
         Bootloader::Grub => match boot_type {
             BootType::Bls => {
-                let bls_config = get_sorted_type1_boot_entries(&boot_dir, false)?;
+                let bls_config = get_sorted_type1_boot_entries(boot_dir, false)?;
                 let bls_config = bls_config
                     .first()
                     .ok_or(anyhow::anyhow!("First boot entry not found"))?;
@@ -392,7 +379,7 @@ pub(crate) async fn composefs_deployment_status_from(
             BootType::Uki => {
                 let mut s = String::new();
 
-                !get_sorted_grub_uki_boot_entries(&boot_dir, &mut s)?
+                !get_sorted_grub_uki_boot_entries(boot_dir, &mut s)?
                     .first()
                     .ok_or(anyhow::anyhow!("First boot entry not found"))?
                     .body
@@ -403,7 +390,7 @@ pub(crate) async fn composefs_deployment_status_from(
 
         // We will have BLS stuff and the UKI stuff in the same DIR
         Bootloader::Systemd => {
-            let bls_config = get_sorted_type1_boot_entries(&boot_dir, false)?;
+            let bls_config = get_sorted_type1_boot_entries(boot_dir, false)?;
             let bls_config = bls_config
                 .first()
                 .ok_or(anyhow::anyhow!("First boot entry not found"))?;