block: Move VHD format files into formats/vhd/

Move VHD format implementation into a structured directory layout:

  fixed_vhd.rs       -> formats/vhd/internal/fixed.rs     (FixedVhd)
  fixed_vhd_disk.rs  -> formats/vhd/mod.rs                (VhdDisk)
  vhd.rs             -> formats/vhd/internal/footer.rs     (VhdFooter)
  fixed_vhd_sync.rs  -> formats/vhd/worker/sync.rs         (FixedVhdSync)
  fixed_vhd_async.rs -> formats/vhd/worker/async_uring.rs  (FixedVhdAsync)

Add #[allow(dead_code)] to VhdFooter struct and impl because the
module is now pub(crate) and the compiler can see that several
fields and getters are only exercised by unit tests. Re-export
formats::vhd as fixed_vhd_disk in lib.rs for backward
compatibility with external consumers.

Signed-off-by: Anatol Belski <anbelski@linux.microsoft.com>

block/src/formats/mod.rs

@@ -8,3 +8,4 @@
 //! format specific internals, and sync/async I/O workers.
 
 pub mod raw;
+pub mod vhd;

block/src/formats/vhd/internal/fixed.rs

@@ -0,0 +1,99 @@
+// Copyright © 2021 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+
+use std::fs::File;
+use std::io::{Read, Seek, SeekFrom, Write};
+use std::os::unix::io::{AsRawFd, RawFd};
+
+use super::footer::VhdFooter;
+use crate::BlockBackend;
+
+#[derive(Debug)]
+pub struct FixedVhd {
+    file: File,
+    size: u64,
+    position: u64,
+}
+
+impl FixedVhd {
+    pub fn new(mut file: File) -> std::io::Result<Self> {
+        let footer = VhdFooter::new(&mut file)?;
+
+        Ok(Self {
+            file,
+            size: footer.current_size(),
+            position: 0,
+        })
+    }
+}
+
+impl AsRawFd for FixedVhd {
+    fn as_raw_fd(&self) -> RawFd {
+        self.file.as_raw_fd()
+    }
+}
+
+impl Read for FixedVhd {
+    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+        match self.file.read(buf) {
+            Ok(r) => {
+                self.position = self.position.checked_add(r.try_into().unwrap()).unwrap();
+                Ok(r)
+            }
+            Err(e) => Err(e),
+        }
+    }
+}
+
+impl Write for FixedVhd {
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        match self.file.write(buf) {
+            Ok(r) => {
+                self.position = self.position.checked_add(r.try_into().unwrap()).unwrap();
+                Ok(r)
+            }
+            Err(e) => Err(e),
+        }
+    }
+
+    fn flush(&mut self) -> std::io::Result<()> {
+        self.file.sync_all()
+    }
+}
+
+impl Seek for FixedVhd {
+    fn seek(&mut self, newpos: SeekFrom) -> std::io::Result<u64> {
+        match self.file.seek(newpos) {
+            Ok(pos) => {
+                self.position = pos;
+                Ok(pos)
+            }
+            Err(e) => Err(e),
+        }
+    }
+}
+
+impl BlockBackend for FixedVhd {
+    fn logical_size(&self) -> Result<u64, crate::Error> {
+        Ok(self.size)
+    }
+
+    /// Returns the physical size of the underlying file.
+    fn physical_size(&self) -> Result<u64, crate::Error> {
+        self.file
+            .metadata()
+            .map(|m| m.len())
+            .map_err(crate::Error::GetFileMetadata)
+    }
+}
+
+impl Clone for FixedVhd {
+    fn clone(&self) -> Self {
+        Self {
+            file: self.file.try_clone().expect("FixedVhd cloning failed"),
+            size: self.size,
+            position: self.position,
+        }
+    }
+}

block/src/formats/vhd/internal/footer.rs

@@ -0,0 +1,225 @@
+// Copyright © 2021 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+
+use std::fs::File;
+use std::io::{Seek, SeekFrom};
+
+use crate::{DiskTopology, read_aligned_block_size};
+
+// Production code uses: cookie, file_format_version, data_offset,
+// current_size, disk_type. The remaining fields are parsed for VHD
+// spec completeness and exercised only by unit tests.
+#[derive(Clone, Copy)]
+#[allow(dead_code)]
+pub struct VhdFooter {
+    cookie: u64,
+    features: u32,
+    file_format_version: u32,
+    data_offset: u64,
+    time_stamp: u32,
+    creator_application: u32,
+    creator_version: u32,
+    creator_host_os: u32,
+    original_size: u64,
+    current_size: u64,
+    disk_geometry: u32,
+    disk_type: u32,
+    checksum: u32,
+    unique_id: u128,
+    saved_state: u8,
+}
+
+#[allow(dead_code)]
+impl VhdFooter {
+    pub fn new(file: &mut File) -> std::io::Result<VhdFooter> {
+        let blocksize = DiskTopology::probe(file)?.logical_block_size as usize;
+
+        // Place the cursor in the last block of the file
+        file.seek(SeekFrom::End(0 - (blocksize as i64)))?;
+        // Read in the last block
+        let data = read_aligned_block_size(file)?;
+
+        // We only care about the last sector
+        let offset = blocksize - 512;
+        let sector = &data[offset..];
+
+        Ok(VhdFooter {
+            cookie: u64::from_be_bytes(sector[0..8].try_into().unwrap()),
+            features: u32::from_be_bytes(sector[8..12].try_into().unwrap()),
+            file_format_version: u32::from_be_bytes(sector[12..16].try_into().unwrap()),
+            data_offset: u64::from_be_bytes(sector[16..24].try_into().unwrap()),
+            time_stamp: u32::from_be_bytes(sector[24..28].try_into().unwrap()),
+            creator_application: u32::from_be_bytes(sector[28..32].try_into().unwrap()),
+            creator_version: u32::from_be_bytes(sector[32..36].try_into().unwrap()),
+            creator_host_os: u32::from_be_bytes(sector[36..40].try_into().unwrap()),
+            original_size: u64::from_be_bytes(sector[40..48].try_into().unwrap()),
+            current_size: u64::from_be_bytes(sector[48..56].try_into().unwrap()),
+            disk_geometry: u32::from_be_bytes(sector[56..60].try_into().unwrap()),
+            disk_type: u32::from_be_bytes(sector[60..64].try_into().unwrap()),
+            checksum: u32::from_be_bytes(sector[64..68].try_into().unwrap()),
+            unique_id: u128::from_be_bytes(sector[68..84].try_into().unwrap()),
+            saved_state: u8::from_be_bytes(sector[84..85].try_into().unwrap()),
+        })
+    }
+
+    pub fn cookie(&self) -> u64 {
+        self.cookie
+    }
+    pub fn features(&self) -> u32 {
+        self.features
+    }
+    pub fn file_format_version(&self) -> u32 {
+        self.file_format_version
+    }
+    pub fn data_offset(&self) -> u64 {
+        self.data_offset
+    }
+    pub fn time_stamp(&self) -> u32 {
+        self.time_stamp
+    }
+    pub fn creator_application(&self) -> u32 {
+        self.creator_application
+    }
+    pub fn creator_version(&self) -> u32 {
+        self.creator_version
+    }
+    pub fn creator_host_os(&self) -> u32 {
+        self.creator_host_os
+    }
+    pub fn original_size(&self) -> u64 {
+        self.original_size
+    }
+    pub fn current_size(&self) -> u64 {
+        self.current_size
+    }
+    pub fn disk_geometry(&self) -> u32 {
+        self.disk_geometry
+    }
+    pub fn disk_type(&self) -> u32 {
+        self.disk_type
+    }
+    pub fn checksum(&self) -> u32 {
+        self.checksum
+    }
+    pub fn unique_id(&self) -> u128 {
+        self.unique_id
+    }
+    pub fn saved_state(&self) -> u8 {
+        self.saved_state
+    }
+}
+
+/// Determine image type through file parsing.
+pub fn is_fixed_vhd(f: &mut File) -> std::io::Result<bool> {
+    let footer = VhdFooter::new(f)?;
+
+    // "conectix" => 0x636f6e6563746978
+    Ok(footer.cookie() == 0x636f6e6563746978
+        && footer.file_format_version() == 0x0001_0000
+        && footer.data_offset() == 0xffff_ffff_ffff_ffff
+        && footer.disk_type() == 0x2)
+}
+
+#[cfg(test)]
+mod unit_tests {
+    use std::fs::File;
+    use std::io::{Seek, SeekFrom, Write};
+
+    use vmm_sys_util::tempfile::TempFile;
+
+    use super::{VhdFooter, is_fixed_vhd};
+
+    fn valid_fixed_vhd_footer() -> Vec<u8> {
+        vec![
+            0x63, 0x6f, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x78, // cookie
+            0x00, 0x00, 0x00, 0x02, // features
+            0x00, 0x01, 0x00, 0x00, // file format version
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // data offset
+            0x27, 0xa6, 0xa6, 0x5d, // time stamp
+            0x71, 0x65, 0x6d, 0x75, // creator application
+            0x00, 0x05, 0x00, 0x03, // creator version
+            0x57, 0x69, 0x32, 0x6b, // creator host os
+            0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, // original size
+            0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, // current size
+            0x11, 0xe0, 0x10, 0x3f, // disk geometry
+            0x00, 0x00, 0x00, 0x02, // disk type
+            0x00, 0x00, 0x00, 0x00, // checksum
+            0x98, 0x7b, 0xb1, 0xcd, 0x84, 0x14, 0x41, 0xfc, 0xa4, 0xab, 0xd0, 0x69, 0x45, 0x2b,
+            0xf2, 0x23, // unique id
+            0x00, // saved state
+        ]
+    }
+
+    fn valid_dynamic_vhd_footer() -> Vec<u8> {
+        vec![
+            0x63, 0x6f, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x78, // cookie
+            0x00, 0x00, 0x00, 0x02, // features
+            0x00, 0x01, 0x00, 0x00, // file format version
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // data offset
+            0x27, 0xa6, 0xa6, 0x5d, // time stamp
+            0x71, 0x65, 0x6d, 0x75, // creator application
+            0x00, 0x05, 0x00, 0x03, // creator version
+            0x57, 0x69, 0x32, 0x6b, // creator host os
+            0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, // original size
+            0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, // current size
+            0x11, 0xe0, 0x10, 0x3f, // disk geometry
+            0x00, 0x00, 0x00, 0x03, // disk type
+            0x00, 0x00, 0x00, 0x00, // checksum
+            0x98, 0x7b, 0xb1, 0xcd, 0x84, 0x14, 0x41, 0xfc, 0xa4, 0xab, 0xd0, 0x69, 0x45, 0x2b,
+            0xf2, 0x23, // unique id
+            0x00, // saved state
+        ]
+    }
+
+    fn with_file<F>(footer: &[u8], mut testfn: F)
+    where
+        F: FnMut(File),
+    {
+        let mut disk_file: File = TempFile::new().unwrap().into_file();
+        disk_file.set_len(0x1000_0200).unwrap();
+        disk_file.seek(SeekFrom::Start(0x1000_0000)).unwrap();
+        disk_file.write_all(footer).unwrap();
+
+        testfn(disk_file); // File closed when the function exits.
+    }
+
+    #[test]
+    fn test_check_vhd_footer() {
+        with_file(&valid_fixed_vhd_footer(), |mut file: File| {
+            let vhd_footer = VhdFooter::new(&mut file).expect("Failed to create VHD footer");
+            assert_eq!(vhd_footer.cookie(), 0x636f_6e65_6374_6978);
+            assert_eq!(vhd_footer.features(), 0x0000_0002);
+            assert_eq!(vhd_footer.file_format_version(), 0x0001_0000);
+            assert_eq!(vhd_footer.data_offset(), 0xffff_ffff_ffff_ffff);
+            assert_eq!(vhd_footer.time_stamp(), 0x27a6_a65d);
+            assert_eq!(vhd_footer.creator_application(), 0x7165_6d75);
+            assert_eq!(vhd_footer.creator_version(), 0x0005_0003);
+            assert_eq!(vhd_footer.creator_host_os(), 0x5769_326b);
+            assert_eq!(vhd_footer.original_size(), 0x0000_0000_1000_0000);
+            assert_eq!(vhd_footer.current_size(), 0x0000_0000_1000_0000);
+            assert_eq!(vhd_footer.disk_geometry(), 0x11e0_103f);
+            assert_eq!(vhd_footer.disk_type(), 0x0000_0002);
+            assert_eq!(vhd_footer.checksum(), 0x0000_0000);
+            assert_eq!(
+                vhd_footer.unique_id(),
+                0x987b_b1cd_8414_41fc_a4ab_d069_452b_f223
+            );
+            assert_eq!(vhd_footer.saved_state(), 0x00);
+        });
+    }
+
+    #[test]
+    fn test_is_fixed_vhd() {
+        with_file(&valid_fixed_vhd_footer(), |mut file: File| {
+            assert!(is_fixed_vhd(&mut file).unwrap());
+        });
+    }
+
+    #[test]
+    fn test_is_not_fixed_vhd() {
+        with_file(&valid_dynamic_vhd_footer(), |mut file: File| {
+            assert!(!(is_fixed_vhd(&mut file).unwrap()));
+        });
+    }
+}

block/src/formats/vhd/internal/mod.rs

@@ -0,0 +1,11 @@
+// Copyright 2026 The Cloud Hypervisor Authors. All rights reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+
+//! VHD format parsing and data structures.
+//!
+//! Contains the footer parser and the low level fixed VHD
+//! block backend.
+
+pub(crate) mod fixed;
+pub(crate) mod footer;

block/src/formats/vhd/mod.rs

@@ -0,0 +1,252 @@
+// Copyright 2026 The Cloud Hypervisor Authors. All rights reserved.
+//
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+//
+// SPDX-License-Identifier: Apache-2.0
+
+//! Fixed VHD disk image format.
+//!
+//! Provides [`VhdDisk`], the `DiskFile` wrapper for fixed size VHD
+//! images.
+
+pub(crate) mod internal;
+pub(crate) mod worker;
+
+use std::fs::File;
+use std::io;
+use std::os::unix::io::AsRawFd;
+
+pub use internal::footer::is_fixed_vhd;
+
+use self::internal::fixed::FixedVhd;
+#[cfg(feature = "io_uring")]
+use self::worker::async_uring::FixedVhdAsync;
+use self::worker::sync::FixedVhdSync;
+use crate::async_io::{AsyncIo, BorrowedDiskFd, DiskFileError};
+use crate::disk_file::DiskSize;
+use crate::error::{BlockError, BlockErrorKind, BlockResult, ErrorOp};
+use crate::{BlockBackend, Error, disk_file};
+
+#[derive(Debug)]
+pub struct VhdDisk {
+    inner: FixedVhd,
+    use_io_uring: bool,
+}
+
+impl VhdDisk {
+    pub fn new(file: File, use_io_uring: bool) -> BlockResult<Self> {
+        #[cfg(not(feature = "io_uring"))]
+        if use_io_uring {
+            return Err(BlockError::new(
+                BlockErrorKind::UnsupportedFeature,
+                DiskFileError::NewAsyncIo(io::Error::other(
+                    "io_uring requested but feature is not enabled",
+                )),
+            ));
+        }
+
+        Ok(Self {
+            inner: FixedVhd::new(file).map_err(|e| BlockError::from(e).with_op(ErrorOp::Open))?,
+            use_io_uring,
+        })
+    }
+}
+
+impl disk_file::DiskSize for VhdDisk {
+    fn logical_size(&self) -> BlockResult<u64> {
+        self.inner
+            .logical_size()
+            .map_err(|e| BlockError::new(BlockErrorKind::Io, e))
+    }
+}
+
+impl disk_file::PhysicalSize for VhdDisk {
+    fn physical_size(&self) -> BlockResult<u64> {
+        self.inner.physical_size().map_err(|e| match e {
+            Error::GetFileMetadata(io) => {
+                BlockError::new(BlockErrorKind::Io, Error::GetFileMetadata(io))
+            }
+            _ => unreachable!("unexpected error from FixedVhd::physical_size(): {e}"),
+        })
+    }
+}
+
+impl disk_file::DiskFd for VhdDisk {
+    fn fd(&self) -> BorrowedDiskFd<'_> {
+        BorrowedDiskFd::new(self.inner.as_raw_fd())
+    }
+}
+
+impl disk_file::Geometry for VhdDisk {}
+
+impl disk_file::SparseCapable for VhdDisk {}
+
+impl disk_file::Resizable for VhdDisk {
+    fn resize(&mut self, _size: u64) -> BlockResult<()> {
+        Err(BlockError::new(
+            BlockErrorKind::UnsupportedFeature,
+            DiskFileError::ResizeError(io::Error::other("resize not supported for fixed VHD")),
+        )
+        .with_op(ErrorOp::Resize))
+    }
+}
+
+impl disk_file::DiskFile for VhdDisk {}
+
+impl disk_file::AsyncDiskFile for VhdDisk {
+    fn try_clone(&self) -> BlockResult<Box<dyn disk_file::AsyncDiskFile>> {
+        Ok(Box::new(VhdDisk {
+            inner: self.inner.clone(),
+            use_io_uring: self.use_io_uring,
+        }))
+    }
+
+    fn create_async_io(&self, ring_depth: u32) -> BlockResult<Box<dyn AsyncIo>> {
+        let size = self.logical_size()?;
+
+        if self.use_io_uring {
+            #[cfg(feature = "io_uring")]
+            {
+                return Ok(Box::new(FixedVhdAsync::new(
+                    self.inner.as_raw_fd(),
+                    ring_depth,
+                    size,
+                )?));
+            }
+
+            #[cfg(not(feature = "io_uring"))]
+            unreachable!("use_io_uring is set but io_uring feature is not enabled");
+        }
+
+        let _ = ring_depth;
+        Ok(Box::new(
+            FixedVhdSync::new(self.inner.as_raw_fd(), size).map_err(|e| {
+                BlockError::new(BlockErrorKind::Io, DiskFileError::NewAsyncIo(e))
+                    .with_op(ErrorOp::Open)
+            })?,
+        ))
+    }
+}
+
+#[cfg(test)]
+mod unit_tests {
+    use std::fs::File;
+    use std::io::{Seek, SeekFrom, Write};
+    #[cfg(feature = "io_uring")]
+    use std::os::fd::AsRawFd;
+
+    use vmm_sys_util::tempfile::TempFile;
+
+    use super::*;
+    use crate::async_io::AsyncIo;
+    #[cfg(feature = "io_uring")]
+    use crate::async_io::{AsyncIoOperation, OwnedIoBuffer};
+    use crate::disk_file::{AsyncDiskFile, DiskSize, PhysicalSize, Resizable};
+
+    /// Minimal fixed VHD footer (disk type = 2, current_size = 0x11223344).
+    fn fixed_vhd_footer() -> &'static [u8] {
+        &[
+            0x63, 0x6f, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x78, // cookie
+            0x00, 0x00, 0x00, 0x02, // features
+            0x00, 0x01, 0x00, 0x00, // file format version
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // data offset
+            0x27, 0xa6, 0xa6, 0x5d, // time stamp
+            0x71, 0x65, 0x6d, 0x75, // creator application
+            0x00, 0x05, 0x00, 0x03, // creator version
+            0x57, 0x69, 0x32, 0x6b, // creator host os
+            0x00, 0x00, 0x00, 0x00, 0x11, 0x22, 0x33, 0x44, // original size
+            0x00, 0x00, 0x00, 0x00, 0x11, 0x22, 0x33, 0x44, // current size
+            0x11, 0xe0, 0x10, 0x3f, // disk geometry
+            0x00, 0x00, 0x00, 0x02, // disk type
+            0x00, 0x00, 0x00, 0x00, // checksum
+            0x98, 0x7b, 0xb1, 0xcd, 0x84, 0x14, 0x41, 0xfc, // unique id
+            0xa4, 0xab, 0xd0, 0x69, 0x45, 0x2b, 0xf2, 0x23, 0x00, // saved state
+        ]
+    }
+
+    fn make_vhd_file() -> File {
+        let mut file: File = TempFile::new().unwrap().into_file();
+        let data_size: u64 = 0x1122_3344;
+        file.set_len(data_size + 0x200).unwrap();
+        file.seek(SeekFrom::Start(data_size)).unwrap();
+        file.write_all(fixed_vhd_footer()).unwrap();
+        file
+    }
+
+    #[test]
+    fn new_sync_returns_correct_size() {
+        let file = make_vhd_file();
+        let disk = VhdDisk::new(file, false).unwrap();
+        assert_eq!(disk.logical_size().unwrap(), 0x1122_3344);
+    }
+
+    fn assert_async_io_from_dyn(disk: &dyn AsyncDiskFile, expect_batch: bool) {
+        let io: Box<dyn AsyncIo> = disk.create_async_io(128).unwrap();
+        assert_eq!(io.batch_requests_enabled(), expect_batch);
+    }
+
+    fn assert_async_io(disk: &VhdDisk, expect_batch: bool) {
+        assert_async_io_from_dyn(disk, expect_batch);
+    }
+
+    #[test]
+    fn sync_backend_disables_batch_requests() {
+        let file = make_vhd_file();
+        let disk = VhdDisk::new(file, false).unwrap();
+        assert_async_io(&disk, false);
+    }
+
+    #[cfg(feature = "io_uring")]
+    #[test]
+    fn io_uring_backend_enables_batch_requests() {
+        let file = make_vhd_file();
+        let disk = VhdDisk::new(file, true).unwrap();
+        assert_async_io(&disk, true);
+    }
+
+    #[cfg(feature = "io_uring")]
+    #[test]
+    fn io_uring_batch_rejects_request_past_logical_size() {
+        let file = TempFile::new().unwrap().into_file();
+        file.set_len(0x2000).unwrap();
+        let mut async_io = FixedVhdAsync::new(file.as_raw_fd(), 8, 0x1000).unwrap();
+        let op = AsyncIoOperation::read_to_vec(0x800, OwnedIoBuffer::from_vec(vec![0; 0x900]), 1);
+
+        assert!(matches!(
+            async_io.submit_batch_requests(vec![op]),
+            Err(crate::async_io::AsyncIoError::ReadVectored(_))
+        ));
+    }
+
+    #[test]
+    fn try_clone_preserves_sync_dispatch() {
+        let file = make_vhd_file();
+        let disk = VhdDisk::new(file, false).unwrap();
+        let cloned = disk.try_clone().unwrap();
+        assert_async_io_from_dyn(cloned.as_ref(), false);
+    }
+
+    #[cfg(feature = "io_uring")]
+    #[test]
+    fn try_clone_preserves_io_uring_dispatch() {
+        let file = make_vhd_file();
+        let disk = VhdDisk::new(file, true).unwrap();
+        let cloned = disk.try_clone().unwrap();
+        assert_async_io_from_dyn(cloned.as_ref(), true);
+    }
+
+    #[test]
+    fn resize_returns_error() {
+        let file = make_vhd_file();
+        let mut disk = VhdDisk::new(file, false).unwrap();
+        assert!(disk.resize(0x2000_0000).is_err());
+    }
+
+    #[test]
+    fn physical_size_includes_footer() {
+        let file = make_vhd_file();
+        let disk = VhdDisk::new(file, false).unwrap();
+        // Data region (0x1122_3344) + VHD footer (0x200).
+        assert_eq!(disk.physical_size().unwrap(), 0x1122_3344 + 0x200);
+    }
+}

block/src/formats/vhd/worker/async_uring.rs

@@ -0,0 +1,103 @@
+// Copyright © 2021 Intel Corporation
+//
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+//
+// SPDX-License-Identifier: Apache-2.0
+
+use std::os::unix::io::RawFd;
+
+use vmm_sys_util::eventfd::EventFd;
+
+use crate::async_io::{AsyncIo, AsyncIoCompletion, AsyncIoError, AsyncIoOperation, AsyncIoResult};
+use crate::error::BlockResult;
+use crate::formats::raw::worker::async_uring::RawAsync;
+
+pub struct FixedVhdAsync {
+    raw_file_async: RawAsync,
+    size: u64,
+}
+
+impl FixedVhdAsync {
+    pub fn new(fd: RawFd, ring_depth: u32, size: u64) -> BlockResult<Self> {
+        let raw_file_async = RawAsync::new(fd, ring_depth)?;
+
+        Ok(FixedVhdAsync {
+            raw_file_async,
+            size,
+        })
+    }
+
+    fn validate_operation_bounds(&self, op: &AsyncIoOperation) -> AsyncIoResult<()> {
+        let offset = u64::try_from(op.offset()).map_err(|_| self.bounds_error(op))?;
+        let len = u64::try_from(op.total_len()).map_err(|_| self.bounds_error(op))?;
+        let end = offset
+            .checked_add(len)
+            .ok_or_else(|| self.bounds_error(op))?;
+
+        if end > self.size {
+            return Err(self.bounds_error(op));
+        }
+
+        Ok(())
+    }
+
+    fn bounds_error(&self, op: &AsyncIoOperation) -> AsyncIoError {
+        let error = std::io::Error::new(
+            std::io::ErrorKind::InvalidData,
+            format!(
+                "Invalid request offset {} and length {}, can't exceed file size {}",
+                op.offset(),
+                op.total_len(),
+                self.size
+            ),
+        );
+        if op.is_read() {
+            AsyncIoError::ReadVectored(error)
+        } else {
+            AsyncIoError::WriteVectored(error)
+        }
+    }
+}
+
+impl AsyncIo for FixedVhdAsync {
+    fn notifier(&self) -> &EventFd {
+        self.raw_file_async.notifier()
+    }
+
+    fn submit_data_operation(&mut self, op: AsyncIoOperation) -> AsyncIoResult<()> {
+        self.validate_operation_bounds(&op)?;
+        self.raw_file_async.submit_data_operation(op)
+    }
+
+    fn fsync(&mut self, user_data: Option<u64>) -> AsyncIoResult<()> {
+        self.raw_file_async.fsync(user_data)
+    }
+
+    fn next_completed_request(&mut self) -> Option<AsyncIoCompletion> {
+        self.raw_file_async.next_completed_request()
+    }
+
+    fn punch_hole(&mut self, _offset: u64, _length: u64, _user_data: u64) -> AsyncIoResult<()> {
+        Err(AsyncIoError::PunchHole(std::io::Error::other(
+            "punch_hole not supported for fixed VHD",
+        )))
+    }
+
+    fn write_zeroes(&mut self, _offset: u64, _length: u64, _user_data: u64) -> AsyncIoResult<()> {
+        Err(AsyncIoError::WriteZeroes(std::io::Error::other(
+            "write_zeroes not supported for fixed VHD",
+        )))
+    }
+
+    fn batch_requests_enabled(&self) -> bool {
+        true
+    }
+
+    fn submit_batch_requests(&mut self, batch_request: Vec<AsyncIoOperation>) -> AsyncIoResult<()> {
+        for op in &batch_request {
+            self.validate_operation_bounds(op)?;
+        }
+
+        self.raw_file_async.submit_batch_requests(batch_request)
+    }
+}

block/src/formats/vhd/worker/mod.rs

@@ -0,0 +1,12 @@
+// Copyright 2026 The Cloud Hypervisor Authors. All rights reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+
+//! Sync/async I/O workers for fixed VHD images.
+//!
+//! Thin wrappers around the raw workers that clamp I/O to the
+//! virtual disk size.
+
+#[cfg(feature = "io_uring")]
+pub(crate) mod async_uring;
+pub(crate) mod sync;

block/src/formats/vhd/worker/sync.rs

@@ -0,0 +1,72 @@
+// Copyright © 2021 Intel Corporation
+//
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+//
+// SPDX-License-Identifier: Apache-2.0
+
+use std::os::unix::io::RawFd;
+
+use vmm_sys_util::eventfd::EventFd;
+
+use crate::async_io::{AsyncIo, AsyncIoCompletion, AsyncIoError, AsyncIoOperation, AsyncIoResult};
+use crate::formats::raw::worker::sync::RawSync;
+
+pub struct FixedVhdSync {
+    raw_file_sync: RawSync,
+    size: u64,
+}
+
+impl FixedVhdSync {
+    pub fn new(fd: RawFd, size: u64) -> std::io::Result<Self> {
+        Ok(FixedVhdSync {
+            raw_file_sync: RawSync::new(fd),
+            size,
+        })
+    }
+}
+
+impl AsyncIo for FixedVhdSync {
+    fn notifier(&self) -> &EventFd {
+        self.raw_file_sync.notifier()
+    }
+
+    fn submit_data_operation(&mut self, op: AsyncIoOperation) -> AsyncIoResult<()> {
+        let offset = op.offset();
+        if offset as u64 >= self.size {
+            let error = std::io::Error::new(
+                std::io::ErrorKind::InvalidData,
+                format!(
+                    "Invalid offset {}, can't be larger than file size {}",
+                    offset, self.size
+                ),
+            );
+            return Err(if op.is_read() {
+                AsyncIoError::ReadVectored(error)
+            } else {
+                AsyncIoError::WriteVectored(error)
+            });
+        }
+
+        self.raw_file_sync.submit_data_operation(op)
+    }
+
+    fn fsync(&mut self, user_data: Option<u64>) -> AsyncIoResult<()> {
+        self.raw_file_sync.fsync(user_data)
+    }
+
+    fn next_completed_request(&mut self) -> Option<AsyncIoCompletion> {
+        self.raw_file_sync.next_completed_request()
+    }
+
+    fn punch_hole(&mut self, _offset: u64, _length: u64, _user_data: u64) -> AsyncIoResult<()> {
+        Err(AsyncIoError::PunchHole(std::io::Error::other(
+            "punch_hole not supported for fixed VHD",
+        )))
+    }
+
+    fn write_zeroes(&mut self, _offset: u64, _length: u64, _user_data: u64) -> AsyncIoResult<()> {
+        Err(AsyncIoError::WriteZeroes(std::io::Error::other(
+            "write_zeroes not supported for fixed VHD",
+        )))
+    }
+}