Respect bootloader=none in flat mode; add test

- flat_install() now checks config_opts.bootloader for Bootloader::None
  and skips bootloader installation, matching the ostree path behaviour.
  This enables running the flat install test in CI without a real EFI
  partition/bootupd.
- Add InstallFlat subcommand to tests-integration and a
  "flat install to-filesystem" trial that:
    * Creates a 5 GiB loopback ext4 target
    * Runs bootc install to-filesystem --bootloader=none --flat
    * Verifies etc/.bootc-flat marker, absence of ostree/, presence of
      boot/loader/entries/flat-*.conf and boot/vmlinuz-*

Signed-off-by: Eric Curtin <eric.curtin@docker.com>

Author: ericcurtin

crates/lib/src/install.rs

@@ -1830,16 +1830,17 @@ async fn install_with_sysroot(
 
     if cfg!(target_arch = "s390x") {
         // TODO: Integrate s390x support into install_via_bootupd
-        crate::bootloader::install_via_zipl(&rootfs.device_info, boot_uuid)?;
+        install_bootloader_via_zipl(&rootfs.device_info, boot_uuid)?;
     } else {
         match postfetch.detected_bootloader {
             Bootloader::Grub => {
-                crate::bootloader::install_via_bootupd(
+                let target_root = rootfs
+                    .target_root_path
+                    .as_ref()
+                    .unwrap_or(&rootfs.physical_root_path);
+                install_bootloader_via_bootupd(
                     &rootfs.device_info,
-                    &rootfs
-                        .target_root_path
-                        .clone()
-                        .unwrap_or(rootfs.physical_root_path.clone()),
+                    target_root,
                     &state.config_opts,
                     Some(&deployment_path.as_str()),
                 )?;
@@ -1875,6 +1876,35 @@ async fn install_with_sysroot(
     Ok(())
 }
 
+/// Install the bootloader using bootupd.
+///
+/// This is a helper to reduce duplication between ostree and flat installs.
+///
+/// # Arguments
+/// * `device_info` - Device information for the target
+/// * `target_root` - Path to the target root filesystem
+/// * `config_opts` - Configuration options
+/// * `deployment_path` - Optional deployment path for ostree-based installs
+#[context("Installing bootloader via bootupd")]
+fn install_bootloader_via_bootupd(
+    device_info: &DeviceSetup,
+    target_root: &Utf8PathBuf,
+    config_opts: &ConfigOpts,
+    deployment_path: Option<&str>,
+) -> Result<()> {
+    crate::bootloader::install_via_bootupd(device_info, target_root, config_opts, deployment_path)
+}
+
+/// Install the bootloader using zipl (s390x architecture).
+///
+/// # Arguments
+/// * `device_info` - Device information for the target
+/// * `boot_uuid` - Boot UUID (required for zipl)
+#[context("Installing bootloader via zipl")]
+fn install_bootloader_via_zipl(device_info: &DeviceSetup, boot_uuid: &str) -> Result<()> {
+    crate::bootloader::install_via_zipl(device_info, boot_uuid)
+}
+
 enum BoundImages {
     Skip,
     Resolved(Vec<ResolvedBoundImage>),
@@ -1946,20 +1976,26 @@ fn copy_kernel_to_boot(
             let vmlinuz_dest = format!("boot/vmlinuz-{version}");
             let initramfs_dest = format!("boot/initramfs-{version}.img");
 
-            // Copy vmlinuz
-            let vmlinuz_data = root
-                .read(path.as_str())
-                .with_context(|| format!("Reading kernel {path}"))?;
-            root.atomic_write(&vmlinuz_dest, &vmlinuz_data)
-                .with_context(|| format!("Writing {vmlinuz_dest}"))?;
+            // Copy vmlinuz using streaming to avoid loading entire file into memory
+            let mut vmlinuz_f = root
+                .open(path.as_str())
+                .with_context(|| format!("Opening kernel {path}"))?;
+            root.atomic_write_with(&vmlinuz_dest, |to_f| {
+                std::io::copy(&mut vmlinuz_f, to_f)?;
+                Ok(())
+            })
+            .with_context(|| format!("Writing {vmlinuz_dest}"))?;
 
             // Copy initramfs (it may not exist; dracut will regenerate it if missing)
             if root.try_exists(initramfs.as_str())? {
-                let initramfs_data = root
-                    .read(initramfs.as_str())
-                    .with_context(|| format!("Reading initramfs {initramfs}"))?;
-                root.atomic_write(&initramfs_dest, &initramfs_data)
-                    .with_context(|| format!("Writing {initramfs_dest}"))?;
+                let mut initramfs_f = root
+                    .open(initramfs.as_str())
+                    .with_context(|| format!("Opening initramfs {initramfs}"))?;
+                root.atomic_write_with(&initramfs_dest, |to_f| {
+                    std::io::copy(&mut initramfs_f, to_f)?;
+                    Ok(())
+                })
+                .with_context(|| format!("Writing {initramfs_dest}"))?;
             }
 
             // Return absolute paths for use in BLS entry
@@ -2071,26 +2107,38 @@ async fn flat_install(state: &State, rootfs: &RootSetup) -> Result<()> {
     regenerate_initramfs_for_flat(&target_path, &kernel_version, &initramfs_boot_path)?;
 
     // Step 5: Create BLS entry
-    create_flat_bls_entry(rootfs, &kernel_version, &vmlinuz_boot_path, &initramfs_boot_path)?;
+    create_flat_bls_entry(
+        rootfs,
+        &kernel_version,
+        &vmlinuz_boot_path,
+        &initramfs_boot_path,
+    )?;
 
     // Step 6: Install bootloader
-    if cfg!(target_arch = "s390x") {
-        let boot_uuid = rootfs
-            .get_boot_uuid()?
-            .or(rootfs.rootfs_uuid.as_deref())
-            .ok_or_else(|| anyhow!("No uuid for boot/root"))?;
-        crate::bootloader::install_via_zipl(&rootfs.device_info, boot_uuid)?;
-    } else {
-        let target_root = rootfs
-            .target_root_path
-            .as_ref()
-            .unwrap_or(&rootfs.physical_root_path);
-        crate::bootloader::install_via_bootupd(
-            &rootfs.device_info,
-            target_root,
-            &state.config_opts,
-            None, // No deployment path for flat installs
-        )?;
+    match state.config_opts.bootloader.as_ref() {
+        Some(crate::spec::Bootloader::None) => {
+            tracing::debug!("Skipping bootloader installation (bootloader=none)");
+        }
+        _ => {
+            if cfg!(target_arch = "s390x") {
+                let boot_uuid = rootfs
+                    .get_boot_uuid()?
+                    .or(rootfs.rootfs_uuid.as_deref())
+                    .ok_or_else(|| anyhow!("No uuid for boot/root"))?;
+                install_bootloader_via_zipl(&rootfs.device_info, boot_uuid)?;
+            } else {
+                let target_root = rootfs
+                    .target_root_path
+                    .as_ref()
+                    .unwrap_or(&rootfs.physical_root_path);
+                install_bootloader_via_bootupd(
+                    &rootfs.device_info,
+                    target_root,
+                    &state.config_opts,
+                    None, // No deployment path for flat installs
+                )?;
+            }
+        }
     }
 
     // Step 7: Write flat install marker

crates/tests-integration/src/install.rs

@@ -173,3 +173,79 @@ pub(crate) fn run_alongside(image: &str, mut testargs: libtest_mimic::Arguments)
 
     libtest_mimic::run(&testargs, tests.into()).exit()
 }
+
+#[context("Flat install tests")]
+pub(crate) fn run_flat(image: &str, mut testargs: libtest_mimic::Arguments) -> Result<()> {
+    testargs.test_threads = Some(1);
+    let image: &'static str = String::from(image).leak();
+
+    let tests = [Trial::test("flat install to-filesystem", move || {
+        let sh = &xshell::Shell::new()?;
+        // Create a sparse file and format it as ext4
+        let size = 5 * 1000 * 1000 * 1000u64;
+        let mut tmpdisk = tempfile::NamedTempFile::new_in("/var/tmp")?;
+        tmpdisk.as_file_mut().set_len(size)?;
+        let tmpdisk = tmpdisk.into_temp_path();
+        let tmpdisk_str = tmpdisk.to_str().unwrap();
+
+        // Set up loop device and format
+        let loopdev = cmd!(sh, "sudo losetup --find --show {tmpdisk_str}")
+            .read()?
+            .trim()
+            .to_string();
+        cmd!(sh, "sudo mkfs.ext4 -L root {loopdev}").run()?;
+
+        // Mount the target
+        let tmpdir = tempfile::TempDir::new_in("/var/tmp")?;
+        let target = tmpdir.path().to_str().unwrap();
+        cmd!(sh, "sudo mount {loopdev} {target}").run()?;
+
+        // Run flat install (skip bootloader for CI) and capture result for cleanup
+        let r = (|| -> Result<()> {
+            cmd!(sh, "sudo {BASE_ARGS...} -v {target}:/target {image} bootc install to-filesystem --bootloader=none --flat /target").run()?;
+
+            // Verify flat install marker
+            assert!(
+                std::path::Path::new(target)
+                    .join("etc/.bootc-flat")
+                    .exists(),
+                "Missing flat install marker"
+            );
+
+            // Verify no ostree directory was created
+            assert!(
+                !std::path::Path::new(target).join("ostree").exists(),
+                "ostree directory should not exist in flat install"
+            );
+
+            // Verify boot entries exist
+            let boot_entries = std::path::Path::new(target).join("boot/loader/entries");
+            let has_entry = boot_entries.exists()
+                && std::fs::read_dir(&boot_entries)?.any(|e| {
+                    e.ok()
+                        .map(|e| e.file_name().to_string_lossy().contains("flat-"))
+                        .unwrap_or(false)
+                });
+            assert!(has_entry, "No flat BLS entry found in boot/loader/entries");
+
+            // Verify vmlinuz was copied to /boot
+            let has_vmlinuz =
+                std::fs::read_dir(std::path::Path::new(target).join("boot"))?.any(|e| {
+                    e.ok()
+                        .map(|e| e.file_name().to_string_lossy().starts_with("vmlinuz-"))
+                        .unwrap_or(false)
+                });
+            assert!(has_vmlinuz, "No vmlinuz-* found in /boot");
+
+            Ok(())
+        })();
+
+        // Clean up regardless of result
+        let _ = cmd!(sh, "sudo umount --lazy {target}").run();
+        let _ = cmd!(sh, "sudo losetup --detach {loopdev}").run();
+
+        Ok(r?)
+    })];
+
+    libtest_mimic::run(&testargs, tests.into()).exit()
+}

crates/tests-integration/src/tests-integration.rs

@@ -26,6 +26,12 @@ pub(crate) enum Opt {
         #[clap(flatten)]
         testargs: libtest_mimic::Arguments,
     },
+    InstallFlat {
+        /// Source container image reference
+        image: String,
+        #[clap(flatten)]
+        testargs: libtest_mimic::Arguments,
+    },
     HostPrivileged {
         image: String,
         #[clap(flatten)]
@@ -54,6 +60,7 @@ fn main() {
     let r = match opt {
         Opt::SystemReinstall { image, testargs } => system_reinstall::run(&image, testargs),
         Opt::InstallAlongside { image, testargs } => install::run_alongside(&image, testargs),
+        Opt::InstallFlat { image, testargs } => install::run_flat(&image, testargs),
         Opt::HostPrivileged { image, testargs } => hostpriv::run_hostpriv(&image, testargs),
         Opt::Container { testargs } => container::run(testargs),
         Opt::RunVM(opts) => runvm::run(opts),

hack/Containerfile.flat-test

@@ -0,0 +1,21 @@
+# Build a test image with --flat support layered on fedora-bootc:43
+# Stage 1: build bootc binary on Fedora 43 (matching target libraries)
+FROM quay.io/fedora/fedora-bootc:43 AS builder
+
+RUN dnf -y install cargo rust gcc openssl-devel pkg-config perl \
+    ostree-devel glib2-devel libzstd-devel make skopeo \
+    && dnf clean all
+
+COPY . /src
+WORKDIR /src
+
+# Build only the bootc binary (release mode for speed)
+RUN --mount=type=cache,target=/root/.cargo/registry \
+    --mount=type=cache,target=/src/target \
+    cargo build -p bootc --release && \
+    cp target/release/bootc /usr/local/bin/bootc-flat
+
+# Stage 2: final image is fedora-bootc:43 with our bootc
+FROM quay.io/fedora/fedora-bootc:43
+
+COPY --from=builder /usr/local/bin/bootc-flat /usr/bin/bootc