install: Don't require EFI if booted via BIOS and doing alongside

lib/src/bootloader.rs

@@ -1,4 +1,5 @@
 use std::os::unix::prelude::PermissionsExt;
+use std::path::Path;
 
 use anyhow::{Context, Result};
 use camino::Utf8Path;
@@ -51,20 +52,51 @@ fn install_grub2_efi(efidir: &Dir, uuid: &str) -> Result<()> {
     Ok(())
 }
 
+/// Return `true` if the system is booted via EFI
+pub(crate) fn is_efi_booted() -> Result<bool> {
+    if !super::install::ARCH_USES_EFI {
+        return Ok(false);
+    }
+    Path::new("/sys/firmware/efi")
+        .try_exists()
+        .map_err(Into::into)
+}
+
 #[context("Installing bootloader")]
 pub(crate) fn install_via_bootupd(
     device: &Utf8Path,
     rootfs: &Utf8Path,
     boot_uuid: &str,
+    is_alongside: bool,
 ) -> Result<()> {
     let verbose = std::env::var_os("BOOTC_BOOTLOADER_DEBUG").map(|_| "-vvvv");
-    let args = ["backend", "install"].into_iter().chain(verbose).chain([
-        "--src-root",
-        "/",
-        "--device",
-        device.as_str(),
-        rootfs.as_str(),
-    ]);
+    // If we're doing an alongside install, only match the boot method because Anaconda defaults
+    // to only doing that.  This is only on x86_64 because that's the only arch that has multiple
+    // components right now.
+    // TODO: Add --component=auto which moves this logic into bootupd
+    let (install_efi, component_args) = if cfg!(target_arch = "x86_64") && is_alongside {
+        assert!(super::install::ARCH_USES_EFI);
+        let install_efi = is_efi_booted()?;
+        let component_arg = if install_efi {
+            "--component=EFI"
+        } else {
+            "--component=BIOS"
+        };
+        (install_efi, Some(component_arg))
+    } else {
+        (super::install::ARCH_USES_EFI, None)
+    };
+    let args = ["backend", "install"]
+        .into_iter()
+        .chain(verbose)
+        .chain(component_args)
+        .chain([
+            "--src-root",
+            "/",
+            "--device",
+            device.as_str(),
+            rootfs.as_str(),
+        ]);
     Task::new_and_run("Running bootupctl to install bootloader", "bootupctl", args)?;
 
     let grub2_uuid_contents = format!("set BOOT_UUID=\"{boot_uuid}\"\n");
@@ -73,7 +105,7 @@ pub(crate) fn install_via_bootupd(
     let bootfs =
         Dir::open_ambient_dir(bootfs, cap_std::ambient_authority()).context("Opening boot")?;
 
-    if super::install::ARCH_USES_EFI {
+    if super::install::ARCH_USES_EFI && install_efi {
         let efidir = bootfs.open_dir("efi").context("Opening efi")?;
         install_grub2_efi(&efidir, &grub2_uuid_contents)?;
     }

lib/src/install.rs

@@ -632,8 +632,8 @@ pub(crate) struct RootSetup {
     rootfs: Utf8PathBuf,
     rootfs_fd: Dir,
     rootfs_uuid: Option<String>,
-    /// If true, do not try to remount the root read-only and flush the journal, etc.
-    skip_finalize: bool,
+    /// True if this is an "alongside" install where we didn't create the filesystem
+    is_alongside: bool,
     boot: Option<MountSpec>,
     kargs: Vec<String>,
 }
@@ -861,7 +861,12 @@ async fn install_to_filesystem_impl(state: &State, rootfs: &mut RootSetup) -> Re
         .get_boot_uuid()?
         .or(rootfs.rootfs_uuid.as_deref())
         .ok_or_else(|| anyhow!("No uuid for boot/root"))?;
-    crate::bootloader::install_via_bootupd(&rootfs.device, &rootfs.rootfs, boot_uuid)?;
+    crate::bootloader::install_via_bootupd(
+        &rootfs.device,
+        &rootfs.rootfs,
+        boot_uuid,
+        rootfs.is_alongside,
+    )?;
     tracing::debug!("Installed bootloader");
 
     // If Ignition is specified, enable it
@@ -882,7 +887,7 @@ async fn install_to_filesystem_impl(state: &State, rootfs: &mut RootSetup) -> Re
         .run()?;
 
     // Finalize mounted filesystems
-    if !rootfs.skip_finalize {
+    if !rootfs.is_alongside {
         let bootfs = rootfs.rootfs.join("boot");
         for fs in [bootfs.as_path(), rootfs.rootfs.as_path()] {
             finalize_filesystem(fs)?;
@@ -1112,7 +1117,7 @@ pub(crate) async fn install_to_filesystem(opts: InstallToFilesystemOpts) -> Resu
         rootfs_uuid: inspect.uuid.clone(),
         boot,
         kargs,
-        skip_finalize: matches!(fsopts.replace, Some(ReplaceMode::Alongside)),
+        is_alongside: matches!(fsopts.replace, Some(ReplaceMode::Alongside)),
     };
 
     install_to_filesystem_impl(&state, &mut rootfs).await?;

lib/src/install/baseline.rs

@@ -387,6 +387,6 @@ pub(crate) fn install_create_rootfs(
         rootfs_uuid: Some(root_uuid.to_string()),
         boot: Some(boot),
         kargs,
-        skip_finalize: false,
+        is_alongside: false,
     })
 }