Update PagingHandler, adding methods for allocating/deallocating multiple frames (#37)

* add methods for allocating/deallocating multiple frams to `PagingHandler`, add default implementation for single-page allocation/deallocation

* bump to 0.6.0

Author: aarkegz

Cargo.lock

@@ -4,7 +4,7 @@ resolver = "2"
 members = ["page_table_multiarch", "page_table_entry"]
 
 [workspace.package]
-version = "0.5.7"
+version = "0.6.0"
 edition = "2024"
 authors = ["Yuekai Jia <[email protected]>"]
 license = "GPL-3.0-or-later OR Apache-2.0 OR MulanPSL-2.0"
@@ -17,4 +17,4 @@ rust-version = "1.85"
 
 [workspace.dependencies]
 memory_addr = "0.4"
-page_table_entry = { path = "page_table_entry", version = "0.5" }
+page_table_entry = { path = "page_table_entry", version = "0.6" }

Cargo.toml

@@ -49,12 +49,20 @@ impl PagingHandler for PagingHandlerImpl {
         Some(PhysAddr::from(ptr as usize))
     }
 
+    fn alloc_frames(num: usize, align_pow2: usize) -> Option<PhysAddr> {
+        todo!();
+    }
+
     fn dealloc_frame(paddr: PhysAddr) {
         let layout = Layout::from_size_align(0x1000, 0x1000).unwrap();
         let ptr = paddr.as_usize() as *mut u8;
         unsafe { alloc::alloc::dealloc(ptr, layout) };
     }
 
+    fn dealloc_frames(paddr: PhysAddr, num: usize) {
+        todo!();
+    }
+
     fn phys_to_virt(paddr: PhysAddr) -> VirtAddr {
         VirtAddr::from(paddr.as_usize())
     }

page_table_multiarch/README.md

@@ -10,7 +10,7 @@ mod bits64;
 
 use core::{fmt::Debug, marker::PhantomData};
 
-use memory_addr::{MemoryAddr, PhysAddr, VirtAddr};
+use memory_addr::{MemoryAddr, PAGE_SIZE_4K, PhysAddr, VirtAddr};
 #[doc(no_inline)]
 pub use page_table_entry::{GenericPTE, MappingFlags};
 
@@ -90,9 +90,20 @@ pub trait PagingMetaData: Sync + Send {
 /// [`PageTable64`].
 pub trait PagingHandler: Sized {
     /// Request to allocate a 4K-sized physical frame.
-    fn alloc_frame() -> Option<PhysAddr>;
+    fn alloc_frame() -> Option<PhysAddr> {
+        Self::alloc_frames(1, PAGE_SIZE_4K)
+    }
+    /// Allocate `num` contiguous physical frames, with the starting physical
+    /// address aligned to `align` bytes (must be a power of two, and must be
+    /// a multiple of 4K).
+    fn alloc_frames(num: usize, align: usize) -> Option<PhysAddr>;
     /// Request to free a allocated physical frame.
-    fn dealloc_frame(paddr: PhysAddr);
+    fn dealloc_frame(paddr: PhysAddr) {
+        Self::dealloc_frames(paddr, 1)
+    }
+    /// Free `num` contiguous physical frames starting from the given physical
+    /// address. The `num` must be the same as that used in allocation.
+    fn dealloc_frames(paddr: PhysAddr, num: usize);
     /// Returns a virtual address that maps to the given physical address.
     ///
     /// Used to access the physical memory directly in page table

page_table_multiarch/src/lib.rs

@@ -1,7 +1,7 @@
 use std::{
     alloc::{self, Layout},
     cell::RefCell,
-    collections::HashSet,
+    collections::{HashMap, HashSet},
     marker::PhantomData,
 };
 
@@ -10,10 +10,23 @@ use page_table_entry::{GenericPTE, MappingFlags};
 use page_table_multiarch::{PageSize, PageTable64, PagingHandler, PagingMetaData, PagingResult};
 use rand::{Rng, SeedableRng, rngs::SmallRng};
 
-const PAGE_LAYOUT: Layout = unsafe { Layout::from_size_align_unchecked(4096, 4096) };
+/// Creates a layout for allocating `num` pages with alignment of `2^align_pow2`
+/// pages.
+const fn pages_layout(num: usize, align: usize) -> Layout {
+    if !align.is_power_of_two() {
+        panic!("alignment must be a power of two");
+    }
+    if align % 4096 != 0 {
+        panic!("alignment must be a multiple of 4K");
+    }
+    unsafe { Layout::from_size_align_unchecked(4096 * num, align) }
+}
+
+const PAGE_LAYOUT: Layout = pages_layout(1, 4096);
 
 thread_local! {
     static ALLOCATED: RefCell<HashSet<usize>> = RefCell::default();
+    static ALIGN: RefCell<HashMap<usize, usize>> = RefCell::default();
 }
 
 struct TrackPagingHandler<M: PagingMetaData>(PhantomData<M>);
@@ -29,6 +42,24 @@ impl<M: PagingMetaData> PagingHandler for TrackPagingHandler<M> {
         Some(PhysAddr::from_usize(ptr))
     }
 
+    fn alloc_frames(num: usize, align: usize) -> Option<PhysAddr> {
+        let layout = pages_layout(num, align);
+        let ptr = unsafe { alloc::alloc(layout) } as usize;
+        assert!(
+            ptr <= M::PA_MAX_ADDR,
+            "allocated frame address exceeds PA_MAX_ADDR"
+        );
+        ALLOCATED.with_borrow_mut(|it| {
+            for i in 0..num {
+                it.insert(ptr + i * 4096);
+            }
+        });
+        ALIGN.with_borrow_mut(|it| {
+            it.insert(ptr, align);
+        });
+        Some(PhysAddr::from_usize(ptr))
+    }
+
     fn dealloc_frame(paddr: PhysAddr) {
         let ptr = paddr.as_usize();
         ALLOCATED.with_borrow_mut(|it| {
@@ -39,6 +70,24 @@ impl<M: PagingMetaData> PagingHandler for TrackPagingHandler<M> {
         }
     }
 
+    fn dealloc_frames(paddr: PhysAddr, num: usize) {
+        let ptr = paddr.as_usize();
+        ALLOCATED.with_borrow_mut(|it| {
+            for i in 0..num {
+                let addr = ptr + i * 4096;
+                assert!(it.remove(&addr), "dealloc a frame that was not allocated");
+            }
+        });
+        let align = ALIGN.with_borrow_mut(|it| {
+            it.remove(&ptr)
+                .expect("dealloc frames that were not allocated")
+        });
+        let layout = pages_layout(num, align);
+        unsafe {
+            alloc::dealloc(ptr as _, layout);
+        }
+    }
+
     fn phys_to_virt(paddr: PhysAddr) -> VirtAddr {
         assert!(paddr.as_usize() > 0);
         VirtAddr::from_usize(paddr.as_usize())