efi: transfer usr/lib/ostree-boot to usr/lib/efi

Author: HuijingHei

src/component.rs

@@ -117,6 +117,7 @@ pub(crate) fn component_updatedirname(component: &dyn Component) -> PathBuf {
     target_arch = "aarch64",
     target_arch = "riscv64"
 ))]
+#[allow(dead_code)]
 pub(crate) fn component_updatedir(sysroot: &str, component: &dyn Component) -> PathBuf {
     Path::new(sysroot).join(component_updatedirname(component))
 }

src/efi.rs

@@ -14,6 +14,7 @@ use bootc_internal_utils::CommandRunExt;
 use camino::{Utf8Path, Utf8PathBuf};
 use cap_std::fs::Dir;
 use cap_std_ext::cap_std;
+use cap_std_ext::dirext::CapStdExtDirExt;
 use chrono::prelude::*;
 use fn_error_context::context;
 use openat_ext::OpenatDirExt;
@@ -447,20 +448,42 @@ impl Component for Efi {
     }
 
     fn generate_update_metadata(&self, sysroot: &str) -> Result<ContentMetadata> {
-        let sysroot_path = Utf8Path::new(sysroot);
+        let sysroot_path = Path::new(sysroot);
 
-        let efilib_path = sysroot_path.join(EFILIB);
-        let efi_comps = if efilib_path.exists() {
-            get_efi_component_from_usr(&sysroot_path, EFILIB)?
-        } else {
-            None
-        };
+        let sysroot_dir = Dir::open_ambient_dir(sysroot_path, cap_std::ambient_authority())?;
+
+        if let Some(ostreeboot) = sysroot_dir
+            .open_dir_optional(ostreeutil::BOOT_PREFIX)
+            .context("Opening usr/lib/ostree-boot")?
+        {
+            let cruft = ["loader", "grub2"];
+            for p in cruft.iter() {
+                ostreeboot.remove_all_optional(p)?;
+            }
+
+            let efisrc = sysroot_path.join(ostreeutil::BOOT_PREFIX).join("efi/EFI");
+            if efisrc.exists() {
+                let files = WalkDir::new(&efisrc)
+                    .into_iter()
+                    .filter_map(Result::ok)
+                    .filter(|e| e.file_type().is_file())
+                    .map(|e| e.path().to_path_buf())
+                    .collect::<Vec<_>>();
+
+                if !files.is_empty() {
+                    transfter_ostree_boot_to_usr(sysroot_path, &files)?;
+                }
+                // Remove usr/lib/ostree-boot/efi/EFI dir (after transfer) or if it is empty
+                ostreeboot.remove_all_optional("efi/EFI")?;
+            }
+        }
 
         // copy EFI files to updates dir from usr/lib/efi
-        let meta = if let Some(efi_components) = efi_comps {
+        if let Some(efi_components) =
+            get_efi_component_from_usr(Utf8Path::from_path(sysroot_path).unwrap(), EFILIB)?
+        {
             let mut packages = Vec::new();
             let mut modules_vec: Vec<Module> = vec![];
-            let sysroot_dir = Dir::open_ambient_dir(sysroot_path, cap_std::ambient_authority())?;
             for efi in efi_components {
                 util::copy_in_fd(&sysroot_dir, &efi.path, crate::model::BOOTUPD_UPDATES_DIR)?;
                 packages.push(format!("{}-{}", efi.name, efi.version));
@@ -473,50 +496,16 @@ impl Component for Efi {
 
             // change to now to workaround https://github.com/coreos/bootupd/issues/933
             let timestamp = std::time::SystemTime::now();
-            ContentMetadata {
+            let meta = ContentMetadata {
                 timestamp: chrono::DateTime::<Utc>::from(timestamp),
                 version: packages.join(","),
                 versions: Some(modules_vec),
-            }
+            };
+            write_update_metadata(sysroot, self, &meta)?;
+            Ok(meta)
         } else {
-            let ostreebootdir = sysroot_path.join(ostreeutil::BOOT_PREFIX);
-
-            // move EFI files to updates dir from /usr/lib/ostree-boot
-            if ostreebootdir.exists() {
-                let cruft = ["loader", "grub2"];
-                for p in cruft.iter() {
-                    let p = ostreebootdir.join(p);
-                    if p.exists() {
-                        std::fs::remove_dir_all(&p)?;
-                    }
-                }
-
-                let efisrc = ostreebootdir.join("efi/EFI");
-                if !efisrc.exists() {
-                    bail!("Failed to find {:?}", &efisrc);
-                }
-
-                let dest_efidir = component_updatedir(sysroot, self);
-                let dest_efidir =
-                    Utf8PathBuf::from_path_buf(dest_efidir).expect("Path is invalid UTF-8");
-                // Fork off mv() because on overlayfs one can't rename() a lower level
-                // directory today, and this will handle the copy fallback.
-                Command::new("mv").args([&efisrc, &dest_efidir]).run()?;
-
-                let efidir = openat::Dir::open(dest_efidir.as_std_path())
-                    .with_context(|| format!("Opening {}", dest_efidir))?;
-                let files = crate::util::filenames(&efidir)?.into_iter().map(|mut f| {
-                    f.insert_str(0, "/boot/efi/EFI/");
-                    f
-                });
-                query_files(sysroot, files)?
-            } else {
-                anyhow::bail!("Failed to find {ostreebootdir}");
-            }
-        };
-
-        write_update_metadata(sysroot, self, &meta)?;
-        Ok(meta)
+            anyhow::bail!("Failed to find EFI components");
+        }
     }
 
     fn query_update(&self, sysroot: &openat::Dir) -> Result<Option<ContentMetadata>> {
@@ -766,6 +755,44 @@ fn get_efi_component_from_usr<'a>(
     Ok(Some(components))
 }
 
+fn transfter_ostree_boot_to_usr(sysroot: &Path, ostreeboot_files: &Vec<PathBuf>) -> Result<()> {
+    let ostreeboot = sysroot.join(ostreeutil::BOOT_PREFIX).join("efi");
+    for entry in ostreeboot_files {
+        // get path: EFI/{BOOT,<vendor>}/<file>
+        let filepath = entry.strip_prefix(&ostreeboot)?;
+        // get path: /boot/efi/EFI/{BOOT,<vendor>}/<file>
+        let boot_filepath = Path::new("/boot/efi").join(filepath);
+
+        // Run `rpm -qf <filepath>`
+        let pkg = crate::packagesystem::query_file(
+            sysroot.to_str().unwrap(),
+            boot_filepath.to_str().unwrap(),
+        )?;
+
+        if let Some((name, evr)) = pkg.split_once('/') {
+            let component = name.splitn(2, '-').next().unwrap_or("");
+            let version = evr.strip_prefix("(none):").unwrap_or(evr);
+            let dest = Path::new(EFILIB)
+                .join(component)
+                .join(version)
+                .join(filepath);
+
+            let sysroot_dir = openat::Dir::open(sysroot)?;
+            // Ensure parent directory exists
+            if let Some(parent) = sysroot.join(&dest).parent() {
+                sysroot_dir.ensure_dir_all(parent, 0o755)?;
+            }
+            let src = entry.strip_prefix(sysroot)?;
+            sysroot_dir.copy_file(src, &dest)?;
+
+            println!("Copied {:?} -> {:?}", src, dest);
+        } else {
+            bail!("Could not find split charater in {pkg}");
+        }
+    }
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use cap_std_ext::dirext::CapStdExtDirExt;

src/packagesystem.rs

@@ -101,6 +101,27 @@ where
     rpm_parse_metadata(&rpmout.stdout)
 }
 
+/// Query the rpm database and get package <name>/<epoch>:<version>-<release>.
+pub(crate) fn query_file(sysroot_path: &str, path: &str) -> Result<String> {
+    let mut c = ostreeutil::rpm_cmd(sysroot_path)?;
+    c.args([
+        "-q",
+        "--queryformat",
+        "%{NAME}/%{EPOCH}:%{VERSION}-%{RELEASE}",
+        "-f",
+        path,
+    ]);
+
+    let rpmout = c.output()?;
+    if !rpmout.status.success() {
+        std::io::stderr().write_all(&rpmout.stderr)?;
+        bail!("Failed to invoke rpm -qf");
+    }
+
+    let output = String::from_utf8(rpmout.stdout)?;
+    Ok(output.trim().to_string())
+}
+
 fn parse_evr(pkg: &str) -> Module {
     // assume it is "grub2-1:2.12-28.fc42" (from usr/lib/efi)
     if !pkg.ends_with(std::env::consts::ARCH) {

src/util.rs

@@ -21,6 +21,7 @@ pub(crate) fn getenv_utf8(n: &str) -> Result<Option<String>> {
     }
 }
 
+#[allow(dead_code)]
 pub(crate) fn filenames(dir: &openat::Dir) -> Result<HashSet<String>> {
     let mut ret = HashSet::new();
     for entry in dir.list_dir(".")? {