6.3 記憶體管理與簡易頁表#

// src/mem.rs
use x86_64::structures::paging::page_table::{PageTable, PageTableFlags};
use x86_64::{PhysAddr, VirtAddr};

pub struct PageTableManager {
    pub l4: &'static mut PageTable,   // Level 4 表
    phys_offset: VirtAddr,            // 物理記憶體在虛擬空間的映射起點
}

impl PageTableManager {
    /// 關鍵技巧：核心自己也在虛擬位址上執行，
    /// 要改「實體位址 P 的頁表」，得先知道 P 對應的虛擬位址。
    /// bootloader 已建立「全物理記憶體映射到 phys_offset 起」的區域，
    /// 所以 phys_offset + p 就是答案。
    fn phys_to_virt(&self, phys: PhysAddr) -> *mut PageTable {
        (self.phys_offset + phys.as_u64()).as_mut_ptr()
    }

    /// 建立新映射：虛擬頁 → 物理頁框
    pub unsafe fn map_page(&mut self, virt: VirtAddr, phys: PhysAddr) {
        let p4 = self.l4;
        let idx4 = p4_index(virt);
        let idx3 = p3_index(virt);
        let idx2 = p2_index(virt);
        let idx1 = p1_index(virt);

        // 沿途建立中間級表（不存在就分配）
        let p3 = self.next_table_or_create(p4, idx4);
        let p2 = self.next_table_or_create(p3, idx3);
        let p1 = self.next_table_or_create(p2, idx2);

        // 最後一級寫入映射 + 權限位元
        p1[idx1].set_addr(phys, PageTableFlags::PRESENT | PageTableFlags::WRITABLE);
    }

    unsafe fn next_table_or_create<'a>(
        &mut self,
        table: &'a mut PageTable,
        idx: usize,
    ) -> &'a mut PageTable {
        if table[idx].is_unused() {
            let frame = alloc_frame().expect("out of physical frames");
            table[idx].set_frame(frame, PageTableFlags::PRESENT | PageTableFlags::WRITABLE);
            // 新表要清零——髒的頁表條目 = 隨機映射 = 安全漏洞
            let pt = self.phys_to_virt(frame.start_address());
            core::ptr::write_bytes(pt as *mut u8, 0, 4096);
        }
        &mut *self.phys_to_virt(table[idx].addr())
    }
}

// src/frame.rs
pub struct FrameAllocator {
    bitmap: &'static mut [u8],   // 每位元對應一個 4KB 框
    next_free: usize,
}

impl FrameAllocator {
    pub fn alloc(&mut self) -> Option<PhysFrame> {
        // 找到第一個 0 位元
        for i in self.next_free..self.bitmap.len() * 8 {
            if !self.is_used(i) {
                self.set_used(i);
                self.next_free = i + 1;
                return Some(PhysFrame::containing_address(PhysAddr::new(i as u64 * 4096)));
            }
        }
        None
    }

    pub fn dealloc(&mut self, frame: PhysFrame) {
        let idx = frame.start_address().as_u64() as usize / 4096;
        self.set_free(idx);
        self.next_free = self.next_free.min(idx);
    }
}

// src/heap.rs
use linked_list_allocator::LockedHeap;

#[global_allocator]
static ALLOCATOR: LockedHeap = LockedHeap::empty();

pub fn init_heap(phys_offset: VirtAddr, ptm: &mut PageTableManager) {
    const HEAP_START: u64 = 0o_000_000_000_000;   // 選個不衝突的虛擬位址
    const HEAP_SIZE: u64 = 100 * 1024;             // 100 KiB

    // 1. 向頁框分配器要物理頁
    // 2. map_page 把 [HEAP_START, HEAP_START+HEAP_SIZE] 映射上去
    for page in Page::range_inclusive(
        Page::containing_address(VirtAddr::new(HEAP_START)),
        Page::containing_address(VirtAddr::new(HEAP_START + HEAP_SIZE - 1)),
    ) {
        let frame = alloc_frame().unwrap();
        unsafe { ptm.map_page(page.start_address(), frame.start_address()); }
    }

    // 3. 告訴全域分配器這段範圍可用
    unsafe { ALLOCATOR.lock().init(HEAP_START as *mut u8, HEAP_SIZE as usize); }
}

// 現在裸機上可以：
let v = vec![1, 2, 3];      // Vec → malloc → 空閒鏈表 → 頁框 → 頁表 → 實體記憶體
let b = Box::new(42);       // 整條鏈第一次全部點亮