bootc: Adapt to a few composefs-rs API changes

Assisted-by: OpenCode (Claude Sonnet 4)
Signed-off-by: Colin Walters <walters@verbum.org>

Author: cgwalters

crates/etc-merge/src/lib.rs

@@ -52,6 +52,7 @@ impl From<(&cap_std::fs::Metadata, Xattrs)> for MyStat {
             st_uid: value.0.uid(),
             st_gid: value.0.gid(),
             st_mtim_sec: value.0.mtime(),
+            st_mtim_nsec: value.0.mtime_nsec() as u32,
             xattrs: value.1,
         })
     }

crates/initramfs/src/lib.rs

@@ -28,7 +28,7 @@ use composefs::{
     mountcompat::{overlayfs_set_fd, overlayfs_set_lower_and_data_fds, prepare_mount},
     repository::Repository,
 };
-use composefs_boot::cmdline::get_cmdline_composefs;
+use composefs_boot::cmdline::ComposefsCmdline;
 use composefs_ctl::composefs;
 use composefs_ctl::composefs_boot;
 
@@ -463,7 +463,10 @@ pub fn setup_root(args: Args) -> Result<()> {
         config
     };
 
-    let (image, insecure) = get_cmdline_composefs::<Sha512HashValue>(&cmdline)?;
+    let composefs = ComposefsCmdline::<Sha512HashValue>::from_cmdline(&cmdline)?
+        .context("No composefs= or composefs.digest.v1= karg found")?;
+    let image = composefs.digest();
+    let insecure = composefs.is_insecure();
 
     let new_root = match &args.root_fs {
         Some(path) => open_root_fs(path).context("Failed to clone specified root fs")?,

crates/lib/src/bootc_composefs/boot.rs

@@ -82,7 +82,9 @@ use composefs_boot::bootloader::{
     BootEntry as ComposefsBootEntry, EFI_ADDON_DIR_EXT, EFI_ADDON_FILE_EXT, EFI_EXT, PEType,
     UsrLibModulesVmlinuz, get_boot_resources,
 };
-use composefs_boot::{cmdline::get_cmdline_composefs, os_release::OsReleaseInfo, uki};
+use composefs_boot::{
+    cmdline::ComposefsCmdline as BootComposefsCmdline, os_release::OsReleaseInfo, uki,
+};
 use composefs_ctl::composefs;
 use composefs_ctl::composefs_boot;
 use composefs_ctl::composefs_oci;
@@ -811,8 +813,11 @@ fn write_pe_to_esp(
     if matches!(pe_type, PEType::Uki) {
         let cmdline = uki::get_cmdline_buffered(&mut uki_reader).context("Getting UKI cmdline")?;
 
-        let (composefs_cmdline, missing_verity_allowed_cmdline) =
-            get_cmdline_composefs::<Sha512HashValue>(&cmdline).context("Parsing composefs=")?;
+        let parsed_cmdline = BootComposefsCmdline::<Sha512HashValue>::from_cmdline(&cmdline)
+            .context("Parsing composefs=")?
+            .context("No composefs= or composefs.digest.v1= karg found in UKI cmdline")?;
+        let composefs_cmdline = parsed_cmdline.digest().clone();
+        let missing_verity_allowed_cmdline = parsed_cmdline.is_insecure();
 
         // If the UKI cmdline does not match what the user has passed as cmdline option
         // NOTE: This will only be checked for new installs and now upgrades/switches

crates/lib/src/bootc_composefs/digest.rs

@@ -10,7 +10,9 @@ use camino::Utf8Path;
 use cap_std_ext::cap_std;
 use cap_std_ext::cap_std::fs::Dir;
 use composefs::dumpfile;
-use composefs::fsverity::{Algorithm, FsVerityHashValue};
+use composefs::erofs::format::FormatVersion;
+use composefs::fsverity::FsVerityHashValue;
+use composefs::repository::RepositoryConfig;
 use composefs_boot::BootOps as _;
 use composefs_ctl::composefs;
 use composefs_ctl::composefs_boot;
@@ -20,21 +22,26 @@ use crate::store::ComposefsRepository;
 
 /// Creates a temporary composefs repository for computing digests.
 ///
+/// The `erofs_version` controls which EROFS format the digest is computed for:
+/// use `FormatVersion::V1` to get a `composefs.digest.v1=` karg (V1 EROFS, C-tool
+/// compatible) or `FormatVersion::V2` for the legacy `composefs=` karg.
+///
 /// Returns the TempDir guard (must be kept alive for the repo to remain valid)
 /// and the repository wrapped in Arc.
 #[fn_error_context::context("Creating new temp composefs repo")]
-pub(crate) fn new_temp_composefs_repo() -> Result<(TempDir, Arc<ComposefsRepository>)> {
+pub(crate) fn new_temp_composefs_repo(
+    erofs_version: FormatVersion,
+) -> Result<(TempDir, Arc<ComposefsRepository>)> {
     let td_guard = tempfile::tempdir_in("/var/tmp")?;
     let td_path = td_guard.path();
     let td_dir = Dir::open_ambient_dir(td_path, cap_std::ambient_authority())?;
 
     td_dir.create_dir("repo")?;
     let repo_dir = td_dir.open_dir("repo")?;
-    let (mut repo, _created) =
-        ComposefsRepository::init_path(&repo_dir, ".", Algorithm::SHA512, false)
-            .context("Init cfs repo")?;
-    // We don't need to hard require verity on the *host* system, we're just computing a checksum here
-    repo.set_insecure();
+    let mut config = RepositoryConfig::new(composefs::fsverity::Algorithm::SHA512).set_insecure();
+    config.erofs_formats = composefs::erofs::format::FormatConfig::single(erofs_version);
+    let (repo, _created) =
+        ComposefsRepository::init_path(&repo_dir, ".", config).context("Init cfs repo")?;
     Ok((td_guard, Arc::new(repo)))
 }
 
@@ -58,13 +65,14 @@ pub(crate) fn new_temp_composefs_repo() -> Result<(TempDir, Arc<ComposefsReposit
 #[fn_error_context::context("Computing composefs digest")]
 pub(crate) async fn compute_composefs_digest(
     path: &Utf8Path,
+    erofs_version: FormatVersion,
     write_dumpfile_to: Option<&Utf8Path>,
 ) -> Result<String> {
     if path.as_str() == "/" {
         anyhow::bail!("Cannot operate on active root filesystem; mount separate target instead");
     }
 
-    let (_td_guard, repo) = new_temp_composefs_repo()?;
+    let (_td_guard, repo) = new_temp_composefs_repo(erofs_version)?;
 
     // Read filesystem from path, transform for boot, compute digest
     let dirfd: OwnedFd = rustix::fs::open(
@@ -81,7 +89,7 @@ pub(crate) async fn compute_composefs_digest(
     .await
     .context("Reading container root")?;
     fs.transform_for_boot(&repo).context("Preparing for boot")?;
-    let id = fs.compute_image_id();
+    let id = fs.compute_image_id(erofs_version);
     let digest = id.to_hex();
 
     if let Some(dumpfile_path) = write_dumpfile_to {
@@ -135,7 +143,9 @@ mod tests {
 
         // Compute the digest
         let path = Utf8Path::from_path(td.path()).unwrap();
-        let digest = compute_composefs_digest(path, None).await.unwrap();
+        let digest = compute_composefs_digest(path, FormatVersion::V2, None)
+            .await
+            .unwrap();
 
         // Verify it's a valid hex string of expected length (SHA-512 = 128 hex chars)
         assert_eq!(
@@ -150,7 +160,9 @@ mod tests {
         );
 
         // Verify consistency - computing twice on the same filesystem produces the same result
-        let digest2 = compute_composefs_digest(path, None).await.unwrap();
+        let digest2 = compute_composefs_digest(path, FormatVersion::V2, None)
+            .await
+            .unwrap();
         assert_eq!(
             digest, digest2,
             "Digest should be consistent across multiple computations"
@@ -159,7 +171,7 @@ mod tests {
 
     #[tokio::test]
     async fn test_compute_composefs_digest_rejects_root() {
-        let result = compute_composefs_digest(Utf8Path::new("/"), None).await;
+        let result = compute_composefs_digest(Utf8Path::new("/"), FormatVersion::V2, None).await;
         assert!(result.is_err());
         let err = result.unwrap_err();
         let found = err.chain().any(|e| {

crates/lib/src/bootc_composefs/repo.rs

@@ -99,16 +99,18 @@ pub(crate) async fn initialize_composefs_repository(
 
     crate::store::ensure_composefs_dir(rootfs_dir)?;
 
-    let (mut repo, _created) = crate::store::ComposefsRepository::init_path(
-        rootfs_dir,
-        "composefs",
-        composefs::fsverity::Algorithm::SHA512,
-        !allow_missing_fsverity,
-    )
-    .context("Failed to initialize composefs repository")?;
-    if allow_missing_fsverity {
-        repo.set_insecure();
-    }
+    let config = {
+        let c =
+            composefs::repository::RepositoryConfig::new(composefs::fsverity::Algorithm::SHA512);
+        if allow_missing_fsverity {
+            c.set_insecure()
+        } else {
+            c
+        }
+    };
+    let (repo, _created) =
+        crate::store::ComposefsRepository::init_path(rootfs_dir, "composefs", config)
+            .context("Failed to initialize composefs repository")?;
 
     let imgref: containers_image_proxy::ImageReference = state
         .source

crates/lib/src/bootc_composefs/update.rs

@@ -141,7 +141,7 @@ pub(crate) fn validate_update(
     let mut fs = create_filesystem(repo, &oci_digest, Some(config_verity))?;
     fs.transform_for_boot(&repo)?;
 
-    let image_id = fs.compute_image_id();
+    let image_id = fs.compute_image_id(composefs::erofs::format::FormatVersion::V2);
 
     let all_deployments = host.all_composefs_deployments()?;
 

crates/lib/src/cli.rs

@@ -17,6 +17,7 @@ use clap::CommandFactory;
 use clap::Parser;
 use clap::ValueEnum;
 use composefs::dumpfile;
+use composefs::erofs::format::FormatVersion;
 use composefs::fsverity;
 use composefs::fsverity::FsVerityHashValue;
 use composefs_ctl::composefs;
@@ -438,6 +439,14 @@ pub(crate) enum ContainerOpts {
         #[clap(long)]
         allow_missing_verity: bool,
 
+        /// EROFS format version to use when computing the composefs digest.
+        ///
+        /// V1 produces a `composefs.digest.v1=<hex>` karg (C-tool compatible).
+        /// V2 produces the legacy `composefs=<hex>` karg (composefs-rs native).
+        /// Must match the format version used when images were committed to the repository.
+        #[clap(hide = true, long, default_value = "v2")]
+        erofs_version: ErofsVersionArg,
+
         /// Write a dumpfile to this path
         #[clap(long)]
         write_dumpfile_to: Option<Utf8PathBuf>,
@@ -484,6 +493,24 @@ pub(crate) enum ContainerOpts {
     },
 }
 
+/// EROFS format version for `bootc container ukify --erofs-version`.
+#[derive(Debug, Clone, Copy, ValueEnum, PartialEq, Eq)]
+pub(crate) enum ErofsVersionArg {
+    /// V1 EROFS (C-tool compatible, `composefs.digest.v1=` karg).
+    V1,
+    /// V2 EROFS (composefs-rs native, `composefs=` karg).  Default.
+    V2,
+}
+
+impl From<ErofsVersionArg> for FormatVersion {
+    fn from(v: ErofsVersionArg) -> Self {
+        match v {
+            ErofsVersionArg::V1 => FormatVersion::V1,
+            ErofsVersionArg::V2 => FormatVersion::V2,
+        }
+    }
+}
+
 #[derive(Debug, Clone, ValueEnum, PartialEq, Eq)]
 pub(crate) enum ExportFormat {
     /// Export as tar archive
@@ -1841,15 +1868,20 @@ async fn run_from_opt(opt: Opt) -> Result<()> {
                 path,
                 write_dumpfile_to,
             } => {
-                let digest = compute_composefs_digest(&path, write_dumpfile_to.as_deref()).await?;
+                let digest = compute_composefs_digest(
+                    &path,
+                    FormatVersion::V2,
+                    write_dumpfile_to.as_deref(),
+                )
+                .await?;
                 println!("{digest}");
                 Ok(())
             }
             ContainerOpts::ComputeComposefsDigestFromStorage {
                 write_dumpfile_to,
                 image,
             } => {
-                let (_td_guard, repo) = new_temp_composefs_repo()?;
+                let (_td_guard, repo) = new_temp_composefs_repo(FormatVersion::V2)?;
 
                 let mut proxycfg = crate::deploy::new_proxy_config();
 
@@ -1892,7 +1924,7 @@ async fn run_from_opt(opt: Opt) -> Result<()> {
                 )
                 .context("Populating fs")?;
                 fs.transform_for_boot(&repo).context("Preparing for boot")?;
-                let id = fs.compute_image_id();
+                let id = fs.compute_image_id(composefs::erofs::format::FormatVersion::V2);
                 println!("{}", id.to_hex());
 
                 if let Some(path) = write_dumpfile_to.as_deref() {
@@ -1908,6 +1940,7 @@ async fn run_from_opt(opt: Opt) -> Result<()> {
                 rootfs,
                 kargs,
                 allow_missing_verity,
+                erofs_version,
                 write_dumpfile_to,
                 kernel_dir,
                 args,
@@ -1940,6 +1973,7 @@ async fn run_from_opt(opt: Opt) -> Result<()> {
                     &args,
                     kernel,
                     allow_missing_verity,
+                    erofs_version.into(),
                     write_dumpfile_to.as_deref(),
                 )
                 .await

crates/lib/src/install.rs

@@ -2023,8 +2023,9 @@ async fn install_to_filesystem_impl(
             let (cfs_repo, _created) = crate::store::ComposefsRepository::init_path(
                 &rootfs.physical_root,
                 crate::store::COMPOSEFS,
-                composefs_ctl::composefs::fsverity::Algorithm::SHA512,
-                false,
+                composefs_ctl::composefs::repository::RepositoryConfig::new(
+                    composefs_ctl::composefs::fsverity::Algorithm::SHA512,
+                ),
             )?;
             crate::deploy::check_disk_space_composefs(
                 &cfs_repo,

crates/lib/src/store/mod.rs

@@ -111,6 +111,7 @@ use ostree_ext::{gio, ostree};
 use rustix::fs::Mode;
 
 use composefs::fsverity::Sha512HashValue;
+use composefs::repository::RepositoryConfig;
 use composefs_ctl::composefs;
 
 use crate::bootc_composefs::backwards_compat::bcompat_boot::prepend_custom_prefix;
@@ -618,16 +619,19 @@ impl Storage {
         let ostree = self.get_ostree()?;
         let ostree_repo = &ostree.repo();
         let ostree_verity = ostree_ext::fsverity::is_verity_enabled(ostree_repo)?;
-        let (mut composefs, _created) = ComposefsRepository::init_path(
-            self.physical_root.open_dir(COMPOSEFS)?,
-            ".",
-            composefs::fsverity::Algorithm::SHA512,
-            ostree_verity.enabled,
-        )?;
+        let config = {
+            let c = RepositoryConfig::new(composefs::fsverity::Algorithm::SHA512);
+            if !ostree_verity.enabled {
+                c.set_insecure()
+            } else {
+                c
+            }
+        };
         if !ostree_verity.enabled {
             tracing::debug!("Setting insecure mode for composefs repo");
-            composefs.set_insecure();
         }
+        let (composefs, _created) =
+            ComposefsRepository::init_path(self.physical_root.open_dir(COMPOSEFS)?, ".", config)?;
         let composefs = Arc::new(composefs);
         let r = Arc::clone(self.composefs.get_or_init(|| composefs));
         Ok(r)

crates/lib/src/testutils.rs

@@ -164,14 +164,15 @@ impl TestRoot {
 
         // Initialize the composefs repo (creates meta.json)
         let repo_dir = root.open_dir("composefs")?;
-        let (mut repo, _created) = ComposefsRepository::init_path(
+        let (repo, _created) = ComposefsRepository::init_path(
             &repo_dir,
             ".",
-            composefs_ctl::composefs::fsverity::Algorithm::SHA512,
-            false,
+            composefs_ctl::composefs::repository::RepositoryConfig::new(
+                composefs_ctl::composefs::fsverity::Algorithm::SHA512,
+            )
+            .set_insecure(),
         )
         .context("Initializing composefs repo")?;
-        repo.set_insecure();
 
         let mut test_root = Self {
             root,