feat(block): handle VIRTIO_BLK_T_WRITE_ZEROES requests

Wire up Request::parse() validation and Request::process() handling
for write-zeroes requests, mirroring the discard path:

  - parse(): reject write-only data descriptors and require data_len
    to be a non-zero multiple of DISCARD_SEGMENT_SIZE (the
    DiscardWriteZeroes struct is shared between both ops).
  - parse_write_zeroes_segment(): validate flags (only bit 0,
    VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP, is permitted), reject
    num_sectors=0, check sector range, and return the unmap flag
    so process() can pick the fallocate mode.
  - process(): short-circuit to VIRTIO_BLK_S_UNSUPP if a previous
    EOPNOTSUPP set disk.write_zeroes_unsupported; otherwise dispatch
    to FileEngine::write_zeroes().
  - the (Ok(_), RequestType::WriteZeroes) finish() arm now increments
    the write_zeroes_count metric and returns VIRTIO_BLK_S_OK.
  - the EOPNOTSUPP detection in the error path also handles
    RequestType::WriteZeroes, setting the cache and returning
    Status::WriteZeroesUnsupported (silent UNSUPP).

Add the write_zeroes_count metric and aggregate() line.

The feature flag is not yet advertised — that lands in the next
commit, after the request handling is fully in place.

Signed-off-by: Nikita Kalyazin <nikita.kalyazin@e2b.dev>

Author: kalyazin

src/vmm/src/devices/virtio/block/virtio/device.rs

@@ -596,6 +596,29 @@ impl VirtioBlock {
                             });
                         continue;
                     }
+                    if is_eopnotsupp && pending.request_type() == RequestType::WriteZeroes {
+                        if !self.disk.write_zeroes_unsupported {
+                            warn!(
+                                "Block write_zeroes not supported by host filesystem; disabling \
+                                 write_zeroes"
+                            );
+                            self.disk.write_zeroes_unsupported = true;
+                        }
+                        let finished = pending.finish(
+                            &active_state.mem,
+                            Err(IoErr::WriteZeroesUnsupported),
+                            &self.metrics,
+                        );
+                        queue
+                            .add_used(finished.desc_idx, finished.num_bytes_to_mem)
+                            .unwrap_or_else(|err| {
+                                error!(
+                                    "Failed to add available descriptor head {}: {}",
+                                    finished.desc_idx, err
+                                )
+                            });
+                        continue;
+                    }
 
                     let res = match cqe_result {
                         Ok(count) => Ok(count),

src/vmm/src/devices/virtio/block/virtio/metrics.rs

@@ -186,6 +186,8 @@ pub struct BlockDeviceMetrics {
     pub remaining_reqs_count: SharedIncMetric,
     /// Number of successful discard (TRIM) operations.
     pub discard_count: SharedIncMetric,
+    /// Number of successful write-zeroes operations.
+    pub write_zeroes_count: SharedIncMetric,
 }
 
 impl BlockDeviceMetrics {
@@ -233,6 +235,8 @@ impl BlockDeviceMetrics {
         self.remaining_reqs_count
             .add(other.remaining_reqs_count.fetch_diff());
         self.discard_count.add(other.discard_count.fetch_diff());
+        self.write_zeroes_count
+            .add(other.write_zeroes_count.fetch_diff());
     }
 }
 

src/vmm/src/devices/virtio/block/virtio/request.rs

@@ -15,7 +15,7 @@ use crate::devices::virtio::block::virtio::metrics::BlockDeviceMetrics;
 pub use crate::devices::virtio::generated::virtio_blk::{
     VIRTIO_BLK_ID_BYTES, VIRTIO_BLK_S_IOERR, VIRTIO_BLK_S_OK, VIRTIO_BLK_S_UNSUPP,
     VIRTIO_BLK_T_DISCARD, VIRTIO_BLK_T_FLUSH, VIRTIO_BLK_T_GET_ID, VIRTIO_BLK_T_IN,
-    VIRTIO_BLK_T_OUT, VIRTIO_BLK_T_WRITE_ZEROES,
+    VIRTIO_BLK_T_OUT, VIRTIO_BLK_T_WRITE_ZEROES, VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP,
 };
 use crate::devices::virtio::queue::DescriptorChain;
 use crate::logger::{IncMetric, error, warn};
@@ -228,8 +228,10 @@ impl PendingRequest {
                 }
             }
             (Ok(_), RequestType::WriteZeroes) => {
-                // Placeholder: replaced when feature is wired up.
-                Status::WriteZeroesUnsupported
+                block_metrics.write_zeroes_count.inc();
+                Status::Ok {
+                    num_bytes_to_mem: 0,
+                }
             }
             (Err(IoErr::DiscardUnsupported), _) => Status::DiscardUnsupported,
             (Err(IoErr::WriteZeroesUnsupported), _) => Status::WriteZeroesUnsupported,
@@ -267,6 +269,32 @@ fn parse_discard_segment(
     ))
 }
 
+fn parse_write_zeroes_segment(
+    data_addr: GuestAddress,
+    nsectors: u64,
+    mem: &GuestMemoryMmap,
+) -> Result<(u64, u64, bool), IoErr> {
+    // max_write_zeroes_seg = 1 guarantees exactly one segment per request.
+    let seg: DiscardWriteZeroes = mem.read_obj(data_addr).map_err(IoErr::GetId)?;
+    // Only bit 0 (UNMAP) is defined; all other bits MUST be 0 per virtio spec
+    // §5.2.6.14.
+    if seg.flags & !VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP != 0 {
+        return Err(IoErr::InvalidFlags);
+    }
+    if seg.num_sectors == 0 {
+        return Err(IoErr::InvalidOffset);
+    }
+    seg.sector
+        .checked_add(u64::from(seg.num_sectors))
+        .filter(|&top| top <= nsectors)
+        .ok_or(IoErr::InvalidOffset)?;
+    Ok((
+        seg.sector << SECTOR_SHIFT,
+        u64::from(seg.num_sectors) << SECTOR_SHIFT,
+        seg.flags & VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP != 0,
+    ))
+}
+
 /// The request header represents the mandatory fields of each block device request.
 ///
 /// A request header contains the following fields:
@@ -364,6 +392,9 @@ impl Request {
             if data_desc.is_write_only() && req.r#type == RequestType::Discard {
                 return Err(VirtioBlockError::UnexpectedWriteOnlyDescriptor);
             }
+            if data_desc.is_write_only() && req.r#type == RequestType::WriteZeroes {
+                return Err(VirtioBlockError::UnexpectedWriteOnlyDescriptor);
+            }
             if !data_desc.is_write_only() && req.r#type == RequestType::In {
                 return Err(VirtioBlockError::UnexpectedReadOnlyDescriptor);
             }
@@ -401,6 +432,11 @@ impl Request {
                     return Err(VirtioBlockError::InvalidDataLength);
                 }
             }
+            RequestType::WriteZeroes => {
+                if req.data_len == 0 || req.data_len % DISCARD_SEGMENT_SIZE != 0 {
+                    return Err(VirtioBlockError::InvalidDataLength);
+                }
+            }
             _ => {}
         }
 
@@ -498,12 +534,25 @@ impl Request {
                 }
             }
             RequestType::WriteZeroes => {
-                // Placeholder: replaced when feature is wired up in a later commit.
-                return ProcessingResult::Executed(pending.finish(
-                    mem,
-                    Err(IoErr::WriteZeroesUnsupported),
-                    block_metrics,
-                ));
+                if disk.write_zeroes_unsupported {
+                    return ProcessingResult::Executed(pending.finish(
+                        mem,
+                        Err(IoErr::WriteZeroesUnsupported),
+                        block_metrics,
+                    ));
+                }
+                match parse_write_zeroes_segment(self.data_addr, disk.nsectors, mem) {
+                    Err(io_err) => {
+                        return ProcessingResult::Executed(pending.finish(
+                            mem,
+                            Err(io_err),
+                            block_metrics,
+                        ));
+                    }
+                    Ok((offset, len, unmap)) => {
+                        disk.file_engine.write_zeroes(offset, len, unmap, pending)
+                    }
+                }
             }
             RequestType::Unsupported(_) => {
                 return ProcessingResult::Executed(pending.finish(mem, Ok(0), block_metrics));
@@ -530,6 +579,21 @@ impl Request {
                         Err(IoErr::DiscardUnsupported),
                         block_metrics,
                     ))
+                } else if err.error.is_eopnotsupp()
+                    && err.req.request_type() == RequestType::WriteZeroes
+                {
+                    if !disk.write_zeroes_unsupported {
+                        warn!(
+                            "Block write_zeroes not supported by host filesystem; disabling \
+                             write_zeroes"
+                        );
+                        disk.write_zeroes_unsupported = true;
+                    }
+                    ProcessingResult::Executed(err.req.finish(
+                        mem,
+                        Err(IoErr::WriteZeroesUnsupported),
+                        block_metrics,
+                    ))
                 } else {
                     ProcessingResult::Executed(err.req.finish(
                         mem,