block: Add support for writing and flushing to block device

Refactor the common code and add a SectorWrite trait in order to support
writing and flushing blocks on the device.

Signed-off-by: Rob Bradford <robert.bradford@intel.com>

Author: rbradford

src/block.rs

@@ -114,6 +114,21 @@ pub trait SectorRead {
     fn read(&self, sector: u64, data: &mut [u8]) -> Result<(), Error>;
 }
 
+pub trait SectorWrite {
+    /// Write a single sector (512 bytes) from the block device. `data` must be
+    /// exactly 512 bytes long.
+    fn write(&self, sector: u64, data: &mut [u8]) -> Result<(), Error>;
+    fn flush(&self) -> Result<(), Error>;
+}
+
+#[cfg(not(test))]
+#[derive(PartialEq, Copy, Clone)]
+enum RequestType {
+    Read = 0,
+    Write = 1,
+    Flush = 4,
+}
+
 #[cfg(not(test))]
 impl<'a> VirtioBlockDevice<'a> {
     pub fn new(transport: &'a mut VirtioTransport) -> VirtioBlockDevice<'a> {
@@ -208,12 +223,16 @@ impl<'a> VirtioBlockDevice<'a> {
         u64::from(self.transport.read_device_config(0))
             | u64::from(self.transport.read_device_config(4)) << 32
     }
-}
 
-#[cfg(not(test))]
-impl<'a> SectorRead for VirtioBlockDevice<'a> {
-    fn read(&self, sector: u64, data: &mut [u8]) -> Result<(), Error> {
-        assert_eq!(512, data.len());
+    fn request(
+        &self,
+        sector: u64,
+        data: Option<&mut [u8]>,
+        request: RequestType,
+    ) -> Result<(), Error> {
+        if request != RequestType::Flush {
+            assert_eq!(512, data.as_ref().unwrap().len());
+        }
 
         const VIRTQ_DESC_F_NEXT: u16 = 1;
         const VIRTQ_DESC_F_WRITE: u16 = 2;
@@ -223,7 +242,7 @@ impl<'a> SectorRead for VirtioBlockDevice<'a> {
         const VIRTIO_BLK_S_UNSUPP: u8 = 2;
 
         let header = BlockRequestHeader {
-            request: 0,
+            request: request as u32,
             reserved: 0,
             sector,
         };
@@ -242,9 +261,17 @@ impl<'a> SectorRead for VirtioBlockDevice<'a> {
 
         let mut d = &mut state.descriptors[next_desc];
         let next_desc = (next_desc + 1) % QUEUE_SIZE;
-        d.addr = data.as_ptr() as u64;
-        d.length = core::mem::size_of::<[u8; 512]>() as u32;
-        d.flags = VIRTQ_DESC_F_NEXT | VIRTQ_DESC_F_WRITE;
+        if request != RequestType::Flush {
+            d.addr = data.unwrap().as_ptr() as u64;
+            d.length = core::mem::size_of::<[u8; 512]>() as u32;
+        }
+
+        d.flags = VIRTQ_DESC_F_NEXT
+            | if request == RequestType::Read {
+                VIRTQ_DESC_F_WRITE
+            } else {
+                0
+            };
         d.next = next_desc as u16;
 
         let mut d = &mut state.descriptors[next_desc];
@@ -279,3 +306,21 @@ impl<'a> SectorRead for VirtioBlockDevice<'a> {
         }
     }
 }
+
+#[cfg(not(test))]
+impl<'a> SectorRead for VirtioBlockDevice<'a> {
+    fn read(&self, sector: u64, data: &mut [u8]) -> Result<(), Error> {
+        self.request(sector, Some(data), RequestType::Read)
+    }
+}
+
+#[cfg(not(test))]
+impl<'a> SectorWrite for VirtioBlockDevice<'a> {
+    fn write(&self, sector: u64, data: &mut [u8]) -> Result<(), Error> {
+        self.request(sector, Some(data), RequestType::Write)
+    }
+
+    fn flush(&self) -> Result<(), Error> {
+        self.request(0, None, RequestType::Flush)
+    }
+}