feat(block): advertise VIRTIO_BLK_F_WRITE_ZEROES for non-read-only devices

Set VIRTIO_BLK_F_WRITE_ZEROES in avail_features for any non-read-only
block device, alongside VIRTIO_BLK_F_DISCARD. Populate the
max_write_zeroes_sectors, max_write_zeroes_seg, and
write_zeroes_may_unmap config fields in both VirtioBlock::new() and
the persist::restore() path so the values match what the guest sees
on a fresh boot vs after a snapshot restore.

write_zeroes_may_unmap=1 lets the guest set the UNMAP flag on
individual segments, which we then translate to fallocate's
PUNCH_HOLE mode (UNMAP=0 uses ZERO_RANGE).

Update the test_virtio_features and test_virtio_read_config
expectations to account for the new feature bit and config fields.

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

Author: kalyazin

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

@@ -27,7 +27,8 @@ use crate::devices::virtio::block::CacheType;
 use crate::devices::virtio::block::virtio::metrics::{BlockDeviceMetrics, BlockMetricsPerDevice};
 use crate::devices::virtio::device::{ActiveState, DeviceState, VirtioDevice};
 use crate::devices::virtio::generated::virtio_blk::{
-    VIRTIO_BLK_F_DISCARD, VIRTIO_BLK_F_FLUSH, VIRTIO_BLK_F_RO, VIRTIO_BLK_ID_BYTES,
+    VIRTIO_BLK_F_DISCARD, VIRTIO_BLK_F_FLUSH, VIRTIO_BLK_F_RO, VIRTIO_BLK_F_WRITE_ZEROES,
+    VIRTIO_BLK_ID_BYTES,
 };
 use crate::devices::virtio::generated::virtio_config::VIRTIO_F_VERSION_1;
 use crate::devices::virtio::generated::virtio_ids::VIRTIO_ID_BLOCK;
@@ -360,6 +361,7 @@ impl VirtioBlock {
             avail_features |= 1u64 << VIRTIO_BLK_F_RO;
         } else {
             avail_features |= 1u64 << VIRTIO_BLK_F_DISCARD;
+            avail_features |= 1u64 << VIRTIO_BLK_F_WRITE_ZEROES;
         }
 
         let queue_evts = [EventFd::new(libc::EFD_NONBLOCK).map_err(VirtioBlockError::EventFd)?];
@@ -385,6 +387,25 @@ impl VirtioBlock {
             // serialising them). max_discard_sectors is set to the full disk
             // so contiguous ranges are never split, regardless of this limit.
             max_discard_seg: if !config.is_read_only { 1 } else { 0 },
+            max_write_zeroes_sectors: if !config.is_read_only {
+                discard_sectors
+            } else {
+                0
+            },
+            // max_write_zeroes_seg = 1: each VIRTIO_BLK_T_WRITE_ZEROES
+            // request carries exactly one (sector, num_sectors, flags) tuple.
+            // Raising this would let the guest batch disjoint zero ranges
+            // (e.g. mkfs zeroing several inode tables) into a single
+            // multi-segment request, saving virtqueue round-trips. We keep
+            // it at 1 in this iteration because the async io_uring engine
+            // currently produces exactly one SQE per virtio request;
+            // multi-segment would require submitting N SQEs and only
+            // completing the virtio request after all N CQEs return (or
+            // serialising them). max_write_zeroes_sectors is set to the
+            // full disk so contiguous ranges are never split, regardless of
+            // this limit.
+            max_write_zeroes_seg: if !config.is_read_only { 1 } else { 0 },
+            write_zeroes_may_unmap: if !config.is_read_only { 1 } else { 0 },
             ..Default::default()
         };
 
@@ -912,10 +933,12 @@ mod tests {
 
             assert_eq!(block.device_type(), VIRTIO_ID_BLOCK);
 
-            // default_block is non-read-only, so VIRTIO_BLK_F_DISCARD is advertised.
+            // default_block is non-read-only, so VIRTIO_BLK_F_DISCARD and
+            // VIRTIO_BLK_F_WRITE_ZEROES are advertised.
             let features: u64 = (1u64 << VIRTIO_F_VERSION_1)
                 | (1u64 << VIRTIO_RING_F_EVENT_IDX)
-                | (1u64 << VIRTIO_BLK_F_DISCARD);
+                | (1u64 << VIRTIO_BLK_F_DISCARD)
+                | (1u64 << VIRTIO_BLK_F_WRITE_ZEROES);
 
             assert_eq!(
                 block.avail_features_by_page(0),
@@ -942,11 +965,14 @@ mod tests {
             let mut actual_config_space = ConfigSpace::default();
             block.read_config(0, actual_config_space.as_mut_slice());
             // The block's backing file size is 0x1000, so there are 8 (4096/512) sectors.
-            // default_block is non-read-only, so discard fields are populated.
+            // default_block is non-read-only, so discard and write-zeroes fields are populated.
             let expected_config_space = ConfigSpace {
                 capacity: 8,
                 max_discard_sectors: 8,
                 max_discard_seg: 1,
+                max_write_zeroes_sectors: 8,
+                max_write_zeroes_seg: 1,
+                write_zeroes_may_unmap: 1,
                 ..Default::default()
             };
             assert_eq!(actual_config_space, expected_config_space);

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

@@ -116,6 +116,9 @@ impl Persist<'_> for VirtioBlock {
             capacity: disk_properties.nsectors.to_le(),
             max_discard_sectors: if !is_read_only { discard_sectors } else { 0 },
             max_discard_seg: if !is_read_only { 1 } else { 0 },
+            max_write_zeroes_sectors: if !is_read_only { discard_sectors } else { 0 },
+            max_write_zeroes_seg: if !is_read_only { 1 } else { 0 },
+            write_zeroes_may_unmap: if !is_read_only { 1 } else { 0 },
             ..Default::default()
         };