dma: allocate the nearest size

Currently in the `DmaAllocator`, if the request size was greater than
PAGE_SIZE (4KiB), the allocator would allocate a 2MiB page to satisfy
the allocation request. The memory required to satisfy the request is
relaxed by finding the nearest buddy order from the allocation request
size and allocating with that order instead.

Signed-off-by: Andy-Python-Programmer <[email protected]>

Author: Andy-Python-Programmer

src/aero_kernel/src/mem/paging/addr.rs

@@ -111,14 +111,20 @@ impl VirtAddr {
         }
     }
 
+    pub fn as_bytes_mut(&self, size_bytes: usize) -> &mut [u8] {
+        assert!(self.validate_read::<&[u8]>());
+        unsafe { core::slice::from_raw_parts_mut(self.as_mut_ptr(), size_bytes) }
+    }
+
     /// Converts this HHDM (Higher Half Direct Map) virtual address to its physical address.
     pub fn as_hhdm_phys(&self) -> PhysAddr {
         unsafe { PhysAddr::new(self.clone() - crate::PHYSICAL_MEMORY_OFFSET) }
     }
 
     /// Returns if the address is valid to read `sizeof(T)` bytes at the address.
     fn validate_read<T: Sized>(&self) -> bool {
-        // FIXME: (*self + core::mem::size_of::<T>()) <= crate::arch::task::userland_last_address() // in-range
+        // FIXME: (*self + core::mem::size_of::<T>()) <= crate::arch::task::userland_last_address()
+        // // in-range
         self.0 != 0 // non-null
     }
 

src/aero_kernel/src/mem/paging/frame.rs

@@ -78,19 +78,26 @@ impl LockedFrameAllocator {
         self.0
             .call_once(|| Mutex::new(GlobalFrameAllocator::new(memory_map)));
     }
+
+    pub fn alloc(&self, size_bytes: usize) -> Option<PhysAddr> {
+        let order = order_from_size(size_bytes as u64);
+
+        let mut allocator = self.0.get()?.lock_irq();
+        allocator.allocate_frame_inner(order)
+    }
+
+    pub fn alloc_zeroed(&self, size_bytes: usize) -> Option<PhysAddr> {
+        let addr = self.alloc(size_bytes)?;
+        addr.as_hhdm_virt().as_bytes_mut(size_bytes).fill(0);
+
+        Some(addr)
+    }
 }
 
 unsafe impl FrameAllocator<Size4KiB> for LockedFrameAllocator {
     fn allocate_frame(&self) -> Option<PhysFrame<Size4KiB>> {
-        self.0.get().map(|m| {
-            m.lock_irq()
-                .allocate_frame_inner(order_from_size(Size4KiB::SIZE))
-                .map(|f| {
-                    let frame = PhysFrame::containing_address(f);
-                    frame.as_slice_mut().fill(0);
-                    frame
-                })
-        })?
+        let phys = self.alloc(Size4KiB::SIZE as _)?;
+        Some(PhysFrame::containing_address(phys))
     }
 
     fn deallocate_frame(&self, frame: PhysFrame<Size4KiB>) {
@@ -106,11 +113,8 @@ unsafe impl FrameAllocator<Size4KiB> for LockedFrameAllocator {
 
 unsafe impl FrameAllocator<Size2MiB> for LockedFrameAllocator {
     fn allocate_frame(&self) -> Option<PhysFrame<Size2MiB>> {
-        self.0.get().map(|m| {
-            m.lock_irq()
-                .allocate_frame_inner(order_from_size(Size2MiB::SIZE))
-                .map(|f| PhysFrame::containing_address(f))
-        })?
+        let phys = self.alloc(Size2MiB::SIZE as _)?;
+        Some(PhysFrame::containing_address(phys))
     }
 
     fn deallocate_frame(&self, frame: PhysFrame<Size2MiB>) {
@@ -177,15 +181,9 @@ pub fn pmm_alloc(order: BuddyOrdering) -> PhysAddr {
     let order = order as usize;
     debug_assert!(order <= BUDDY_SIZE.len());
 
-    let addr = super::FRAME_ALLOCATOR
-        .0
-        .get()
-        .expect("pmm: frame allocator not initialized")
-        .lock()
-        .allocate_frame_inner(order)
-        .expect("pmm: out of memory");
-
-    addr
+    super::FRAME_ALLOCATOR
+        .alloc_zeroed(BUDDY_SIZE[order] as _)
+        .unwrap()
 }
 
 #[derive(Debug)]

src/aero_kernel/src/utils/dma.rs

@@ -35,23 +35,14 @@ pub struct DmaAllocator;
 unsafe impl Allocator for DmaAllocator {
     fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
         // XXX: The DMA buffer must be aligned to a page boundary.
-        let size_bytes = layout.size() as u64;
-
-        let phys = if size_bytes <= Size4KiB::SIZE {
-            let frame: PhysFrame<Size4KiB> = FRAME_ALLOCATOR.allocate_frame().ok_or(AllocError)?;
-            frame.start_address()
-        } else {
-            assert!(size_bytes <= Size2MiB::SIZE);
-
-            let frame: PhysFrame<Size2MiB> = FRAME_ALLOCATOR.allocate_frame().ok_or(AllocError)?;
-            frame.start_address()
-        };
+        let size_bytes = layout.size();
 
+        let phys = FRAME_ALLOCATOR.alloc(size_bytes).ok_or(AllocError)?;
         let virt = phys.as_hhdm_virt();
 
         // SAFETY: The frame is aligned and non-null.
         let ptr = unsafe { NonNull::new_unchecked(virt.as_mut_ptr() as *mut u8) };
-        Ok(NonNull::slice_from_raw_parts(ptr, size_bytes as _))
+        Ok(NonNull::slice_from_raw_parts(ptr, size_bytes))
     }
 
     unsafe fn deallocate(&self, _ptr: NonNull<u8>, _layout: Layout) {}
@@ -63,11 +54,6 @@ pub type DmaBuffer<T> = Box<T, DmaAllocator>;
 pub struct Dma<T: ?Sized>(DmaBuffer<T>);
 
 impl<T> Dma<T> {
-    /// Creates a new DMA buffer intialized with `value`.
-    pub fn new(value: T) -> Self {
-        Dma(DmaBuffer::new_in(value, DmaAllocator))
-    }
-
     /// Creates a new DMA (Direct Memory Access) buffer and is initialized
     /// with zeros.
     ///