Added the ability to allocate sequential physical frames

There are some cases where we need to be able to allocate more
than one frame, and for the full allocation to be contiguous,
such as when using MMIO.

The implementation has some false negatives, as it won't find
sequential frames that span a boundary of the 64-bit boundary.
However, it shouldn't ever return the wrong sequence of addresses.
The implementation is fairly basic, but the similarly basic
tests work, so hopefully it's fine. Improvements here would
be very welcome.

Signed-off-by: SlyMarbo <[email protected]>

Author: SlyMarbo

kernel/src/lib.rs

@@ -112,10 +112,14 @@ impl Bitmap {
     /// bits set to true.
     ///
     pub fn new_set(num: usize) -> Self {
-        Bitmap {
-            num,
-            bits: vec![!0u64; (num + 63) / 64],
+        // Make sure we only set the bits we
+        // have.
+        let mut bitmap = Bitmap::new_unset(num);
+        for i in 0..num {
+            bitmap.set(i);
         }
+
+        bitmap
     }
 
     /// new_unset returns a new bitmap with all
@@ -196,6 +200,27 @@ impl Bitmap {
         None
     }
 
+    // next_n_set returns the smallest i, such that
+    // bits i to i+n-1 are set (true), or None if
+    // no such i can be found..
+    //
+    pub fn next_n_set(&self, n: usize) -> Option<usize> {
+        let mut mask = 0u64;
+        for i in 0..n {
+            mask |= 1 << i;
+        }
+
+        for (i, values) in self.bits.iter().enumerate() {
+            for j in 0..64 - n {
+                if values & mask << j == mask << j {
+                    return Some(i * 64 + j);
+                }
+            }
+        }
+
+        None
+    }
+
     // next_unset returns the smallest n, such that
     // bit n is unset (false), or None if all bits
     // are true.

kernel/src/memory/pmm/bitmap.rs

@@ -6,6 +6,7 @@ use crate::{println, Bitmap};
 use alloc::vec::Vec;
 use bootloader::bootinfo::{MemoryRegion, MemoryRegionType};
 use core::slice::Iter;
+use x86_64::structures::paging::frame::PhysFrameRange;
 use x86_64::structures::paging::{FrameAllocator, FrameDeallocator, PhysFrame, Size4KiB};
 use x86_64::PhysAddr;
 
@@ -121,6 +122,29 @@ impl BitmapPool {
         }
     }
 
+    /// allocate_n_frames returns n sequential free frames,
+    /// or None.
+    ///
+    pub fn allocate_n_frames(&mut self, n: usize) -> Option<PhysFrameRange> {
+        if n == 0 || self.free_frames == 0 {
+            return None;
+        }
+
+        match self.bitmap.next_n_set(n) {
+            None => None,
+            Some(index) => {
+                for i in 0..n {
+                    self.bitmap.unset(index + i);
+                }
+
+                self.free_frames -= n as u64;
+                let start = self.frame_at(index);
+                let end = self.frame_at(index + n);
+                Some(PhysFrame::range(start, end))
+            }
+        }
+    }
+
     /// mark_frame_allocated marks the given frame as
     /// allocated.
     ///
@@ -234,6 +258,20 @@ impl BitmapFrameAllocator {
         }
     }
 
+    /// allocate_n_frames returns n sequential free frames,
+    /// or None.
+    ///
+    pub fn allocate_n_frames(&mut self, n: usize) -> Option<PhysFrameRange> {
+        for pool in self.pools.iter_mut() {
+            if let Some(range) = pool.allocate_n_frames(n) {
+                self.free_frames -= n as u64;
+                return Some(range);
+            }
+        }
+
+        None
+    }
+
     /// mark_frame_allocated marks the given frame as
     /// already allocated.
     ///

kernel/tests/heap_allocation.rs

@@ -13,6 +13,7 @@ use core::panic::PanicInfo;
 use kernel::memory::pmm::BitmapFrameAllocator;
 use kernel::memory::KERNEL_HEAP;
 use kernel::Bitmap;
+use x86_64::structures::paging::frame::PhysFrameRange;
 use x86_64::structures::paging::{FrameAllocator, FrameDeallocator, PhysFrame};
 use x86_64::PhysAddr;
 
@@ -197,6 +198,29 @@ fn bitmap_frame_allocator() {
     assert_eq!(alloc.allocate_frame(), None);
     assert_eq!(alloc.num_frames, 6u64);
     assert_eq!(alloc.free_frames, 0u64);
+
+    // Check that sequential allocations work correctly.
+
+    // Deallocate 2 non-sequential frames, expect None.
+    unsafe { alloc.deallocate_frame(frame_for(0x5000)) };
+    unsafe { alloc.deallocate_frame(frame_for(0x7000)) };
+    assert_eq!(alloc.allocate_n_frames(2), None);
+
+    // Leave 2 sequential frames, check we get the right pair.
+    // Note: we use PhysFrameRange, not PhysFrameRangeInclusive.
+    assert_eq!(alloc.allocate_frame(), Some(frame_for(0x5000)));
+    unsafe { alloc.deallocate_frame(frame_for(0x6000)) };
+    assert_eq!(
+        alloc.allocate_n_frames(2),
+        Some(PhysFrameRange {
+            start: frame_for(0x6000),
+            end: frame_for(0x8000) // exclusive
+        })
+    );
+
+    // Check that we get nothing once we run out of frames.
+    assert_eq!(alloc.num_frames, 6u64);
+    assert_eq!(alloc.free_frames, 0u64);
 }
 
 #[panic_handler]