Move locking into block device

Author: nbdd0121

lib/io/src/block/file.rs

@@ -77,12 +77,12 @@ impl File {
 
 impl Block for File {
     #[cfg(unix)]
-    fn read_exact_at(&mut self, buf: &mut [u8], offset: u64) -> Result<()> {
+    fn read_exact_at(&self, buf: &mut [u8], offset: u64) -> Result<()> {
         self.file.read_exact_at(buf, offset)
     }
 
     #[cfg(windows)]
-    fn read_exact_at(&mut self, mut buf: &mut [u8], mut offset: u64) -> Result<()> {
+    fn read_exact_at(&self, mut buf: &mut [u8], mut offset: u64) -> Result<()> {
         while !buf.is_empty() {
             match self.file.seek_read(buf, offset) {
                 Ok(0) => {
@@ -103,12 +103,12 @@ impl Block for File {
     }
 
     #[cfg(unix)]
-    fn write_all_at(&mut self, buf: &[u8], offset: u64) -> Result<()> {
+    fn write_all_at(&self, buf: &[u8], offset: u64) -> Result<()> {
         self.file.write_all_at(buf, offset)
     }
 
     #[cfg(windows)]
-    fn write_all_at(&mut self, mut buf: &[u8], mut offset: u64) -> Result<()> {
+    fn write_all_at(&self, mut buf: &[u8], mut offset: u64) -> Result<()> {
         while !buf.is_empty() {
             match self.file.seek_write(buf, offset) {
                 Ok(0) => {
@@ -125,7 +125,7 @@ impl Block for File {
         Ok(())
     }
 
-    fn flush(&mut self) -> Result<()> {
+    fn flush(&self) -> Result<()> {
         self.file.sync_data()
     }
 

lib/io/src/block/mod.rs

@@ -35,31 +35,31 @@ pub trait Block {
     /// Reads the exact number of byte required to fill buf from the given offset.
     ///
     /// Caller must ensure `offset` and buffer size is aligned to `blksize` queried by `capability`.
-    fn read_exact_at(&mut self, buf: &mut [u8], offset: u64) -> Result<()>;
+    fn read_exact_at(&self, buf: &mut [u8], offset: u64) -> Result<()>;
 
     /// Attempts to write an entire buffer starting from a given offset.
     ///
     /// Caller must ensure `offset` and buffer size is aligned to `blksize` queried by `capability`.
-    fn write_all_at(&mut self, buf: &[u8], offset: u64) -> Result<()>;
+    fn write_all_at(&self, buf: &[u8], offset: u64) -> Result<()>;
 
     /// Attempts to write zero to a given offset.
     ///
     /// Caller must ensure `offset` and `len` is aligned to `blksize` queried by `capability`.
-    fn write_zero_at(&mut self, offset: u64, len: usize) -> Result<()> {
+    fn write_zero_at(&self, offset: u64, len: usize) -> Result<()> {
         let buf = vec![0; len];
         self.write_all_at(&buf, offset)
     }
 
     /// Discard contents at the given offset.
     ///
     /// Caller must ensure `offset` and `len` is aligned to `blksize` queried by `capability`.
-    fn discard(&mut self, offset: u64, len: usize) -> Result<()> {
+    fn discard(&self, offset: u64, len: usize) -> Result<()> {
         let _ = (offset, len);
         Ok(())
     }
 
     /// Flush this block device.
-    fn flush(&mut self) -> Result<()> {
+    fn flush(&self) -> Result<()> {
         Ok(())
     }
 

lib/io/src/block/shadow.rs

@@ -1,26 +1,28 @@
 use super::{Block, Capability};
 use fnv::FnvHashMap;
 use std::io::Result;
+use std::sync::RwLock;
 
 /// A shadow block device that captures all write requests to the underlying block device.
 ///
 /// All modified data will be kept in memory and not forwarded to the underlying block device.
 pub struct Shadow<T> {
-    overlay: FnvHashMap<u64, Box<[u8]>>,
+    overlay: RwLock<FnvHashMap<u64, Box<[u8]>>>,
     block: T,
 }
 
 impl<T> Shadow<T> {
     /// Construct a new `Shadow`.
     pub fn new(block: T) -> Self {
-        Shadow { block, overlay: FnvHashMap::default() }
+        Shadow { block, overlay: RwLock::new(FnvHashMap::default()) }
     }
 }
 
 impl<T: Block> Block for Shadow<T> {
-    fn read_exact_at(&mut self, buf: &mut [u8], mut offset: u64) -> Result<()> {
+    fn read_exact_at(&self, buf: &mut [u8], mut offset: u64) -> Result<()> {
+        let overlay = self.overlay.read().unwrap();
         for chunk in buf.chunks_mut(512) {
-            match self.overlay.get(&offset) {
+            match overlay.get(&offset) {
                 None => self.block.read_exact_at(chunk, offset)?,
                 Some(v) => chunk.copy_from_slice(v),
             }
@@ -29,15 +31,16 @@ impl<T: Block> Block for Shadow<T> {
         Ok(())
     }
 
-    fn write_all_at(&mut self, buf: &[u8], mut offset: u64) -> Result<()> {
+    fn write_all_at(&self, buf: &[u8], mut offset: u64) -> Result<()> {
+        let mut overlay = self.overlay.write().unwrap();
         for chunk in buf.chunks(512) {
-            self.overlay.insert(offset, chunk.to_owned().into_boxed_slice());
+            overlay.insert(offset, chunk.to_owned().into_boxed_slice());
             offset += 512
         }
         Ok(())
     }
 
-    fn flush(&mut self) -> Result<()> {
+    fn flush(&self) -> Result<()> {
         Ok(())
     }
 

lib/io/src/hw/virtio/block.rs

@@ -1,7 +1,6 @@
 use super::{Device, DeviceId, Queue};
 use crate::block::Block as BlockDevice;
 use crate::{IrqPin, RuntimeContext};
-use parking_lot::Mutex;
 use std::sync::Arc;
 
 #[allow(dead_code)]
@@ -28,7 +27,7 @@ pub struct Block {
 }
 
 struct Inner {
-    file: Mutex<Box<dyn BlockDevice + Send>>,
+    file: Box<dyn BlockDevice + Send + Sync>,
     irq: Box<dyn IrqPin>,
 }
 
@@ -37,13 +36,13 @@ impl Block {
     pub fn new(
         ctx: Arc<dyn RuntimeContext>,
         irq: Box<dyn IrqPin>,
-        file: Box<dyn BlockDevice + Send>,
+        file: Box<dyn BlockDevice + Send + Sync>,
     ) -> Block {
         let len = file.len();
         if len % 512 != 0 {
             panic!("Size of block device must be multiple of 512 bytes");
         }
-        let inner = Arc::new(Inner { file: Mutex::new(file), irq });
+        let inner = Arc::new(Inner { file, irq });
         Block { status: 0, config: (len / 512).to_le_bytes(), ctx, inner }
     }
 
@@ -64,11 +63,8 @@ impl Block {
                         let mut io_buffer = Vec::with_capacity(writer.len());
                         unsafe { io_buffer.set_len(io_buffer.capacity() - 1) };
 
-                        {
-                            let mut file = inner.file.lock();
-                            (*file).read_exact_at(&mut io_buffer, header.sector * 512).unwrap();
-                            trace!(target: "VirtioBlk", "read {} bytes from sector {:x}", io_buffer.len(), header.sector);
-                        }
+                        inner.file.read_exact_at(&mut io_buffer, header.sector * 512).unwrap();
+                        trace!(target: "VirtioBlk", "read {} bytes from sector {:x}", io_buffer.len(), header.sector);
 
                         io_buffer.push(0);
                         writer.write_all(&io_buffer).await.unwrap();
@@ -78,13 +74,10 @@ impl Block {
                         unsafe { io_buffer.set_len(io_buffer.capacity()) };
                         reader.read_exact(&mut io_buffer).await.unwrap();
 
-                        {
-                            let mut file = inner.file.lock();
-                            file.write_all_at(&io_buffer, header.sector * 512).unwrap();
-                            // We must make sure the data has been flushed into the disk before returning
-                            file.flush().unwrap();
-                            trace!(target: "VirtioBlk", "write {} bytes from sector {:x}", io_buffer.len(), header.sector);
-                        }
+                        inner.file.write_all_at(&io_buffer, header.sector * 512).unwrap();
+                        // We must make sure the data has been flushed into the disk before returning
+                        inner.file.flush().unwrap();
+                        trace!(target: "VirtioBlk", "write {} bytes from sector {:x}", io_buffer.len(), header.sector);
 
                         writer.write_all(&[0]).await.unwrap();
                     }

lib/io/src/system/mod.rs

@@ -194,7 +194,7 @@ impl IoSystem {
             .open(&config.config.path)
             .unwrap();
         let file = crate::block::File::new(file).unwrap();
-        let file: Box<dyn crate::block::Block + Send> = if config.config.shadow {
+        let file: Box<dyn crate::block::Block + Send + Sync> = if config.config.shadow {
             Box::new(crate::block::Shadow::new(file))
         } else {
             Box::new(file)