composefs/status: Read UKI entries to check for queued rollback

Parse the Grub menuentry file, `boot/grub2/user.cfg` to get a list of
bootable UKIs and figure out if a rollback is currently queued.

Signed-off-by: Johan-Liebert1 <[email protected]>

Author: Johan-Liebert1

crates/lib/src/deploy.rs

@@ -4,7 +4,7 @@
 
 use std::collections::HashSet;
 use std::fs::create_dir_all;
-use std::io::{BufRead, Write};
+use std::io::{BufRead, Read as _, Write};
 use std::path::PathBuf;
 
 use anyhow::Ok;
@@ -27,6 +27,7 @@ use rustix::fs::{fsync, renameat_with, AtFlags, RenameFlags};
 use crate::bls_config::{parse_bls_config, BLSConfig};
 #[allow(unused_imports)]
 use crate::install::{get_efi_uuid_source, get_user_config, BootType};
+use crate::parsers::grub_menuconfig::{parse_grub_menuentry_file, MenuEntry};
 use crate::progress_jsonl::{Event, ProgressWriter, SubTaskBytes, SubTaskStep};
 use crate::spec::ImageReference;
 use crate::spec::{BootEntry, BootOrder, HostSpec};
@@ -786,8 +787,15 @@ const CURRENT_ENTRIES: &str = "entries";
 const STAGED_ENTRIES: &str = "entries.staged";
 const ROLLBACK_ENTRIES: &str = STAGED_ENTRIES;
 
+// Need str to store lifetime
+pub(crate) fn get_sorted_uki_boot_entries<'a>(str: &'a mut String) -> Result<Vec<MenuEntry<'a>>> {
+    let mut file = std::fs::File::open("/sysroot/boot/grub2/user.cfg")?;
+    file.read_to_string(str)?;
+    parse_grub_menuentry_file(str)
+}
+
 #[context("Getting boot entries")]
-pub(crate) fn get_sorted_boot_entries(ascending: bool) -> Result<Vec<BLSConfig>> {
+pub(crate) fn get_sorted_bls_boot_entries(ascending: bool) -> Result<Vec<BLSConfig>> {
     let mut all_configs = vec![];
 
     for entry in std::fs::read_dir(format!("/sysroot/boot/loader/{CURRENT_ENTRIES}"))? {
@@ -822,7 +830,7 @@ pub(crate) fn rollback_composefs_bls() -> Result<()> {
     // After this:
     // all_configs[0] -> booted depl
     // all_configs[1] -> rollback depl
-    let mut all_configs = get_sorted_boot_entries(false)?;
+    let mut all_configs = get_sorted_bls_boot_entries(false)?;
 
     // Update the indicies so that they're swapped
     for (idx, cfg) in all_configs.iter_mut().enumerate() {

crates/lib/src/kernel_cmdline.rs

@@ -328,7 +328,7 @@ mod tests {
         // non-UTF8 things are in fact valid
         let non_utf8_byte = b"\xff";
         #[allow(invalid_from_utf8)]
-        let failed_conversion = str::from_utf8(non_utf8_byte);
+        let failed_conversion = std::str::from_utf8(non_utf8_byte);
         assert!(failed_conversion.is_err());
         let mut p = b"foo=".to_vec();
         p.push(non_utf8_byte[0]);

crates/lib/src/parsers/grub_menuconfig.rs

@@ -14,13 +14,13 @@ use nom::{
 #[derive(Debug, PartialEq, Eq)]
 pub(crate) struct MenuentryBody<'a> {
     /// Kernel modules to load
-    insmod: Vec<&'a str>,
+    pub(crate) insmod: Vec<&'a str>,
     /// Chainloader path (optional)
-    chainloader: Option<&'a str>,
+    pub(crate) chainloader: Option<&'a str>,
     /// Search command (optional)
-    search: Option<&'a str>,
+    pub(crate) search: Option<&'a str>,
     /// Additional commands
-    extra: Vec<(&'a str, &'a str)>,
+    pub(crate) extra: Vec<(&'a str, &'a str)>,
 }
 
 impl<'a> Display for MenuentryBody<'a> {

crates/lib/src/status.rs

@@ -24,7 +24,8 @@ use ostree_ext::ostree;
 use tokio::io::AsyncReadExt;
 
 use crate::cli::OutputFormat;
-use crate::deploy::get_sorted_boot_entries;
+use crate::deploy::get_sorted_bls_boot_entries;
+use crate::deploy::get_sorted_uki_boot_entries;
 use crate::install::BootType;
 use crate::install::ORIGIN_KEY_BOOT;
 use crate::install::ORIGIN_KEY_BOOT_TYPE;
@@ -438,6 +439,9 @@ pub(crate) async fn composefs_deployment_status() -> Result<Host> {
         Err(e) => Err(e),
     }?;
 
+    // NOTE: This cannot work if we support both BLS and UKI at the same time
+    let mut boot_type: Option<BootType> = None;
+
     for depl in deployments {
         let depl = depl?;
 
@@ -457,6 +461,21 @@ pub(crate) async fn composefs_deployment_status() -> Result<Host> {
         let boot_entry =
             boot_entry_from_composefs_deployment(ini, depl_file_name.to_string()).await?;
 
+        // SAFETY: boot_entry.composefs will always be present
+        let boot_type_from_origin = boot_entry.composefs.as_ref().unwrap().boot_type;
+
+        match boot_type {
+            Some(current_type) => {
+                if current_type != boot_type_from_origin {
+                    anyhow::bail!("Conflicting boot types")
+                }
+            }
+
+            None => {
+                boot_type = Some(boot_type_from_origin);
+            }
+        };
+
         if depl.file_name() == booted_image_verity {
             host.spec.image = boot_entry.image.as_ref().map(|x| x.image.clone());
             host.status.booted = Some(boot_entry);
@@ -473,11 +492,32 @@ pub(crate) async fn composefs_deployment_status() -> Result<Host> {
         host.status.rollback = Some(boot_entry);
     }
 
-    host.status.rollback_queued = !get_sorted_boot_entries(false)?
-        .first()
-        .ok_or(anyhow::anyhow!("First boot entry not found"))?
-        .options
-        .contains(composefs_arg.as_ref());
+    // Shouldn't really happen, but for sanity nonetheless
+    let Some(boot_type) = boot_type else {
+        anyhow::bail!("Could not determine boot type");
+    };
+
+    match boot_type {
+        BootType::Bls => {
+            host.status.rollback_queued = !get_sorted_bls_boot_entries(false)?
+                .first()
+                .ok_or(anyhow::anyhow!("First boot entry not found"))?
+                .options
+                .contains(composefs_arg.as_ref());
+        }
+
+        BootType::Uki => {
+            let mut s = String::new();
+
+            host.status.rollback_queued = !get_sorted_uki_boot_entries(&mut s)?
+                .first()
+                .ok_or(anyhow::anyhow!("First boot entry not found"))?
+                .body
+                .chainloader
+                .map(|v| v.contains(composefs_arg.as_ref()))
+                .unwrap_or_default()
+        }
+    };
 
     if host.status.rollback_queued {
         host.spec.boot_order = BootOrder::Rollback