install/bootupd: chroot to deployment

crates/lib/src/bootloader.rs

@@ -10,6 +10,7 @@ use fn_error_context::context;
 
 use bootc_blockdev::{Partition, PartitionTable};
 use bootc_mount as mount;
+use rustix::mount::UnmountFlags;
 
 use crate::bootc_composefs::boot::{get_sysroot_parent_dev, mount_esp, SecurebootKeys};
 use crate::{discoverable_partition_specification, utils};
@@ -91,22 +92,101 @@ pub(crate) fn install_via_bootupd(
     // bootc defaults to only targeting the platform boot method.
     let bootupd_opts = (!configopts.generic_image).then_some(["--update-firmware", "--auto"]);
 
-    let abs_deployment_path = deployment_path.map(|v| rootfs.join(v));
-    let src_root_arg = if let Some(p) = abs_deployment_path.as_deref() {
-        vec!["--src-root", p.as_str()]
+    let abs_deployment_path = deployment_path.map(|deploy| rootfs.join(deploy));
+    // When not running inside the target container (through `--src-imgref`) we chroot
+    // into the deployment before running bootupd. This makes sure we use binaries
+    // from the target image rather than the buildroot
+    // In some cases (e.g. --write-uuid), bootupd needs to find the underlying device
+    // for /boot. But since we don't control where the destination rootfs is mounted
+    // let's bind mount it to a temp mountpoint under /run
+    // so it gets carried over in the chroot.
+
+    // let rootfs_mountpoint: TempDir;
+    let rootfs_mount = if rootfs.starts_with("/run") {
+        rootfs.as_str()
+    } else {
+        "/"
+    };
+
+    // We mount the linux API file systems into the target deployment before chrooting
+    // so bootupd can find the proper backing device.
+    // xref https://systemd.io/API_FILE_SYSTEMS/
+    let bind_mount_dirs = ["/dev", "/run", "/proc", "/sys"];
+    let chroot_args = if let Some(target_root) = abs_deployment_path.as_deref() {
+        tracing::debug!("Setting up bind-mounts before chrooting to the target deployment");
+        for src in bind_mount_dirs {
+            let dest = target_root
+                // joining an absolute path
+                // makes it replace self, so we strip the prefix
+                .join_os(src.strip_prefix("/").unwrap());
+            tracing::debug!("bind mounting {}", dest.display());
+            rustix::mount::mount_bind_recursive(src, dest)?;
+        }
+        // WIP : let's try to bind-mount /target/boot into the deployment as well rather than bind-mounting the whole thing??
+        if !rootfs.starts_with("/run") {
+            tracing::debug!(
+                "We need to access the target /boot filesystem so let's also bind-mount it"
+            );
+            let trgt_boot = rootfs.as_std_path().join("boot");
+            let chrooted_boot = target_root.join_os("boot");
+            tracing::debug!(
+                "bind-mounting {} in {}",
+                &trgt_boot.display(),
+                &chrooted_boot.display()
+            );
+            rustix::mount::mount_bind_recursive(trgt_boot, chrooted_boot)?;
+        }
+
+        // Append the `bootupctl` command, it will be passed as
+        // an argument to chroot
+        vec![target_root.as_str(), "bootupctl"]
     } else {
         vec![]
     };
+
     let devpath = device.path();
     println!("Installing bootloader via bootupd");
-    Command::new("bootupctl")
+    let mut bootupctl = if abs_deployment_path.is_some() {
+        Command::new("chroot")
+    } else {
+        Command::new("bootupctl")
+    };
+    let install_result = bootupctl
+        .args(chroot_args)
+        // Inject a reasonnable PATH here so we find the required tools
+        // when running chrooted in the deployment. Testing show that
+        // the default $PATH value in the chroot is insufficient.
+        .env(
+            "PATH",
+            "/bin:/usr/bin:/sbin:/usr/sbin:/usr/local/bin:/usr/local/sbin",
+        )
         .args(["backend", "install", "--write-uuid"])
         .args(verbose)
         .args(bootupd_opts.iter().copied().flatten())
-        .args(src_root_arg)
-        .args(["--device", devpath.as_str(), rootfs.as_str()])
+        .args(["--device", devpath.as_str(), rootfs_mount])
         .log_debug()
-        .run_inherited_with_cmd_context()
+        .run_inherited_with_cmd_context();
+
+    // Clean up the mounts after ourselves
+    if let Some(target_root) = abs_deployment_path {
+        if let Err(e) = rustix::mount::unmount(
+            target_root.join("boot").into_std_path_buf(),
+            UnmountFlags::DETACH,
+        ) {
+            tracing::warn!("Error unmounting target/boot: {e}");
+        }
+        for dir in bind_mount_dirs {
+            let mount = target_root
+                .join(dir.strip_prefix("/").unwrap())
+                .into_std_path_buf();
+            if let Err(e) = rustix::mount::unmount(&mount, UnmountFlags::DETACH) {
+                // let's not propagate the error up because in some cases we can't unmount
+                // e.g. when running `to-existing-root`
+                tracing::warn!("Error unmounting {}: {e}", mount.display());
+            }
+        }
+    }
+    install_result
 }
 
 #[context("Installing bootloader")]

crates/tests-integration/src/install.rs

@@ -9,7 +9,17 @@ use fn_error_context::context;
 use libtest_mimic::Trial;
 use xshell::{cmd, Shell};
 
-pub(crate) const BASE_ARGS: &[&str] = &["podman", "run", "--rm", "--privileged", "--pid=host"];
+pub(crate) const BASE_ARGS: &[&str] = &[
+    "podman",
+    "run",
+    "--rm",
+    "--privileged",
+    "--pid=host",
+    "--env",
+    "BOOTC_BOOTLOADER_DEBUG=true",
+    "--env",
+    "RUST_LOG=debug",
+];
 
 // Arbitrary
 const NON_DEFAULT_STATEROOT: &str = "foo";