page_cache: read directly to the allocate page

Signed-off-by: Andy-Python-Programmer <andypythonappdeveloper@gmail.com>

Author: Andy-Python-Programmer

src/aero_kernel/src/drivers/block/ide/mod.rs

@@ -70,6 +70,15 @@ impl BlockDeviceInterface for IdeDrive {
         todo!()
     }
 
+    fn read_dma(
+        &self,
+        _sector: usize,
+        _start: crate::mem::paging::PhysAddr,
+        _size: usize,
+    ) -> Option<usize> {
+        unimplemented!()
+    }
+
     fn write_block(&self, _sector: usize, _buf: &[u8]) -> Option<usize> {
         unimplemented!()
     }

src/aero_kernel/src/drivers/block/nvme/mod.rs

@@ -231,11 +231,10 @@ struct Namespace<'a> {
 }
 
 impl<'a> Namespace<'a> {
-    fn read(&self, sector: usize, dest: &mut [MaybeUninit<u8>]) {
-        let size_bytes = dest.len();
-        let blocks = size_bytes.ceil_div(self.block_size);
+    fn read(&self, sector: usize, start: PhysAddr, size_bytes: usize) {
+        assert!(size_bytes != 0);
 
-        let buffer = Dma::<u8>::new_uninit_slice(dest.len());
+        let blocks = size_bytes.ceil_div(self.block_size);
         let mut read_cmd = ReadWriteCommand::default();
 
         read_cmd.opcode = CommandOpcode::Read as u8;
@@ -252,21 +251,16 @@ impl<'a> Namespace<'a> {
             let mut prps = self.prps.lock();
 
             for i in 0..prp_num {
-                prps[i]
-                    .write((buffer.addr().as_u64() + Size4KiB::SIZE) + (Size4KiB::SIZE * i as u64));
+                prps[i].write((start.as_u64() + Size4KiB::SIZE) + (Size4KiB::SIZE * i as u64));
             }
 
-            read_cmd.data_ptr.prp1 = buffer.addr().as_u64();
+            read_cmd.data_ptr.prp1 = start.as_u64();
             read_cmd.data_ptr.prp2 = prps.addr().as_u64();
         } else {
-            read_cmd.data_ptr.prp1 = buffer.addr().as_u64();
+            read_cmd.data_ptr.prp1 = start.as_u64();
         }
 
         self.controller.io_queue.lock_irq().submit_command(read_cmd);
-
-        // SAFETY: The buffer is initialized above.
-        let buffer = unsafe { buffer.assume_init() };
-        MaybeUninit::write_slice(dest, &*buffer);
     }
 }
 
@@ -468,8 +462,17 @@ impl<'a> Controller<'a> {
 }
 
 impl<'a> BlockDeviceInterface for Controller<'a> {
+    fn read_dma(&self, sector: usize, start: PhysAddr, size: usize) -> Option<usize> {
+        self.namespaces.lock()[0].read(sector, start, size);
+        Some(size)
+    }
+
     fn read_block(&self, sector: usize, dest: &mut [MaybeUninit<u8>]) -> Option<usize> {
-        self.namespaces.lock()[0].read(sector, dest);
+        let buffer = Dma::<u8>::new_uninit_slice(dest.len());
+        self.namespaces.lock()[0].read(sector, buffer.addr(), dest.len());
+
+        // SAFETY: The buffer is initialized above.
+        dest.copy_from_slice(&buffer);
         Some(dest.len())
     }
 

src/aero_kernel/src/fs/block/mod.rs

@@ -70,6 +70,10 @@ impl CachedPage {
         unsafe { core::slice::from_raw_parts_mut(data_ptr, Size4KiB::SIZE as usize) }
     }
 
+    fn data_addr(&self) -> PhysAddr {
+        self.page.start_address()
+    }
+
     fn make_key(device: Weak<dyn CachedAccess>, offset: usize) -> PageCacheKey {
         (device.as_ptr() as *const u8 as usize, offset)
     }
@@ -107,12 +111,10 @@ impl Cache<PageCacheKey, CachedPage> {
         let device = device.upgrade().expect("page_cache: device dropped");
 
         let aligned_offset = align_down(offset as u64, Size4KiB::SIZE) as usize;
+        let sector = aligned_offset / device.block_size();
 
         device
-            // FIXME(perf,mem): internally read_block makes use of the DMA API (cc drivers::nvme::dma), which in turn
-            // allocates another frame in order to make sure the destination buffer is DMA capable. In this
-            // case, this is not required since we have already allocated a DMA capable frame.
-            .read_block(aligned_offset / device.block_size(), page.data_mut())
+            .read_dma(sector, page.data_addr(), Size4KiB::SIZE as usize)
             .expect("page_cache: failed to read block");
 
         PAGE_CACHE.make_item_cached(page)
@@ -122,6 +124,8 @@ impl Cache<PageCacheKey, CachedPage> {
 pub trait BlockDeviceInterface: Send + Sync {
     fn block_size(&self) -> usize;
 
+    fn read_dma(&self, sector: usize, start: PhysAddr, size: usize) -> Option<usize>;
+
     fn read_block(&self, sector: usize, dest: &mut [MaybeUninit<u8>]) -> Option<usize>;
     fn write_block(&self, sector: usize, buf: &[u8]) -> Option<usize>;
 }
@@ -147,6 +151,33 @@ pub trait CachedAccess: BlockDeviceInterface {
 
         Some(loc)
     }
+
+    /// Writes the given data to the device at the given offset and returns the
+    /// number of bytes written.
+    ///
+    /// ## Notes
+    ///
+    /// * This function does **not** sync the written data to the disk.
+    fn write(&self, mut offset: usize, buffer: &[u8]) -> Option<usize> {
+        let mut loc = 0;
+
+        while loc < buffer.len() {
+            let page = PAGE_CACHE.get_page(self.sref(), offset);
+
+            let page_offset = offset % Size4KiB::SIZE as usize;
+            let size = core::cmp::min(Size4KiB::SIZE as usize - page_offset, buffer.len() - loc);
+
+            MaybeUninit::write_slice(
+                &mut page.data_mut()[page_offset..page_offset + size],
+                &buffer[loc..loc + size],
+            );
+
+            loc += size;
+            offset += align_down(offset as u64 + Size4KiB::SIZE, Size4KiB::SIZE) as usize;
+        }
+
+        Some(loc)
+    }
 }
 
 static BLOCK_DEVS: Mutex<BTreeMap<usize, Arc<BlockDevice>>> = Mutex::new(BTreeMap::new());
@@ -189,6 +220,10 @@ impl BlockDeviceInterface for BlockDevice {
         self.dev.block_size()
     }
 
+    fn read_dma(&self, sector: usize, start: PhysAddr, size: usize) -> Option<usize> {
+        self.dev.read_dma(sector, start, size)
+    }
+
     fn read_block(&self, sector: usize, dest: &mut [MaybeUninit<u8>]) -> Option<usize> {
         self.dev.read_block(sector, dest)
     }
@@ -249,17 +284,25 @@ impl BlockDeviceInterface for PartitionBlockDevice {
         self.device.read_block(self.offset + sector, dest)
     }
 
-    fn block_size(&self) -> usize {
-        self.device.block_size()
-    }
-
     fn write_block(&self, sector: usize, buf: &[u8]) -> Option<usize> {
         if sector >= self.size {
             return None;
         }
 
         self.device.write_block(self.offset + sector, buf)
     }
+
+    fn read_dma(&self, sector: usize, start: PhysAddr, size: usize) -> Option<usize> {
+        if sector >= self.size {
+            return None;
+        }
+
+        self.device.read_dma(self.offset + sector, start, size)
+    }
+
+    fn block_size(&self) -> usize {
+        self.device.block_size()
+    }
 }
 
 impl CachedAccess for PartitionBlockDevice {