use super::{PageTable, PageTableEntry, PageTableFlags, PhysAddr, SimpleFrameAllocator, VirtAddr};
pub fn walk_page_table(root_paddr: PhysAddr, vaddr: VirtAddr) -> Option<PhysAddr> {
let root_table = unsafe { &*(root_paddr.as_usize() as *const PageTable) };
let vpn2 = vaddr.vpn2();
let pte2 = root_table.get_entry(vpn2);
if !pte2.is_valid() {
return None; }
if pte2.is_leaf() {
let offset = vaddr.as_usize() & 0x3FFF_FFFF;
return Some(PhysAddr::new(pte2.phys_addr().as_usize() + offset));
}
let table1 = unsafe { &*(pte2.phys_addr().as_usize() as *const PageTable) };
let vpn1 = vaddr.vpn1();
let pte1 = table1.get_entry(vpn1);
if !pte1.is_valid() {
return None;
}
if pte1.is_leaf() {
let offset = vaddr.as_usize() & 0x1F_FFFF;
return Some(PhysAddr::new(pte1.phys_addr().as_usize() + offset));
}
let table0 = unsafe { &*(pte1.phys_addr().as_usize() as *const PageTable) };
let vpn0 = vaddr.vpn0();
let pte0 = table0.get_entry(vpn0);
if !pte0.is_valid() {
return None;
}
let offset = vaddr.page_offset();
Some(PhysAddr::new(pte0.phys_addr().as_usize() + offset))
}
pub fn walk_page_table_verbose(root_paddr: PhysAddr, vaddr: VirtAddr) -> Option<PhysAddr> {
crate::serial_println!("\n╔════════════════════════════════════════╗");
crate::serial_println!("║ 页表遍历过程(Sv39) ║");
crate::serial_println!("╠════════════════════════════════════════╣");
crate::serial_println!("║ 虚拟地址: {:#018x} ║", vaddr.as_usize());
crate::serial_println!("║ 根页表: {:#018x} ║", root_paddr.as_usize());
crate::serial_println!("╚════════════════════════════════════════╝");
let vpn2 = vaddr.vpn2();
let vpn1 = vaddr.vpn1();
let vpn0 = vaddr.vpn0();
let offset = vaddr.page_offset();
crate::serial_println!("\n[1] 虚拟地址分解:");
crate::serial_println!(" VPN[2] = {:3} (bits 38-30)", vpn2);
crate::serial_println!(" VPN[1] = {:3} (bits 29-21)", vpn1);
crate::serial_println!(" VPN[0] = {:3} (bits 20-12)", vpn0);
crate::serial_println!(" Offset = {:#05x} (bits 11-0)", offset);
let root_table = unsafe { &*(root_paddr.as_usize() as *const PageTable) };
crate::serial_println!("\n[2] Level 2 查找 (VPN[2] = {}):", vpn2);
let pte2 = root_table.get_entry(vpn2);
if !pte2.is_valid() {
crate::serial_println!(" ✗ 页表项无效 (V=0)");
return None;
}
crate::serial_println!(" ✓ 页表项有效");
crate::serial_println!(" PPN = {:#x}", pte2.ppn());
crate::serial_println!(" Flags = {:#04x}", pte2.flags());
if pte2.is_leaf() {
crate::serial_println!(" → 这是一个 1GB 大页");
let paddr = PhysAddr::new(pte2.phys_addr().as_usize() + (vaddr.as_usize() & 0x3FFF_FFFF));
crate::serial_println!(
"\n✓ 转换完成: {:#x} → {:#x}\n",
vaddr.as_usize(),
paddr.as_usize()
);
return Some(paddr);
}
crate::serial_println!(" → 指向下一级页表");
let table1_paddr = pte2.phys_addr();
crate::serial_println!("\n[3] Level 1 查找 (VPN[1] = {}):", vpn1);
crate::serial_println!(" 页表地址: {:#x}", table1_paddr.as_usize());
let table1 = unsafe { &*(table1_paddr.as_usize() as *const PageTable) };
let pte1 = table1.get_entry(vpn1);
if !pte1.is_valid() {
crate::serial_println!(" ✗ 页表项无效 (V=0)");
return None;
}
crate::serial_println!(" ✓ 页表项有效");
crate::serial_println!(" PPN = {:#x}", pte1.ppn());
crate::serial_println!(" Flags = {:#04x}", pte1.flags());
if pte1.is_leaf() {
crate::serial_println!(" → 这是一个 2MB 大页");
let paddr = PhysAddr::new(pte1.phys_addr().as_usize() + (vaddr.as_usize() & 0x1F_FFFF));
crate::serial_println!(
"\n✓ 转换完成: {:#x} → {:#x}\n",
vaddr.as_usize(),
paddr.as_usize()
);
return Some(paddr);
}
crate::serial_println!(" → 指向下一级页表");
let table0_paddr = pte1.phys_addr();
crate::serial_println!("\n[4] Level 0 查找 (VPN[0] = {}):", vpn0);
crate::serial_println!(" 页表地址: {:#x}", table0_paddr.as_usize());
let table0 = unsafe { &*(table0_paddr.as_usize() as *const PageTable) };
let pte0 = table0.get_entry(vpn0);
if !pte0.is_valid() {
crate::serial_println!(" ✗ 页表项无效 (V=0)");
return None;
}
crate::serial_println!(" ✓ 页表项有效 (4KB 页)");
crate::serial_println!(" PPN = {:#x}", pte0.ppn());
crate::serial_println!(" Flags = {:#04x}", pte0.flags());
let paddr = PhysAddr::new(pte0.phys_addr().as_usize() + offset);
crate::serial_println!("\n[5] 最终物理地址:");
crate::serial_println!(" 物理页帧: {:#x}", pte0.phys_addr().as_usize());
crate::serial_println!(" 页内偏移: {:#x}", offset);
crate::serial_println!(" 物理地址: {:#x}", paddr.as_usize());
crate::serial_println!(
"\n✓ 转换完成: {:#x} → {:#x}\n",
vaddr.as_usize(),
paddr.as_usize()
);
Some(paddr)
}
pub fn map_page(
root_table: &mut PageTable,
vaddr: VirtAddr,
paddr: PhysAddr,
flags: usize,
allocator: &mut SimpleFrameAllocator,
) -> Result<(), &'static str> {
let vpn2 = vaddr.vpn2();
let pte2 = root_table.get_entry_mut(vpn2);
let intermediate_flags = PageTableFlags::Valid as usize;
let table1 = if !pte2.is_valid() {
let frame = allocator.allocate().ok_or("Out of memory")?;
let table1_paddr = frame.start_address();
pte2.set(table1_paddr.as_usize() >> 12, intermediate_flags);
let table1 = unsafe { &mut *(table1_paddr.as_usize() as *mut PageTable) };
table1.zero();
table1
} else {
unsafe { &mut *(pte2.phys_addr().as_usize() as *mut PageTable) }
};
let vpn1 = vaddr.vpn1();
let pte1 = table1.get_entry_mut(vpn1);
let table0 = if !pte1.is_valid() {
let frame = allocator.allocate().ok_or("Out of memory")?;
let table0_paddr = frame.start_address();
pte1.set(table0_paddr.as_usize() >> 12, intermediate_flags);
let table0 = unsafe { &mut *(table0_paddr.as_usize() as *mut PageTable) };
table0.zero();
table0
} else {
unsafe { &mut *(pte1.phys_addr().as_usize() as *mut PageTable) }
};
let vpn0 = vaddr.vpn0();
let pte0 = table0.get_entry_mut(vpn0);
if pte0.is_valid() {
return Err("Page already mapped");
}
pte0.set(
paddr.as_usize() >> 12,
flags | PageTableFlags::Valid as usize,
);
unsafe {
core::arch::asm!(
"sfence.vma {0}, zero",
in(reg) vaddr.as_usize(),
);
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::memory::{PageTableFlags, PAGE_SIZE};
#[test_case]
fn user_mapping_keeps_intermediate_ptes_permissionless() {
let mut allocator = crate::memory::SimpleFrameAllocator::new(0x8060_0000, 0x8070_0000);
let root_frame = allocator.allocate().expect("root page table");
let root = unsafe { &mut *(root_frame.start_address().as_usize() as *mut PageTable) };
root.zero();
let user_vaddr = VirtAddr::new(0x10078);
let user_page = VirtAddr::new(user_vaddr.as_usize() & !(PAGE_SIZE - 1));
let user_frame = allocator.allocate().expect("user frame");
let leaf_flags = PageTableFlags::Read as usize
| PageTableFlags::Execute as usize
| PageTableFlags::User as usize;
map_page(
root,
user_page,
user_frame.start_address(),
leaf_flags,
&mut allocator,
)
.expect("map user page");
let pte2 = root.get_entry(user_vaddr.vpn2());
assert!(pte2.is_valid());
assert!(!pte2.is_leaf());
assert_eq!(pte2.flags(), PageTableFlags::Valid as usize);
let table1 = unsafe { &*(pte2.phys_addr().as_usize() as *const PageTable) };
let pte1 = table1.get_entry(user_vaddr.vpn1());
assert!(pte1.is_valid());
assert!(!pte1.is_leaf());
assert_eq!(pte1.flags(), PageTableFlags::Valid as usize);
let table0 = unsafe { &*(pte1.phys_addr().as_usize() as *const PageTable) };
let pte0 = table0.get_entry(user_vaddr.vpn0());
assert!(pte0.is_valid());
assert!(pte0.is_leaf());
assert_ne!(pte0.flags() & PageTableFlags::User as usize, 0);
assert_ne!(pte0.flags() & PageTableFlags::Execute as usize, 0);
}
}
pub fn map_page_verbose(
root_table: &mut PageTable,
vaddr: VirtAddr,
paddr: PhysAddr,
flags: usize,
allocator: &mut SimpleFrameAllocator,
) -> Result<(), &'static str> {
crate::serial_println!("\n╔════════════════════════════════════════╗");
crate::serial_println!("║ 页面映射过程 ║");
crate::serial_println!("╠════════════════════════════════════════╣");
crate::serial_println!("║ 虚拟地址: {:#018x} ║", vaddr.as_usize());
crate::serial_println!("║ 物理地址: {:#018x} ║", paddr.as_usize());
crate::serial_println!("║ 标志位: {:#010x} ║", flags);
crate::serial_println!("╚════════════════════════════════════════╝");
let result = map_page(root_table, vaddr, paddr, flags, allocator);
if result.is_ok() {
crate::serial_println!("✓ 映射成功!\n");
} else {
crate::serial_println!("✗ 映射失败: {:?}\n", result);
}
result
}
pub fn unmap_page(root_table: &mut PageTable, vaddr: VirtAddr) -> Result<PhysAddr, &'static str> {
let vpn2 = vaddr.vpn2();
let pte2 = root_table.get_entry_mut(vpn2);
if !pte2.is_valid() {
return Err("Page not mapped");
}
let table1 = unsafe { &mut *(pte2.phys_addr().as_usize() as *mut PageTable) };
let vpn1 = vaddr.vpn1();
let pte1 = table1.get_entry_mut(vpn1);
if !pte1.is_valid() {
return Err("Page not mapped");
}
let table0 = unsafe { &mut *(pte1.phys_addr().as_usize() as *mut PageTable) };
let vpn0 = vaddr.vpn0();
let pte0 = table0.get_entry_mut(vpn0);
if !pte0.is_valid() {
return Err("Page not mapped");
}
let paddr = pte0.phys_addr();
*pte0 = PageTableEntry::new();
unsafe {
core::arch::asm!(
"sfence.vma {0}, zero",
in(reg) vaddr.as_usize(),
);
}
Ok(paddr)
}
pub fn translate_addr(vaddr: VirtAddr) -> Option<PhysAddr> {
use riscv::register::satp;
let satp_value = satp::read();
let root_ppn = satp_value.ppn();
let root_paddr = PhysAddr::new(root_ppn << 12);
walk_page_table(root_paddr, vaddr)
}