feat(extend_payload_to_esp):add payload to bootupd efi updates dir.

Bootup extend_payload_to_esp <path> will move the it to /usr

This features gives user ability to stage payloads to be picked up by
metadata generator.This will help in mounting fimwares and uboot binaries
to esp as required by rpi4.
example usage: `bootupctl backend extend_payload_to_esp /usr/lib/mydata`
will move the content of the dir to
`/usr/lib/efi/firmware/<name>/<version>/EFI/boot/efi/`

Author: say-paul

src/bios.rs

@@ -267,4 +267,7 @@ impl Component for Bios {
     fn get_efi_vendor(&self, _: &openat::Dir) -> Result<Option<String>> {
         Ok(None)
     }
+    fn extend_payload(&self, _: &str, _: &str) -> Result<Option<bool>> {
+        Ok(None)
+    }
 }

src/cli/bootupctl.rs

@@ -73,6 +73,8 @@ pub enum CtlBackend {
     Generate(super::bootupd::GenerateOpts),
     #[clap(name = "install", hide = true)]
     Install(super::bootupd::InstallOpts),
+    #[clap(name = "extend-payload-to-esp", hide = true)]
+    ExtendPayload(super::bootupd::ExtendPayloadOpts),
 }
 
 #[derive(Debug, Parser)]
@@ -109,6 +111,9 @@ impl CtlCommand {
             CtlVerb::Backend(CtlBackend::Install(opts)) => {
                 super::bootupd::DCommand::run_install(opts)
             }
+            CtlVerb::Backend(CtlBackend::ExtendPayload(opts)) => {
+                super::bootupd::DCommand::run_extend_payload(opts)
+            }
             CtlVerb::MigrateStaticGrubConfig => Self::run_migrate_static_grub_config(),
         }
     }

src/cli/bootupd.rs

@@ -35,6 +35,11 @@ pub enum DVerb {
     GenerateUpdateMetadata(GenerateOpts),
     #[clap(name = "install", about = "Install components")]
     Install(InstallOpts),
+    #[clap(
+        name = "extend-payload-to-esp",
+        about = "Extend bootloader payload with additional files"
+    )]
+    ExtendPayload(ExtendPayloadOpts),
 }
 
 #[derive(Debug, Parser)]
@@ -82,12 +87,20 @@ pub struct GenerateOpts {
     sysroot: Option<String>,
 }
 
+#[derive(Debug, Parser)]
+pub struct ExtendPayloadOpts {
+    /// Source directory containing files to add
+    #[clap(value_parser)]
+    src_root: String,
+}
+
 impl DCommand {
     /// Run CLI application.
     pub fn run(self) -> Result<()> {
         match self.cmd {
             DVerb::Install(opts) => Self::run_install(opts),
             DVerb::GenerateUpdateMetadata(opts) => Self::run_generate_meta(opts),
+            DVerb::ExtendPayload(opts) => Self::run_extend_payload(opts),
         }
     }
 
@@ -122,4 +135,17 @@ impl DCommand {
         .context("boot data installation failed")?;
         Ok(())
     }
+
+    pub(crate) fn run_extend_payload(opts: ExtendPayloadOpts) -> Result<()> {
+        let components = crate::bootupd::get_components();
+        let sysroot = "/";
+        for component in components.values() {
+            if let Some(updated) = component.extend_payload(sysroot, &opts.src_root)? {
+                if updated {
+                    println!("Extended payload for {} successfully", component.name());
+                }
+            }
+        }
+        Ok(())
+    }
 }

src/component.rs

@@ -79,6 +79,9 @@ pub(crate) trait Component {
 
     /// Locating efi vendor dir
     fn get_efi_vendor(&self, sysroot: &openat::Dir) -> Result<Option<String>>;
+
+    /// Extending payload from input dir
+    fn extend_payload(&self, sysroot: &str, src_root: &str) -> Result<Option<bool>>;
 }
 
 /// Given a component name, create an implementation.

src/efi.rs

@@ -9,7 +9,7 @@ use std::os::unix::io::AsRawFd;
 use std::path::{Path, PathBuf};
 use std::process::Command;
 
-use anyhow::{bail, Context, Result};
+use anyhow::{anyhow, bail, Context, Result};
 use bootc_utils::CommandRunExt;
 use cap_std::fs::Dir;
 use cap_std_ext::cap_std;
@@ -454,6 +454,93 @@ impl Component for Efi {
         Ok(meta)
     }
 
+    fn extend_payload(&self, sysroot_path: &str, src_input: &str) -> Result<Option<bool>> {
+        let dest_efidir_base = Path::new(sysroot_path).join("usr/lib/efi").join("firmware");
+
+        // Fetch version and release from the source input using query_files
+        let src_input_path = Path::new(src_input);
+        let meta_from_src = packagesystem::query_files(sysroot_path, [src_input_path])
+            .context(format!("Querying RPM metadata for {:?}", src_input_path))?;
+
+        let version_string_part = meta_from_src.version.split( ',').next()
+            .ok_or_else(|| anyhow!(
+                "RPM query returned an empty or malformed version string (no package name found in '{}').",
+                meta_from_src.version
+            ))?;
+
+        let parts: Vec<&str> = version_string_part.split('-').collect();
+
+        let (pkg_name, version_release_str) = if parts.len() >= 3 {
+            // Successfully extracted package name, version, and release
+            let actual_pkg_name = parts[0];
+            let version_part = parts[parts.len() - 2]; // version, e.g., "1.0"
+            let release_part = parts[parts.len() - 1]
+                .split('.')
+                .next()
+                .unwrap_or(parts[parts.len() - 1]); // release, e.g., "1" from "1.el8.noarch"
+            (
+                actual_pkg_name.to_string(),
+                format!("{}-{}", version_part, release_part),
+            )
+        } else {
+            return Err(anyhow!(
+                "Unexpected RPM version string format: '{}'. Expected at least <pkg_name>-<version>-<release>.",
+                version_string_part
+            ));
+        };
+
+        let final_dest_efi_path = dest_efidir_base
+            .join(&pkg_name) // add the package name as a directory
+            .join(&version_release_str)
+            .join("EFI/boot/efi");
+
+        // Ensure the destination directory exists
+        std::fs::create_dir_all(&final_dest_efi_path).with_context(|| {
+            format!(
+                "Failed to create destination directory {:?}",
+                &final_dest_efi_path
+            )
+        })?;
+
+        let src_metadata = std::fs::metadata(src_input_path)
+            .with_context(|| format!("Failed to get metadata for {:?}", src_input_path))?;
+
+        if src_metadata.is_dir() {
+            log::debug!(
+                "Copying contents of directory {:?} to {:?}",
+                src_input,
+                &final_dest_efi_path
+            );
+            Command::new("cp")
+                .args([
+                    "-rp",
+                    &format!("{}/.", src_input),
+                    final_dest_efi_path.to_str().unwrap(),
+                ])
+                .run()
+                .with_context(|| {
+                    format!(
+                        "Failed to copy contents of {:?} to {:?}",
+                        src_input, &final_dest_efi_path
+                    )
+                })?;
+        } else if src_metadata.is_file() {
+            log::debug!("Copying file {:?} to {:?}", src_input, &final_dest_efi_path);
+            Command::new("cp")
+                .args(["-p", src_input, final_dest_efi_path.to_str().unwrap()])
+                .run()
+                .with_context(|| {
+                    format!(
+                        "Failed to copy file {:?} to {:?}",
+                        src_input, &final_dest_efi_path
+                    )
+                })?;
+        } else {
+            anyhow::bail!("Unsupported src_input type: {:?}", src_input);
+        }
+        Ok(Some(true))
+    }
+
     fn query_update(&self, sysroot: &openat::Dir) -> Result<Option<ContentMetadata>> {
         get_component_update(sysroot, self)
     }