virtio-blk: blockdev-mirroring for live storage migration

block/src/async_io.rs

@@ -109,4 +109,12 @@ pub trait AsyncIo: Send {
     fn alignment(&self) -> u64 {
         SECTOR_SIZE
     }
+
+    /// Returns true when this implementation has request pairings in flight
+    /// that have not yet been acked to the guest. Only the mirroring
+    /// implementation tracks such pairings, plain backends always return
+    /// false.
+    fn has_inflight_requests(&self) -> bool {
+        false
+    }
 }

block/src/error.rs

@@ -42,6 +42,18 @@ pub enum BlockErrorKind {
     NotFound,
     /// An internal counter or limit was exceeded.
     Overflow,
+    /// The file already exists, when disk creation was requested.
+    AlreadyExists,
+    /// A mirror operation was requested but no mirror is active for the device.
+    MirrorNotActive,
+    /// A completion was requested but the mirror has not reached the ready phase.
+    MirrorNotReady,
+    /// A mirror swap was requested but was unsuccessful.
+    MirrorSwap,
+    /// A mirror completion is already in progress.
+    MirrorCompletionInProgress,
+    /// A mirror operation was requested while the device is paused.
+    MirrorDevicePaused,
 }
 
 impl Display for BlockErrorKind {
@@ -54,6 +66,14 @@ impl Display for BlockErrorKind {
             Self::OutOfBounds => write!(f, "Out of bounds"),
             Self::NotFound => write!(f, "Not found"),
             Self::Overflow => write!(f, "Overflow"),
+            Self::AlreadyExists => write!(f, "Already exists"),
+            Self::MirrorNotActive => write!(f, "No active mirror for the device"),
+            Self::MirrorNotReady => write!(f, "Mirror is not yet ready, cannot complete"),
+            Self::MirrorSwap => write!(f, "Failed to swap AsyncIO in virtqueue worker for mirror"),
+            Self::MirrorCompletionInProgress => write!(f, "Mirror completion already in progress"),
+            Self::MirrorDevicePaused => {
+                write!(f, "Mirror operation rejected: the device is paused")
+            }
         }
     }
 }

block/src/factory.rs

@@ -21,6 +21,7 @@ use crate::block_io_uring_is_supported;
 use crate::disk_file::AsyncFullDiskFile;
 use crate::error::{BlockError, BlockErrorKind, BlockResult};
 use crate::fixed_vhd_disk::FixedVhdDisk;
+use crate::qcow::{QcowFile, RawFile};
 use crate::qcow_disk::QcowDisk;
 use crate::raw_disk::{RawBackend, RawDisk};
 use crate::vhdx_sync::VhdxDiskSync;
@@ -203,6 +204,47 @@ fn open_qcow2(
     ))
 }
 
+/// Create a new disk image at `options.path` of the given image type
+/// and logical `size`. The file must not exist yet.
+pub fn create_disk(
+    options: &DiskOpenOptions<'_>,
+    image_type: ImageType,
+    size: u64,
+) -> BlockResult<()> {
+    if options.path.exists() {
+        return Err(BlockError::from_kind(BlockErrorKind::AlreadyExists).with_path(options.path));
+    }
+    let file = fs::OpenOptions::new()
+        .read(true)
+        .write(true)
+        .create_new(true)
+        .open(options.path)
+        .map_err(|e| {
+            BlockError::from_kind(BlockErrorKind::Io)
+                .with_path(options.path)
+                .with_source(e)
+        })?;
+
+    match image_type {
+        ImageType::Raw => {
+            file.set_len(size)
+                .map_err(|e| BlockError::from(e).with_path(options.path))?;
+        }
+        ImageType::Qcow2 => {
+            let raw_file = RawFile::new(file.try_clone()?, options.direct);
+            QcowFile::new(raw_file, 3, size, options.sparse)
+                .map_err(|e| e.with_path(options.path))?;
+        }
+        _ => {
+            return Err(
+                BlockError::from_kind(BlockErrorKind::UnsupportedFeature).with_path(options.path)
+            );
+        }
+    }
+
+    Ok(())
+}
+
 #[cfg(test)]
 mod unit_tests {
     use std::io::Write;

block/src/lib.rs

@@ -20,6 +20,7 @@ pub mod fixed_vhd;
 pub mod fixed_vhd_async;
 pub mod fixed_vhd_disk;
 pub mod fixed_vhd_sync;
+pub mod mirror;
 pub mod qcow;
 #[cfg(feature = "io_uring")]
 pub(crate) mod qcow_async;