Allocate multiple pages at once

Author: jdreaver

README.md

@@ -92,8 +92,6 @@ make test
 ## TODO
 
 - Stack size: figure out why stacks need to be so large when compiling in debug mode. Is Rust putting a ton of debug info on the stack?
-- Review/refactor kernel stack + guard page code
-- Replace `allocate_and_map_page` with `allocate_and_map_pages`, which accepts a `PageRange`, so we don't have to keep taking a bunch of locks in a loop.
 - Synchronization primitives
   - Mutex (not spinlock "mutex") that handles sleeping and waking
     - I like Linux's mutex where they store the current holder's task ID in an atomic variable

kernel/src/heap.rs

@@ -26,10 +26,8 @@ pub(crate) fn init() -> Result<(), MapToError<Size4KiB>> {
         Page::range_inclusive(heap_start_page, heap_end_page)
     };
 
-    for page in page_range {
-        let flags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE;
-        memory::allocate_and_map_page(page, flags)?;
-    }
+    let flags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE;
+    memory::allocate_and_map_pages(page_range, flags)?;
 
     unsafe {
         // `init() actually writes to the heap, which is why we can only

kernel/src/memory.rs

@@ -87,14 +87,18 @@ pub(crate) fn allocate_physical_frame<S: PageSize>() -> Option<PhysFrame<S>> {
 /// virtual page to the physical frame in the page table. Useful for
 /// initializing a virtual region that is known not to be backed by memory, like
 /// initializing the kernel heap.
-pub(crate) fn allocate_and_map_page(
-    page: Page,
+pub(crate) fn allocate_and_map_pages(
+    pages: impl Iterator<Item = Page>,
     flags: PageTableFlags,
 ) -> Result<(), MapToError<Size4KiB>> {
-    let frame = allocate_physical_frame::<Size4KiB>().ok_or(MapToError::FrameAllocationFailed)?;
     KERNEL_PHYSICAL_ALLOCATOR.with_lock(|allocator| {
         KERNEL_MAPPER.with_lock(|mapper| unsafe {
-            mapper.map_to(page, frame, flags, allocator)?.flush();
+            for page in pages {
+                let frame = allocator
+                    .allocate_frame()
+                    .ok_or(MapToError::FrameAllocationFailed)?;
+                mapper.map_to(page, frame, flags, allocator)?.flush();
+            }
             Ok(())
         })
     })

kernel/src/sched/stack.rs

@@ -60,22 +60,16 @@ impl KernelStackAllocator<'_> {
         );
         let stack = KernelStack { start_addr };
 
-        // Allocate physical memory
-        // let physical_size = KERNEL_STACK_SIZE_BYTES - memory::PAGE_SIZE;
-        // let buffer = PhysicalBuffer::allocate_zeroed(physical_size)
-        //     .expect("failed to allocate PhysicalBuffer for kernel stack");
-
         // Map the guard page as invalid
         unsafe {
             memory::map_guard_page(stack.guard_page())
                 .expect("failed to map kernel stack guard page");
         }
 
         // Map the physical memory into the virtual address space
-        for page in stack.physically_mapped_pages() {
-            let flags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE;
-            memory::allocate_and_map_page(page, flags).expect("failed to map kernel stack page");
-        }
+        let pages = stack.physically_mapped_pages();
+        let flags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE;
+        memory::allocate_and_map_pages(pages, flags).expect("failed to map kernel stack pages");
 
         // Zero out the memory
         unsafe {
@@ -86,8 +80,6 @@ impl KernelStackAllocator<'_> {
         Some(stack)
     }
 
-    // TODO: Instead of a free method, implement Drop for KernelStack that frees
-    // itself. I'm just a bit wary about calling a Mutex with Drop.
     fn free(&mut self, stack: &KernelStack) {
         let stack_index = (stack.start_addr.as_u64() - KERNEL_STACK_START_VIRT_ADDR as u64)
             / KERNEL_STACK_SIZE_BYTES as u64;