fix: remove kernel handling

Author: p5

src/bootupd.rs

@@ -12,7 +12,7 @@ use crate::efi;
 use crate::freezethaw::fsfreeze_thaw_cycle;
 use crate::model::{ComponentStatus, ComponentUpdatable, ContentMetadata, SavedState, Status};
 use crate::{ostreeutil, util};
-use anyhow::{anyhow, Context, Result};
+use anyhow::{anyhow, bail, Context, Result};
 use camino::{Utf8Path, Utf8PathBuf};
 use clap::crate_version;
 use fn_error_context::context;
@@ -25,10 +25,12 @@ use std::fs::{self, File};
 use std::io::{BufRead, BufReader, BufWriter, Write};
 use std::path::{Path, PathBuf};
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum ConfigMode {
     None,
     Static,
     WithUUID,
+    SystemdBoot,
 }
 
 impl ConfigMode {
@@ -37,6 +39,7 @@ impl ConfigMode {
             ConfigMode::None => None,
             ConfigMode::Static => Some(false),
             ConfigMode::WithUUID => Some(true),
+            ConfigMode::SystemdBoot => Some(false),
         }
     }
 }
@@ -96,14 +99,18 @@ pub(crate) fn install(
         let meta = component
             .install(&source_root, dest_root, device, update_firmware)
             .with_context(|| format!("installing component {}", component.name()))?;
-        log::warn!("Installed {} {}", component.name(), meta.meta.version);
+        log::info!("Installed {} {}", component.name(), meta.meta.version);
         state.installed.insert(component.name().into(), meta);
-        // 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);
+        // 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);
+            }
         }
     }
+
     let sysroot = &openat::Dir::open(dest_root)?;
 
     match configs.enabled_with_uuid() {
@@ -122,6 +129,17 @@ pub(crate) fn install(
         None => {}
     }
 
+    if configs == ConfigMode::SystemdBoot {
+        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)) {
+            let esp_dir = openat::Dir::open(&mnt).context("Opening mounted ESP")?;
+            crate::systemd_boot_configs::install(&esp_dir, false)?;
+        } else {
+            bail!("ESP not mounted, cannot install systemd-boot entries");
+        }
+    }
+
     // Unmount the ESP, etc.
     drop(target_components);
 
@@ -303,7 +321,7 @@ pub(crate) fn adopt_and_update(
         return Ok(Some(update));
     } else {
         // Nothing adopted, skip
-        log::warn!("Component '{}' skipped adoption", component.name());
+        log::info!("Component '{}' skipped adoption", component.name());
         return Ok(None);
     }
 }

src/cli/bootupd.rs

@@ -73,6 +73,10 @@ 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)]
@@ -103,13 +107,18 @@ impl DCommand {
 
     /// Runner for `install` verb.
     pub(crate) fn run_install(opts: InstallOpts) -> Result<()> {
-        let configmode = if opts.write_uuid {
+        let mut 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/efi.rs

@@ -16,13 +16,10 @@ use cap_std::fs::Dir;
 use cap_std_ext::cap_std;
 use chrono::prelude::*;
 use fn_error_context::context;
-use log::{info, warn};
 use openat_ext::OpenatDirExt;
 use os_release::OsRelease;
-use std::io::Write;
 use rustix::fd::BorrowedFd;
 use walkdir::WalkDir;
-use widestring::U16CString;
 
 use crate::bootupd::RootContext;
 use crate::freezethaw::fsfreeze_thaw_cycle;
@@ -151,35 +148,6 @@ impl Efi {
         clear_efi_target(&product_name)?;
         create_efi_boot_entry(device, espdir, vendordir, &product_name)
     }
-
-    /// Find a kernel and optional initramfs/uki file in the update directory for systemd-boot
-    fn find_kernel_and_initrd(dir: &openat::Dir) -> Result<(String, Option<String>)> {
-        let mut kernel: Option<String> = None;
-        let mut initrd: Option<String> = None;
-        log::warn!("Searching for kernel and initrd in update dir: {:?}", dir.recover_path());
-        for entry in dir.list_dir(".")? {
-            log::warn!("Found entry: {:?}", entry);
-            let entry = entry?;
-            let fname = entry.file_name().to_string_lossy();
-            if fname.starts_with("vmlinuz") || fname.ends_with(".efi") || fname.ends_with(".uki") {
-                log::warn!("Found kernel/UKI file: {}", fname);
-                if kernel.is_some() {
-                    log::warn!("Multiple kernel/UKI files found in update dir");
-                    bail!("Multiple kernel/UKI files found in update dir");
-                }
-                kernel = Some(fname.to_string());
-            } else if fname.starts_with("initrd") || fname.ends_with(".img") || fname.ends_with(".cpio.gz") {
-                log::warn!("Found initramfs file: {}", fname);
-                if initrd.is_some() {
-                    log::warn!("Multiple initramfs files found in update dir");
-                    bail!("Multiple initramfs files found in update dir");
-                }
-                initrd = Some(fname.to_string());
-            }
-        }
-        let kernel = kernel.ok_or_else(|| anyhow::anyhow!("No kernel or UKI file found in update dir"))?;
-        Ok((kernel, initrd))
-    }
 }
 
 #[context("Get product name")]
@@ -207,11 +175,6 @@ impl Component for Efi {
             return Ok(None);
         };
 
-        // // Don't adopt if the system is booted with systemd-boot or
-        // // systemd-stub since those will be managed with bootctl.
-        // if skip_systemd_bootloaders() {
-        //     return Ok(None);
-        // }
         crate::component::query_adopt_state()
     }
 
@@ -306,11 +269,10 @@ impl Component for Efi {
         device: &str,
         update_firmware: bool,
     ) -> Result<InstalledContent> {
-        log::warn!("Installing component: {}", self.name());
         let Some(meta) = get_component_update(src_root, self)? else {
             anyhow::bail!("No update metadata for component {} found", self.name());
         };
-        log::warn!("Found metadata {}", meta.version);
+        log::debug!("Found metadata {}", meta.version);
         let srcdir_name = component_updatedirname(self);
         let ft = crate::filetree::FileTree::new_from_dir(&src_root.sub_dir(&srcdir_name)?)?;
 
@@ -329,15 +291,10 @@ impl Component for Efi {
             self.mount_esp_device(Path::new(dest_root), Path::new(&esp_device))?
         };
 
-        let destpath_clone = destpath.clone();
-
         let destd = &openat::Dir::open(&destpath)
             .with_context(|| format!("opening dest dir {}", destpath.display()))?;
         validate_esp_fstype(destd)?;
 
-        // let using_systemd_boot = skip_systemd_bootloaders();
-        let using_systemd_boot = true;
-
         // TODO - add some sort of API that allows directly setting the working
         // directory to a file descriptor.
         std::process::Command::new("cp")
@@ -347,71 +304,7 @@ impl Component for Efi {
             .current_dir(format!("/proc/self/fd/{}", src_root.as_raw_fd()))
             .run()?;
 
-        // Configure systemd-boot loader config/entry
-        if using_systemd_boot {
-            let loader_dir = destpath.join("loader");
-            if !loader_dir.exists() {
-                log::warn!("Creating systemd-boot loader directory at {}", loader_dir.display());
-                std::fs::create_dir_all(&loader_dir)
-                    .with_context(|| format!("creating systemd-boot loader directory {}", loader_dir.display()))?;
-            }
-            let entries_dir = loader_dir.join("entries");
-            log::warn!("Using systemd-boot, creating entries dir at {}", entries_dir.display());
-            std::fs::create_dir_all(&entries_dir)
-                .with_context(|| format!("creating entries dir {}", entries_dir.display()))?;
-            log::warn!("Installing systemd-boot entry in {}/bootupd.conf", entries_dir.display());
-            // Write loader.conf if it doesn't exist
-            let loader_conf_path = loader_dir.join("loader.conf");
-            if !loader_conf_path.exists() {
-                let mut loader_conf = std::fs::File::create(&loader_conf_path)
-                    .with_context(|| format!("creating loader.conf at {}", loader_conf_path.display()))?;
-                writeln!(loader_conf, "default auto")?;
-                writeln!(loader_conf, "timeout 20")?;
-                writeln!(loader_conf, "editor no")?;
-            }
-            log::warn!("Installed: {}/bootupd.conf", entries_dir.display());
-
-            // let sysroot = Dir::open_ambient_dir("/", cap_std::ambient_authority())?;
-            // let product_name = get_product_name(&sysroot).unwrap_or("Unknown Product".to_string());
-            // log::warn!("Get product name: '{product_name}'");
-
-            // Find the kernel/UKI and optional initramfs in the update dir
-            log::warn!(
-                "Searching for kernel and initrd in update dir: {:?}",
-                crate::model::BOOTUPD_UPDATES_DIR
-            );
-            let update_dir = src_root.sub_dir(&srcdir_name)
-                .context("opening update dir")?;
-            log::debug!("Searching for kernel and initrd in update dir: {:?}", update_dir.recover_path());
-            let (kernel_file, initrd_file) = Self::find_kernel_and_initrd(&update_dir)?;
-
-            log::warn!(
-                "Installing systemd-boot entry for kernel: {}, initrd: {:?}",
-                kernel_file, initrd_file
-            );
-            crate::systemd_boot_configs::install(
-                &destd,
-                true,
-                "Unknown Product",
-                &kernel_file,
-                initrd_file.as_deref(),
-            ).context("installing systemd-boot entry")?;
-        }
-
-        // If using systemd-boot, run `bootctl install` to set up the bootloader.
-        if using_systemd_boot {
-            log::warn!("Using systemd-boot, running bootctl install");
-            let status = std::process::Command::new("bootctl")
-                .args(["install", "--esp-path", destpath_clone.to_str().unwrap()])
-                .status()
-                .context("running bootctl install")?;
-            log::warn!("bootctl install status: {}", status);
-            if !status.success() {
-                bail!("bootctl install failed with status: {}", status);
-            }
-        }
-
-        if update_firmware && !using_systemd_boot {
+        if update_firmware {
             if let Some(vendordir) = self.get_efi_vendor(&src_root)? {
                 self.update_firmware(device, destd, &vendordir)?
             }
@@ -750,12 +643,9 @@ fn get_efi_component_from_usr<'a>(
         .filter_map(|entry| {
             let entry = entry.ok()?;
             if !entry.file_type().is_dir() || entry.file_name() != "EFI" {
-                info!("Skipping non-directory or non-EFI entry: {}", entry.path().display());
                 return None;
             }
 
-            info!("Found EFI component at {}", entry.path().display());
-
             let abs_path = entry.path();
             let rel_path = abs_path.strip_prefix(sysroot).ok()?;
             let utf8_rel_path = Utf8PathBuf::from_path_buf(rel_path.to_path_buf()).ok()?;