test(block): add unit tests for VIRTIO_BLK_F_WRITE_ZEROES

Add three tests parametrised over Sync and Async file engines:

  - test_write_zeroes_feature_and_config: VIRTIO_BLK_F_WRITE_ZEROES
    advertised on writable devices; max_write_zeroes_sectors,
    max_write_zeroes_seg, and write_zeroes_may_unmap populated as
    expected; read-only devices advertise none of these.
  - test_write_zeroes: end-to-end happy path (UNMAP=1 → PUNCH_HOLE,
    metric incremented, VIRTIO_BLK_S_OK) plus four error cases
    (reserved flag bit set, sector range out of bounds, num_sectors=0,
    invalid data length).
  - test_write_zeroes_unsupported_cached: pre-set the cache flag and
    verify subsequent requests return VIRTIO_BLK_S_UNSUPP without
    incrementing the success or invalid-request counters.

The UNMAP=0 (ZERO_RANGE) happy path is not asserted in the unit
tests because ZERO_RANGE support is filesystem-dependent (the host's
tmpfs in some kernels returns EOPNOTSUPP); end-to-end UNMAP=0
correctness is left to the integration tests running on ext4. The
unit tests cover wire-flag handling for UNMAP=0 via the
invalid-flags and zero-sectors cases.

Also extend test_request_type_from to assert the new
VIRTIO_BLK_T_WRITE_ZEROES → RequestType::WriteZeroes mapping.

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

Author: kalyazin

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

@@ -2194,4 +2194,237 @@ mod tests {
             );
         }
     }
+
+    #[test]
+    fn test_write_zeroes_feature_and_config() {
+        // Non-read-only block: VIRTIO_BLK_F_WRITE_ZEROES set, write-zeroes config
+        // fields populated.
+        for engine in [FileEngineType::Sync, FileEngineType::Async] {
+            let block = default_block(engine);
+            assert_ne!(
+                block.avail_features & (1u64 << VIRTIO_BLK_F_WRITE_ZEROES),
+                0
+            );
+            assert_eq!(block.avail_features & (1u64 << VIRTIO_BLK_F_RO), 0);
+            // default_block has 0x1000-byte backing file → 8 sectors.
+            assert_eq!(block.config_space.max_write_zeroes_sectors, 8);
+            assert_eq!(block.config_space.max_write_zeroes_seg, 1);
+            assert_eq!(block.config_space.write_zeroes_may_unmap, 1);
+        }
+
+        // Read-only block: VIRTIO_BLK_F_RO set, no write-zeroes.
+        let f = TempFile::new().unwrap();
+        f.as_file().set_len(0x1000).unwrap();
+        let config = VirtioBlockConfig {
+            drive_id: "test_ro_wz".to_string(),
+            path_on_host: f.as_path().to_str().unwrap().to_string(),
+            is_root_device: false,
+            partuuid: None,
+            is_read_only: true,
+            cache_type: CacheType::Unsafe,
+            rate_limiter: None,
+            file_engine_type: FileEngineType::default(),
+        };
+        let ro_block = VirtioBlock::new(config).unwrap();
+        assert_eq!(
+            ro_block.avail_features & (1u64 << VIRTIO_BLK_F_WRITE_ZEROES),
+            0
+        );
+        assert_ne!(ro_block.avail_features & (1u64 << VIRTIO_BLK_F_RO), 0);
+        assert_eq!(ro_block.config_space.max_write_zeroes_sectors, 0);
+        assert_eq!(ro_block.config_space.max_write_zeroes_seg, 0);
+        assert_eq!(ro_block.config_space.write_zeroes_may_unmap, 0);
+    }
+
+    #[test]
+    fn test_write_zeroes() {
+        for engine in [FileEngineType::Sync, FileEngineType::Async] {
+            let mut block = default_block(engine);
+            let mem = default_mem();
+            let interrupt = default_interrupt();
+            let vq = VirtQueue::new(GuestAddress(0), &mem, 16);
+            set_queue(&mut block, 0, vq.create_queue());
+            block.activate(mem.clone(), interrupt).unwrap();
+            read_blk_req_descriptors(&vq);
+
+            let request_type_addr = GuestAddress(vq.dtable[0].addr.get());
+            let data_addr = GuestAddress(vq.dtable[1].addr.get());
+            let status_addr = GuestAddress(vq.dtable[2].addr.get());
+
+            // Write-zeroes data descriptor is read-only (guest sends the segment list).
+            vq.dtable[1].flags.set(VIRTQ_DESC_F_NEXT);
+            vq.dtable[1].len.set(DISCARD_SEGMENT_SIZE);
+
+            // Valid write-zeroes with UNMAP=1 (PUNCH_HOLE — supported on tmpfs).
+            // The UNMAP=0 (ZERO_RANGE) happy path is not asserted here because
+            // ZERO_RANGE support is filesystem-dependent (e.g. older tmpfs returns
+            // EOPNOTSUPP); the wire-flag handling for UNMAP=0 is covered by the
+            // invalid-flag and zero-sectors cases below, and end-to-end correctness
+            // is left to the integration tests on ext4.
+            {
+                mem.write_obj::<u32>(VIRTIO_BLK_T_WRITE_ZEROES, request_type_addr)
+                    .unwrap();
+                mem.write_obj(
+                    DiscardWriteZeroes {
+                        sector: 0,
+                        num_sectors: 4,
+                        flags: VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP,
+                    },
+                    data_addr,
+                )
+                .unwrap();
+
+                check_metric_after_block!(
+                    &block.metrics.write_zeroes_count,
+                    1,
+                    simulate_queue_and_async_completion_events(&mut block, true)
+                );
+
+                assert_eq!(vq.used.idx.get(), 1);
+                assert_eq!(vq.used.ring[0].get().id, 0);
+                assert_eq!(vq.used.ring[0].get().len, 1); // status byte only
+                assert_eq!(mem.read_obj::<u32>(status_addr).unwrap(), VIRTIO_BLK_S_OK);
+            }
+
+            // Invalid: reserved flag bit set (any bit other than UNMAP).
+            {
+                vq.used.idx.set(0);
+                set_queue(&mut block, 0, vq.create_queue());
+                mem.write_obj::<u32>(VIRTIO_BLK_T_WRITE_ZEROES, request_type_addr)
+                    .unwrap();
+                mem.write_obj(
+                    DiscardWriteZeroes {
+                        sector: 0,
+                        num_sectors: 4,
+                        flags: 0x2, // reserved bit
+                    },
+                    data_addr,
+                )
+                .unwrap();
+
+                simulate_queue_event(&mut block, Some(true));
+
+                assert_eq!(vq.used.idx.get(), 1);
+                assert_eq!(
+                    u32::from(mem.read_obj::<u8>(status_addr).unwrap()),
+                    VIRTIO_BLK_S_IOERR
+                );
+            }
+
+            // Invalid: sector range exceeds disk bounds.
+            {
+                vq.used.idx.set(0);
+                set_queue(&mut block, 0, vq.create_queue());
+                mem.write_obj::<u32>(VIRTIO_BLK_T_WRITE_ZEROES, request_type_addr)
+                    .unwrap();
+                // 8-sector disk; sector 7 + 4 = 11 > 8.
+                mem.write_obj(
+                    DiscardWriteZeroes {
+                        sector: 7,
+                        num_sectors: 4,
+                        flags: 0,
+                    },
+                    data_addr,
+                )
+                .unwrap();
+
+                simulate_queue_event(&mut block, Some(true));
+
+                assert_eq!(vq.used.idx.get(), 1);
+                assert_eq!(
+                    u32::from(mem.read_obj::<u8>(status_addr).unwrap()),
+                    VIRTIO_BLK_S_IOERR
+                );
+            }
+
+            // Invalid: num_sectors=0.
+            {
+                vq.used.idx.set(0);
+                set_queue(&mut block, 0, vq.create_queue());
+                mem.write_obj::<u32>(VIRTIO_BLK_T_WRITE_ZEROES, request_type_addr)
+                    .unwrap();
+                mem.write_obj(
+                    DiscardWriteZeroes {
+                        sector: 0,
+                        num_sectors: 0,
+                        flags: 0,
+                    },
+                    data_addr,
+                )
+                .unwrap();
+
+                simulate_queue_event(&mut block, Some(true));
+
+                assert_eq!(vq.used.idx.get(), 1);
+                assert_eq!(
+                    u32::from(mem.read_obj::<u8>(status_addr).unwrap()),
+                    VIRTIO_BLK_S_IOERR
+                );
+            }
+
+            // Invalid data length: not a multiple of DISCARD_SEGMENT_SIZE → parse error.
+            {
+                vq.used.idx.set(0);
+                set_queue(&mut block, 0, vq.create_queue());
+                vq.dtable[1].len.set(DISCARD_SEGMENT_SIZE - 1);
+                mem.write_obj::<u32>(VIRTIO_BLK_T_WRITE_ZEROES, request_type_addr)
+                    .unwrap();
+
+                simulate_queue_event(&mut block, Some(true));
+
+                // Parse error → descriptor chain discarded (used len = 0).
+                assert_eq!(vq.used.idx.get(), 1);
+                assert_eq!(vq.used.ring[0].get().len, 0);
+            }
+        }
+    }
+
+    #[test]
+    fn test_write_zeroes_unsupported_cached() {
+        for engine in [FileEngineType::Sync, FileEngineType::Async] {
+            let mut block = default_block(engine);
+            let mem = default_mem();
+            let interrupt = default_interrupt();
+            let vq = VirtQueue::new(GuestAddress(0), &mem, 16);
+            set_queue(&mut block, 0, vq.create_queue());
+            block.activate(mem.clone(), interrupt).unwrap();
+            read_blk_req_descriptors(&vq);
+
+            let request_type_addr = GuestAddress(vq.dtable[0].addr.get());
+            let data_addr = GuestAddress(vq.dtable[1].addr.get());
+            let status_addr = GuestAddress(vq.dtable[2].addr.get());
+
+            vq.dtable[1].flags.set(VIRTQ_DESC_F_NEXT);
+            vq.dtable[1].len.set(DISCARD_SEGMENT_SIZE);
+
+            mem.write_obj::<u32>(VIRTIO_BLK_T_WRITE_ZEROES, request_type_addr)
+                .unwrap();
+            mem.write_obj(
+                DiscardWriteZeroes {
+                    sector: 0,
+                    num_sectors: 4,
+                    flags: 0,
+                },
+                data_addr,
+            )
+            .unwrap();
+
+            // Pre-set the flag as if a previous EOPNOTSUPP was already detected.
+            block.disk.write_zeroes_unsupported = true;
+
+            // Neither write_zeroes_count nor invalid_reqs_count should increment.
+            let wz_before = block.metrics.write_zeroes_count.count();
+            let invalid_before = block.metrics.invalid_reqs_count.count();
+            simulate_queue_and_async_completion_events(&mut block, true);
+            assert_eq!(block.metrics.write_zeroes_count.count(), wz_before);
+            assert_eq!(block.metrics.invalid_reqs_count.count(), invalid_before);
+
+            assert_eq!(vq.used.idx.get(), 1);
+            assert_eq!(vq.used.ring[0].get().len, 1); // status byte only
+            assert_eq!(
+                u32::from(mem.read_obj::<u8>(status_addr).unwrap()),
+                VIRTIO_BLK_S_UNSUPP
+            );
+        }
+    }
 }

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

@@ -666,6 +666,10 @@ mod tests {
             RequestType::from(VIRTIO_BLK_T_GET_ID),
             RequestType::GetDeviceID
         );
+        assert_eq!(
+            RequestType::from(VIRTIO_BLK_T_WRITE_ZEROES),
+            RequestType::WriteZeroes
+        );
         assert_eq!(RequestType::from(42), RequestType::Unsupported(42));
     }