feat(mm): add PageAlloc, FrameAlloc

Co-authored-by: m-mueller678 <[email protected]>

Author: mkroening

src/mm/mod.rs

@@ -41,6 +41,7 @@
 //! ```
 
 pub(crate) mod device_alloc;
+mod page_range_alloc;
 pub(crate) mod physicalmem;
 pub(crate) mod virtualmem;
 
@@ -53,6 +54,9 @@ use hermit_sync::{Lazy, RawInterruptTicketMutex};
 pub use memory_addresses::{PhysAddr, VirtAddr};
 use talc::{ErrOnOom, Span, Talc, Talck};
 
+pub use self::page_range_alloc::PageRangeAllocator;
+pub use self::physicalmem::FrameAlloc;
+pub use self::virtualmem::PageAlloc;
 #[cfg(any(target_arch = "x86_64", target_arch = "riscv64"))]
 use crate::arch::mm::paging::HugePageSize;
 pub use crate::arch::mm::paging::virtual_to_physical;

src/mm/page_range_alloc.rs

@@ -0,0 +1,21 @@
+use core::alloc::AllocError;
+
+use free_list::{PageLayout, PageRange};
+
+/// An allocator that allocates memory in page granularity.
+pub trait PageRangeAllocator {
+	unsafe fn init();
+
+	/// Attempts to allocate a range of memory in page granularity.
+	fn allocate(layout: PageLayout) -> Result<PageRange, AllocError>;
+
+	/// Attempts to allocate the pages described by `range`.
+	fn allocate_at(range: PageRange) -> Result<(), AllocError>;
+
+	/// Deallocates the pages described by `range`.
+	///
+	/// # Safety
+	///
+	/// - `range` must described a range of pages _currently allocated_ via this allocator.
+	unsafe fn deallocate(range: PageRange);
+}

src/mm/physicalmem.rs

@@ -1,20 +1,58 @@
+use core::alloc::AllocError;
+use core::fmt;
 use core::sync::atomic::{AtomicUsize, Ordering};
 
 use align_address::Align;
-use free_list::{FreeList, PageRange, PageRangeError};
+use free_list::{FreeList, PageLayout, PageRange, PageRangeError};
 use hermit_sync::InterruptTicketMutex;
 use memory_addresses::{PhysAddr, VirtAddr};
 
 #[cfg(target_arch = "x86_64")]
 use crate::arch::mm::paging::PageTableEntryFlagsExt;
 use crate::arch::mm::paging::{self, HugePageSize, PageSize, PageTableEntryFlags};
 use crate::env;
+use crate::mm::PageRangeAllocator;
 use crate::mm::device_alloc::DeviceAlloc;
 
 pub static PHYSICAL_FREE_LIST: InterruptTicketMutex<FreeList<16>> =
 	InterruptTicketMutex::new(FreeList::new());
 pub static TOTAL_MEMORY: AtomicUsize = AtomicUsize::new(0);
 
+pub struct FrameAlloc;
+
+impl PageRangeAllocator for FrameAlloc {
+	unsafe fn init() {
+		init();
+	}
+
+	fn allocate(layout: PageLayout) -> Result<PageRange, AllocError> {
+		PHYSICAL_FREE_LIST
+			.lock()
+			.allocate(layout)
+			.map_err(|_| AllocError)
+	}
+
+	fn allocate_at(range: PageRange) -> Result<(), AllocError> {
+		PHYSICAL_FREE_LIST
+			.lock()
+			.allocate_at(range)
+			.map_err(|_| AllocError)
+	}
+
+	unsafe fn deallocate(range: PageRange) {
+		unsafe {
+			PHYSICAL_FREE_LIST.lock().deallocate(range).unwrap();
+		}
+	}
+}
+
+impl fmt::Display for FrameAlloc {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		let free_list = PHYSICAL_FREE_LIST.lock();
+		write!(f, "FrameAlloc free list:\n{free_list}")
+	}
+}
+
 pub fn total_memory_size() -> usize {
 	TOTAL_MEMORY.load(Ordering::Relaxed)
 }

src/mm/virtualmem.rs

@@ -1,10 +1,50 @@
-use free_list::{FreeList, PageRange};
+use core::alloc::AllocError;
+use core::fmt;
+
+use free_list::{FreeList, PageLayout, PageRange};
 use hermit_sync::InterruptTicketMutex;
 use memory_addresses::VirtAddr;
 
+use crate::mm::PageRangeAllocator;
+
 pub static KERNEL_FREE_LIST: InterruptTicketMutex<FreeList<16>> =
 	InterruptTicketMutex::new(FreeList::new());
 
+pub struct PageAlloc;
+
+impl PageRangeAllocator for PageAlloc {
+	unsafe fn init() {
+		init();
+	}
+
+	fn allocate(layout: PageLayout) -> Result<PageRange, AllocError> {
+		KERNEL_FREE_LIST
+			.lock()
+			.allocate(layout)
+			.map_err(|_| AllocError)
+	}
+
+	fn allocate_at(range: PageRange) -> Result<(), AllocError> {
+		KERNEL_FREE_LIST
+			.lock()
+			.allocate_at(range)
+			.map_err(|_| AllocError)
+	}
+
+	unsafe fn deallocate(range: PageRange) {
+		unsafe {
+			KERNEL_FREE_LIST.lock().deallocate(range).unwrap();
+		}
+	}
+}
+
+impl fmt::Display for PageAlloc {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		let free_list = KERNEL_FREE_LIST.lock();
+		write!(f, "PageAlloc free list:\n{free_list}")
+	}
+}
+
 pub fn init() {
 	let range = PageRange::new(
 		kernel_heap_end().as_usize().div_ceil(2),