add write_at default method implementation

Author: tsatke

filesystem/src/block/mem.rs

@@ -16,6 +16,10 @@ where
         }
         Some(Self { sector_size, data })
     }
+
+    pub fn data(&self) -> &T {
+        &self.data
+    }
 }
 
 impl<T> BlockDevice for MemoryBlockDevice<T>
@@ -53,9 +57,10 @@ where
 
 #[cfg(test)]
 mod tests {
+    use alloc::vec;
+
     use crate::block::mem::MemoryBlockDevice;
     use crate::BlockDevice;
-    use alloc::vec;
 
     #[test]
     fn test_read_at_short() {
@@ -111,4 +116,53 @@ mod tests {
         let expected = [1_u8, 2, 3, 4, 5, 6, 7, 8, 9, 10];
         assert_eq!(expected, buf);
     }
+
+    #[test]
+    fn test_write_at() {
+        let data = vec![0xFF_u8; 16];
+        let mut device = MemoryBlockDevice::try_new(4, data).unwrap();
+
+        device.write_at(0, &[1, 2, 3, 4, 5, 6, 7, 8]).unwrap();
+        assert_eq!(&[1, 2, 3, 4, 5, 6, 7, 8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF], device.data().as_slice());
+    }
+
+    #[test]
+    fn test_write_at_unaligned() {
+        let data = vec![0xFF_u8; 16];
+        let mut device = MemoryBlockDevice::try_new(4, data).unwrap();
+
+        device.write_at(1, &[1, 2, 3, 4, 5, 6, 7, 8]).unwrap();
+        assert_eq!(&[0xFF, 1, 2, 3, 4, 5, 6, 7, 8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF], device.data().as_slice());
+    }
+
+    #[test]
+    fn test_write_at_aligned_short() {
+        let data = vec![0xFF_u8; 16];
+        let mut device = MemoryBlockDevice::try_new(4, data).unwrap();
+
+        device.write_at(0, &[1, 2]).unwrap();
+        assert_eq!(&[1, 2, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF], device.data().as_slice());
+        device.write_at(0, &[1, 2, 3]).unwrap();
+        assert_eq!(&[1, 2, 3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF], device.data().as_slice());
+    }
+
+    #[test]
+    fn test_write_at_unaligned_short() {
+        let data = vec![0xFF_u8; 16];
+        let mut device = MemoryBlockDevice::try_new(4, data).unwrap();
+
+        device.write_at(1, &[1, 2]).unwrap();
+        assert_eq!(&[0xFF, 1, 2, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF], device.data().as_slice());
+        device.write_at(1, &[1, 2, 3]).unwrap();
+        assert_eq!(&[0xFF, 1, 2, 3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF], device.data().as_slice());
+    }
+
+    #[test]
+    fn test_write_at_aligned_one_sector() {
+        let data = vec![0xFF_u8; 16];
+        let mut device = MemoryBlockDevice::try_new(4, data).unwrap();
+
+        device.write_at(0, &[1, 2, 3, 4]).unwrap();
+        assert_eq!(&[1, 2, 3, 4, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF], device.data().as_slice());
+    }
 }

filesystem/src/block/mod.rs

@@ -1,9 +1,9 @@
 use alloc::vec;
 
-mod mem;
-
 pub use mem::*;
 
+mod mem;
+
 pub trait BlockDevice {
     type Error;
 
@@ -31,7 +31,7 @@ pub trait BlockDevice {
     /// an appropriate error.
     fn write_sector(&mut self, sector_index: usize, buf: &[u8]) -> Result<usize, Self::Error>;
 
-    /// Reads `buf.len()` bytes starting at at the given **byte** offset
+    /// Reads `buf.len()` bytes starting at the given **byte** offset
     /// into the given buffer. Returns an error if the read would exceed
     /// the length of this block device.
     ///
@@ -57,11 +57,11 @@ pub trait BlockDevice {
         };
         let sector_count = end_sector - start_sector
             + if relative_offset == 0 && buf.len() % sector_size == 0 && start_sector != end_sector
-            {
-                0
-            } else {
-                1
-            };
+        {
+            0
+        } else {
+            1
+        };
 
         // read sectors
         let mut data = vec![0_u8; sector_count * sector_size];
@@ -76,4 +76,73 @@ pub trait BlockDevice {
 
         Ok(buf.len())
     }
+
+    /// Writes `buf.len()` bytes starting at the given **byte** offset
+    /// onto the block device. Returns an error if the write would exceed
+    /// the length of this block device.
+    ///
+    /// Zero-sized writes are allowed.
+    fn write_at(&mut self, offset: usize, buf: &[u8]) -> Result<usize, Self::Error> {
+        if buf.is_empty() {
+            return Ok(0);
+        }
+
+        let sector_size = self.sector_size();
+
+        if offset % buf.len() == 0 && buf.len() == sector_size {
+            // if we write exactly one sector, and that write is aligned, delegate to the device impl
+            return self.write_sector(offset / sector_size, buf);
+        }
+
+        let start_sector = offset / sector_size;
+        let relative_start_offset = offset % sector_size;
+        let end_sector = if relative_start_offset + buf.len() <= sector_size {
+            start_sector
+        } else {
+            (offset + buf.len()) / sector_size
+        };
+        let relative_end_offset = (relative_start_offset + buf.len()) % sector_size;
+
+        // The write is not aligned, so we have to read the first and last sector, merge
+        // the data with the given buffer, and write the merged data back to the device.
+        // For all other sectors in between, we can write the data directly to the device.
+
+        if start_sector == end_sector {
+            // If we have a read that is shorter than a single sector, read that sector, merge the data
+            // and write it back.
+            let mut first_sector = vec![0_u8; sector_size];
+            self.read_sector(start_sector, &mut first_sector)?;
+            // if we have a 1 sector write and a relative_end_offset of 0, that means we need to write until the end of the sector
+            let actual_end_offset = if relative_end_offset == 0 { sector_size } else { relative_end_offset };
+            first_sector.as_mut_slice()[relative_start_offset..actual_end_offset].copy_from_slice(&buf);
+            return self.write_sector(start_sector, &first_sector);
+        }
+
+        let (mut first_sector, mut last_sector) = {
+            let mut first = vec![0_u8; sector_size];
+            self.read_sector(start_sector, &mut first)?;
+            let mut last = vec![0_u8; sector_size];
+            self.read_sector(end_sector, &mut last)?;
+            (first, last)
+        };
+
+        // merge the write data into first[relative_offset..]
+        first_sector.as_mut_slice()[relative_start_offset..].copy_from_slice(&buf[..sector_size - relative_start_offset]);
+        // merge the write data into last[..relative_end_offset]
+        last_sector.as_mut_slice()[..relative_end_offset].copy_from_slice(&buf[buf.len() - relative_end_offset..]);
+        let in_between_data = &buf[sector_size - relative_start_offset..buf.len() - relative_end_offset];
+
+        // write the first sector
+        self.write_sector(start_sector, &first_sector)?;
+
+        // write the in-between sectors
+        in_between_data.chunks_exact(sector_size).enumerate().try_for_each(|(i, chunk)| {
+            self.write_sector(start_sector + i + 1, chunk).map(|_| ())
+        })?;
+
+        // write the last sector
+        self.write_sector(end_sector, &last_sector)?;
+
+        Ok(buf.len())
+    }
 }