feat(box): CRI writable volume mounts via copy materialization

CreateContainer previously rejected any writable mount and any
selinux_relabel mount with Unimplemented, so the "starting container with
volume" conformance specs (which mount a host dir writable with
SelinuxRelabel=true) failed. Both are now accepted:
- Writable mounts are materialized like read-only ones — the source is
  COPIED into the container rootfs at container_path. The host-created
  content is visible in the container and the container may write to its
  copy. NOTE: writes do NOT propagate back to the host source (microVM
  containers cannot bind-mount host paths post-boot); sufficient for
  read-oriented volumes + the conformance, logged as a warning.
- selinux_relabel is a no-op on this non-SELinux runtime; accepted rather
  than failing the container.

Non-private mount propagation (rshared/rslave/rprivate) remains
Unimplemented — it needs a real shared mount, not a copy.

Verified on the KVM server: "starting container with volume [Conformance]"
and "...when host path is a symlink" both pass; build + clippy clean, 219
cri tests pass (rejection test replaced with a writable-materialize test).

Author: Roy Lin

src/cri/src/runtime_service/convert.rs

@@ -102,18 +102,16 @@ fn validate_container_mount(mount: &Mount) -> Result<(), Status> {
             mount.container_path
         )));
     }
-    if !mount.readonly {
-        return Err(Status::unimplemented(format!(
-            "Writable CRI mounts are not yet supported for microVM-backed containers: {}",
-            mount.container_path
-        )));
-    }
-    if mount.selinux_relabel {
-        return Err(Status::unimplemented(format!(
-            "SELinux relabeling is not supported for CRI mount {}",
-            mount.container_path
-        )));
-    }
+    // Writable mounts are accepted but materialized by COPYING the source into
+    // the container rootfs (microVM-backed containers cannot bind-mount host
+    // paths post-boot). The container sees the contents and may write to its
+    // copy, but writes do NOT propagate back to the host source — sufficient for
+    // read-oriented volumes (configMap/secret/downwardAPI) and the basic volume
+    // conformance; true host propagation (and the propagation modes below) needs
+    // a shared mount and is intentionally still rejected.
+    //
+    // SELinux relabeling is a no-op on this non-SELinux runtime; accept it
+    // rather than failing the container so labeled volumes still work.
 
     let propagation = crate::cri_api::mount::MountPropagation::try_from(mount.propagation)
         .map_err(|_| {

src/cri/src/runtime_service/mod.rs

@@ -55,7 +55,7 @@ use convert::{
 };
 #[cfg(test)]
 use log_writer::CriLogWriter;
-use mounts::materialize_readonly_container_mount;
+use mounts::materialize_container_mount;
 use network::{
     bridge_network_name, connect_sandbox_to_network_store, default_network_store,
     disconnect_sandbox_from_network_store, sandbox_network_name,
@@ -880,7 +880,7 @@ impl RuntimeService for BoxRuntimeService {
         };
         if !mounts.is_empty() {
             if let Err(status) = self
-                .materialize_readonly_container_mounts(&rootfs_path, &mounts)
+                .materialize_container_mounts(&rootfs_path, &mounts)
                 .await
             {
                 self.cleanup_container_rootfs_path(&rootfs_path).await;

src/cri/src/runtime_service/mounts.rs

@@ -1,7 +1,9 @@
-//! Read-only container mount materialization for the CRI runtime service.
+//! Container mount materialization for the CRI runtime service.
 //!
 //! Copies CRI mount sources into a prepared rootfs, since microVM-backed
-//! containers cannot bind-mount host paths directly.
+//! containers cannot bind-mount host paths directly. This serves both read-only
+//! and writable mounts; for writable mounts the container writes to its private
+//! copy and those writes do NOT propagate back to the host source.
 
 use std::path::{Path, PathBuf};
 
@@ -66,7 +68,7 @@ fn copy_mount_source(source: &Path, target: &Path) -> std::io::Result<()> {
     Ok(())
 }
 
-pub(super) fn materialize_readonly_container_mount(
+pub(super) fn materialize_container_mount(
     rootfs: &Path,
     mount: &ContainerMount,
 ) -> Result<(), Status> {
@@ -78,6 +80,14 @@ pub(super) fn materialize_readonly_container_mount(
         )));
     }
 
+    if !mount.readonly {
+        tracing::warn!(
+            host_path = %mount.host_path,
+            container_path = %mount.container_path,
+            "Writable CRI mount is materialized by copy; in-container writes do not propagate to the host source"
+        );
+    }
+
     let target = container_path_inside_rootfs(rootfs, &mount.container_path)?;
     remove_existing_mount_target(&target).map_err(|e| {
         Status::internal(format!(
@@ -87,7 +97,7 @@ pub(super) fn materialize_readonly_container_mount(
     })?;
     copy_mount_source(source, &target).map_err(|e| {
         Status::internal(format!(
-            "Failed to materialize CRI read-only mount {} -> {}: {e}",
+            "Failed to materialize CRI mount {} -> {}: {e}",
             source.display(),
             target.display()
         ))

src/cri/src/runtime_service/service_ops.rs

@@ -152,7 +152,7 @@ impl BoxRuntimeService {
         })
     }
 
-    pub(super) async fn materialize_readonly_container_mounts(
+    pub(super) async fn materialize_container_mounts(
         &self,
         rootfs_path: &str,
         mounts: &[ContainerMount],
@@ -170,7 +170,7 @@ impl BoxRuntimeService {
         let mounts = mounts.to_vec();
         tokio::task::spawn_blocking(move || {
             for mount in &mounts {
-                materialize_readonly_container_mount(&rootfs, mount)?;
+                materialize_container_mount(&rootfs, mount)?;
             }
             Ok::<(), Status>(())
         })

src/cri/src/runtime_service/tests.rs

@@ -1726,36 +1726,52 @@ async fn test_create_container_materializes_readonly_mount() {
 }
 
 #[tokio::test]
-async fn test_create_container_rejects_writable_mounts() {
+async fn test_create_container_materializes_writable_mount() {
     let svc = make_test_service();
     svc.store.sandboxes.add(test_sandbox("sb-1")).await;
+    put_test_oci_image(&svc.image_store, "nginx:latest").await;
 
-    let result = svc
+    // Mirrors the CRI volume conformance: a writable mount with selinux_relabel
+    // set. Both are now accepted (relabel is a no-op on this non-SELinux
+    // runtime); the source is materialized by copy into the rootfs so the
+    // host-created file is visible in the container.
+    let source = tempfile::tempdir().unwrap();
+    std::fs::write(source.path().join("testVolume.file"), b"data").unwrap();
+
+    let resp = svc
         .create_container(Request::new(CreateContainerRequest {
             pod_sandbox_id: "sb-1".to_string(),
             config: Some(ContainerConfig {
                 metadata: Some(ContainerMetadata {
                     name: "mounted".to_string(),
                     attempt: 0,
                 }),
-                command: vec!["/bin/true".to_string()],
+                image: Some(ImageSpec {
+                    image: "nginx:latest".to_string(),
+                    annotations: HashMap::new(),
+                }),
+                command: vec!["nginx".to_string()],
                 mounts: vec![Mount {
                     container_path: "/data".to_string(),
-                    host_path: "/tmp".to_string(),
+                    host_path: source.path().to_string_lossy().to_string(),
                     readonly: false,
-                    selinux_relabel: false,
+                    selinux_relabel: true,
                     propagation: crate::cri_api::mount::MountPropagation::PropagationPrivate as i32,
                 }],
                 ..Default::default()
             }),
             sandbox_config: None,
         }))
-        .await;
+        .await
+        .unwrap()
+        .into_inner();
 
-    assert!(result.is_err());
-    let err = result.unwrap_err();
-    assert_eq!(err.code(), tonic::Code::Unimplemented);
-    assert!(err.message().contains("Writable CRI mounts"));
+    let container = svc.store.containers.get(&resp.container_id).await.unwrap();
+    assert_eq!(container.mounts.len(), 1);
+    let mounted_file = PathBuf::from(&container.rootfs_path)
+        .join("data")
+        .join("testVolume.file");
+    assert_eq!(std::fs::read_to_string(mounted_file).unwrap(), "data");
 }
 
 #[tokio::test]