Step 0-3: add heap and frame allocators

Author: equation314

hypervisor/Cargo.lock

@@ -11,7 +11,9 @@ log = "0.4"
 spin = "0.9"
 cfg-if = "1.0"
 bitflags = "1.3"
+buddy_system_allocator = "0.8"
 lazy_static = { version = "1.4.0", features = ["spin_no_std"] }
+bitmap-allocator = { git = "https://github.com/rcore-os/bitmap-allocator", rev = "88e871a" }
 
 [target.'cfg(target_arch = "x86_64")'.dependencies]
 x86 = "0.52"

hypervisor/Cargo.toml

@@ -1,5 +1,10 @@
 pub const PHYS_VIRT_OFFSET: usize = 0xffff_ff80_0000_0000;
 
 pub const BOOT_KERNEL_STACK_SIZE: usize = 4096 * 4; // 16K
+pub const KERNEL_HEAP_SIZE: usize = 0x40_0000; // 4M
+
+pub const PHYS_MEMORY_BASE: usize = 0;
+pub const PHYS_MEMORY_SIZE: usize = 0x400_0000; // 64M
+pub const PHYS_MEMORY_END: usize = PHYS_MEMORY_BASE + PHYS_MEMORY_SIZE;
 
 pub const TICKS_PER_SEC: u64 = 100;

hypervisor/src/config.rs

@@ -11,6 +11,7 @@ mod logging;
 
 mod arch;
 mod config;
+mod mm;
 mod timer;
 
 #[cfg(not(test))]
@@ -64,10 +65,12 @@ fn main() -> ! {
         option_env!("LOG").unwrap_or(""),
     );
 
+    mm::init_heap_early();
     logging::init();
     info!("Logging is enabled.");
 
     arch::init();
+    mm::init();
     INIT_OK.store(true, Ordering::SeqCst);
     println!("Initialization completed.\n");
 

hypervisor/src/main.rs

@@ -0,0 +1,21 @@
+use super::PAGE_SIZE;
+use crate::config::PHYS_VIRT_OFFSET;
+
+pub(super) type PhysAddr = usize;
+pub(super) type VirtAddr = usize;
+
+pub const fn phys_to_virt(paddr: PhysAddr) -> VirtAddr {
+    paddr + PHYS_VIRT_OFFSET
+}
+
+pub const fn virt_to_phys(vaddr: VirtAddr) -> PhysAddr {
+    vaddr - PHYS_VIRT_OFFSET
+}
+
+pub const fn align_down(addr: usize) -> usize {
+    addr & !(PAGE_SIZE - 1)
+}
+
+pub const fn align_up(addr: usize) -> usize {
+    (addr + PAGE_SIZE - 1) & !(PAGE_SIZE - 1)
+}

hypervisor/src/mm/address.rs

@@ -0,0 +1,65 @@
+use bitmap_allocator::BitAlloc;
+use spin::Mutex;
+
+use super::address::{align_down, align_up, virt_to_phys, PhysAddr};
+use super::PAGE_SIZE;
+use crate::config::PHYS_MEMORY_END;
+
+// Support max 1M * 4096 = 1GB memory.
+type FrameAlloc = bitmap_allocator::BitAlloc1M;
+
+static FRAME_ALLOCATOR: Mutex<FrameAllocator> = Mutex::new(FrameAllocator::empty());
+
+struct FrameAllocator {
+    base: PhysAddr,
+    inner: FrameAlloc,
+}
+
+impl FrameAllocator {
+    const fn empty() -> Self {
+        Self {
+            base: 0,
+            inner: FrameAlloc::DEFAULT,
+        }
+    }
+
+    fn init(&mut self, base: PhysAddr, size: usize) {
+        self.base = align_up(base);
+        let page_count = align_up(size) / PAGE_SIZE;
+        self.inner.insert(0..page_count);
+    }
+
+    unsafe fn alloc(&mut self) -> Option<PhysAddr> {
+        let ret = self.inner.alloc().map(|idx| idx * PAGE_SIZE + self.base);
+        trace!("Allocate frame: {:x?}", ret);
+        ret
+    }
+
+    unsafe fn dealloc(&mut self, target: PhysAddr) {
+        trace!("Deallocate frame: {:x}", target);
+        self.inner.dealloc((target - self.base) / PAGE_SIZE)
+    }
+}
+
+pub unsafe fn alloc_page() -> Option<PhysAddr> {
+    FRAME_ALLOCATOR.lock().alloc()
+}
+
+pub unsafe fn dealloc_page(paddr: PhysAddr) {
+    FRAME_ALLOCATOR.lock().dealloc(paddr)
+}
+
+pub(super) fn init() {
+    extern "C" {
+        fn ekernel();
+    }
+
+    let mem_pool_start = align_up(virt_to_phys(ekernel as usize));
+    let mem_pool_end = align_down(PHYS_MEMORY_END);
+    let mem_pool_size = mem_pool_end - mem_pool_start;
+    println!(
+        "Initializing frame allocator at: [{:#x?}, {:#x?})",
+        mem_pool_start, mem_pool_end
+    );
+    FRAME_ALLOCATOR.lock().init(mem_pool_start, mem_pool_size);
+}

hypervisor/src/mm/frame.rs

@@ -0,0 +1,25 @@
+use buddy_system_allocator::LockedHeap;
+use core::{alloc::Layout, mem::size_of};
+
+use crate::config::KERNEL_HEAP_SIZE;
+
+#[global_allocator]
+static HEAP_ALLOCATOR: LockedHeap<32> = LockedHeap::empty();
+
+#[alloc_error_handler]
+fn handle_alloc_error(layout: Layout) -> ! {
+    panic!("Heap allocation error, layout = {:?}", layout);
+}
+
+static mut HEAP_SPACE: [u64; KERNEL_HEAP_SIZE / size_of::<u64>()] =
+    [0; KERNEL_HEAP_SIZE / size_of::<u64>()];
+
+pub(super) fn init() {
+    let heap_start = unsafe { HEAP_SPACE.as_ptr() as usize };
+    println!(
+        "Initializing heap at: [{:#x}, {:#x})",
+        heap_start,
+        heap_start + KERNEL_HEAP_SIZE
+    );
+    unsafe { HEAP_ALLOCATOR.lock().init(heap_start, KERNEL_HEAP_SIZE) }
+}

hypervisor/src/mm/heap.rs

@@ -0,0 +1,16 @@
+#![allow(dead_code)]
+
+mod heap;
+
+pub mod address;
+pub mod frame;
+
+pub const PAGE_SIZE: usize = 0x1000;
+
+pub fn init_heap_early() {
+    heap::init();
+}
+
+pub fn init() {
+    frame::init();
+}