composefs/uki: Use custom prefix for UKI name

Similar to how we do with BLS binaries, we now add our custom prefix to
UKI and UKI Addons. This is useful for us to find our EFI binaries in
the ESP

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

Author: Johan-Liebert1

crates/lib/src/bootc_composefs/boot.rs

@@ -91,7 +91,6 @@ use rustix::{mount::MountFlags, path::Arg};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
-use crate::parsers::bls_config::{BLSConfig, BLSConfigType};
 use crate::task::Task;
 use crate::{
     bootc_composefs::repo::get_imgref,
@@ -109,6 +108,10 @@ use crate::{
     bootc_composefs::status::get_container_manifest_and_config, bootc_kargs::compute_new_kargs,
 };
 use crate::{bootc_composefs::status::get_sorted_grub_uki_boot_entries, install::PostFetchState};
+use crate::{
+    composefs_consts::UKI_NAME_PREFIX,
+    parsers::bls_config::{BLSConfig, BLSConfigType},
+};
 use crate::{
     composefs_consts::{
         BOOT_LOADER_ENTRIES, COMPOSEFS_CMDLINE, ORIGIN_KEY_BOOT, ORIGIN_KEY_BOOT_DIGEST,
@@ -274,10 +277,26 @@ pub(crate) fn secondary_sort_key(os_id: &str) -> String {
 }
 
 /// Returns the name of the directory where we store Type1 boot entries
-pub(crate) fn get_type1_dir_name(depl_verity: &String) -> String {
+pub(crate) fn get_type1_dir_name(depl_verity: &str) -> String {
     format!("{TYPE1_BOOT_DIR_PREFIX}{depl_verity}")
 }
 
+/// Returns the name of a UKI given verity digest
+pub(crate) fn get_uki_name(depl_verity: &str) -> String {
+    format!("{UKI_NAME_PREFIX}{depl_verity}{EFI_EXT}")
+}
+
+/// Returns the name of a UKI Addon directory given verity digest
+pub(crate) fn get_uki_addon_dir_name(depl_verity: &str) -> String {
+    format!("{UKI_NAME_PREFIX}{depl_verity}{EFI_ADDON_DIR_EXT}")
+}
+
+#[allow(dead_code)]
+/// Returns the name of a UKI Addon given verity digest
+pub(crate) fn get_uki_addon_file_name(depl_verity: &str) -> String {
+    format!("{UKI_NAME_PREFIX}{depl_verity}{EFI_ADDON_FILE_EXT}")
+}
+
 /// Compute SHA256Sum of VMlinuz + Initrd
 ///
 /// # Arguments
@@ -873,7 +892,7 @@ fn write_pe_to_esp(
         Some(parent) => {
             let renamed_path = match parent.as_str().ends_with(EFI_ADDON_DIR_EXT) {
                 true => {
-                    let dir_name = format!("{}{}", uki_id.to_hex(), EFI_ADDON_DIR_EXT);
+                    let dir_name = get_uki_addon_dir_name(&uki_id.to_hex());
 
                     parent
                         .parent()
@@ -897,7 +916,7 @@ fn write_pe_to_esp(
         .with_context(|| format!("Opening {final_pe_path:?}"))?;
 
     let pe_name = match pe_type {
-        PEType::Uki => &format!("{}{}", uki_id.to_hex(), EFI_EXT),
+        PEType::Uki => &get_uki_name(&uki_id.to_hex()),
         PEType::UkiAddon => file_path
             .components()
             .last()
@@ -1017,7 +1036,7 @@ fn write_systemd_uki_config(
     bls_conf
         .with_title(boot_label.boot_label)
         .with_cfg(BLSConfigType::EFI {
-            efi: format!("/{BOOTC_UKI_DIR}/{}{}", id.to_hex(), EFI_EXT).into(),
+            efi: format!("/{BOOTC_UKI_DIR}/{}", get_uki_name(&id.to_hex())).into(),
         })
         .with_sort_key(primary_sort_key.clone())
         .with_version(boot_label.version.unwrap_or_else(|| id.to_hex()));

crates/lib/src/bootc_composefs/gc.rs

@@ -7,15 +7,15 @@
 use anyhow::{Context, Result};
 use cap_std_ext::{cap_std::fs::Dir, dirext::CapStdExtDirExt};
 use composefs::repository::GcResult;
-use composefs_boot::bootloader::{EFI_ADDON_DIR_EXT, EFI_EXT};
+use composefs_boot::bootloader::EFI_EXT;
 
 use crate::{
     bootc_composefs::{
-        boot::{BOOTC_UKI_DIR, BootType, get_type1_dir_name},
+        boot::{BOOTC_UKI_DIR, BootType, get_type1_dir_name, get_uki_addon_dir_name, get_uki_name},
         delete::{delete_image, delete_staged, delete_state_dir},
         status::{get_composefs_status, get_imginfo, list_bootloader_entries},
     },
-    composefs_consts::{STATE_DIR_RELATIVE, TYPE1_BOOT_DIR_PREFIX},
+    composefs_consts::{STATE_DIR_RELATIVE, TYPE1_BOOT_DIR_PREFIX, UKI_NAME_PREFIX},
     store::{BootedComposefs, Storage},
 };
 
@@ -89,8 +89,12 @@ fn collect_uki_binaries(boot_dir: &Dir, boot_binaries: &mut Vec<BootBinary>) ->
         let entry = entry?;
         let name = entry.file_name()?;
 
+        let Some(verity) = name.strip_prefix(UKI_NAME_PREFIX) else {
+            continue;
+        };
+
         if name.ends_with(EFI_EXT) {
-            boot_binaries.push((BootType::Uki, name));
+            boot_binaries.push((BootType::Uki, verity.into()));
         }
     }
 
@@ -151,15 +155,15 @@ fn delete_uki(storage: &Storage, uki_id: &str, dry_run: bool) -> Result<()> {
         let entry_name = entry.file_name()?;
 
         // The actual UKI PE binary
-        if entry_name == format!("{}{}", uki_id, EFI_EXT) {
+        if entry_name == get_uki_name(uki_id) {
             tracing::debug!("Deleting UKI: {}", entry_name);
 
             if dry_run {
                 continue;
             }
 
             entry.remove_file().context("Deleting UKI")?;
-        } else if entry_name == format!("{}{}", uki_id, EFI_ADDON_DIR_EXT) {
+        } else if entry_name == get_uki_addon_dir_name(uki_id) {
             // Addons dir
             tracing::debug!("Deleting UKI addons directory: {}", entry_name);
 

crates/lib/src/bootc_composefs/utils.rs

@@ -1,6 +1,6 @@
 use crate::{
     bootc_composefs::{
-        boot::{BOOTC_UKI_DIR, compute_boot_digest_uki},
+        boot::{BOOTC_UKI_DIR, compute_boot_digest_uki, get_uki_name},
         state::update_boot_digest_in_origin,
     },
     store::Storage,
@@ -12,7 +12,7 @@ use fn_error_context::context;
 fn get_uki(storage: &Storage, deployment_verity: &str) -> Result<Vec<u8>> {
     let uki_dir = storage.require_esp()?.fd.open_dir(BOOTC_UKI_DIR)?;
 
-    let req_fname = format!("{deployment_verity}.efi");
+    let req_fname = get_uki_name(deployment_verity);
 
     for entry in uki_dir.entries_utf8()? {
         let pe = entry?;

crates/lib/src/composefs_consts.rs

@@ -39,3 +39,6 @@ pub(crate) const BOOTC_FINALIZE_STAGED_SERVICE: &str = "bootc-finalize-staged.se
 
 /// The prefix for the directories containing kernel + initrd
 pub(crate) const TYPE1_BOOT_DIR_PREFIX: &str = "bootc_composefs-";
+
+/// The prefix for names of UKI and UKI Addons
+pub(crate) const UKI_NAME_PREFIX: &str = TYPE1_BOOT_DIR_PREFIX;

crates/lib/src/parsers/bls_config.rs

@@ -14,7 +14,7 @@ use std::fmt::Display;
 use uapi_version::Version;
 
 use crate::bootc_composefs::status::ComposefsCmdline;
-use crate::composefs_consts::COMPOSEFS_CMDLINE;
+use crate::composefs_consts::{COMPOSEFS_CMDLINE, UKI_NAME_PREFIX};
 
 #[derive(Debug, PartialEq, Eq, Default)]
 pub enum BLSConfigType {
@@ -174,14 +174,20 @@ impl BLSConfig {
 
     pub(crate) fn get_verity(&self) -> Result<String> {
         match &self.cfg_type {
-            BLSConfigType::EFI { efi } => Ok(efi
-                .components()
-                .last()
-                .ok_or(anyhow::anyhow!("Empty efi field"))?
-                .to_string()
-                .strip_suffix(EFI_EXT)
-                .ok_or(anyhow::anyhow!("efi doesn't end with .efi"))?
-                .to_string()),
+            BLSConfigType::EFI { efi } => {
+                let name = efi
+                    .components()
+                    .last()
+                    .ok_or(anyhow::anyhow!("Empty efi field"))?
+                    .to_string()
+                    .strip_prefix(UKI_NAME_PREFIX)
+                    .ok_or_else(|| anyhow::anyhow!("efi does not start with custom prefix"))?
+                    .strip_suffix(EFI_EXT)
+                    .ok_or_else(|| anyhow::anyhow!("efi doesn't end with .efi"))?
+                    .to_string();
+
+                Ok(name)
+            }
 
             BLSConfigType::NonEFI { options, .. } => {
                 let options = options.as_ref().ok_or(anyhow::anyhow!("No options"))?;

crates/lib/src/parsers/grub_menuconfig.rs

@@ -15,7 +15,10 @@ use nom::{
     sequence::delimited,
 };
 
-use crate::bootc_composefs::boot::BOOTC_UKI_DIR;
+use crate::{
+    bootc_composefs::boot::{BOOTC_UKI_DIR, get_uki_name},
+    composefs_consts::UKI_NAME_PREFIX,
+};
 
 /// Body content of a GRUB menuentry containing parsed commands.
 #[derive(Debug, PartialEq, Eq)]
@@ -91,13 +94,12 @@ impl<'a> Display for MenuEntry<'a> {
 }
 
 impl<'a> MenuEntry<'a> {
-    #[allow(dead_code)]
     pub(crate) fn new(boot_label: &str, uki_id: &str) -> Self {
         Self {
             title: format!("{boot_label}: ({uki_id})"),
             body: MenuentryBody {
                 insmod: vec!["fat", "chain"],
-                chainloader: format!("/{BOOTC_UKI_DIR}/{uki_id}.efi"),
+                chainloader: format!("/{BOOTC_UKI_DIR}/{}", get_uki_name(uki_id)),
                 search: "--no-floppy --set=root --fs-uuid \"${EFI_PART_UUID}\"",
                 version: 0,
                 extra: vec![],
@@ -108,14 +110,18 @@ impl<'a> MenuEntry<'a> {
     pub(crate) fn get_verity(&self) -> Result<String> {
         let to_path = Utf8PathBuf::from(self.body.chainloader.clone());
 
-        Ok(to_path
+        let name = to_path
             .components()
             .last()
             .ok_or(anyhow::anyhow!("Empty efi field"))?
             .to_string()
+            .strip_prefix(UKI_NAME_PREFIX)
+            .ok_or_else(|| anyhow::anyhow!("efi does not start with custom prefix"))?
             .strip_suffix(EFI_EXT)
-            .ok_or(anyhow::anyhow!("efi doesn't end with .efi"))?
-            .to_string())
+            .ok_or_else(|| anyhow::anyhow!("efi doesn't end with .efi"))?
+            .to_string();
+
+        Ok(name)
     }
 }