composefs: Update gc and finalize functions to use passed Storage/BootedComposefs

Update composefs_gc(), composefs_backend_finalize(), and get_etc_diff() to accept
Storage and BootedComposefs parameters instead of calling composefs_deployment_status()
and opening hardcoded paths.

Changes:
- composefs_gc() now accepts storage and booted_cfs parameters
- composefs_backend_finalize() uses storage.physical_root instead of hardcoded "/sysroot"
- get_etc_diff() uses storage.physical_root instead of hardcoded "/sysroot"
- Update CLI dispatchers to use BootedStorageKind pattern for finalize and config-diff
- Remove unused imports from finalize.rs (open_dir, CWD)

This eliminates remaining composefs_deployment_status() calls from gc.rs and finalize.rs,
and removes several hardcoded "/sysroot" paths.

Assisted-by: Claude Code (Sonnet 4.5)
Signed-off-by: Colin Walters <[email protected]>

Author: cgwalters

crates/lib/src/bootc_composefs/delete.rs

@@ -364,7 +364,7 @@ pub(crate) async fn delete_composefs_deployment(
 
     delete_depl_boot_entries(&depl_to_del, deleting_staged)?;
 
-    composefs_gc().await?;
+    composefs_gc(storage, booted_cfs).await?;
 
     Ok(())
 }

crates/lib/src/bootc_composefs/finalize.rs

@@ -4,28 +4,28 @@ use crate::bootc_composefs::boot::{
     get_esp_partition, get_sysroot_parent_dev, mount_esp, 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;
 use crate::spec::Bootloader;
-use crate::{
-    bootc_composefs::status::composefs_deployment_status, composefs_consts::STATE_DIR_ABS,
-};
+use crate::store::{BootedComposefs, Storage};
 use anyhow::{Context, Result};
-use bootc_initramfs_setup::{mount_composefs_image, open_dir};
+use bootc_initramfs_setup::mount_composefs_image;
 use bootc_mount::tempmount::TempMount;
 use cap_std_ext::cap_std::{ambient_authority, fs::Dir};
 use cap_std_ext::dirext::CapStdExtDirExt;
 use etc_merge::{compute_diff, merge, print_diff, traverse_etc};
-use rustix::fs::{fsync, renameat, CWD};
+use rustix::fs::{fsync, renameat};
 use rustix::path::Arg;
 
 use fn_error_context::context;
 
-pub(crate) async fn get_etc_diff() -> Result<()> {
-    let host = composefs_deployment_status().await?;
+pub(crate) async fn get_etc_diff(storage: &Storage, booted_cfs: &BootedComposefs) -> Result<()> {
+    let host = get_composefs_status(storage, booted_cfs).await?;
     let booted_composefs = host.require_composefs_booted()?;
 
     // Mount the booted EROFS image to get pristine etc
-    let sysroot = open_dir(CWD, "/sysroot").context("Opening /sysroot")?;
-    let composefs_fd = mount_composefs_image(&sysroot, &booted_composefs.verity, false)?;
+    let sysroot_fd = storage.physical_root.reopen_as_ownedfd()?;
+    let composefs_fd = mount_composefs_image(&sysroot_fd, &booted_composefs.verity, false)?;
 
     let erofs_tmp_mnt = TempMount::mount_fd(&composefs_fd)?;
 
@@ -41,8 +41,11 @@ pub(crate) async fn get_etc_diff() -> Result<()> {
     Ok(())
 }
 
-pub(crate) async fn composefs_backend_finalize() -> Result<()> {
-    let host = composefs_deployment_status().await?;
+pub(crate) async fn composefs_backend_finalize(
+    storage: &Storage,
+    booted_cfs: &BootedComposefs,
+) -> Result<()> {
+    let host = get_composefs_status(storage, booted_cfs).await?;
 
     let booted_composefs = host.require_composefs_booted()?;
 
@@ -56,8 +59,8 @@ pub(crate) async fn composefs_backend_finalize() -> Result<()> {
     ))?;
 
     // Mount the booted EROFS image to get pristine etc
-    let sysroot = open_dir(CWD, "/sysroot")?;
-    let composefs_fd = mount_composefs_image(&sysroot, &booted_composefs.verity, false)?;
+    let sysroot_fd = storage.physical_root.reopen_as_ownedfd()?;
+    let composefs_fd = mount_composefs_image(&sysroot_fd, &booted_composefs.verity, false)?;
 
     let erofs_tmp_mnt = TempMount::mount_fd(&composefs_fd)?;
 
@@ -88,8 +91,10 @@ pub(crate) async fn composefs_backend_finalize() -> Result<()> {
     let (esp_part, ..) = get_esp_partition(&sysroot_parent)?;
 
     let esp_mount = mount_esp(&esp_part)?;
-    let boot_dir = Dir::open_ambient_dir("/sysroot/boot", ambient_authority())
-        .context("Opening sysroot/boot")?;
+    let boot_dir = storage
+        .physical_root
+        .open_dir("boot")
+        .context("Opening boot")?;
 
     // NOTE: Assuming here we won't have two bootloaders at the same time
     match booted_composefs.bootloader {

crates/lib/src/bootc_composefs/gc.rs

@@ -16,12 +16,13 @@ use crate::{
         boot::{get_esp_partition, get_sysroot_parent_dev, mount_esp},
         delete::{delete_image, delete_staged, delete_state_dir, get_image_objects},
         status::{
-            composefs_deployment_status, get_bootloader, get_sorted_grub_uki_boot_entries,
+            get_bootloader, get_composefs_status, get_sorted_grub_uki_boot_entries,
             get_sorted_type1_boot_entries,
         },
     },
     composefs_consts::{STATE_DIR_RELATIVE, USER_CFG},
     spec::Bootloader,
+    store::{BootedComposefs, Storage},
 };
 
 #[fn_error_context::context("Listing EROFS images")]
@@ -172,12 +173,11 @@ pub(crate) fn gc_objects(sysroot: &Dir) -> Result<()> {
 /// Similarly if EROFS image B1 doesn't exist, but state dir does, then delete the state dir and
 /// perform GC
 #[fn_error_context::context("Running composefs garbage collection")]
-pub(crate) async fn composefs_gc() -> Result<()> {
-    let host = composefs_deployment_status().await?;
-    let booted_cfs = host.require_composefs_booted()?;
+pub(crate) async fn composefs_gc(storage: &Storage, booted_cfs: &BootedComposefs) -> Result<()> {
+    let host = get_composefs_status(storage, booted_cfs).await?;
+    let booted_cfs_status = host.require_composefs_booted()?;
 
-    let sysroot =
-        Dir::open_ambient_dir("/sysroot", ambient_authority()).context("Opening sysroot")?;
+    let sysroot = &storage.physical_root;
 
     let bootloader_entries = list_bootloader_entries()?;
     let images = list_erofs_images(&sysroot)?;
@@ -190,10 +190,10 @@ pub(crate) async fn composefs_gc() -> Result<()> {
 
     let staged = &host.status.staged;
 
-    if img_bootloader_diff.contains(&&booted_cfs.verity) {
+    if img_bootloader_diff.contains(&&booted_cfs_status.verity) {
         anyhow::bail!(
             "Inconsistent state. Booted entry '{}' found for cleanup",
-            booted_cfs.verity
+            booted_cfs_status.verity
         )
     }
 

crates/lib/src/bootc_composefs/status.rs

@@ -19,7 +19,6 @@ use crate::{
 use std::str::FromStr;
 
 use bootc_utils::try_deserialize_timestamp;
-use cap_std_ext::cap_std::ambient_authority;
 use cap_std_ext::cap_std::fs::Dir;
 use ostree_container::OstreeImageReference;
 use ostree_ext::container::deploy::ORIGIN_CONTAINER;
@@ -247,16 +246,6 @@ async fn boot_entry_from_composefs_deployment(
     return Ok(e);
 }
 
-pub(crate) async fn composefs_deployment_status() -> Result<Host> {
-    let composefs_state = composefs_booted()?
-        .ok_or_else(|| anyhow::anyhow!("Failed to find composefs parameter in kernel cmdline"))?;
-
-    let sysroot =
-        Dir::open_ambient_dir("/sysroot", ambient_authority()).context("Opening sysroot")?;
-
-    composefs_deployment_status_from(&sysroot, composefs_state).await
-}
-
 /// Get composefs status using provided storage and booted composefs data
 /// instead of scraping global state.
 #[context("Getting composefs deployment status")]

crates/lib/src/cli.rs

@@ -1146,9 +1146,7 @@ async fn rollback(opts: &RollbackOpts) -> Result<()> {
         BootedStorageKind::Ostree(booted_ostree) => {
             rollback_ostree(opts, storage, &booted_ostree).await
         }
-        BootedStorageKind::Composefs(booted_cfs) => {
-            composefs_rollback(storage, &booted_cfs).await
-        }
+        BootedStorageKind::Composefs(booted_cfs) => composefs_rollback(storage, &booted_cfs).await,
     }
 }
 
@@ -1628,9 +1626,29 @@ async fn run_from_opt(opt: Opt) -> Result<()> {
             }
         },
 
-        Opt::ComposefsFinalizeStaged => composefs_backend_finalize().await,
+        Opt::ComposefsFinalizeStaged => {
+            let storage = &get_storage().await?;
+            match storage.kind()? {
+                BootedStorageKind::Ostree(_) => {
+                    anyhow::bail!("ComposefsFinalizeStaged is only supported for composefs backend")
+                }
+                BootedStorageKind::Composefs(booted_cfs) => {
+                    composefs_backend_finalize(storage, &booted_cfs).await
+                }
+            }
+        }
 
-        Opt::ConfigDiff => get_etc_diff().await,
+        Opt::ConfigDiff => {
+            let storage = &get_storage().await?;
+            match storage.kind()? {
+                BootedStorageKind::Ostree(_) => {
+                    anyhow::bail!("ConfigDiff is only supported for composefs backend")
+                }
+                BootedStorageKind::Composefs(booted_cfs) => {
+                    get_etc_diff(storage, &booted_cfs).await
+                }
+            }
+        }
 
         Opt::DeleteDeployment { depl_id } => {
             let storage = &get_storage().await?;

crates/lib/src/status.rs

@@ -19,7 +19,6 @@ use ostree_ext::sysroot::SysrootLock;
 
 use ostree_ext::ostree;
 
-use crate::bootc_composefs::status::composefs_deployment_status;
 use crate::cli::OutputFormat;
 use crate::spec::BootEntryComposefs;
 use crate::spec::ImageStatus;
@@ -376,7 +375,9 @@ async fn get_host() -> Result<Host> {
                 let (_deployments, host) = get_status(&booted_ostree)?;
                 host
             }
-            crate::store::BootedStorageKind::Composefs(_) => composefs_deployment_status().await?,
+            crate::store::BootedStorageKind::Composefs(booted_cfs) => {
+                crate::bootc_composefs::status::get_composefs_status(&storage, &booted_cfs).await?
+            }
         }
     } else {
         Default::default()