composefs: Pass BootedComposefs data down instead of scraping global state

Update composefs command functions to accept and use Storage and BootedComposefs
parameters instead of calling composefs_deployment_status() which scrapes global
state.

Changes:
- Add get_composefs_status(storage, booted_cfs) helper in status.rs
- Update upgrade_composefs() to use passed composefs.repo and get_composefs_status()
- Update switch_composefs() to accept and use storage/booted_cfs parameters
- Update composefs_rollback() to use storage.physical_root for opening directories
- Update delete_composefs_deployment() to accept and pass through parameters
- Update CLI dispatchers to pass storage and booted_cfs to all composefs functions

This eliminates composefs_deployment_status() calls from command functions,
completing the pattern established with BootedOstree for ostree commands.

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

Author: cgwalters

crates/lib/src/bootc_composefs/delete.rs

@@ -17,7 +17,7 @@ use crate::{
         gc::composefs_gc,
         repo::open_composefs_repo,
         rollback::{composefs_rollback, rename_exchange_user_cfg},
-        status::{composefs_deployment_status, get_sorted_grub_uki_boot_entries},
+        status::{get_composefs_status, get_sorted_grub_uki_boot_entries},
     },
     composefs_consts::{
         COMPOSEFS_STAGED_DEPLOYMENT_FNAME, COMPOSEFS_TRANSIENT_STATE_DIR, STATE_DIR_RELATIVE,
@@ -26,6 +26,7 @@ use crate::{
     parsers::bls_config::{parse_bls_config, BLSConfigType},
     spec::{BootEntry, Bootloader, DeploymentEntry},
     status::Slot,
+    store::{BootedComposefs, Storage},
 };
 
 #[fn_error_context::context("Deleting Type1 Entry {}", depl.deployment.verity)]
@@ -316,8 +317,12 @@ pub(crate) fn delete_staged(staged: &Option<BootEntry>) -> Result<()> {
 }
 
 #[fn_error_context::context("Deleting composefs deployment {}", deployment_id)]
-pub(crate) async fn delete_composefs_deployment(deployment_id: &str) -> Result<()> {
-    let host = composefs_deployment_status().await?;
+pub(crate) async fn delete_composefs_deployment(
+    deployment_id: &str,
+    storage: &Storage,
+    booted_cfs: &BootedComposefs,
+) -> Result<()> {
+    let host = get_composefs_status(storage, booted_cfs).await?;
 
     let booted = host.require_composefs_booted()?;
 
@@ -344,7 +349,7 @@ pub(crate) async fn delete_composefs_deployment(deployment_id: &str) -> Result<(
 
     // Unqueue rollback. This makes it easier to delete boot entries later on
     if matches!(depl_to_del.ty, Some(Slot::Rollback)) && host.status.rollback_queued {
-        composefs_rollback().await?;
+        composefs_rollback(storage, booted_cfs).await?;
     }
 
     let kind = if depl_to_del.pinned {

crates/lib/src/bootc_composefs/rollback.rs

@@ -1,7 +1,6 @@
 use std::io::Write;
 
 use anyhow::{anyhow, Context, Result};
-use cap_std_ext::cap_std::ambient_authority;
 use cap_std_ext::cap_std::fs::Dir;
 use cap_std_ext::dirext::CapStdExtDirExt;
 use fn_error_context::context;
@@ -10,9 +9,10 @@ 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::status::{composefs_deployment_status, get_sorted_type1_boot_entries};
+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::store::{BootedComposefs, Storage};
 use crate::{
     bootc_composefs::{boot::get_efi_uuid_source, status::get_sorted_grub_uki_boot_entries},
     composefs_consts::{
@@ -164,8 +164,11 @@ fn rollback_composefs_entries(boot_dir: &Dir, bootloader: Bootloader) -> Result<
 }
 
 #[context("Rolling back composefs")]
-pub(crate) async fn composefs_rollback() -> Result<()> {
-    let host = composefs_deployment_status().await?;
+pub(crate) async fn composefs_rollback(
+    storage: &Storage,
+    booted_cfs: &BootedComposefs,
+) -> Result<()> {
+    let host = get_composefs_status(storage, booted_cfs).await?;
 
     let new_spec = {
         let mut new_spec = host.spec.clone();
@@ -195,7 +198,9 @@ pub(crate) async fn composefs_rollback() -> Result<()> {
 
     match &rollback_entry.bootloader {
         Bootloader::Grub => {
-            let boot_dir = Dir::open_ambient_dir("/sysroot/boot", ambient_authority())
+            let boot_dir = storage
+                .physical_root
+                .open_dir("boot")
                 .context("Opening boot dir")?;
 
             match rollback_entry.boot_type {

crates/lib/src/bootc_composefs/status.rs

@@ -257,6 +257,16 @@ pub(crate) async fn composefs_deployment_status() -> Result<Host> {
     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")]
+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
+}
+
 #[context("Getting composefs deployment status")]
 pub(crate) async fn composefs_deployment_status_from(
     sysroot: &Dir,

crates/lib/src/bootc_composefs/switch.rs

@@ -8,17 +8,22 @@ use crate::{
         repo::pull_composefs_repo,
         service::start_finalize_stated_svc,
         state::write_composefs_state,
-        status::composefs_deployment_status,
+        status::get_composefs_status,
     },
     cli::{imgref_for_switch, SwitchOpts},
+    store::{BootedComposefs, Storage},
 };
 
 #[context("Composefs Switching")]
-pub(crate) async fn switch_composefs(opts: SwitchOpts) -> Result<()> {
+pub(crate) async fn switch_composefs(
+    opts: SwitchOpts,
+    storage: &Storage,
+    booted_cfs: &BootedComposefs,
+) -> Result<()> {
     let target = imgref_for_switch(&opts)?;
     // TODO: Handle in-place
 
-    let host = composefs_deployment_status()
+    let host = get_composefs_status(storage, booted_cfs)
         .await
         .context("Getting composefs deployment status")?;
 
@@ -63,6 +68,7 @@ pub(crate) async fn switch_composefs(opts: SwitchOpts) -> Result<()> {
         }
     };
 
+    // TODO: Remove this hardcoded path when write_composefs_state accepts a Dir
     write_composefs_state(
         &Utf8PathBuf::from("/sysroot"),
         id,

crates/lib/src/bootc_composefs/update.rs

@@ -7,18 +7,16 @@ use ostree_ext::oci_spec::image::{ImageConfiguration, ImageManifest};
 use crate::{
     bootc_composefs::{
         boot::{setup_composefs_bls_boot, setup_composefs_uki_boot, BootSetupType, BootType},
-        repo::{get_imgref, open_composefs_repo, pull_composefs_repo},
+        repo::{get_imgref, pull_composefs_repo},
         service::start_finalize_stated_svc,
         state::write_composefs_state,
-        status::{composefs_deployment_status, get_container_manifest_and_config},
+        status::{get_composefs_status, get_container_manifest_and_config},
     },
     cli::UpgradeOpts,
     spec::ImageReference,
     store::{BootedComposefs, ComposefsRepository, Storage},
 };
 
-use cap_std_ext::cap_std::{ambient_authority, fs::Dir};
-
 #[context("Getting SHA256 Digest for {id}")]
 pub fn str_to_sha256digest(id: &str) -> Result<Sha256Digest> {
     let id = id.strip_prefix("sha256:").unwrap_or(id);
@@ -63,10 +61,10 @@ async fn is_image_pulled(
 #[context("Upgrading composefs")]
 pub(crate) async fn upgrade_composefs(
     opts: UpgradeOpts,
-    _storage: &Storage,
-    _composefs: &BootedComposefs,
+    storage: &Storage,
+    composefs: &BootedComposefs,
 ) -> Result<()> {
-    let host = composefs_deployment_status()
+    let host = get_composefs_status(storage, composefs)
         .await
         .context("Getting composefs deployment status")?;
 
@@ -76,9 +74,7 @@ pub(crate) async fn upgrade_composefs(
         .as_ref()
         .ok_or_else(|| anyhow::anyhow!("No image source specified"))?;
 
-    let sysroot =
-        Dir::open_ambient_dir("/sysroot", ambient_authority()).context("Opening sysroot")?;
-    let repo = open_composefs_repo(&sysroot)?;
+    let repo = &*composefs.repo;
 
     let (img_pulled, mut manifest, mut config) = is_image_pulled(&repo, imgref).await?;
     let booted_img_digest = manifest.config().digest().digest();

crates/lib/src/cli.rs

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