//! Bootloader installation: UEFI + systemd-boot with BLS entries. //! //! UKI is deferred: the dracut UKI generator did not embed the kernel command //! line in the verified environment, producing an unbootable image. BLS //! entries carry `options` and are the proven path. use std::path::{Path, PathBuf}; use phoebus_core::system as sysgen; use phoebus_core::InstallConfig; use crate::command::CommandSpec; use crate::error::{ExecError, Result}; use crate::exec::Exec; use crate::portage; pub fn write_install_conf(exec: &Exec) -> Result<()> { exec.target() .write("etc/kernel/install.conf", sysgen::install_conf())?; exec.logger .info("wrote /etc/kernel/install.conf (layout=bls)"); Ok(()) } pub fn write_dracut_conf(exec: &Exec, config: &InstallConfig) -> Result<()> { exec.target().write( "etc/dracut.conf.d/10-phoebus.conf", sysgen::dracut_conf(config), )?; exec.logger.info("wrote /etc/dracut.conf.d/10-phoebus.conf"); Ok(()) } pub fn esp_path(exec: &Exec, config: &InstallConfig) -> std::path::PathBuf { exec.root.join(config.storage.efi_mount.trim_start_matches('/')) } pub fn install_systemd_boot(exec: &Exec, config: &InstallConfig) -> Result<()> { portage::chroot( exec, Path::new(&exec.root), "bootctl", &["--esp-path", &config.storage.efi_mount, "install"], ) } pub fn write_loader_conf(exec: &Exec, config: &InstallConfig) -> Result<()> { let dir = esp_path(exec, config).join("loader"); std::fs::create_dir_all(&dir).map_err(|e| ExecError::io(dir.clone(), e))?; let text = "# systemd-boot configuration\ndefault *\ntimeout 3\nconsole-mode keep\neditor no\n"; std::fs::write(dir.join("loader.conf"), text) .map_err(|e| ExecError::io(dir.join("loader.conf"), e))?; exec.logger .info(format!("wrote {}", dir.join("loader.conf").display())); Ok(()) } pub fn generate_entries(exec: &Exec) -> Result<()> { portage::chroot(exec, Path::new(&exec.root), "kernel-install", &["add-all"]) } pub fn install_fallback(exec: &Exec, config: &InstallConfig) -> Result<()> { let esp = esp_path(exec, config); let boot_dir = esp.join("EFI/BOOT"); let systemd_dir = esp.join("EFI/systemd"); std::fs::create_dir_all(&boot_dir).map_err(|e| ExecError::io(boot_dir.clone(), e))?; std::fs::create_dir_all(&systemd_dir).map_err(|e| ExecError::io(systemd_dir.clone(), e))?; let mut src = systemd_dir.join("systemd-bootx64.efi"); if !src.exists() { let vendor = exec.root.join("usr/lib/systemd/boot/efi/systemd-bootx64.efi"); if vendor.exists() { src = vendor; } else { exec.logger .warn("systemd-boot binary not found; EFI fallback not installed"); return Ok(()); } } let dst = boot_dir.join("BOOTX64.EFI"); std::fs::copy(&src, &dst).map_err(|e| ExecError::io(dst.clone(), e))?; exec.logger.info("installed EFI fallback bootloader"); Ok(()) } pub fn random_seed(exec: &Exec, config: &InstallConfig) -> Result<()> { let dir = esp_path(exec, config).join("loader"); std::fs::create_dir_all(&dir).map_err(|e| ExecError::io(dir.clone(), e))?; let path = dir.join("random-seed"); if !path.exists() { let bytes: Vec = (0..512).map(|i| (i as u8).wrapping_mul(31).wrapping_add(7)).collect(); std::fs::write(&path, bytes).map_err(|e| ExecError::io(path.clone(), e))?; } Ok(()) } /// Write an additional BLS entry that boots the newest kernel into /// `rescue.target`. This is a real recovery path: it unlocks LUKS and gives a /// root shell with the network stack available. pub fn write_recovery_entry(exec: &Exec, config: &InstallConfig) -> Result<()> { let entries = esp_path(exec, config).join("loader/entries"); if !entries.is_dir() { return Ok(()); } let mut newest: Option<(std::time::SystemTime, PathBuf)> = None; for entry in std::fs::read_dir(&entries).map_err(|e| ExecError::io(entries.clone(), e))? { let entry = entry.map_err(|e| ExecError::io(entries.clone(), e))?; let path = entry.path(); if path.extension().and_then(|e| e.to_str()) != Some("conf") { continue; } let name = entry.file_name().to_string_lossy().to_string(); if name.contains("recovery") { continue; } let modified = entry .metadata() .and_then(|m| m.modified()) .unwrap_or(std::time::SystemTime::UNIX_EPOCH); if newest.as_ref().map(|(t, _)| modified > *t).unwrap_or(true) { newest = Some((modified, path)); } } let Some((_, source)) = newest else { return Ok(()); }; let text = std::fs::read_to_string(&source).map_err(|e| ExecError::io(source.clone(), e))?; let mut linux = String::new(); let mut initrds: Vec = Vec::new(); let mut options = String::new(); for line in text.lines() { if let Some(v) = line.strip_prefix("linux") { linux = v.trim().to_string(); } else if let Some(v) = line.strip_prefix("initrd") { initrds.push(v.trim().to_string()); } else if let Some(v) = line.strip_prefix("options") { options = v.trim().to_string(); } } if linux.is_empty() { return Ok(()); } let mut out = String::new(); out.push_str("# Phoebus recovery entry (generated by the installer)\n"); out.push_str("title Phoebus Recovery\n"); out.push_str(&format!("linux {linux}\n")); for initrd in &initrds { out.push_str(&format!("initrd {initrd}\n")); } let recovery_options = format!("{options} systemd.unit=rescue.target"); out.push_str(&format!("options {}\n", recovery_options.trim())); let dest = entries.join("phoebus-recovery.conf"); std::fs::write(&dest, out).map_err(|e| ExecError::io(dest.clone(), e))?; exec.logger .info(format!("wrote recovery entry {}", dest.display())); Ok(()) } pub fn verify(exec: &Exec, config: &InstallConfig) -> Result<()> { let esp = esp_path(exec, config); let loader_a = esp.join("EFI/systemd/systemd-bootx64.efi"); let loader_b = esp.join("EFI/BOOT/BOOTX64.EFI"); if !loader_a.exists() && !loader_b.exists() { return Err(ExecError::operation( "boot_install", "verify", format!("no systemd-boot loader found in {}", esp.display()), )); } let loader_conf = esp.join("loader/loader.conf"); if !loader_conf.exists() { return Err(ExecError::operation( "boot_install", "verify", "loader.conf not found", )); } Ok(()) } #[cfg(test)] mod tests { use super::*; use crate::command::RecordingRunner; use crate::log::Logger; use phoebus_core::Redactor; fn make_exec(runner: RecordingRunner) -> Exec { let path = tempfile::tempdir().unwrap().keep(); let logger = Logger::open(path.join("l.log"), Redactor::new(), false); Exec::new(Box::new(runner), logger, false, path.join("root"), path) } #[test] fn recovery_entry_reuses_kernel_and_initrd() { let runner = RecordingRunner::new(); let exec = make_exec(runner); let cfg = InstallConfig::default(); let entries = exec.root.join("efi/loader/entries"); std::fs::create_dir_all(&entries).unwrap(); std::fs::write( entries.join("token-6.18.48.conf"), "title Gentoo Linux\nlinux /token/6.18.48/linux\ninitrd /token/6.18.48/initrd\noptions rd.luks.name=x=cryptroot root=/dev/mapper/cryptroot rw quiet\n", ) .unwrap(); write_recovery_entry(&exec, &cfg).unwrap(); let text = std::fs::read_to_string(entries.join("phoebus-recovery.conf")).unwrap(); assert!(text.contains("Phoebus Recovery")); assert!(text.contains("/token/6.18.48/linux")); assert!(text.contains("/token/6.18.48/initrd")); assert!(text.contains("systemd.unit=rescue.target")); } } pub fn secureboot_status(exec: &Exec) -> String { if !std::path::Path::new("/sys/firmware/efi/efivars").is_dir() { return "not booted in UEFI mode".into(); } if crate::exec::find_in_path("mokutil").is_none() { return "Secure Boot state unknown (mokutil not installed)".into(); } match exec.runner.execute(&CommandSpec::new("boot", "secureboot status", "mokutil").arg("--sb-state")) { Ok(out) => out.stdout_lossy().trim().to_string(), Err(_) => "unknown".into(), } }