install-to-fs: Move ostree target check before prepare_install

We need to know the underlying filesystem for the install to filesystem
target, which we can't get just by `findmnt` if `/` is mounted as
overlay, which is the case for ostree systems (and composefs systems) in
the future.

We already had code checking for this, move it around so we have that
info BEFORE we call `prepare_install`

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

Author: Johan-Liebert1

crates/lib/src/install.rs

@@ -201,7 +201,7 @@ use crate::store::Storage;
 use crate::task::Task;
 use crate::utils::sigpolicy_from_opt;
 use bootc_kernel_cmdline::{INITRD_ARG_PREFIX, ROOTFLAGS, bytes, utf8};
-use bootc_mount::{Filesystem, inspect_filesystem};
+use bootc_mount::Filesystem;
 use composefs::fsverity::FsVerityHashValue;
 
 /// The toplevel boot directory
@@ -2353,43 +2353,11 @@ pub(crate) async fn install_to_filesystem(
         target_path
     );
 
-    let fs_inspect = inspect_filesystem(&opts.filesystem_opts.root_path)?;
-
-    // Gather global state, destructuring the provided options.
-    // IMPORTANT: We might re-execute the current process in this function (for SELinux among other things)
-    // IMPORTANT: and hence anything that is done before MUST BE IDEMPOTENT.
-    // IMPORTANT: In practice, we should only be gathering information before this point,
-    // IMPORTANT: and not performing any mutations at all.
-    let state = prepare_install(
-        opts.config_opts,
-        opts.source_opts,
-        opts.target_opts,
-        opts.composefs_opts,
-        Some(fs_inspect.fstype.as_str().try_into()?),
-    )
-    .await?;
-
     // And the last bit of state here is the fsopts, which we also destructure now.
     let mut fsopts = opts.filesystem_opts;
 
-    // If we're doing an alongside install, automatically set up the host rootfs
-    // mount if it wasn't done already.
-    if targeting_host_root
-        && fsopts.root_path.as_str() == ALONGSIDE_ROOT_MOUNT
-        && !fsopts.root_path.try_exists()?
-    {
-        tracing::debug!("Mounting host / to {ALONGSIDE_ROOT_MOUNT}");
-        std::fs::create_dir(ALONGSIDE_ROOT_MOUNT)?;
-        bootc_mount::bind_mount_from_pidns(
-            bootc_mount::PID1,
-            "/".into(),
-            ALONGSIDE_ROOT_MOUNT.into(),
-            true,
-        )
-        .context("Mounting host / to {ALONGSIDE_ROOT_MOUNT}")?;
-    }
-
     let target_root_path = fsopts.root_path.clone();
+
     // Get a file descriptor for the root path /target
     let target_rootfs_fd =
         Dir::open_ambient_dir(&target_root_path, cap_std::ambient_authority())
@@ -2412,11 +2380,6 @@ pub(crate) async fn install_to_filesystem(
         }
     }
 
-    // Check to see if this happens to be the real host root
-    if !fsopts.acknowledge_destructive {
-        warn_on_host_root(&target_rootfs_fd)?;
-    }
-
     // If we're installing to an ostree root, then find the physical root from
     // the deployment root.
     let possible_physical_root = fsopts.root_path.join("sysroot");
@@ -2446,6 +2409,100 @@ pub(crate) async fn install_to_filesystem(
         target_rootfs_fd.try_clone()?
     };
 
+    // Gather data about the root filesystem
+    let inspect = bootc_mount::inspect_filesystem(&fsopts.root_path)?;
+
+    // Gather global state, destructuring the provided options.
+    // IMPORTANT: We might re-execute the current process in this function (for SELinux among other things)
+    // IMPORTANT: and hence anything that is done before MUST BE IDEMPOTENT.
+    // IMPORTANT: In practice, we should only be gathering information before this point,
+    // IMPORTANT: and not performing any mutations at all.
+    let state = prepare_install(
+        opts.config_opts,
+        opts.source_opts,
+        opts.target_opts,
+        opts.composefs_opts,
+        Some(inspect.fstype.as_str().try_into()?),
+    )
+    .await?;
+
+    // And the last bit of state here is the fsopts, which we also destructure now.
+    // let mut fsopts = opts.filesystem_opts;
+
+    // If we're doing an alongside install, automatically set up the host rootfs
+    // mount if it wasn't done already.
+    if targeting_host_root
+        && target_root_path.as_str() == ALONGSIDE_ROOT_MOUNT
+        && !target_root_path.try_exists()?
+    {
+        tracing::debug!("Mounting host / to {ALONGSIDE_ROOT_MOUNT}");
+        std::fs::create_dir(ALONGSIDE_ROOT_MOUNT)?;
+        bootc_mount::bind_mount_from_pidns(
+            bootc_mount::PID1,
+            "/".into(),
+            ALONGSIDE_ROOT_MOUNT.into(),
+            true,
+        )
+        .context("Mounting host / to {ALONGSIDE_ROOT_MOUNT}")?;
+    }
+
+    // let target_root_path = fsopts.root_path.clone();
+    // // Get a file descriptor for the root path /target
+    // let target_rootfs_fd =
+    //     Dir::open_ambient_dir(&target_root_path, cap_std::ambient_authority())
+    //         .with_context(|| format!("Opening target root directory {target_root_path}"))?;
+    //
+    // tracing::debug!("Target root filesystem: {target_root_path}");
+    //
+    // if let Some(false) = target_rootfs_fd.is_mountpoint(".")? {
+    //     anyhow::bail!("Not a mountpoint: {target_root_path}");
+    // }
+    //
+    // // Check that the target is a directory
+    // {
+    //     let root_path = &fsopts.root_path;
+    //     let st = root_path
+    //         .symlink_metadata()
+    //         .with_context(|| format!("Querying target filesystem {root_path}"))?;
+    //     if !st.is_dir() {
+    //         anyhow::bail!("Not a directory: {root_path}");
+    //     }
+    // }
+
+    // Check to see if this happens to be the real host root
+    if !fsopts.acknowledge_destructive {
+        warn_on_host_root(&target_rootfs_fd)?;
+    }
+
+    // // If we're installing to an ostree root, then find the physical root from
+    // // the deployment root.
+    // let possible_physical_root = fsopts.root_path.join("sysroot");
+    // let possible_ostree_dir = possible_physical_root.join("ostree");
+    // let is_already_ostree = possible_ostree_dir.exists();
+    // if is_already_ostree {
+    //     tracing::debug!(
+    //         "ostree detected in {possible_ostree_dir}, assuming target is a deployment root and using {possible_physical_root}"
+    //     );
+    //     fsopts.root_path = possible_physical_root;
+    // };
+    //
+    // // Get a file descriptor for the root path
+    // // It will be /target/sysroot on ostree OS, or will be /target
+    // let rootfs_fd = if is_already_ostree {
+    //     let root_path = &fsopts.root_path;
+    //     let rootfs_fd = Dir::open_ambient_dir(&fsopts.root_path, cap_std::ambient_authority())
+    //         .with_context(|| format!("Opening target root directory {root_path}"))?;
+    //
+    //     tracing::debug!("Root filesystem: {root_path}");
+    //
+    //     if let Some(false) = rootfs_fd.is_mountpoint(".")? {
+    //         anyhow::bail!("Not a mountpoint: {root_path}");
+    //     }
+    //     rootfs_fd
+    // } else {
+    //     target_rootfs_fd.try_clone()?
+    // };
+
     match fsopts.replace {
         Some(ReplaceMode::Wipe) => {
             let rootfs_fd = rootfs_fd.try_clone()?;
@@ -2459,9 +2516,6 @@ pub(crate) async fn install_to_filesystem(
         None => require_empty_rootdir(&rootfs_fd)?,
     }
 
-    // Gather data about the root filesystem
-    let inspect = bootc_mount::inspect_filesystem(&fsopts.root_path)?;
-
     // We support overriding the mount specification for root (i.e. LABEL vs UUID versus
     // raw paths).
     // We also support an empty specification as a signal to omit any mountspec kargs.