cfs/to-existing-root: Bootloader support

To figure out which bootloader to install, get the host's bootloader
(read from LoaderInfo from efivars) and store it in state. Before
finalizing the bootloader, check if the detected bootloader is
compatible with the current image (as the bootloader on host and the one in
the new image might differ)

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

Author: Johan-Liebert1

crates/lib/src/install.rs

@@ -642,8 +642,12 @@ pub(crate) struct State {
     #[allow(dead_code)]
     pub(crate) composefs_required: bool,
 
-    // If Some, then --composefs_native is passed
+    /// If Some, then --composefs-backend is passed
     pub(crate) composefs_options: InstallComposefsOpts,
+
+    /// The bootloader on the host (determined by reading LoaderInfo from efivars)
+    /// Only Some when bootc is invoked with `install to-existing-root`
+    pub(crate) host_bootloader: Option<Bootloader>,
 }
 
 // Shared read-only global state
@@ -1709,8 +1713,13 @@ async fn prepare_install(
 
     // Read efivars to get the bootloader
     // Only if the operation is to replace the existing installation
-    if let Some(..) = replace_mode {
-        config_opts.bootloader = Some(get_bootloader().context("Determining existing bootloader")?)
+    let host_bootloader = match replace_mode {
+        Some(..) => {
+            let host_bootloader = get_bootloader().context("Determining existing bootloader")?;
+            println!("Detected bootloader on host: {host_bootloader}");
+            Some(host_bootloader)
+        }
+        None => None,
     };
 
     // Now, deal with SELinux state.
@@ -1819,26 +1828,60 @@ async fn prepare_install(
         host_is_container,
         composefs_required,
         composefs_options,
+        host_bootloader,
     });
 
     Ok(state)
 }
 
 impl PostFetchState {
     pub(crate) fn new(state: &State, d: &Dir) -> Result<Self> {
+        let supports_bootupd = crate::bootloader::supports_bootupd(d)?;
+
         // Determine bootloader type for the target system
         // Priority: user-specified > bootupd availability > systemd-boot fallback
         let detected_bootloader = {
             if let Some(bootloader) = state.config_opts.bootloader.clone() {
                 bootloader
             } else {
-                if crate::bootloader::supports_bootupd(d)? {
+                // TODO(Johan-Liebert1): The new release of bootupd would support all
+                if supports_bootupd {
                     crate::spec::Bootloader::Grub
                 } else {
                     crate::spec::Bootloader::Systemd
                 }
             }
         };
+
+        // If this exists it means we're replacing the current root
+        // or installing alongside it. The new image may or may not have
+        // the same bootloader as the host
+        //
+        // We could simply throw an error here, but at this point we'd have
+        // already nuked the boot or ESP so we should try our best to figure
+        // out what to install
+        let detected_bootloader = match state.host_bootloader {
+            Some(b) => match b {
+                Bootloader::Grub | Bootloader::GrubCC => {
+                    if supports_bootupd {
+                        b
+                    } else {
+                        Bootloader::Systemd
+                    }
+                }
+                Bootloader::Systemd => match crate::bootloader::bootctl_systemd_version() {
+                    Ok(_) => Bootloader::Systemd,
+                    Err(_) => {
+                        println!("Could not find bootctl, defaulting to Grub");
+                        Bootloader::Grub
+                    }
+                },
+                Bootloader::None => Bootloader::None,
+            },
+
+            None => detected_bootloader,
+        };
+
         println!("Bootloader: {detected_bootloader}");
         let r = Self {
             detected_bootloader,
@@ -2651,21 +2694,31 @@ pub(crate) async fn install_to_filesystem(
         }
     };
 
-    // Find the UUID of /boot because we need it for GRUB.
-    let boot_uuid = match state.config_opts.bootloader {
-        Some(Bootloader::Grub) | None if boot_is_mount => {
-            let boot_path = target_root_path.join(BOOT);
-            tracing::debug!("boot_path={boot_path}");
-            let u = bootc_mount::inspect_filesystem(&boot_path)
-                .with_context(|| format!("Inspecting /{BOOT}"))?
-                .uuid
-                .ok_or_else(|| anyhow!("No UUID found for /{BOOT}"))?;
-            Some(u)
-        }
-
-        _ => None,
+    let mut boot_uuid = None;
+
+    let get_boot_uuid = || -> Result<Option<String>> {
+        let boot_path = target_root_path.join(BOOT);
+        tracing::debug!("boot_path={boot_path}");
+        let u = bootc_mount::inspect_filesystem(&boot_path)
+            .with_context(|| format!("Inspecting /{BOOT}"))?
+            .uuid
+            .ok_or_else(|| anyhow!("No UUID found for /{BOOT}"))?;
+
+        Ok(Some(u))
     };
 
+    // Find the UUID of /boot because we need it for GRUB.
+    if boot_is_mount {
+        if matches!(state.host_bootloader, Some(Bootloader::Grub)) {
+            boot_uuid = get_boot_uuid().context("Getting boot uuid")?;
+        }
+
+        // If not set by `host_bootloader`
+        if boot_uuid.is_none() && matches!(state.config_opts.bootloader, Some(Bootloader::Grub)) {
+            boot_uuid = get_boot_uuid().context("Getting boot uuid")?;
+        }
+    }
+
     tracing::debug!("boot UUID: {boot_uuid:?}");
 
     // Find the real underlying backing device for the root.  This is currently just required

crates/lib/src/utils.rs

@@ -84,7 +84,9 @@ pub fn have_executable(name: &str) -> Result<bool> {
 /// Given a target directory, if it's a read-only mount, then remount it writable
 #[context("Opening {target} with writable mount")]
 pub(crate) fn open_dir_remount_rw(root: &Dir, target: &Utf8Path) -> Result<Dir> {
-    let target_dir = root.open_dir(target).with_context(|| format!("Opening {target}"))?;
+    let target_dir = root
+        .open_dir(target)
+        .with_context(|| format!("Opening {target}"))?;
 
     if matches!(target_dir.is_mountpoint("."), Ok(Some(true))) {
         let st = rustix::fs::fstatvfs(target_dir.as_fd())