block: Improve block device request error handling

The current implementation of `VirtioBlockDevice::request()` panics if
`data` is `None` or `data` size is not equal to sector size. This commit
removes the panics and adds error handlings.

Signed-off-by: Akira Moroo <retrage01@gmail.com>

Author: retrage

src/block.rs

@@ -77,7 +77,9 @@ struct DriverState {
 
 #[derive(Debug, PartialEq, Eq)]
 pub enum Error {
-    BlockIOError,
+    BlockIO,
+    NoDataBuf,
+    InvalidDataBufSize,
 
     BlockNotSupported,
 }
@@ -236,10 +238,6 @@ impl<'a> VirtioBlockDevice<'a> {
         data: Option<&mut [u8]>,
         request: RequestType,
     ) -> Result<(), Error> {
-        if request != RequestType::Flush {
-            assert_eq!(SectorBuf::len(), data.as_ref().unwrap().len());
-        }
-
         const VIRTQ_DESC_F_NEXT: u16 = 1;
         const VIRTQ_DESC_F_WRITE: u16 = 2;
 
@@ -268,8 +266,18 @@ impl<'a> VirtioBlockDevice<'a> {
         let mut d = &mut state.descriptors[next_desc];
         let next_desc = (next_desc + 1) % QUEUE_SIZE;
         if request != RequestType::Flush {
-            d.addr = data.unwrap().as_ptr() as u64;
-            d.length = SectorBuf::len() as u32;
+            match data {
+                None => {
+                    return Err(Error::NoDataBuf);
+                }
+                Some(data) => {
+                    if data.len() != SectorBuf::len() {
+                        return Err(Error::InvalidDataBufSize);
+                    }
+                    d.addr = data.as_ptr() as u64;
+                    d.length = SectorBuf::len() as u32;
+                }
+            }
         }
 
         d.flags = VIRTQ_DESC_F_NEXT
@@ -306,7 +314,7 @@ impl<'a> VirtioBlockDevice<'a> {
 
         match footer.status {
             VIRTIO_BLK_S_OK => Ok(()),
-            VIRTIO_BLK_S_IOERR => Err(Error::BlockIOError),
+            VIRTIO_BLK_S_IOERR => Err(Error::BlockIO),
             VIRTIO_BLK_S_UNSUPP => Err(Error::BlockNotSupported),
             _ => Err(Error::BlockNotSupported),
         }

src/fat.rs

@@ -554,7 +554,7 @@ impl<'a> Read for File<'a> {
 impl<'a> SectorRead for Filesystem<'a> {
     fn read(&self, sector: u64, data: &mut [u8]) -> Result<(), crate::block::Error> {
         if self.start + sector > self.last {
-            Err(crate::block::Error::BlockIOError)
+            Err(crate::block::Error::BlockIO)
         } else {
             self.device.read(self.start + sector, data)
         }

src/part.rs

@@ -182,11 +182,11 @@ pub mod tests {
             let mut file = self.file.borrow_mut();
             match file.seek(SeekFrom::Start(sector * SectorBuf::len() as u64)) {
                 Ok(_) => {}
-                Err(_) => return Err(block::Error::BlockIOError),
+                Err(_) => return Err(block::Error::BlockIO),
             }
             match file.read(data) {
                 Ok(_) => {}
-                Err(_) => return Err(block::Error::BlockIOError),
+                Err(_) => return Err(block::Error::BlockIO),
             }
             Ok(())
         }