Introduce #[cfg(efi_arch)]

A utility cfg macro defined in build.rs so that we can deny EFI only
bootloaders - GrubCC and SystemdBoot, on non-EFI systems at compile time

Also, only allow setting default bootloaders for EFI systems

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

Author: Johan-Liebert1

build.rs

@@ -0,0 +1,11 @@
+fn main() {
+    println!("cargo::rustc-check-cfg=cfg(efi_arch)");
+
+    if cfg!(any(
+        target_arch = "x86_64",
+        target_arch = "aarch64",
+        target_arch = "riscv64"
+    )) {
+        println!("cargo:rustc-cfg=efi_arch");
+    }
+}

src/backend/statefile.rs

@@ -2,7 +2,7 @@
 
 use crate::bootloader::Bootloader;
 use crate::bootupd::list_dev_current_root;
-use crate::freezethaw::fsfreeze_thaw_cycle;
+
 use crate::model::SavedState;
 use crate::util::SignalTerminationGuard;
 use anyhow::{bail, Context, Result};
@@ -134,22 +134,7 @@ impl SavedState {
                     }
                 }
 
-                #[cfg(any(target_arch = "powerpc64", target_arch = "s390x"))]
-                Bootloader::GrubCC | Bootloader::SystemdBoot => {
-                    let arch = if cfg!(target_arch = "powerpc64") {
-                        "powerpc64"
-                    } else {
-                        "s390x"
-                    };
-
-                    anyhow::bail!("Only Grub is supported for {arch}");
-                }
-
-                #[cfg(any(
-                    target_arch = "x86_64",
-                    target_arch = "aarch64",
-                    target_arch = "riscv64"
-                ))]
+                #[cfg(efi_arch)]
                 Bootloader::GrubCC | Bootloader::SystemdBoot => {
                     use crate::efi::Efi;
                     let efi = Efi::default();
@@ -201,6 +186,7 @@ impl SavedState {
                 bail!("{} already exists", statepath.display());
             }
 
+            #[cfg(efi_arch)]
             Bootloader::GrubCC | Bootloader::SystemdBoot => {
                 bail!("{} already exists in the ESP", Self::STATEFILE_NAME);
             }
@@ -211,6 +197,7 @@ impl SavedState {
 /// Write-lock guard for statefile, protecting against concurrent state updates.
 #[derive(Debug)]
 pub(crate) struct StateLockGuard {
+    #[allow(dead_code)]
     pub(crate) sysroot_path: Utf8PathBuf,
     pub(crate) sysroot: Dir,
     #[allow(dead_code)]
@@ -234,39 +221,22 @@ impl StateLockGuard {
         return Ok(());
     }
 
-    #[cfg(any(target_arch = "powerpc64", target_arch = "s390x"))]
-    #[context("Updating state")]
-    pub(crate) fn update_state(
-        &mut self,
-        state: &SavedState,
-        bootloader: Bootloader,
-    ) -> Result<()> {
-        let arch = if cfg!(target_arch = "powerpc64") {
-            "powerpc64"
-        } else {
-            "s390x"
-        };
-
-        if bootloader != Bootloader::Grub {
-            anyhow::bail!("Found bootloader: {bootloader}. Only Grub is supported for {arch}");
-        }
-
-        self.write_grub_statefile(state)
-    }
-
     /// Atomically replace the on-disk state with a new version.
-    #[cfg(not(any(target_arch = "powerpc64", target_arch = "s390x")))]
     #[context("Updating state")]
     pub(crate) fn update_state(
         &mut self,
         state: &SavedState,
         bootloader: Bootloader,
     ) -> Result<()> {
+        #[cfg(not(efi_arch))]
+        return self.write_grub_statefile(state);
+
         if bootloader == Bootloader::Grub {
             return self.write_grub_statefile(state);
         }
 
         use crate::efi::Efi;
+        use crate::freezethaw::fsfreeze_thaw_cycle;
 
         let device = get_parent_device(&self.sysroot)?;
         let all_esps = device

src/bootloader.rs

@@ -1,29 +1,34 @@
 use anyhow::Result;
 use fn_error_context::context;
 use serde::{Deserialize, Serialize};
-use std::{fmt::Display, sync::OnceLock};
+use std::fmt::Display;
 
 #[derive(
     Debug, Default, Copy, Clone, clap::ValueEnum, PartialEq, Eq, Hash, Serialize, Deserialize,
 )]
 pub enum Bootloader {
     #[default]
     Grub,
+    #[cfg(efi_arch)]
     GrubCC,
+    #[cfg(efi_arch)]
     SystemdBoot,
 }
 
 impl Display for Bootloader {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Bootloader::Grub => f.write_str("grub"),
+            #[cfg(efi_arch)]
             Bootloader::GrubCC => f.write_str("grub-cc"),
+            #[cfg(efi_arch)]
             Bootloader::SystemdBoot => f.write_str("systemd-boot"),
         }
     }
 }
 
 impl Bootloader {
+    #[cfg(efi_arch)]
     fn next(self) -> Option<Self> {
         match self {
             Self::Grub => Some(Self::GrubCC),
@@ -32,6 +37,13 @@ impl Bootloader {
         }
     }
 
+    #[cfg(not(efi_arch))]
+    fn next(self) -> Option<Self> {
+        match self {
+            Self::Grub => None,
+        }
+    }
+
     pub(crate) fn iter() -> impl Iterator<Item = Self> {
         std::iter::successors(Some(Self::Grub), |v| v.next())
     }
@@ -47,31 +59,37 @@ impl Bootloader {
     pub(crate) fn efi_component_name(&self) -> &'static str {
         match self {
             Bootloader::Grub => "grub2",
+            #[cfg(efi_arch)]
             Bootloader::GrubCC => "grub-cc",
+            #[cfg(efi_arch)]
             Bootloader::SystemdBoot => "systemd-boot",
         }
     }
 
+    #[cfg(efi_arch)]
     pub(crate) fn try_from_efi_component_name(component_name: &str) -> Result<Self> {
         match component_name {
             "grub2" => Ok(Self::Grub),
+            #[cfg(efi_arch)]
             "grub-cc" => Ok(Self::GrubCC),
+            #[cfg(efi_arch)]
             "systemd-boot" => Ok(Self::SystemdBoot),
             _ => anyhow::bail!("Not a valid bootloader: {component_name}"),
         }
     }
 }
 
-#[cfg(any(target_arch = "powerpc64", target_arch = "s390x"))]
+#[cfg(not(efi_arch))]
 #[context("Getting bootloader")]
 pub(crate) fn get_bootloader() -> Result<Bootloader> {
     Ok(Bootloader::Grub)
 }
 
-#[cfg(not(any(target_arch = "powerpc64", target_arch = "s390x")))]
+#[cfg(efi_arch)]
 #[context("Getting bootloader")]
 pub(crate) fn get_bootloader() -> Result<Bootloader> {
     use crate::efi::get_loader_info;
+    use std::sync::OnceLock;
 
     static BOOTLOADER: OnceLock<Bootloader> = OnceLock::new();
 

src/bootupd.rs

@@ -94,6 +94,7 @@ pub(crate) fn install(opts: &InstallOpts, devices: &[Device], configs: ConfigMod
         anyhow::bail!("No components specified");
     }
 
+    #[cfg(efi_arch)]
     let bootloader = match opts.bootloader {
         // CLI overrides anything else
         Some(b) => b,
@@ -151,6 +152,9 @@ pub(crate) fn install(opts: &InstallOpts, devices: &[Device], configs: ConfigMod
         }
     };
 
+    #[cfg(not(efi_arch))]
+    let bootloader = Bootloader::Grub;
+
     let mut state = SavedState::default();
     let mut installed_efi_vendor = None;
 
@@ -300,6 +304,8 @@ fn get_static_config_meta() -> Result<ContentMetadata> {
         timestamp: self_bin_meta.modified()?.into(),
         version: crate_version!().into(),
         versions: None,
+
+        #[cfg(efi_arch)]
         default_bootloader: None,
     };
     Ok(self_meta)

src/cli/bootupctl.rs

@@ -74,6 +74,7 @@ pub enum CtlBackend {
     #[clap(name = "install", hide = true)]
     Install(super::bootupd::InstallOpts),
     #[clap(hide = true)]
+    #[cfg(efi_arch)]
     SetDefaultBootloader(super::bootupd::DefaultBootloaderOpts),
 }
 
@@ -111,6 +112,7 @@ impl CtlCommand {
             CtlVerb::Backend(CtlBackend::Install(opts)) => {
                 super::bootupd::DCommand::run_install(opts)
             }
+            #[cfg(efi_arch)]
             CtlVerb::Backend(CtlBackend::SetDefaultBootloader(opts)) => {
                 super::bootupd::DCommand::set_default_bootloader(opts)
             }

src/cli/bootupd.rs

@@ -40,6 +40,7 @@ pub enum DVerb {
     GenerateUpdateMetadata(GenerateOpts),
     #[clap(name = "install", about = "Install components")]
     Install(InstallOpts),
+    #[cfg(efi_arch)]
     SetDefaultBootloader(DefaultBootloaderOpts),
 }
 
@@ -114,6 +115,7 @@ impl DCommand {
         match self.cmd {
             DVerb::Install(opts) => Self::run_install(opts),
             DVerb::GenerateUpdateMetadata(opts) => Self::run_generate_meta(opts),
+            #[cfg(efi_arch)]
             DVerb::SetDefaultBootloader(opts) => Self::set_default_bootloader(opts),
         }
     }
@@ -130,12 +132,6 @@ impl DCommand {
 
     /// Runner for `install` verb.
     pub(crate) fn run_install(opts: InstallOpts) -> Result<()> {
-        if !matches!(opts.bootloader, Some(Bootloader::Grub) | None)
-            && cfg!(any(target_arch = "powerpc64", target_arch = "s390x"))
-        {
-            anyhow::bail!("Only Grub is supported for powerpc64 and s390x");
-        }
-
         let configmode = if opts.write_uuid {
             ConfigMode::WithUUID
         } else if opts.with_static_configs {
@@ -162,6 +158,7 @@ impl DCommand {
         Ok(())
     }
 
+    #[cfg(efi_arch)]
     pub(crate) fn set_default_bootloader(opts: DefaultBootloaderOpts) -> Result<()> {
         let all_components = crate::bootupd::get_components();
         let target_components: Vec<_> = all_components.values().collect();

src/component.rs

@@ -14,6 +14,7 @@ use std::path::{Path, PathBuf};
 
 use bootc_internal_blockdev::Device;
 
+#[cfg(efi_arch)]
 use crate::cli::bootupd::DefaultBootloaderOpts;
 use crate::{bootloader::Bootloader, bootupd::RootContext, model::*};
 
@@ -141,6 +142,7 @@ pub(crate) trait Component {
         Path::new(&format!("{}.json", self.name())).into()
     }
 
+    #[cfg(efi_arch)]
     fn set_default_bootloader(&self, opts: &DefaultBootloaderOpts) -> Result<()> {
         if !self.is_bootloader_supported(opts.bootloader) {
             anyhow::bail!("{} not supported for {}", opts.bootloader, self.name());
@@ -167,6 +169,7 @@ pub(crate) trait Component {
         Ok(())
     }
 
+    #[cfg(efi_arch)]
     fn get_default_bootloader(&self, root: &Dir) -> Result<Option<Bootloader>> {
         let update_meta = self
             .get_component_update(&root, None)?
@@ -242,6 +245,7 @@ pub(crate) fn query_adopt_state() -> Result<Option<Adoptable>> {
             timestamp: coreos_aleph.ts,
             version: coreos_aleph.aleph.version,
             versions: None,
+            #[cfg(efi_arch)]
             default_bootloader: None,
         };
         log::trace!("Adoptable: {:?}", &meta);
@@ -260,6 +264,7 @@ pub(crate) fn query_adopt_state() -> Result<Option<Adoptable>> {
             timestamp,
             version: "unknown".to_string(),
             versions: None,
+            #[cfg(efi_arch)]
             default_bootloader: None,
         };
         return Ok(Some(Adoptable {
@@ -273,7 +278,6 @@ pub(crate) fn query_adopt_state() -> Result<Option<Adoptable>> {
 #[cfg(test)]
 mod tests {
     use cap_std::fs::{DirBuilder, DirBuilderExt, Permissions, PermissionsExt};
-    use chrono::Utc;
 
     use super::*;
 
@@ -353,7 +357,10 @@ mod tests {
     }
 
     #[test]
+    #[cfg(efi_arch)]
     fn test_set_default_bootloader() -> Result<()> {
+        use chrono::Utc;
+
         let td = tempfile::tempdir()?;
         let sysroot = td.path().to_str().unwrap().to_string();
         let tdir = Dir::open_ambient_dir(&sysroot, ambient_authority())?;

src/efi.rs

@@ -323,6 +323,10 @@ impl Component for Efi {
     }
 
     fn is_bootloader_supported(&self, bootloader: Bootloader) -> bool {
+        #[cfg(not(efi_arch))]
+        return matches!(bootloader, Bootloader::Grub);
+
+        #[cfg(efi_arch)]
         matches!(
             bootloader,
             Bootloader::Grub | Bootloader::GrubCC | Bootloader::SystemdBoot
@@ -883,6 +887,7 @@ fn generate_meta_from_usr_efi(sysroot_path: &Utf8Path) -> Result<ContentMetadata
         timestamp: get_metadata_timestamp()?,
         version: packages.join(","),
         versions: Some(modules_vec),
+        #[cfg(efi_arch)]
         default_bootloader: None,
     };
 
@@ -1117,6 +1122,7 @@ Boot0003* test";
     }
 
     #[test]
+    #[cfg(efi_arch)]
     fn test_get_efi_component_from_usr() -> Result<()> {
         let tmpdir: &tempfile::TempDir = &tempfile::tempdir()?;
         let tpath = tmpdir.path();