use super::paging::{map_page, unmap_page};
use super::{PageTable, PageTableFlags, PhysAddr, SimpleFrameAllocator, VirtAddr, PAGE_SIZE};
use alloc::vec::Vec;
use core::ops::Range;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MemoryAreaType {
Code, Data, Heap, Stack, Shared, Kernel, }
impl MemoryAreaType {
pub fn default_flags(&self) -> usize {
use PageTableFlags as PTF;
match self {
MemoryAreaType::Code => {
PTF::Valid as usize | PTF::Read as usize | PTF::Execute as usize
}
MemoryAreaType::Data | MemoryAreaType::Heap | MemoryAreaType::Stack => {
PTF::Valid as usize | PTF::Read as usize | PTF::Write as usize
}
MemoryAreaType::Shared => {
PTF::Valid as usize | PTF::Read as usize | PTF::Write as usize
}
MemoryAreaType::Kernel => {
PTF::Valid as usize
| PTF::Read as usize
| PTF::Write as usize
| PTF::Execute as usize
}
}
}
}
#[derive(Debug, Clone)]
pub struct MemoryArea {
pub range: Range<VirtAddr>,
pub area_type: MemoryAreaType,
pub flags: usize,
}
impl MemoryArea {
pub fn new(start: VirtAddr, end: VirtAddr, area_type: MemoryAreaType) -> Self {
MemoryArea {
range: start..end,
area_type,
flags: area_type.default_flags(),
}
}
pub fn size(&self) -> usize {
self.range.end.as_usize() - self.range.start.as_usize()
}
pub fn page_count(&self) -> usize {
self.size().div_ceil(PAGE_SIZE)
}
}
pub struct AddressSpace {
page_table: *mut PageTable,
page_table_paddr: PhysAddr,
areas: Vec<MemoryArea>,
}
pub fn deep_copy_user_address_space(
src_satp: usize,
allocator: &mut SimpleFrameAllocator,
) -> Result<usize, &'static str> {
let src_root_ppn = src_satp & 0x0000_0FFF_FFFF_FFFF;
let src_root_paddr = src_root_ppn << 12;
let new_root_frame = allocator.allocate().ok_or("OOM for root page table")?;
let new_root_paddr = new_root_frame.start_address().as_usize();
unsafe {
let new_root = new_root_paddr as *mut PageTable;
(*new_root).zero();
clone_page_table_level(allocator, src_root_paddr, new_root_paddr, 2, true)?;
}
Ok((8usize << 60) | (new_root_paddr >> 12))
}
unsafe fn clone_page_table_level(
allocator: &mut SimpleFrameAllocator,
src_table_paddr: usize,
dst_table_paddr: usize,
level: usize,
copy_user_pages: bool,
) -> Result<(), &'static str> {
let src = src_table_paddr as *const PageTable;
let dst = dst_table_paddr as *mut PageTable;
for idx in 0..512 {
let entry = (*src).entries[idx];
if !entry.is_valid() {
continue;
}
let flags = entry.flags();
let has_user = (flags & (PageTableFlags::User as usize)) != 0;
if entry.is_leaf() {
if !has_user {
(*dst).entries[idx] = entry;
} else if copy_user_pages {
if level != 0 {
return Err("Unsupported user huge page");
}
let page_paddr = entry.ppn() << 12;
let new_frame = allocator.allocate().ok_or("OOM for user page copy")?;
let new_paddr = new_frame.start_address().as_usize();
copy_4k_page(page_paddr, new_paddr);
(*dst).entries[idx].set(new_paddr >> 12, flags);
}
} else {
if level == 0 {
return Err("Malformed page table: non-leaf at level 0");
}
let src_child_paddr = entry.ppn() << 12;
let new_child_frame = allocator.allocate().ok_or("OOM for intermediate PT")?;
let new_child_paddr = new_child_frame.start_address().as_usize();
let child = new_child_paddr as *mut PageTable;
(*child).zero();
(*dst).entries[idx].set(new_child_paddr >> 12, flags);
clone_page_table_level(
allocator,
src_child_paddr,
new_child_paddr,
level - 1,
copy_user_pages,
)?;
}
}
Ok(())
}
unsafe fn copy_4k_page(src_paddr: usize, dst_paddr: usize) {
let page_size_words = PAGE_SIZE / core::mem::size_of::<u64>();
for off in 0..page_size_words {
let src_word = *((src_paddr + off * core::mem::size_of::<u64>()) as *const u64);
*((dst_paddr + off * core::mem::size_of::<u64>()) as *mut u64) = src_word;
}
}
impl AddressSpace {
pub fn new(allocator: &mut SimpleFrameAllocator) -> Result<Self, &'static str> {
let frame = allocator.allocate().ok_or("Out of memory")?;
let page_table_paddr = frame.start_address();
let page_table_ptr = page_table_paddr.as_usize() as *mut PageTable;
unsafe {
(*page_table_ptr).zero();
}
crate::serial_println!(
"[ADDRESS_SPACE] Created new address space, page table at {:#x}",
page_table_paddr.as_usize()
);
Ok(AddressSpace {
page_table: page_table_ptr,
page_table_paddr,
areas: Vec::new(),
})
}
pub fn copy_kernel_mappings_from(
&mut self,
kernel_root_paddr: PhysAddr,
allocator: &mut SimpleFrameAllocator,
) -> Result<(), &'static str> {
unsafe {
clone_page_table_level(
allocator,
kernel_root_paddr.as_usize(),
self.page_table_paddr.as_usize(),
2,
false,
)
}
}
pub fn map_region(
&mut self,
start: VirtAddr,
size: usize,
area_type: MemoryAreaType,
allocator: &mut SimpleFrameAllocator,
) -> Result<(), &'static str> {
let end = VirtAddr::new(start.as_usize() + size);
let area = MemoryArea::new(start, end, area_type);
crate::serial_println!(
"[ADDRESS_SPACE] Mapping region: {:#x} - {:#x} ({:?})",
start.as_usize(),
end.as_usize(),
area_type
);
let page_count = area.page_count();
for i in 0..page_count {
let vaddr = VirtAddr::new(start.as_usize() + i * PAGE_SIZE);
let frame = allocator.allocate().ok_or("Out of memory")?;
let paddr = frame.start_address();
unsafe {
map_page(&mut *self.page_table, vaddr, paddr, area.flags, allocator)?;
}
}
self.areas.push(area);
Ok(())
}
pub fn map_region_identity(
&mut self,
start: PhysAddr,
size: usize,
area_type: MemoryAreaType,
allocator: &mut SimpleFrameAllocator,
) -> Result<(), &'static str> {
let vstart = VirtAddr::new(start.as_usize());
let end = VirtAddr::new(start.as_usize() + size);
let area = MemoryArea::new(vstart, end, area_type);
crate::serial_println!(
"[ADDRESS_SPACE] Identity mapping region: {:#x} - {:#x} ({:?})",
start.as_usize(),
start.as_usize() + size,
area_type
);
let page_count = area.page_count();
for i in 0..page_count {
let addr = start.as_usize() + i * PAGE_SIZE;
let vaddr = VirtAddr::new(addr);
let paddr = PhysAddr::new(addr);
unsafe {
map_page(&mut *self.page_table, vaddr, paddr, area.flags, allocator)?;
}
}
self.areas.push(area);
Ok(())
}
pub fn unmap_region(&mut self, start: VirtAddr, size: usize) -> Result<(), &'static str> {
let page_count = size.div_ceil(PAGE_SIZE);
for i in 0..page_count {
let vaddr = VirtAddr::new(start.as_usize() + i * PAGE_SIZE);
unsafe {
unmap_page(&mut *self.page_table, vaddr)?;
}
}
self.areas
.retain(|area| area.range.start.as_usize() != start.as_usize());
Ok(())
}
pub fn activate(&self) {
use riscv::register::satp;
let ppn = self.page_table_paddr.as_usize() >> 12;
crate::serial_println!("[ADDRESS_SPACE] Activating address space, PPN: {:#x}", ppn);
unsafe {
satp::set(satp::Mode::Sv39, 0, ppn);
core::arch::asm!("sfence.vma");
}
crate::serial_println!("[ADDRESS_SPACE] Address space activated");
}
pub fn page_table_paddr(&self) -> PhysAddr {
self.page_table_paddr
}
pub fn page_table_ptr(&self) -> *mut PageTable {
self.page_table
}
pub fn areas(&self) -> &[MemoryArea] {
&self.areas
}
pub fn print_layout(&self) {
crate::serial_println!("\n╔════════════════════════════════════════╗");
crate::serial_println!("║ 地址空间布局 ║");
crate::serial_println!("╠════════════════════════════════════════╣");
crate::serial_println!(
"║ 页表物理地址: {:#018x} ║",
self.page_table_paddr.as_usize()
);
crate::serial_println!("╠════════════════════════════════════════╣");
crate::serial_println!("║ 内存区域: ║");
for (i, area) in self.areas.iter().enumerate() {
crate::serial_println!(
"║ [{:2}] {:8?} {:#010x} - {:#010x} ║",
i,
area.area_type,
area.range.start.as_usize(),
area.range.end.as_usize()
);
}
crate::serial_println!("╚════════════════════════════════════════╝\n");
}
}
unsafe impl Send for AddressSpace {}
unsafe impl Sync for AddressSpace {}
pub fn create_kernel_address_space(
allocator: &mut SimpleFrameAllocator,
) -> Result<AddressSpace, &'static str> {
let mut addr_space = AddressSpace::new(allocator)?;
crate::serial_println!("\n[KERNEL] Creating kernel address space...");
const KERNEL_START: usize = 0x8000_0000;
const KERNEL_MAP_SIZE: usize = 8 * 1024 * 1024;
crate::serial_println!("[KERNEL] step1");
addr_space.map_region_identity(
PhysAddr::new(KERNEL_START),
KERNEL_MAP_SIZE,
MemoryAreaType::Kernel,
allocator,
)?;
crate::serial_println!(
"[KERNEL] Kernel region mapped OK ({} MB)",
KERNEL_MAP_SIZE / 1024 / 1024
);
const UART_BASE: usize = 0x1000_0000;
crate::serial_println!("[KERNEL] Mapping UART: {:#x}", UART_BASE);
addr_space.map_region_identity(
PhysAddr::new(UART_BASE),
PAGE_SIZE,
MemoryAreaType::Data,
allocator,
)?;
crate::serial_println!("[KERNEL] Kernel address space created successfully\n");
Ok(addr_space)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::memory::paging::{map_page, walk_page_table};
#[test_case]
fn deep_copy_user_address_space_copies_user_pages_independently() {
let mut allocator = SimpleFrameAllocator::new(0x8060_0000, 0x8070_0000);
let root_frame = allocator.allocate().expect("root frame");
let root_paddr = root_frame.start_address();
let root = unsafe { &mut *(root_paddr.as_usize() as *mut PageTable) };
root.zero();
let user_vaddr = VirtAddr::new(0x4000);
let user_frame = allocator.allocate().expect("user page");
unsafe {
let page = user_frame.start_address().as_usize() as *mut u8;
*page = 0x5a;
*page.add(1) = 0xa5;
}
map_page(
root,
user_vaddr,
user_frame.start_address(),
PageTableFlags::Read as usize
| PageTableFlags::Write as usize
| PageTableFlags::User as usize,
&mut allocator,
)
.expect("map user page");
let kernel_vaddr = VirtAddr::new(0x8000_0000);
let kernel_frame = allocator.allocate().expect("kernel page");
map_page(
root,
kernel_vaddr,
kernel_frame.start_address(),
PageTableFlags::Read as usize | PageTableFlags::Write as usize,
&mut allocator,
)
.expect("map kernel page");
let src_satp = (8usize << 60) | (root_paddr.as_usize() >> 12);
let child_satp =
deep_copy_user_address_space(src_satp, &mut allocator).expect("copy address space");
let child_root_paddr = PhysAddr::new((child_satp & 0x0000_0FFF_FFFF_FFFF) << 12);
let parent_user_paddr =
walk_page_table(root_paddr, user_vaddr).expect("parent user mapping");
let child_user_paddr =
walk_page_table(child_root_paddr, user_vaddr).expect("child user mapping");
assert_ne!(
parent_user_paddr.as_usize() & !(PAGE_SIZE - 1),
child_user_paddr.as_usize() & !(PAGE_SIZE - 1)
);
unsafe {
let parent_page = parent_user_paddr.as_usize() as *mut u8;
let child_page = child_user_paddr.as_usize() as *mut u8;
assert_eq!(*child_page, 0x5a);
assert_eq!(*child_page.add(1), 0xa5);
*child_page = 0x11;
assert_eq!(*parent_page, 0x5a);
}
let child_kernel_paddr =
walk_page_table(child_root_paddr, kernel_vaddr).expect("child kernel mapping");
assert_eq!(child_kernel_paddr, kernel_frame.start_address());
}
}