chore: hide grub and bios, systemd-boot behind feature flags

Author: p5

Cargo.toml

@@ -19,6 +19,11 @@ tier = "2"
 name = "bootupd"
 path = "src/main.rs"
 
+[features]
+default = ["systemd-boot"]
+grub = []
+systemd-boot = []
+
 [dependencies]
 anyhow = "1.0"
 bincode = "1.3.2"

src/blockdev.rs

@@ -69,6 +69,7 @@ pub fn find_colocated_esps(devices: &Vec<String>) -> Result<Option<Vec<String>>>
 }
 
 /// Find bios_boot partition on the same device
+#[cfg(feature = "grub")]
 pub fn get_bios_boot_partition(device: &str) -> Result<Option<String>> {
     const BIOS_BOOT_TYPE_GUID: &str = "21686148-6449-6E6F-744E-656564454649";
     let device_info = bootc_internal_blockdev::partitions_of(Utf8Path::new(device))?;
@@ -83,6 +84,7 @@ pub fn get_bios_boot_partition(device: &str) -> Result<Option<String>> {
 }
 
 /// Find all bios_boot partitions on the devices
+#[cfg(feature = "grub")]
 pub fn find_colocated_bios_boot(devices: &Vec<String>) -> Result<Option<Vec<String>>> {
     // look for all bios_boot parts on those devices
     let mut bios_boots = Vec::new();

src/bootupd.rs

@@ -1,45 +1,65 @@
-#[cfg(any(target_arch = "x86_64", target_arch = "powerpc64"))]
+#[cfg(all(
+    any(target_arch = "x86_64", target_arch = "powerpc64"),
+    feature = "grub"
+))]
 use crate::bios;
 use crate::component;
-use crate::component::{Component, ValidationResult};
+use crate::component::Component;
+#[cfg(feature = "grub")]
+use crate::component::ValidationResult;
 use crate::coreos;
 #[cfg(any(
     target_arch = "x86_64",
     target_arch = "aarch64",
     target_arch = "riscv64"
 ))]
 use crate::efi;
+
+#[cfg(feature = "grub")]
 use crate::freezethaw::fsfreeze_thaw_cycle;
 use crate::model::{ComponentStatus, ComponentUpdatable, ContentMetadata, SavedState, Status};
-use crate::{ostreeutil, util};
+#[cfg(feature = "grub")]
+use crate::ostreeutil;
+use crate::util;
 use anyhow::{anyhow, bail, Context, Result};
 use camino::{Utf8Path, Utf8PathBuf};
+#[cfg(feature = "grub")]
 use clap::crate_version;
+#[cfg(feature = "grub")]
 use fn_error_context::context;
+#[cfg(feature = "grub")]
 use libc::mode_t;
+#[cfg(feature = "grub")]
 use libc::{S_IRGRP, S_IROTH, S_IRUSR, S_IWUSR};
 use serde::{Deserialize, Serialize};
 use std::borrow::Cow;
 use std::collections::BTreeMap;
+
+#[cfg(feature = "grub")]
 use std::fs::{self, File};
-use std::io::{BufRead, BufReader, BufWriter, Write};
-use std::path::{Path, PathBuf};
+#[cfg(feature = "grub")]
+use std::io::{BufRead, BufWriter, Write};
+
+#[cfg(feature = "grub")]
+use std::io::BufReader;
+use std::path::Path;
+#[cfg(feature = "grub")]
+use std::path::PathBuf;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum ConfigMode {
     None,
     Static,
     WithUUID,
-    SystemdBoot,
 }
 
+#[cfg(feature = "grub")]
 impl ConfigMode {
     pub(crate) fn enabled_with_uuid(&self) -> Option<bool> {
         match self {
             ConfigMode::None => None,
             ConfigMode::Static => Some(false),
             ConfigMode::WithUUID => Some(true),
-            ConfigMode::SystemdBoot => Some(false),
         }
     }
 }
@@ -48,7 +68,8 @@ pub(crate) fn install(
     source_root: &str,
     dest_root: &str,
     device: Option<&str>,
-    configs: ConfigMode,
+    #[cfg(feature = "grub")] configs: ConfigMode,
+    #[cfg(not(feature = "grub"))] _configs: ConfigMode,
     update_firmware: bool,
     target_components: Option<&[String]>,
     auto_components: bool,
@@ -85,6 +106,7 @@ pub(crate) fn install(
     }
 
     let mut state = SavedState::default();
+    #[cfg(feature = "grub")]
     let mut installed_efi_vendor = None;
     for &component in target_components.iter() {
         // skip for BIOS if device is empty
@@ -101,18 +123,18 @@ pub(crate) fn install(
             .with_context(|| format!("installing component {}", component.name()))?;
         log::info!("Installed {} {}", component.name(), meta.meta.version);
         state.installed.insert(component.name().into(), meta);
-        // If not systemd-boot, try to get the efi vendor
-        if configs != ConfigMode::SystemdBoot {
-            // Yes this is a hack...the Component thing just turns out to be too generic.
-            if let Some(vendor) = component.get_efi_vendor(&source_root)? {
-                assert!(installed_efi_vendor.is_none());
-                installed_efi_vendor = Some(vendor);
-            }
+
+        // Yes this is a hack...the Component thing just turns out to be too generic.
+        #[cfg(feature = "grub")]
+        if let Some(vendor) = component.get_efi_vendor(&source_root)? {
+            assert!(installed_efi_vendor.is_none());
+            installed_efi_vendor = Some(vendor);
         }
     }
 
     let sysroot = &openat::Dir::open(dest_root)?;
 
+    #[cfg(feature = "grub")]
     match configs.enabled_with_uuid() {
         Some(uuid) => {
             let meta = get_static_config_meta()?;
@@ -129,7 +151,8 @@ pub(crate) fn install(
         None => {}
     }
 
-    if configs == ConfigMode::SystemdBoot {
+    #[cfg(feature = "systemd-boot")]
+    {
         let efi = crate::efi::Efi::default();
         log::warn!("Installing systemd-boot entries");
         if let Ok(Some(mnt)) = efi.get_mounted_esp(Path::new(dest_root)) {
@@ -153,6 +176,7 @@ pub(crate) fn install(
 }
 
 #[context("Get static config metadata")]
+#[cfg(feature = "grub")]
 fn get_static_config_meta() -> Result<ContentMetadata> {
     let self_bin_meta = std::fs::metadata("/proc/self/exe").context("Querying self meta")?;
     let self_meta = ContentMetadata {
@@ -185,9 +209,11 @@ pub(crate) fn get_components_impl(auto: bool) -> Components {
             if is_efi_booted {
                 insert_component(&mut components, Box::new(efi::Efi::default()));
             } else {
+                #[cfg(feature = "grub")]
                 insert_component(&mut components, Box::new(bios::Bios::default()));
             }
         } else {
+            #[cfg(feature = "grub")]
             insert_component(&mut components, Box::new(bios::Bios::default()));
             insert_component(&mut components, Box::new(efi::Efi::default()));
         }
@@ -281,6 +307,7 @@ pub(crate) fn update(name: &str, rootcxt: &RootContext) -> Result<ComponentUpdat
 }
 
 /// daemon implementation of component adoption
+#[cfg(feature = "grub")]
 pub(crate) fn adopt_and_update(
     name: &str,
     rootcxt: &RootContext,
@@ -327,6 +354,7 @@ pub(crate) fn adopt_and_update(
 }
 
 /// daemon implementation of component validate
+#[cfg(feature = "grub")]
 pub(crate) fn validate(name: &str) -> Result<ValidationResult> {
     let state = SavedState::load_from_disk("/")?.unwrap_or_default();
     let component = component::new_from_name(name)?;
@@ -532,6 +560,8 @@ pub(crate) fn client_run_update() -> Result<()> {
         }
         updated = true;
     }
+
+    #[cfg(feature = "grub")]
     for (name, adoptable) in status.adoptable.iter() {
         if adoptable.confident {
             if let Some(r) = adopt_and_update(name, &rootcxt, false)? {
@@ -548,6 +578,7 @@ pub(crate) fn client_run_update() -> Result<()> {
     Ok(())
 }
 
+#[cfg(feature = "grub")]
 pub(crate) fn client_run_adopt_and_update(with_static_config: bool) -> Result<()> {
     let rootcxt = prep_before_update()?;
     let status: Status = status()?;
@@ -563,6 +594,7 @@ pub(crate) fn client_run_adopt_and_update(with_static_config: bool) -> Result<()
     Ok(())
 }
 
+#[cfg(feature = "grub")]
 pub(crate) fn client_run_validate() -> Result<()> {
     let status: Status = status()?;
     if status.components.is_empty() {
@@ -593,6 +625,7 @@ pub(crate) fn client_run_validate() -> Result<()> {
 }
 
 #[context("Migrating to a static GRUB config")]
+#[cfg(feature = "grub")]
 pub(crate) fn client_run_migrate_static_grub_config() -> Result<()> {
     // Did we already complete the migration?
     // We need to migrate if bootloader is not none (or not set)
@@ -679,6 +712,7 @@ pub(crate) fn client_run_migrate_static_grub_config() -> Result<()> {
 
 /// Writes a stripped GRUB config to `stripped_config_name`, removing lines between
 /// `### BEGIN /etc/grub.d/15_ostree ###` and `### END /etc/grub.d/15_ostree ###`.
+#[cfg(feature = "grub")]
 fn strip_grub_config_file(
     current_config_content: impl BufRead,
     dirfd: &openat::Dir,
@@ -739,6 +773,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg(feature = "grub")]
     fn test_strip_grub_config_file() -> Result<()> {
         let root: &tempfile::TempDir = &tempfile::tempdir()?;
         let root_path = root.path();

src/cli/bootupctl.rs

@@ -55,10 +55,13 @@ pub enum CtlVerb {
     Status(StatusOpts),
     #[clap(name = "update", about = "Update all components")]
     Update,
+    #[cfg(feature = "grub")]
     #[clap(name = "adopt-and-update", about = "Update all adoptable components")]
     AdoptAndUpdate(AdoptAndUpdateOpts),
+    #[cfg(feature = "grub")]
     #[clap(name = "validate", about = "Validate system state")]
     Validate,
+    #[cfg(feature = "grub")]
     #[clap(
         name = "migrate-static-grub-config",
         hide = true,
@@ -89,6 +92,7 @@ pub struct StatusOpts {
 }
 
 #[derive(Debug, Parser)]
+#[cfg(feature = "grub")]
 pub struct AdoptAndUpdateOpts {
     /// Install the static GRUB config files
     #[clap(long, action)]
@@ -101,14 +105,17 @@ impl CtlCommand {
         match self.cmd {
             CtlVerb::Status(opts) => Self::run_status(opts),
             CtlVerb::Update => Self::run_update(),
+            #[cfg(feature = "grub")]
             CtlVerb::AdoptAndUpdate(opts) => Self::run_adopt_and_update(opts),
+            #[cfg(feature = "grub")]
             CtlVerb::Validate => Self::run_validate(),
             CtlVerb::Backend(CtlBackend::Generate(opts)) => {
                 super::bootupd::DCommand::run_generate_meta(opts)
             }
             CtlVerb::Backend(CtlBackend::Install(opts)) => {
                 super::bootupd::DCommand::run_install(opts)
             }
+            #[cfg(feature = "grub")]
             CtlVerb::MigrateStaticGrubConfig => Self::run_migrate_static_grub_config(),
         }
     }
@@ -140,18 +147,21 @@ impl CtlCommand {
     }
 
     /// Runner for `update` verb.
+    #[cfg(feature = "grub")]
     fn run_adopt_and_update(opts: AdoptAndUpdateOpts) -> Result<()> {
         ensure_running_in_systemd()?;
         bootupd::client_run_adopt_and_update(opts.with_static_config)
     }
 
     /// Runner for `validate` verb.
+    #[cfg(feature = "grub")]
     fn run_validate() -> Result<()> {
         ensure_running_in_systemd()?;
         bootupd::client_run_validate()
     }
 
     /// Runner for `migrate-static-grub-config` verb.
+    #[cfg(feature = "grub")]
     fn run_migrate_static_grub_config() -> Result<()> {
         ensure_running_in_systemd()?;
         bootupd::client_run_migrate_static_grub_config()

src/cli/bootupd.rs

@@ -73,10 +73,6 @@ pub struct InstallOpts {
     /// then only enable installation to the ESP.
     #[clap(long)]
     auto: bool,
-
-    /// The bootloader to use
-    #[clap(long, default_value = "systemd-boot")]
-    bootloader: Option<String>,
 }
 
 #[derive(Debug, Parser)]
@@ -107,18 +103,14 @@ impl DCommand {
 
     /// Runner for `install` verb.
     pub(crate) fn run_install(opts: InstallOpts) -> Result<()> {
-        let mut configmode = if opts.write_uuid {
+        let configmode = if opts.write_uuid {
             ConfigMode::WithUUID
         } else if opts.with_static_configs {
             ConfigMode::Static
         } else {
             ConfigMode::None
         };
 
-        if opts.bootloader.as_deref() == Some("systemd-boot") {
-            configmode = ConfigMode::SystemdBoot;
-        }
-
         bootupd::install(
             &opts.src_root,
             &opts.dest_root,

src/component.rs

@@ -29,12 +29,15 @@ pub(crate) trait Component {
     /// In an operating system whose initially booted disk image is not
     /// using bootupd, detect whether it looks like the component exists
     /// and "synthesize" content metadata from it.
+    #[cfg(feature = "grub")]
     fn query_adopt(&self, devices: &Option<Vec<String>>) -> Result<Option<Adoptable>>;
 
     // Backup the current grub config, and install static grub config from tree
+    #[cfg(feature = "grub")]
     fn migrate_static_grub_config(&self, sysroot_path: &str, destdir: &openat::Dir) -> Result<()>;
 
     /// Given an adoptable system and an update, perform the update.
+    #[cfg(feature = "grub")]
     fn adopt_update(
         &self,
         rootcxt: &RootContext,
@@ -75,9 +78,11 @@ pub(crate) trait Component {
     ) -> Result<InstalledContent>;
 
     /// Used on the client to validate an installed version.
+    #[cfg(feature = "grub")]
     fn validate(&self, current: &InstalledContent) -> Result<ValidationResult>;
 
     /// Locating efi vendor dir
+    #[cfg(feature = "grub")]
     fn get_efi_vendor(&self, sysroot: &openat::Dir) -> Result<Option<String>>;
 }
 
@@ -91,7 +96,10 @@ pub(crate) fn new_from_name(name: &str) -> Result<Box<dyn Component>> {
         ))]
         #[allow(clippy::box_default)]
         "EFI" => Box::new(crate::efi::Efi::default()),
-        #[cfg(any(target_arch = "x86_64", target_arch = "powerpc64"))]
+        #[cfg(all(
+            any(target_arch = "x86_64", target_arch = "powerpc64"),
+            feature = "grub"
+        ))]
         #[allow(clippy::box_default)]
         "BIOS" => Box::new(crate::bios::Bios::default()),
         _ => anyhow::bail!("No component {}", name),
@@ -117,6 +125,7 @@ pub(crate) fn component_updatedirname(component: &dyn Component) -> PathBuf {
     target_arch = "aarch64",
     target_arch = "riscv64"
 ))]
+#[cfg(feature = "grub")]
 pub(crate) fn component_updatedir(sysroot: &str, component: &dyn Component) -> PathBuf {
     Path::new(sysroot).join(component_updatedirname(component))
 }
@@ -194,9 +203,11 @@ pub(crate) fn query_adopt_state() -> Result<Option<Adoptable>> {
 
 #[cfg(test)]
 mod tests {
+    #[cfg(feature = "grub")]
     use super::*;
 
     #[test]
+    #[cfg(feature = "grub")]
     fn test_get_efi_vendor() -> Result<()> {
         let td = tempfile::tempdir()?;
         let tdp = td.path();