virtio-blk: blockdev-mirroring for live storage migration

block/src/disk_file.rs

@@ -36,7 +36,7 @@
 use std::fmt::Debug;
 
 use crate::async_io::{AsyncIo, BorrowedDiskFd};
-use crate::{BlockResult, DiskTopology};
+use crate::{BlockError, BlockErrorKind, BlockResult, DiskTopology};
 
 /// Reported capacity of a disk image.
 pub trait DiskSize: Send + Debug {
@@ -96,7 +96,12 @@ pub trait Resizable: Send + Debug {
 /// Every disk format implements `DiskSize` and `Geometry`.
 /// `Sync` is required so that `Arc<dyn DiskFile>` can be shared
 /// across threads for concurrent readonly access.
-pub trait DiskFile: DiskSize + Geometry + Sync {}
+pub trait DiskFile: DiskSize + Geometry + Sync {
+    /// Returns an error if this disk image cannot participate in block mirroring.
+    fn supports_mirroring(&self) -> BlockResult<()> {
+        Err(BlockError::from_kind(BlockErrorKind::UnsupportedFeature))
+    }
+}
 
 /// Full capability disk file trait.
 ///

block/src/error.rs

@@ -21,6 +21,37 @@ use std::fmt::{self, Display, Formatter};
 use std::io;
 use std::path::PathBuf;
 
+use thiserror::Error;
+
+/// Errors reported by block mirroring operations.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Error)]
+pub enum MirrorError {
+    /// Block mirroring does not support disk images with backing files.
+    #[error("Block mirroring does not support disk images with backing files")]
+    BackingFileUnsupported,
+    /// A mirror completion is already in progress.
+    #[error("Mirror completion already in progress")]
+    CompletionInProgress,
+    /// The mirror destination advisory lock could not be acquired.
+    #[error("Failed to lock the mirror destination")]
+    DestinationLock,
+    /// A mirror operation was requested before the device was activated.
+    #[error("Mirror operation rejected: the device is not active")]
+    DeviceNotActive,
+    /// A mirror operation was requested while the device is paused.
+    #[error("Mirror operation rejected: the device is paused")]
+    DevicePaused,
+    /// A mirror operation was requested but no mirror is active for the device.
+    #[error("No active mirror for the device")]
+    NotActive,
+    /// A completion was requested but the mirror has not reached the ready phase.
+    #[error("Mirror is not yet ready, cannot complete")]
+    NotReady,
+    /// A mirror swap was requested but was unsuccessful.
+    #[error("Failed to swap AsyncIO in virtqueue worker for mirror")]
+    Swap,
+}
+
 /// Small, stable classification of block errors.
 ///
 /// Callers match on this for control flow. Adding new format specific
@@ -42,6 +73,8 @@ pub enum BlockErrorKind {
     NotFound,
     /// An internal counter or limit was exceeded.
     Overflow,
+    /// A block mirroring operation failed.
+    Mirror(MirrorError),
 }
 
 impl Display for BlockErrorKind {
@@ -54,6 +87,7 @@ impl Display for BlockErrorKind {
             Self::OutOfBounds => write!(f, "Out of bounds"),
             Self::NotFound => write!(f, "Not found"),
             Self::Overflow => write!(f, "Overflow"),
+            Self::Mirror(error) => Display::fmt(error, f),
         }
     }
 }

block/src/fcntl.rs

@@ -248,6 +248,8 @@ impl LockGranularity {
             let _ = self.release_unneeded_locks_qemu(file, current_lock_status);
             return Err(error);
         }
+
+        self.release_unneeded_locks_qemu(file, lock_type)?;
         Ok(())
     }
 
@@ -369,3 +371,31 @@ impl FromStr for LockGranularityChoice {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::fs::OpenOptions;
+
+    use vmm_sys_util::tempfile::TempFile;
+
+    use super::{LockGranularity, LockType};
+
+    #[test]
+    fn qemu_lock_downgrade_allows_another_reader() {
+        let disk = TempFile::new().unwrap();
+        let other_reader = OpenOptions::new()
+            .read(true)
+            .write(true)
+            .open(disk.as_path())
+            .unwrap();
+        let lock = LockGranularity::QemuCompatible;
+
+        lock.try_acquire_lock(disk.as_file(), LockType::Write, LockType::Unlock)
+            .unwrap();
+        lock.try_acquire_lock(disk.as_file(), LockType::Read, LockType::Write)
+            .unwrap();
+
+        lock.try_acquire_lock(&other_reader, LockType::Read, LockType::Unlock)
+            .unwrap();
+    }
+}

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;