Fix builds for powerpc and s390x

Only allow Grub as the bootloader for powerpc and s390x

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

Author: Johan-Liebert1

src/backend/statefile.rs

@@ -2,7 +2,6 @@
 
 use crate::bootloader::Bootloader;
 use crate::bootupd::list_dev_current_root;
-use crate::efi::Efi;
 use crate::freezethaw::fsfreeze_thaw_cycle;
 use crate::model::SavedState;
 use crate::util::SignalTerminationGuard;
@@ -133,7 +132,24 @@ impl SavedState {
                     }
                 }
 
+                #[cfg(any(target_arch = "powerpc64", target_arch = "s390x"))]
                 Bootloader::GrubCC => {
+                    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"
+                ))]
+                Bootloader::GrubCC => {
+                    use crate::efi::Efi;
                     let efi = Efi::default();
 
                     let device = get_parent_device(&root)?;
@@ -202,27 +218,54 @@ pub(crate) struct StateLockGuard {
 }
 
 impl StateLockGuard {
-    /// Atomically replace the on-disk state with a new version.
+    fn write_grub_statefile(&self, state: &SavedState) -> Result<()> {
+        let subdir = self.sysroot.open_dir(SavedState::STATEFILE_DIR)?;
+
+        subdir
+            .atomic_write_with_perms(
+                SavedState::STATEFILE_NAME,
+                serde_json::to_vec(state).context("Serializing state")?,
+                Permissions::from_mode(0o644),
+            )
+            .context("Writing state file")?;
+
+        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<()> {
-        if bootloader == Bootloader::Grub {
-            let subdir = self.sysroot.open_dir(SavedState::STATEFILE_DIR)?;
+        let arch = if cfg!(target_arch = "powerpc64") {
+            "powerpc64"
+        } else {
+            "s390x"
+        };
 
-            subdir
-                .atomic_write_with_perms(
-                    SavedState::STATEFILE_NAME,
-                    serde_json::to_vec(state).context("Serializing state")?,
-                    Permissions::from_mode(0o644),
-                )
-                .context("Writing state file")?;
+        if bootloader != Bootloader::Grub {
+            anyhow::anyhow!("Found bootloader: {bootloader}. Only Grub is supported for {arch}");
+        }
 
-            return Ok(());
+        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<()> {
+        if bootloader == Bootloader::Grub {
+            return self.write_grub_statefile(state);
         }
 
+        use crate::efi::Efi;
+
         let device = get_parent_device(&self.sysroot)?;
         let all_esps = device
             .find_colocated_esps()

src/bootloader.rs

@@ -2,8 +2,6 @@ use anyhow::Result;
 use fn_error_context::context;
 use std::{fmt::Display, sync::OnceLock};
 
-use crate::efi::get_loader_info;
-
 #[derive(Debug, Default, Copy, Clone, clap::ValueEnum, PartialEq, Eq)]
 pub enum Bootloader {
     #[default]
@@ -48,8 +46,17 @@ impl Bootloader {
     }
 }
 
+#[cfg(any(target_arch = "powerpc64", target_arch = "s390x"))]
+#[context("Getting bootloader")]
+pub(crate) fn get_bootloader() -> Result<Bootloader> {
+    Ok(Bootloader::Grub)
+}
+
+#[cfg(not(any(target_arch = "powerpc64", target_arch = "s390x")))]
 #[context("Getting bootloader")]
 pub(crate) fn get_bootloader() -> Result<Bootloader> {
+    use crate::efi::get_loader_info;
+
     static BOOTLOADER: OnceLock<Bootloader> = OnceLock::new();
 
     if let Some(bootloader) = BOOTLOADER.get() {

src/cli/bootupd.rs

@@ -119,6 +119,12 @@ impl DCommand {
 
     /// Runner for `install` verb.
     pub(crate) fn run_install(opts: InstallOpts) -> Result<()> {
+        if opts.bootloader != Bootloader::Grub
+            && 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 {