diff --git a/crates/lib/src/bootc_composefs/state.rs b/crates/lib/src/bootc_composefs/state.rs index e43447a2f5..1bcf951d86 100644 --- a/crates/lib/src/bootc_composefs/state.rs +++ b/crates/lib/src/bootc_composefs/state.rs @@ -329,7 +329,7 @@ pub(crate) async fn write_composefs_state( } pub(crate) fn composefs_usr_overlay(access_mode: FilesystemOverlayAccessMode) -> Result<()> { - let status = get_composefs_usr_overlay_status()?; + let status = get_usr_overlay_status()?; if status.is_some() { println!("An overlayfs is already mounted on /usr"); return Ok(()); @@ -351,7 +351,7 @@ pub(crate) fn composefs_usr_overlay(access_mode: FilesystemOverlayAccessMode) -> Ok(()) } -pub(crate) fn get_composefs_usr_overlay_status() -> Result> { +pub(crate) fn get_usr_overlay_status() -> Result> { let usr = Dir::open_ambient_dir("/usr", ambient_authority()).context("Opening /usr")?; let is_usr_mounted = usr .is_mountpoint(".") diff --git a/crates/lib/src/bootc_composefs/status.rs b/crates/lib/src/bootc_composefs/status.rs index c2a984e794..68b084ab2d 100644 --- a/crates/lib/src/bootc_composefs/status.rs +++ b/crates/lib/src/bootc_composefs/status.rs @@ -14,7 +14,7 @@ use crate::{ bootc_composefs::{ boot::BootType, selinux::are_selinux_policies_compatible, - state::{get_composefs_usr_overlay_status, read_origin}, + state::{get_usr_overlay_status, read_origin}, utils::{compute_store_boot_digest_for_uki, get_uki_cmdline}, }, composefs_consts::{ @@ -1059,7 +1059,7 @@ async fn composefs_deployment_status_from( host.spec.boot_order = BootOrder::Rollback }; - host.status.usr_overlay = get_composefs_usr_overlay_status().ok().flatten(); + host.status.usr_overlay = get_usr_overlay_status().ok().flatten(); set_soft_reboot_capability(storage, &mut host, sorted_bls_config, cmdline)?; diff --git a/crates/lib/src/cli.rs b/crates/lib/src/cli.rs index 51ba364150..bcf6516076 100644 --- a/crates/lib/src/cli.rs +++ b/crates/lib/src/cli.rs @@ -41,6 +41,7 @@ use serde::{Deserialize, Serialize}; use crate::bootc_composefs::delete::delete_composefs_deployment; use crate::bootc_composefs::gc::{GCOpts, composefs_gc}; use crate::bootc_composefs::soft_reboot::{prepare_soft_reboot_composefs, reset_soft_reboot}; +use crate::bootc_composefs::state::get_usr_overlay_status; use crate::bootc_composefs::{ digest::{compute_composefs_digest, new_temp_composefs_repo}, finalize::{composefs_backend_finalize, get_etc_diff}, @@ -1664,6 +1665,12 @@ async fn edit(opts: EditOpts) -> Result<()> { /// Implementation of `bootc usroverlay` async fn usroverlay(access_mode: FilesystemOverlayAccessMode) -> Result<()> { + let status = get_usr_overlay_status()?; + if status.is_some() { + println!("An overlayfs is already mounted on /usr"); + return Ok(()); + } + // This is just a pass-through today. At some point we may make this a libostree API // or even oxidize it. let args = match access_mode { diff --git a/crates/lib/src/install.rs b/crates/lib/src/install.rs index 3c5182fd75..034b9cc238 100644 --- a/crates/lib/src/install.rs +++ b/crates/lib/src/install.rs @@ -1707,12 +1707,12 @@ async fn prepare_install( println!("Digest: {digest}"); } - let root_filesystem = target_fs - .or(install_config - .as_ref() - .and_then(|c| c.filesystem_root()) - .and_then(|r| r.fstype)) - .ok_or_else(|| anyhow::anyhow!("No root filesystem specified"))?; + // Don't error out if a filesystem is not passed in via cli as we could have + // repart.d definitions available + let root_filesystem = target_fs.or(install_config + .as_ref() + .and_then(|c| c.filesystem_root()) + .and_then(|r| r.fstype)); let mut is_uki = false; @@ -1723,37 +1723,43 @@ async fn prepare_install( // we hard require it in that particular case // // NOTE: This isn't really 100% accurate 100% of the time as the cmdline can be in an addon - match kernel { - Some(k) => match k.k_type { - crate::kernel::KernelType::Uki { cmdline, .. } => { - let allow_missing_fsverity = cmdline.is_some_and(|cmd| { - ComposefsCmdline::find_in_cmdline(&cmd) - .is_some_and(|cfs_cmdline| cfs_cmdline.allow_missing_fsverity) - }); - - if !allow_missing_fsverity { - anyhow::ensure!( - root_filesystem.supports_fsverity(), - "Specified filesystem {root_filesystem} does not support fs-verity" - ); - } + if let Some(root_filesystem) = root_filesystem { + match kernel { + Some(k) => match k.k_type { + crate::kernel::KernelType::Uki { cmdline, .. } => { + let allow_missing_fsverity = cmdline.is_some_and(|cmd| { + ComposefsCmdline::find_in_cmdline(&cmd) + .is_some_and(|cfs_cmdline| cfs_cmdline.allow_missing_fsverity) + }); + + if !allow_missing_fsverity { + anyhow::ensure!( + root_filesystem.supports_fsverity(), + "Specified filesystem {root_filesystem} does not support fs-verity" + ); + } - composefs_options.allow_missing_verity = allow_missing_fsverity; - is_uki = true; - } + composefs_options.allow_missing_verity = allow_missing_fsverity; + is_uki = true; + } - crate::kernel::KernelType::Vmlinuz { .. } => {} - }, + crate::kernel::KernelType::Vmlinuz { .. } => {} + }, - None => {} - } + None => {} + } - // If `--allow-missing-verity` is already passed via CLI, don't modify - if composefs_options.composefs_backend && !composefs_options.allow_missing_verity && !is_uki { - composefs_options.allow_missing_verity = !root_filesystem.supports_fsverity(); + // If `--allow-missing-verity` is already passed via CLI, don't modify + if composefs_options.composefs_backend && !composefs_options.allow_missing_verity && !is_uki + { + composefs_options.allow_missing_verity = !root_filesystem.supports_fsverity(); + } } tracing::info!( + root_filesystem = root_filesystem + .map(|f| f.to_string()) + .unwrap_or("None".into()), allow_missing_fsverity = composefs_options.allow_missing_verity, uki = is_uki, "ComposeFS install prep", diff --git a/crates/lib/src/install/baseline.rs b/crates/lib/src/install/baseline.rs index 0db968b20d..562283481b 100644 --- a/crates/lib/src/install/baseline.rs +++ b/crates/lib/src/install/baseline.rs @@ -9,11 +9,13 @@ use std::borrow::Cow; use std::fmt::Display; use std::fmt::Write as _; use std::io::Write; +use std::path::Path; use std::process::Command; use std::process::Stdio; use anyhow::Ok; use anyhow::{Context, Result}; +use bootc_blockdev::Device; use bootc_utils::CommandRunExt; use camino::Utf8Path; use camino::Utf8PathBuf; @@ -65,7 +67,7 @@ pub(crate) const EFIPN_SIZE_MB: u32 = 512; /// EFI Partition size for composefs installations /// We need more space than ostree as we have UKIs and UKI addons /// We might also need to store UKIs for pinned deployments -pub(crate) const CFS_EFIPN_SIZE_MB: u32 = 1024; +pub(crate) const CFS_EFIPN_SIZE_MB: u32 = 2048; #[cfg(feature = "install-to-disk")] pub(crate) const PREPBOOT_GUID: &str = "9E1A2D38-C612-4316-AA26-8B49521E5A8B"; #[cfg(feature = "install-to-disk")] @@ -190,95 +192,178 @@ pub(crate) fn udev_settle() -> Result<()> { Ok(()) } -#[context("Creating rootfs")] -#[cfg(feature = "install-to-disk")] -pub(crate) fn install_create_rootfs( - state: &State, - opts: InstallBlockDeviceOpts, -) -> Result { - let install_config = state.install_config.as_ref(); - let luks_name = "root"; - // Ensure we have a root filesystem upfront - let root_filesystem = opts - .filesystem - .or(install_config - .and_then(|c| c.filesystem_root()) - .and_then(|r| r.fstype)) - .ok_or_else(|| anyhow::anyhow!("No root filesystem specified"))?; - // Verify that the target is empty (if not already wiped in particular, but it's - // also good to verify that the wipe worked) - let mut device = bootc_blockdev::list_dev(&opts.device)?; +/// Partition numbers resulting from partitioning, used to look up devices after. +#[derive(Debug)] +struct PartitionLayout { + esp_partno: Option, + boot_partno: Option, + rootpn: u32, + /// Whether systemd-repart created the ESP/boot partitions (skip mkfs for those) + used_repart: bool, +} - // Always disallow writing to mounted device - if is_mounted_in_pid1_mountns(&device.path())? { - anyhow::bail!("Device {} is mounted", device.path()) +/// The json output for systemd-repart +#[derive(Debug, Deserialize)] +struct RepartPartition { + /// Human readable partition name + /// Ex. "esp", "root-x86_64" + #[serde(rename = "type")] + partition_type: String, + /// 0-indexed partition number + partno: u32, + #[allow(dead_code)] + fs: Option, +} + +fn can_use_systemd_repart() -> bool { + if Command::new("systemd-repart") + .arg("--help") + .stdout(Stdio::null()) + .stderr(Stdio::null()) + .status() + .is_err() + { + return false; } - // Handle wiping any existing data - if opts.wipe { - let dev = &opts.device; - for child in device.children.iter().flatten() { - let child = child.path(); - println!("Wiping {child}"); - wipefs(Utf8Path::new(&child))?; - } - println!("Wiping {dev}"); - wipefs(dev)?; - } else if device.has_children() { - anyhow::bail!( - "Detected existing partitions on {}; use e.g. `wipefs` or --wipe if you intend to overwrite", - opts.device - ); + let repart_config_dirs = [ + Path::new("/etc/repart.d"), + Path::new("/run/repart.d"), + Path::new("/usr/local/lib/repart.d"), + Path::new("/usr/lib/repart.d"), + ]; + + let has_config = repart_config_dirs.iter().any(|d| { + d.is_dir() + && d.read_dir() + .ok() + .is_some_and(|mut entries| entries.next().is_some()) + }); + + return has_config; +} + +/// Create partitions using systemd-repart +/// Assumes we have systemd-repart definitions +#[context("Running systemd-repart")] +fn systemd_repart( + device: &Device, + root_size: Option, + rootfs: Option, +) -> Result { + // Dry-run to check what partitions would be created + let dry_partitions = systemd_repart_run(device, true)?; + + if dry_partitions.is_empty() { + anyhow::bail!("systemd-repart returned empty partitions"); } - let run_bootc = Utf8Path::new(RUN_BOOTC); - let mntdir = run_bootc.join("mounts"); - if mntdir.exists() { - std::fs::remove_dir_all(&mntdir)?; + let has_root = dry_partitions + .iter() + .any(|p| p.partition_type.starts_with("root-")); + + if has_root { + // Root partition is defined in repart.d config, run for real + let partitions = systemd_repart_run(device, false)?; + let layout = parse_repart_layout(&partitions)?; + return Ok(layout); } - // Use the install configuration to find the block setup, if we have one - let block_setup = if let Some(config) = install_config { - config.get_block_setup(opts.block_setup.as_ref().copied())? - } else if opts.filesystem.is_some() { - // Otherwise, if a filesystem is specified then we default to whatever was - // specified via --block-setup, or the default - opts.block_setup.unwrap_or_default() + // Root partition is not defined, create defintion for the root part + let mut root_conf = String::from("[Partition]\nType=root\n"); + if let Some(size_mib) = root_size { + writeln!(root_conf, "SizeMinBytes={size_mib}M")?; + writeln!(root_conf, "SizeMaxBytes={size_mib}M")?; + } + match rootfs { + Some(fs) => writeln!(root_conf, "Format={fs}")?, + None => { + anyhow::bail!("Rootfs not specified") + } + } + + std::fs::create_dir_all("/run/repart.d").context("Creating /run/repart.d")?; + std::fs::write("/run/repart.d/50-root.conf", &root_conf) + .context("Writing root repart config")?; + + let partitions = systemd_repart_run(device, false)?; + let layout = parse_repart_layout(&partitions)?; + Ok(layout) +} + +/// Run systemd-repart on the device and return the parsed JSON output. +/// `dry_run`: if true, no changes are written to disk. +/// `definitions`: if set, uses `--definitions=` and `--empty=allow`; +/// otherwise uses the default config search paths with `--empty=force`. +fn systemd_repart_run(device: &Device, dry_run: bool) -> Result> { + let mut cmd = Command::new("systemd-repart"); + + // Enable fsverity for ext4 + // btrfs has fsverity enabled out of the box + cmd.env("SYSTEMD_REPART_MKFS_OPTIONS_EXT4", "-O verity"); + + let dry_run_arg = if dry_run { + "--dry-run=yes" } else { - // If there was no default filesystem, then there's no default block setup, - // and we need to error out. - anyhow::bail!("No install configuration found, and no filesystem specified") + "--dry-run=no" }; - let serial = device.serial.as_deref().unwrap_or(""); - let model = device.model.as_deref().unwrap_or(""); - let discoverable = use_discoverable_partitions(state); - println!("Block setup: {block_setup}"); - println!(" Size: {}", device.size); - println!(" Serial: {serial}"); - println!(" Model: {model}"); - println!( - " Partitions: {}", - if discoverable { "Discoverable" } else { "UUID" } - ); + cmd.args([ + dry_run_arg, + "--no-pager", + "--json=pretty", + "--empty=force", + "--root=/", + ]); - let root_size = opts - .root_size - .as_deref() - .map(bootc_blockdev::parse_size_mib) - .transpose() - .context("Parsing root size")?; + cmd.arg(device.path()); - // Load the policy from the container root, which also must be our install root - let sepolicy = state.load_policy()?; - let sepolicy = sepolicy.as_ref(); + let output = cmd.output().context("Failed to run systemd-repart")?; - // Create a temporary directory to use for mount points. Note that we're - // in a mount namespace, so these should not be visible on the host. - let physical_root_path = mntdir.join("rootfs"); - std::fs::create_dir_all(&physical_root_path)?; - let bootfs = mntdir.join("boot"); - std::fs::create_dir_all(bootfs)?; + if !output.status.success() { + let stderr = String::from_utf8_lossy(&output.stderr); + anyhow::bail!("systemd-repart failed: {stderr}"); + } + + serde_json::from_slice(&output.stdout).context("Failed to deserialize systemd-repart output") +} +/// Parse partition layout from systemd-repart JSON output. +fn parse_repart_layout(partitions: &[RepartPartition]) -> Result { + let mut esp_partno = None; + let mut boot_partno = None; + let mut rootpn = None; + + for part in partitions { + // repart partno is 0-indexed, lsblk/sfdisk use 1-indexed + let partno = part.partno + 1; + + match part.partition_type.as_str() { + "esp" => esp_partno = Some(partno), + "xbootldr" => boot_partno = Some(partno), + t if t.starts_with("root-") => rootpn = Some(partno), + _ => {} + } + } + + let rootpn = + rootpn.ok_or_else(|| anyhow::anyhow!("systemd-repart output missing root partition"))?; + + Ok(PartitionLayout { + esp_partno, + boot_partno, + rootpn, + used_repart: true, + }) +} + +/// Use sfdisk to create partitions +#[context("Running sfdisk")] +fn sfdisk( + device: &Device, + root_size: Option, + composefs_backend: bool, + requires_bootpart: bool, +) -> Result { // Generate partitioning spec as input to sfdisk let mut partno = 0; let mut partitioning_buf = String::new(); @@ -310,7 +395,7 @@ pub(crate) fn install_create_rootfs( let esp_guid = crate::discoverable_partition_specification::ESP; partno += 1; - let esp_size = if state.composefs_options.composefs_backend { + let esp_size = if composefs_backend { CFS_EFIPN_SIZE_MB } else { EFIPN_SIZE_MB @@ -328,7 +413,7 @@ pub(crate) fn install_create_rootfs( // Initialize the /boot filesystem. Note that in the future, we may match // what systemd/uapi-group encourages and make /boot be FAT32 as well, as // it would aid systemd-boot. - let boot_partno = if block_setup.requires_bootpart() { + let boot_partno = if requires_bootpart { partno += 1; writeln!( &mut partitioning_buf, @@ -355,7 +440,118 @@ pub(crate) fn install_create_rootfs( .quiet() .run_with_stdin_buf(Some(partitioning_buf.as_bytes())) .context("Failed to run sfdisk")?; - tracing::debug!("Created partition table"); + + Ok(PartitionLayout { + esp_partno, + boot_partno, + rootpn, + used_repart: false, + }) +} + +#[context("Creating rootfs")] +#[cfg(feature = "install-to-disk")] +pub(crate) fn install_create_rootfs( + state: &State, + opts: InstallBlockDeviceOpts, +) -> Result { + let install_config = state.install_config.as_ref(); + let luks_name = "root"; + // Verify that the target is empty (if not already wiped in particular, but it's + // also good to verify that the wipe worked) + let mut device = bootc_blockdev::list_dev(&opts.device)?; + + // Always disallow writing to mounted device + if is_mounted_in_pid1_mountns(&device.path())? { + anyhow::bail!("Device {} is mounted", device.path()) + } + + // Handle wiping any existing data + if opts.wipe { + let dev = &opts.device; + for child in device.children.iter().flatten() { + let child = child.path(); + println!("Wiping {child}"); + wipefs(Utf8Path::new(&child))?; + } + println!("Wiping {dev}"); + wipefs(dev)?; + } else if device.has_children() { + anyhow::bail!( + "Detected existing partitions on {}; use e.g. `wipefs` or --wipe if you intend to overwrite", + opts.device + ); + } + + let run_bootc = Utf8Path::new(RUN_BOOTC); + let mntdir = run_bootc.join("mounts"); + if mntdir.exists() { + std::fs::remove_dir_all(&mntdir)?; + } + + let use_systemd_repart = can_use_systemd_repart(); + + // Use the install configuration to find the block setup, if we have one + let block_setup = if let Some(config) = install_config { + config.get_block_setup(opts.block_setup.as_ref().copied())? + } else if opts.filesystem.is_some() || use_systemd_repart { + // Otherwise, if a filesystem is specified then we default to whatever was + // specified via --block-setup, or the default + opts.block_setup.unwrap_or_default() + } else { + // If there was no default filesystem, then there's no default block setup, + // and we need to error out. + anyhow::bail!("No install configuration found, and no filesystem specified") + }; + let serial = device.serial.as_deref().unwrap_or(""); + let model = device.model.as_deref().unwrap_or(""); + let discoverable = use_discoverable_partitions(state); + println!("Block setup: {block_setup}"); + println!(" Size: {}", device.size); + println!(" Serial: {serial}"); + println!(" Model: {model}"); + println!( + " Partitions: {}", + if discoverable { "Discoverable" } else { "UUID" } + ); + + let root_size = opts + .root_size + .as_deref() + .map(bootc_blockdev::parse_size_mib) + .transpose() + .context("Parsing root size")?; + + // Load the policy from the container root, which also must be our install root + let sepolicy = state.load_policy()?; + let sepolicy = sepolicy.as_ref(); + + // Create a temporary directory to use for mount points. Note that we're + // in a mount namespace, so these should not be visible on the host. + let physical_root_path = mntdir.join("rootfs"); + std::fs::create_dir_all(&physical_root_path)?; + let bootfs = mntdir.join("boot"); + std::fs::create_dir_all(bootfs)?; + + let layout = if use_systemd_repart { + systemd_repart(&device, root_size, opts.filesystem)? + } else { + sfdisk( + &device, + root_size, + state.composefs_options.composefs_backend, + block_setup.requires_bootpart(), + )? + }; + + tracing::debug!( + "Created partition table using {}", + if layout.used_repart { + "systemd-repart" + } else { + "sfdisk" + } + ); // Full udev sync; it'd obviously be better to await just the devices // we're targeting, but this is a simple coarse hammer. @@ -364,7 +560,25 @@ pub(crate) fn install_create_rootfs( // Re-read partition table to get updated children device.refresh()?; - let root_device = device.find_device_by_partno(rootpn)?; + // Ensure we have a root filesystem + let root_filesystem = if layout.used_repart { + let root = device.find_device_by_partno(layout.rootpn)?; + root.fstype + .as_ref() + .ok_or_else(|| anyhow::anyhow!("repart: Root filesystem type not defined"))? + } else { + let root_filesystem = opts + .filesystem + .or(install_config + .and_then(|c| c.filesystem_root()) + .and_then(|r| r.fstype)) + .ok_or_else(|| anyhow::anyhow!("No root filesystem specified"))?; + + &root_filesystem.to_string() + }; + + let root_device = device.find_device_by_partno(layout.rootpn)?; + // Verify the partition type matches the DPS root partition type for this architecture let expected_parttype = crate::discoverable_partition_specification::this_arch_root(); if !root_device @@ -373,7 +587,8 @@ pub(crate) fn install_create_rootfs( .is_some_and(|pt| pt.eq_ignore_ascii_case(expected_parttype)) { anyhow::bail!( - "root partition {rootpn} has type {}; expected {expected_parttype}", + "root partition {} has type {}; expected {expected_parttype}", + layout.rootpn, root_device.parttype.as_deref().unwrap_or("") ); } @@ -417,34 +632,63 @@ pub(crate) fn install_create_rootfs( }; // Initialize the /boot filesystem - let bootdev = if let Some(bootpn) = boot_partno { + let bootdev = if let Some(bootpn) = layout.boot_partno { Some(device.find_device_by_partno(bootpn)?) } else { None }; - let boot_uuid = if let Some(bootdev) = bootdev { - Some( - mkfs(&bootdev.path(), root_filesystem, "boot", opts.wipe, []) - .context("Initializing /boot")?, - ) - } else { - None - }; - // Unconditionally enable fsverity for ext4 - let mkfs_options = match root_filesystem { - Filesystem::Ext4 => ["-O", "verity"].as_slice(), - _ => [].as_slice(), + let boot_uuid = match bootdev { + Some(bootdev) => { + let u = if layout.used_repart { + let u = bootdev + .uuid + .as_ref() + .ok_or_else(|| anyhow::anyhow!("bootdev UUID not found"))?; + + u.parse::() + .with_context(|| format!("Parsing bootdev UUID {u}"))? + } else { + mkfs( + &bootdev.path(), + root_filesystem.as_str().try_into()?, + "boot", + opts.wipe, + [], + ) + .context("Initializing /boot")? + }; + + Some(u) + } + None => None, }; - // Initialize rootfs - let root_uuid = mkfs( - &rootdev_path, - root_filesystem, - "root", - opts.wipe, - mkfs_options.iter().copied(), - )?; + let root_uuid = if layout.used_repart { + // systemd-repart creates filesystem, just read the UUID it assigned + let u = root_device.uuid.as_ref().ok_or_else(|| { + anyhow::anyhow!("Root device created by repart has no filesystem UUID") + })?; + + u.parse::() + .with_context(|| format!("Parsing root fs UUID {u}"))? + } else { + let rootfs: Filesystem = root_filesystem.as_str().try_into()?; + + // Unconditionally enable fsverity for ext4 + let mkfs_options = match rootfs { + Filesystem::Ext4 => ["-O", "verity"].as_slice(), + _ => [].as_slice(), + }; + + mkfs( + &rootdev_path, + rootfs, + "root", + opts.wipe, + mkfs_options.iter().copied(), + )? + }; let bootsrc = boot_uuid.as_ref().map(|uuid| format!("UUID={uuid}")); let bootarg = bootsrc.as_deref().map(|bootsrc| format!("boot={bootsrc}")); let boot = bootsrc.map(|bootsrc| MountSpec { @@ -499,13 +743,15 @@ pub(crate) fn install_create_rootfs( crate::lsm::ensure_dir_labeled(&target_rootfs, "boot", None, 0o755.into(), sepolicy)?; // Create the EFI system partition, if applicable - if let Some(esp_partno) = esp_partno { + if let Some(esp_partno) = layout.esp_partno { let espdev = device.find_device_by_partno(esp_partno)?; - Task::new("Creating ESP filesystem", "mkfs.fat") - .args([&espdev.path(), "-n", "EFI-SYSTEM"]) - .verbose() - .quiet_output() - .run()?; + if !layout.used_repart { + Task::new("Creating ESP filesystem", "mkfs.fat") + .args([&espdev.path(), "-n", "EFI-SYSTEM"]) + .verbose() + .quiet_output() + .run()?; + } let efifs_path = bootfs.join(crate::bootloader::EFI_DIR); std::fs::create_dir(&efifs_path).context("Creating efi dir")?; } diff --git a/docs/src/bootc-install.md b/docs/src/bootc-install.md index 55816ec68d..ac3f8d30ba 100644 --- a/docs/src/bootc-install.md +++ b/docs/src/bootc-install.md @@ -424,6 +424,114 @@ If you're building tooling that uses `bootc install to-filesystem`, you should: over `/etc/fstab` for root mount options, as this works better with composefs and DPS auto-discovery. +## systemd-repart + +When `systemd-repart` is available and repart.d definitions are present in the +container image, `bootc install to-disk` uses systemd-repart instead of sfdisk +to partition the target disk. + +### How definitions are discovered + +Definitions are searched in the standard systemd-repart locations relative +to the container root: + +- `/etc/repart.d/*.conf` +- `/run/repart.d/*.conf` +- `/usr/local/lib/repart.d/*.conf` +- `/usr/lib/repart.d/*.conf` + +If `systemd-repart` is not installed or no `.conf` files exist in any of these +directories, bootc falls back to its built-in sfdisk partitioning. + +### Root partition handling + +All repart.d definitions are passed to systemd-repart together so that it can +plan a correct layout with proper space allocation across all partitions. + +If the image's repart.d definitions do **not** include a root partition +(`Type=root`), bootc automatically injects one into `/run/repart.d/` before +invoking systemd-repart. The generated root partition definition: + +- Uses `Type=root` (architecture-specific DPS GUID is resolved by systemd-repart) +- Applies `Format=` from the configured root filesystem type +- Honours `--root-size` if specified (via `SizeMinBytes`/`SizeMaxBytes`) +- Otherwise takes all remaining space on the disk + +This means images can ship repart.d definitions for additional partitions +(e.g. `/home`, swap, `/var`) without needing to also define root. +All definitions run at install time so that systemd-repart can plan the +layout with correct space allocation across all partitions. This is +important because the root filesystem is mounted read-only on bootc +systems (`/sysroot` is ro), so systemd-repart cannot resize it after +installation. + +**Important:** A root filesystem type is always required. It can come from +any of these sources (checked in order): + +1. `--filesystem` CLI argument +2. `install.filesystem.root.type` in the install configuration +3. `Format=` in the repart.d root partition definition + +If none of these provide a filesystem type, the installation will fail. + +### Firstboot definitions + +Images may include repart.d definitions for partitions beyond root, ESP, +and xbootldr, for example `/home`, swap, or `/var`. Because all definitions +run at install time, systemd-repart allocates space for all of them during +installation. + +### DPS auto-mount and symlinked directories + +`systemd-gpt-auto-generator` maps DPS partition types to fixed mount points +(e.g. `Type=home` mounts at `/home`). If the mount point is a symlink +as is common in ostree-based systems where `/home -> /var/home`, the +auto-generated mount unit will fail. + +For this to work, the container image must ensure that `/home` is a real +directory, not a symlink. Alternatively, use `Type=linux-generic` with a +partition label and mount it explicitly via a `systemd.mount-extra` kernel +argument: + +``` +systemd.mount-extra=PARTLABEL=home:/var/home:ext4 +``` + +### Filesystem creation + +When systemd-repart creates partitions, it also creates filesystems according +to the `Format=` directive in each definition. In this case bootc reads +the filesystem UUIDs assigned by systemd-repart rather than running `mkfs` +itself. + +### LUKS (tpm2-luks) + +systemd-repart integration is not supported with `--block-setup tpm2-luks`. +When LUKS is configured, bootc always falls back to sfdisk partitioning. +This is because LUKS needs to format the root partition with `cryptsetup +luksFormat` after partitioning, which conflicts with systemd-repart having +already created a filesystem on that partition. + +### Examples + +For the full definition file format, see +[repart.d(5)](https://www.freedesktop.org/software/systemd/man/latest/repart.d.html). + +#### Minimal: let bootc handle root + +An image that only wants a custom ESP size: + +```ini +# /usr/lib/repart.d/00-esp.conf +[Partition] +Type=esp +Format=vfat +SizeMinBytes=2G +SizeMaxBytes=2G +``` + +bootc will inject a root partition definition automatically. + ## Finding and configuring the physical root filesystem On a bootc system, the "physical root" is different from diff --git a/tmt/plans/integration.fmf b/tmt/plans/integration.fmf index 271d862efe..4f53a83ef0 100644 --- a/tmt/plans/integration.fmf +++ b/tmt/plans/integration.fmf @@ -294,6 +294,13 @@ execute: test: - /tmt/tests/tests/test-46-etc-merge-conflict +/plan-47-install-repart: + summary: Test bootc install to-disk with systemd-repart partitioning + discover: + how: fmf + test: + - /tmt/tests/tests/test-47-install-repart + /plan-48-composefs-uki-dumpfile: summary: Test composefs garbage collection for UKI discover: diff --git a/tmt/tests/booted/test-install-repart.nu b/tmt/tests/booted/test-install-repart.nu new file mode 100644 index 0000000000..6615dbaef1 --- /dev/null +++ b/tmt/tests/booted/test-install-repart.nu @@ -0,0 +1,177 @@ +# number: 47 +# tmt: +# summary: Test bootc install to-disk with systemd-repart partitioning +# duration: 30m + +use std assert +use tap.nu + +let st = bootc status --json | from json + +let bootloader = if ($st.status.booted.composefs? != null) { + $st.status.booted.composefs.bootloader | str downcase +} else { + "grub" +} + +# We need this for grub installation +let bios = if $bootloader == "grub" { + " +RUN < /usr/lib/repart.d/00-bios.conf +[Partition] +Type=21686148-6449-6e6f-744e-656564454649 +Label=BIOS-BOOT +SizeMinBytes=1M +SizeMaxBytes=1M +EOF + " + } else { + "" + } + +def run_install_to_disk [ + target_image: string + extra_bootc_args: list +] { + let composefs_args = if (tap is_composefs) { + ["--composefs-backend", "--bootloader", $bootloader] + } else { + "" + } + + let volume = $"-v /dev:/dev -v /run/udev:/run/udev -v /var/disk.img:/disk.img" + let base = $"podman run --rm --privileged ($volume) --pid=host --security-opt label=type:unconfined_t --env BOOTC_BOOTLOADER_DEBUG=1 ($target_image)" + let args = $"($composefs_args | str join ' ') ($extra_bootc_args | str join ' ')" + let bootc = $"bootc install to-disk ($args) --disable-selinux --via-loopback --source-imgref containers-storage:($target_image) /disk.img" + + tap run_install $"($base) ($bootc)" +} + +def test_repart_full [] { + tap begin "install with systemd-repart (ESP + root defined)" + + bootc image copy-to-storage + + let dockerfile = $"FROM localhost/bootc as base +RUN rm -rf /etc/repart.d /usr/lib/repart.d /usr/local/lib/repart.d /run/repart.d +RUN rm -rf /usr/lib/bootc/bound-images.d/* + +RUN mkdir -p /usr/lib/repart.d +($bios) +RUN <<'EOF' cat > /usr/lib/repart.d/00-esp.conf +[Partition] +Type=esp +Format=vfat +SizeMinBytes=1024M +SizeMaxBytes=1024M +EOF +RUN <<'EOF' cat > /usr/lib/repart.d/10-root.conf +[Partition] +Type=root +Format=ext4 +EOF +" + (tap make_uki_containerfile $dockerfile) | podman build -t localhost/bootc-repart . -f - + + truncate -s 10G /var/disk.img + setenforce 0 + + run_install_to_disk localhost/bootc-repart [] + + # Verify partition layout + let loop = (losetup -f --show /var/disk.img | str trim) + try { + partx -u $loop + udevadm settle + let parts = (lsblk -J -o name,parttype,partuuid $loop | from json) + let children = ($parts.blockdevices.0.children) + let part_types = ($children | get parttype) + + # ESP GUID + let esp_guid = "c12a7328-f81f-11d2-ba4b-00a0c93ec93b" + assert ($part_types | any {|t| ($t | str downcase) == $esp_guid }) "ESP partition not found" + + # Root partition (architecture-specific, just check it exists beyond ESP) + assert (($children | length) >= 2) "Expected at least 2 partitions (ESP + root)" + + print "PASS: repart created ESP + root partitions" + } catch { |e| + losetup -d $loop + error make { msg: $"Verification failed: ($e.msg)" } + } + + losetup -d $loop + rm -rf /var/disk.img +} + +def test_repart_no_root [] { + tap begin "install with systemd-repart (ESP only, root generated by bootc)" + + # Image has ESP + home in repart.d, but no root partition definition + let dockerfile = $"FROM localhost/bootc as base +RUN rm -rf /etc/repart.d /usr/lib/repart.d /usr/local/lib/repart.d /run/repart.d +RUN rm -rf /usr/lib/bootc/bound-images.d/* + +RUN mkdir -p /usr/lib/repart.d +($bios) +RUN <<'EOF' cat > /usr/lib/repart.d/00-esp.conf +[Partition] +Type=esp +Format=vfat +SizeMinBytes=512M +SizeMaxBytes=512M +EOF + +RUN <<'EOF' cat > /usr/lib/repart.d/20-home.conf +[Partition] +Type=home +Format=ext4 +SizeMinBytes=512M +SizeMaxBytes=512M +EOF +" + (tap make_uki_containerfile $dockerfile) | podman build -t localhost/bootc-repart-noroot . -f - + + truncate -s 10G /var/disk.img + setenforce 0 + + run_install_to_disk localhost/bootc-repart-noroot ["--filesystem" "ext4" "--root-size" "5G"] + + # Verify partition layout + let loop = (losetup -f --show /var/disk.img | str trim) + try { + partx -u $loop + udevadm settle + let parts = (lsblk -J --bytes -o name,parttype,partuuid,size $loop | from json) + print $parts + let children = ($parts.blockdevices.0.children) + let part_types = ($children | get parttype) + + # ESP GUID + let esp_guid = "c12a7328-f81f-11d2-ba4b-00a0c93ec93b" + assert ($part_types | any {|t| ($t | str downcase) == $esp_guid }) "ESP partition not found" + + # Should have ESP + root + home (and Bios for grub) + assert (($children | length) >= 3) "Expected at least 3 partitions" + + # Verify root is not using all disk space (--root-size 5G was specified) + let root_part = ($children | last) + let root_size_bytes = ($root_part.size | into int) + let five_gb = (5 * 1024 * 1024 * 1024) + assert ($root_size_bytes <= $five_gb) $"Root partition should be ~5G, got ($root_part.size)" + + print "PASS: repart created ESP, bootc generated root with correct size" + } catch { |e| + losetup -d $loop + error make { msg: $"Verification failed: ($e.msg)" } + } + + losetup -d $loop + rm -rf /var/disk.img +} + +def main [] { + test_repart_full + test_repart_no_root + tap ok +} diff --git a/tmt/tests/tests.fmf b/tmt/tests/tests.fmf index 486e96cfac..dfacfd3b1a 100644 --- a/tmt/tests/tests.fmf +++ b/tmt/tests/tests.fmf @@ -184,6 +184,11 @@ check: duration: 15m test: nu booted/test-etc-merge-conflict.nu +/test-47-install-repart: + summary: Test bootc install to-disk with systemd-repart partitioning + duration: 30m + test: nu booted/test-install-repart.nu + /test-48-composefs-uki-dumpfile: summary: Test composefs garbage collection for UKI duration: 30m