lib: Move sysroot_path into Storage struct

Refactor the unified storage code to get the sysroot path from the
Storage struct instead of passing it as a parameter through multiple
function calls.

Why this change is needed:
The previous implementation passed sysroot_path as an Option parameter
to prepare_for_pull_unified() and pull_unified(). This was awkward
because:
- Callers had to know whether to pass None (for booted systems) or
  Some(path) (for install scenarios)
- The path is inherently tied to the Storage instance's lifecycle
- It required threading parameters through multiple layers

This follows the existing pattern where Storage already encapsulates
storage-related state, and addresses review feedback to "get this stuff
from the Storage".

Assisted-by: Claude Code (Opus 4.5)
Signed-off-by: Joseph Marrero Corchado <jmarrero@redhat.com>

Author: jmarrero

crates/lib/src/cli.rs

@@ -1003,7 +1003,7 @@ async fn upgrade(
         let use_unified = crate::deploy::image_exists_in_unified_storage(storage, imgref).await?;
 
         let fetched = if use_unified {
-            crate::deploy::pull_unified(repo, imgref, None, opts.quiet, prog.clone(), storage, None)
+            crate::deploy::pull_unified(repo, imgref, None, opts.quiet, prog.clone(), storage)
                 .await?
         } else {
             crate::deploy::pull(repo, imgref, None, opts.quiet, prog.clone()).await?
@@ -1167,8 +1167,7 @@ async fn switch_ostree(
     };
 
     let fetched = if use_unified {
-        crate::deploy::pull_unified(repo, &target, None, opts.quiet, prog.clone(), storage, None)
-            .await?
+        crate::deploy::pull_unified(repo, &target, None, opts.quiet, prog.clone(), storage).await?
     } else {
         crate::deploy::pull(repo, &target, None, opts.quiet, prog.clone()).await?
     };

crates/lib/src/deploy.rs

@@ -422,16 +422,11 @@ pub(crate) async fn image_exists_in_unified_storage(
 
 /// Unified approach: Use bootc's CStorage to pull the image, then prepare from containers-storage.
 /// This reuses the same infrastructure as LBIs.
-///
-/// The `sysroot_path` parameter specifies the path to the sysroot where bootc storage is located.
-/// During install, this should be the path to the target disk's mount point.
-/// During upgrade/switch on a running system, pass `None` to use the default `/sysroot`.
 pub(crate) async fn prepare_for_pull_unified(
     repo: &ostree::Repo,
     imgref: &ImageReference,
     target_imgref: Option<&OstreeImageReference>,
     store: &Storage,
-    sysroot_path: Option<&camino::Utf8Path>,
 ) -> Result<PreparedPullResult> {
     // Get or initialize the bootc container storage (same as used for LBIs)
     let imgstore = store.get_ensure_imgstore()?;
@@ -467,14 +462,10 @@ pub(crate) async fn prepare_for_pull_unified(
     // Configure the importer to use bootc storage as an additional image store
     let mut config = ostree_ext::containers_image_proxy::ImageProxyConfig::default();
     let mut cmd = Command::new("skopeo");
-    // Use the actual physical path to bootc storage
-    // During install, this is the target disk's mount point; otherwise default to /sysroot
-    let sysroot_base = sysroot_path
-        .map(|p| p.to_string())
-        .unwrap_or_else(|| "/sysroot".to_string());
+    // Use the physical path to bootc storage from the Storage struct
     let storage_path = format!(
         "{}/{}",
-        sysroot_base,
+        store.physical_root_path,
         crate::podstorage::CStorage::subpath()
     );
     crate::podstorage::set_additional_image_store(&mut cmd, &storage_path);
@@ -525,19 +516,15 @@ pub(crate) async fn prepare_for_pull_unified(
 }
 
 /// Unified pull: Use podman to pull to containers-storage, then read from there
-///
-/// The `sysroot_path` parameter specifies the path to the sysroot where bootc storage is located.
-/// For normal upgrade/switch operations, pass `None` to use the default `/sysroot`.
 pub(crate) async fn pull_unified(
     repo: &ostree::Repo,
     imgref: &ImageReference,
     target_imgref: Option<&OstreeImageReference>,
     quiet: bool,
     prog: ProgressWriter,
     store: &Storage,
-    sysroot_path: Option<&camino::Utf8Path>,
 ) -> Result<Box<ImageState>> {
-    match prepare_for_pull_unified(repo, imgref, target_imgref, store, sysroot_path).await? {
+    match prepare_for_pull_unified(repo, imgref, target_imgref, store).await? {
         PreparedPullResult::AlreadyPresent(existing) => {
             // Log that the image was already present (Debug level since it's not actionable)
             const IMAGE_ALREADY_PRESENT_ID: &str = "5c4d3e2f1a0b9c8d7e6f5a4b3c2d1e0f9";

crates/lib/src/install.rs

@@ -935,7 +935,6 @@ async fn install_container(
             &spec_imgref,
             Some(&state.target_imgref),
             storage,
-            Some(&root_setup.physical_root_path),
         )
         .await?
     } else {

crates/lib/src/store/mod.rs

@@ -22,12 +22,14 @@ use std::sync::Arc;
 
 use anyhow::{Context, Result};
 use bootc_mount::tempmount::TempMount;
+use camino::Utf8PathBuf;
 use cap_std_ext::cap_std;
 use cap_std_ext::cap_std::fs::{Dir, DirBuilder, DirBuilderExt as _};
 use cap_std_ext::dirext::CapStdExtDirExt;
 use fn_error_context::context;
 
 use ostree_ext::container_utils::ostree_booted;
+use ostree_ext::prelude::FileExt;
 use ostree_ext::sysroot::SysrootLock;
 use ostree_ext::{gio, ostree};
 use rustix::fs::Mode;
@@ -185,6 +187,7 @@ impl BootedStorage {
 
                 let storage = Storage {
                     physical_root,
+                    physical_root_path: Utf8PathBuf::from("/sysroot"),
                     run,
                     boot_dir: Some(boot_dir),
                     esp: Some(esp_mount),
@@ -209,6 +212,7 @@ impl BootedStorage {
 
                 let storage = Storage {
                     physical_root,
+                    physical_root_path: Utf8PathBuf::from("/sysroot"),
                     run,
                     boot_dir: None,
                     esp: None,
@@ -254,6 +258,10 @@ pub(crate) struct Storage {
     /// Directory holding the physical root
     pub physical_root: Dir,
 
+    /// Absolute path to the physical root directory.
+    /// This is `/sysroot` on a running system, or the target mount point during install.
+    pub physical_root_path: Utf8PathBuf,
+
     /// The 'boot' directory, useful and `Some` only for composefs systems
     /// For grub booted systems, this points to `/sysroot/boot`
     /// For systemd booted systems, this points to the ESP
@@ -301,17 +309,25 @@ impl Storage {
         // we need to explicitly distinguish the two and the storage
         // here hence holds a reference to the physical root.
         let ostree_sysroot_dir = crate::utils::sysroot_dir(&sysroot)?;
-        let physical_root = if sysroot.is_booted() {
-            ostree_sysroot_dir.open_dir(SYSROOT)?
+        let (physical_root, physical_root_path) = if sysroot.is_booted() {
+            (
+                ostree_sysroot_dir.open_dir(SYSROOT)?,
+                Utf8PathBuf::from("/sysroot"),
+            )
         } else {
-            ostree_sysroot_dir
+            // For non-booted case (install), get the path from the sysroot
+            let path = sysroot.path();
+            let path_str = path.parse_name().to_string();
+            let path = Utf8PathBuf::from(path_str);
+            (ostree_sysroot_dir, path)
         };
 
         let ostree_cell = OnceCell::new();
         let _ = ostree_cell.set(sysroot);
 
         Ok(Self {
             physical_root,
+            physical_root_path,
             run,
             boot_dir: None,
             esp: None,