140fe15e0SLoGin use core::{ 240fe15e0SLoGin fmt::{self, Debug, Error, Formatter}, 340fe15e0SLoGin marker::PhantomData, 440fe15e0SLoGin mem, 540fe15e0SLoGin ops::Add, 640fe15e0SLoGin sync::atomic::{compiler_fence, Ordering}, 740fe15e0SLoGin }; 840fe15e0SLoGin 956cc4dbeSJomo use alloc::sync::Arc; 1056cc4dbeSJomo use hashbrown::{HashMap, HashSet}; 1156cc4dbeSJomo 1240fe15e0SLoGin use crate::{ 1340fe15e0SLoGin arch::{interrupt::ipi::send_ipi, MMArch}, 1440fe15e0SLoGin exception::ipi::{IpiKind, IpiTarget}, 156fc066acSJomo ipc::shm::ShmId, 1640fe15e0SLoGin kerror, kwarn, 1756cc4dbeSJomo libs::spinlock::{SpinLock, SpinLockGuard}, 1840fe15e0SLoGin }; 1940fe15e0SLoGin 2040fe15e0SLoGin use super::{ 2156cc4dbeSJomo allocator::page_frame::FrameAllocator, syscall::ProtFlags, ucontext::LockedVMA, 2256cc4dbeSJomo MemoryManagementArch, PageTableKind, PhysAddr, VirtAddr, 2340fe15e0SLoGin }; 2440fe15e0SLoGin 2523ef2b33SLoGin pub const PAGE_4K_SHIFT: usize = 12; 2623ef2b33SLoGin #[allow(dead_code)] 2723ef2b33SLoGin pub const PAGE_2M_SHIFT: usize = 21; 2823ef2b33SLoGin pub const PAGE_1G_SHIFT: usize = 30; 2923ef2b33SLoGin 30*370472f7SLoGin pub const PAGE_4K_SIZE: usize = 1 << PAGE_4K_SHIFT; 31*370472f7SLoGin pub const PAGE_2M_SIZE: usize = 1 << PAGE_2M_SHIFT; 32*370472f7SLoGin 3356cc4dbeSJomo /// 全局物理页信息管理器 3456cc4dbeSJomo pub static mut PAGE_MANAGER: Option<SpinLock<PageManager>> = None; 3556cc4dbeSJomo 3656cc4dbeSJomo /// 初始化PAGE_MANAGER 3756cc4dbeSJomo pub fn page_manager_init() { 3856cc4dbeSJomo kinfo!("page_manager_init"); 3956cc4dbeSJomo let page_manager = SpinLock::new(PageManager::new()); 4056cc4dbeSJomo 4156cc4dbeSJomo compiler_fence(Ordering::SeqCst); 4256cc4dbeSJomo unsafe { PAGE_MANAGER = Some(page_manager) }; 4356cc4dbeSJomo compiler_fence(Ordering::SeqCst); 4456cc4dbeSJomo 4556cc4dbeSJomo kinfo!("page_manager_init done"); 4656cc4dbeSJomo } 4756cc4dbeSJomo 486fc066acSJomo pub fn page_manager_lock_irqsave() -> SpinLockGuard<'static, PageManager> { 4956cc4dbeSJomo unsafe { PAGE_MANAGER.as_ref().unwrap().lock_irqsave() } 5056cc4dbeSJomo } 5156cc4dbeSJomo 5256cc4dbeSJomo // 物理页管理器 5356cc4dbeSJomo pub struct PageManager { 5456cc4dbeSJomo phys2page: HashMap<PhysAddr, Page>, 5556cc4dbeSJomo } 5656cc4dbeSJomo 5756cc4dbeSJomo impl PageManager { 5856cc4dbeSJomo pub fn new() -> Self { 5956cc4dbeSJomo Self { 6056cc4dbeSJomo phys2page: HashMap::new(), 6156cc4dbeSJomo } 6256cc4dbeSJomo } 6356cc4dbeSJomo 646fc066acSJomo pub fn contains(&self, paddr: &PhysAddr) -> bool { 656fc066acSJomo self.phys2page.contains_key(paddr) 666fc066acSJomo } 676fc066acSJomo 686fc066acSJomo pub fn get(&self, paddr: &PhysAddr) -> Option<&Page> { 696fc066acSJomo self.phys2page.get(paddr) 706fc066acSJomo } 716fc066acSJomo 7256cc4dbeSJomo pub fn get_mut(&mut self, paddr: &PhysAddr) -> &mut Page { 7356cc4dbeSJomo self.phys2page.get_mut(paddr).unwrap() 7456cc4dbeSJomo } 7556cc4dbeSJomo 7656cc4dbeSJomo pub fn insert(&mut self, paddr: PhysAddr, page: Page) { 7756cc4dbeSJomo self.phys2page.insert(paddr, page); 7856cc4dbeSJomo } 7956cc4dbeSJomo 8056cc4dbeSJomo pub fn remove_page(&mut self, paddr: &PhysAddr) { 8156cc4dbeSJomo self.phys2page.remove(paddr); 8256cc4dbeSJomo } 8356cc4dbeSJomo } 8456cc4dbeSJomo 8556cc4dbeSJomo /// 物理页面信息 8656cc4dbeSJomo pub struct Page { 8756cc4dbeSJomo /// 映射计数 8856cc4dbeSJomo map_count: usize, 8956cc4dbeSJomo /// 是否为共享页 9056cc4dbeSJomo shared: bool, 916fc066acSJomo /// 映射计数为0时,是否可回收 926fc066acSJomo free_when_zero: bool, 936fc066acSJomo /// 共享页id(如果是共享页) 946fc066acSJomo shm_id: Option<ShmId>, 9556cc4dbeSJomo /// 映射到当前page的VMA 9656cc4dbeSJomo anon_vma: HashSet<Arc<LockedVMA>>, 9756cc4dbeSJomo } 9856cc4dbeSJomo 9956cc4dbeSJomo impl Page { 10056cc4dbeSJomo pub fn new(shared: bool) -> Self { 1016fc066acSJomo let dealloc_when_zero = !shared; 10256cc4dbeSJomo Self { 10356cc4dbeSJomo map_count: 0, 10456cc4dbeSJomo shared, 1056fc066acSJomo free_when_zero: dealloc_when_zero, 1066fc066acSJomo shm_id: None, 10756cc4dbeSJomo anon_vma: HashSet::new(), 10856cc4dbeSJomo } 10956cc4dbeSJomo } 11056cc4dbeSJomo 11156cc4dbeSJomo /// 将vma加入anon_vma 11256cc4dbeSJomo pub fn insert_vma(&mut self, vma: Arc<LockedVMA>) { 11356cc4dbeSJomo self.anon_vma.insert(vma); 11456cc4dbeSJomo self.map_count += 1; 11556cc4dbeSJomo } 11656cc4dbeSJomo 11756cc4dbeSJomo /// 将vma从anon_vma中删去 11856cc4dbeSJomo pub fn remove_vma(&mut self, vma: &LockedVMA) { 11956cc4dbeSJomo self.anon_vma.remove(vma); 12056cc4dbeSJomo self.map_count -= 1; 12156cc4dbeSJomo } 12256cc4dbeSJomo 12356cc4dbeSJomo /// 判断当前物理页是否能被回 12456cc4dbeSJomo pub fn can_deallocate(&self) -> bool { 1256fc066acSJomo self.map_count == 0 && self.free_when_zero 1266fc066acSJomo } 1276fc066acSJomo 1286fc066acSJomo pub fn shared(&self) -> bool { 1296fc066acSJomo self.shared 1306fc066acSJomo } 1316fc066acSJomo 1326fc066acSJomo pub fn shm_id(&self) -> Option<ShmId> { 1336fc066acSJomo self.shm_id 1346fc066acSJomo } 1356fc066acSJomo 1366fc066acSJomo pub fn set_shm_id(&mut self, shm_id: ShmId) { 1376fc066acSJomo self.shm_id = Some(shm_id); 1386fc066acSJomo } 1396fc066acSJomo 1406fc066acSJomo pub fn set_dealloc_when_zero(&mut self, dealloc_when_zero: bool) { 1416fc066acSJomo self.free_when_zero = dealloc_when_zero; 1426fc066acSJomo } 1436fc066acSJomo 1446fc066acSJomo pub fn anon_vma(&self) -> &HashSet<Arc<LockedVMA>> { 1456fc066acSJomo &self.anon_vma 14656cc4dbeSJomo } 14756cc4dbeSJomo } 14856cc4dbeSJomo 14940fe15e0SLoGin #[derive(Debug)] 15040fe15e0SLoGin pub struct PageTable<Arch> { 15140fe15e0SLoGin /// 当前页表表示的虚拟地址空间的起始地址 15240fe15e0SLoGin base: VirtAddr, 15340fe15e0SLoGin /// 当前页表所在的物理地址 15440fe15e0SLoGin phys: PhysAddr, 15540fe15e0SLoGin /// 当前页表的层级(请注意,最顶级页表的level为[Arch::PAGE_LEVELS - 1]) 15640fe15e0SLoGin level: usize, 15740fe15e0SLoGin phantom: PhantomData<Arch>, 15840fe15e0SLoGin } 15940fe15e0SLoGin 16040fe15e0SLoGin #[allow(dead_code)] 16140fe15e0SLoGin impl<Arch: MemoryManagementArch> PageTable<Arch> { 16240fe15e0SLoGin pub unsafe fn new(base: VirtAddr, phys: PhysAddr, level: usize) -> Self { 16340fe15e0SLoGin Self { 16440fe15e0SLoGin base, 16540fe15e0SLoGin phys, 16640fe15e0SLoGin level, 16740fe15e0SLoGin phantom: PhantomData, 16840fe15e0SLoGin } 16940fe15e0SLoGin } 17040fe15e0SLoGin 17140fe15e0SLoGin /// 获取顶级页表 17240fe15e0SLoGin /// 17340fe15e0SLoGin /// ## 参数 17440fe15e0SLoGin /// 17540fe15e0SLoGin /// - table_kind 页表类型 17640fe15e0SLoGin /// 17740fe15e0SLoGin /// ## 返回值 17840fe15e0SLoGin /// 17940fe15e0SLoGin /// 返回顶级页表 18040fe15e0SLoGin pub unsafe fn top_level_table(table_kind: PageTableKind) -> Self { 18140fe15e0SLoGin return Self::new( 18240fe15e0SLoGin VirtAddr::new(0), 18340fe15e0SLoGin Arch::table(table_kind), 18440fe15e0SLoGin Arch::PAGE_LEVELS - 1, 18540fe15e0SLoGin ); 18640fe15e0SLoGin } 18740fe15e0SLoGin 18840fe15e0SLoGin /// 获取当前页表的物理地址 18940fe15e0SLoGin #[inline(always)] 19040fe15e0SLoGin pub fn phys(&self) -> PhysAddr { 19140fe15e0SLoGin self.phys 19240fe15e0SLoGin } 19340fe15e0SLoGin 19440fe15e0SLoGin /// 当前页表表示的虚拟地址空间的起始地址 19540fe15e0SLoGin #[inline(always)] 19640fe15e0SLoGin pub fn base(&self) -> VirtAddr { 19740fe15e0SLoGin self.base 19840fe15e0SLoGin } 19940fe15e0SLoGin 20040fe15e0SLoGin /// 获取当前页表的层级 20140fe15e0SLoGin #[inline(always)] 20240fe15e0SLoGin pub fn level(&self) -> usize { 20340fe15e0SLoGin self.level 20440fe15e0SLoGin } 20540fe15e0SLoGin 20640fe15e0SLoGin /// 获取当前页表自身所在的虚拟地址 20740fe15e0SLoGin #[inline(always)] 20840fe15e0SLoGin pub unsafe fn virt(&self) -> VirtAddr { 20940fe15e0SLoGin return Arch::phys_2_virt(self.phys).unwrap(); 21040fe15e0SLoGin } 21140fe15e0SLoGin 21240fe15e0SLoGin /// 获取第i个页表项所表示的虚拟内存空间的起始地址 21340fe15e0SLoGin pub fn entry_base(&self, i: usize) -> Option<VirtAddr> { 21440fe15e0SLoGin if i < Arch::PAGE_ENTRY_NUM { 21540fe15e0SLoGin let shift = self.level * Arch::PAGE_ENTRY_SHIFT + Arch::PAGE_SHIFT; 21640fe15e0SLoGin return Some(self.base.add(i << shift)); 21740fe15e0SLoGin } else { 21840fe15e0SLoGin return None; 21940fe15e0SLoGin } 22040fe15e0SLoGin } 22140fe15e0SLoGin 22240fe15e0SLoGin /// 获取当前页表的第i个页表项所在的虚拟地址(注意与entry_base进行区分) 22340fe15e0SLoGin pub unsafe fn entry_virt(&self, i: usize) -> Option<VirtAddr> { 22440fe15e0SLoGin if i < Arch::PAGE_ENTRY_NUM { 22540fe15e0SLoGin return Some(self.virt().add(i * Arch::PAGE_ENTRY_SIZE)); 22640fe15e0SLoGin } else { 22740fe15e0SLoGin return None; 22840fe15e0SLoGin } 22940fe15e0SLoGin } 23040fe15e0SLoGin 23140fe15e0SLoGin /// 获取当前页表的第i个页表项 23240fe15e0SLoGin pub unsafe fn entry(&self, i: usize) -> Option<PageEntry<Arch>> { 23340fe15e0SLoGin let entry_virt = self.entry_virt(i)?; 2347a29d4fcSLoGin return Some(PageEntry::from_usize(Arch::read::<usize>(entry_virt))); 23540fe15e0SLoGin } 23640fe15e0SLoGin 23740fe15e0SLoGin /// 设置当前页表的第i个页表项 23840fe15e0SLoGin pub unsafe fn set_entry(&self, i: usize, entry: PageEntry<Arch>) -> Option<()> { 23940fe15e0SLoGin let entry_virt = self.entry_virt(i)?; 24040fe15e0SLoGin Arch::write::<usize>(entry_virt, entry.data()); 24140fe15e0SLoGin return Some(()); 24240fe15e0SLoGin } 24340fe15e0SLoGin 24440fe15e0SLoGin /// 判断当前页表的第i个页表项是否已经填写了值 24540fe15e0SLoGin /// 24640fe15e0SLoGin /// ## 参数 24740fe15e0SLoGin /// - Some(true) 如果已经填写了值 24840fe15e0SLoGin /// - Some(false) 如果未填写值 24940fe15e0SLoGin /// - None 如果i超出了页表项的范围 25040fe15e0SLoGin pub fn entry_mapped(&self, i: usize) -> Option<bool> { 25140fe15e0SLoGin let etv = unsafe { self.entry_virt(i) }?; 25240fe15e0SLoGin if unsafe { Arch::read::<usize>(etv) } != 0 { 25340fe15e0SLoGin return Some(true); 25440fe15e0SLoGin } else { 25540fe15e0SLoGin return Some(false); 25640fe15e0SLoGin } 25740fe15e0SLoGin } 25840fe15e0SLoGin 25940fe15e0SLoGin /// 根据虚拟地址,获取对应的页表项在页表中的下标 26040fe15e0SLoGin /// 26140fe15e0SLoGin /// ## 参数 26240fe15e0SLoGin /// 26340fe15e0SLoGin /// - addr: 虚拟地址 26440fe15e0SLoGin /// 26540fe15e0SLoGin /// ## 返回值 26640fe15e0SLoGin /// 26740fe15e0SLoGin /// 页表项在页表中的下标。如果addr不在当前页表所表示的虚拟地址空间中,则返回None 26840fe15e0SLoGin pub unsafe fn index_of(&self, addr: VirtAddr) -> Option<usize> { 26940fe15e0SLoGin let addr = VirtAddr::new(addr.data() & Arch::PAGE_ADDRESS_MASK); 27040fe15e0SLoGin let shift = self.level * Arch::PAGE_ENTRY_SHIFT + Arch::PAGE_SHIFT; 27140fe15e0SLoGin 27240fe15e0SLoGin let mask = (MMArch::PAGE_ENTRY_NUM << shift) - 1; 27340fe15e0SLoGin if addr < self.base || addr >= self.base.add(mask) { 27440fe15e0SLoGin return None; 27540fe15e0SLoGin } else { 27640fe15e0SLoGin return Some((addr.data() >> shift) & MMArch::PAGE_ENTRY_MASK); 27740fe15e0SLoGin } 27840fe15e0SLoGin } 27940fe15e0SLoGin 28040fe15e0SLoGin /// 获取第i个页表项指向的下一级页表 28140fe15e0SLoGin pub unsafe fn next_level_table(&self, index: usize) -> Option<Self> { 28240fe15e0SLoGin if self.level == 0 { 28340fe15e0SLoGin return None; 28440fe15e0SLoGin } 28540fe15e0SLoGin 28640fe15e0SLoGin // 返回下一级页表 28740fe15e0SLoGin return Some(PageTable::new( 28840fe15e0SLoGin self.entry_base(index)?, 28940fe15e0SLoGin self.entry(index)?.address().ok()?, 29040fe15e0SLoGin self.level - 1, 29140fe15e0SLoGin )); 29240fe15e0SLoGin } 29340fe15e0SLoGin } 29440fe15e0SLoGin 29540fe15e0SLoGin /// 页表项 29640fe15e0SLoGin #[derive(Copy, Clone)] 29740fe15e0SLoGin pub struct PageEntry<Arch> { 29840fe15e0SLoGin data: usize, 29940fe15e0SLoGin phantom: PhantomData<Arch>, 30040fe15e0SLoGin } 30140fe15e0SLoGin 30240fe15e0SLoGin impl<Arch> Debug for PageEntry<Arch> { 30340fe15e0SLoGin fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> { 30440fe15e0SLoGin f.write_fmt(format_args!("PageEntry({:#x})", self.data)) 30540fe15e0SLoGin } 30640fe15e0SLoGin } 30740fe15e0SLoGin 30840fe15e0SLoGin impl<Arch: MemoryManagementArch> PageEntry<Arch> { 30940fe15e0SLoGin #[inline(always)] 3107a29d4fcSLoGin pub fn new(paddr: PhysAddr, flags: PageFlags<Arch>) -> Self { 3117a29d4fcSLoGin Self { 3127a29d4fcSLoGin data: MMArch::make_entry(paddr, flags.data()), 3137a29d4fcSLoGin phantom: PhantomData, 3147a29d4fcSLoGin } 3157a29d4fcSLoGin } 3167a29d4fcSLoGin #[inline(always)] 3177a29d4fcSLoGin pub fn from_usize(data: usize) -> Self { 31840fe15e0SLoGin Self { 31940fe15e0SLoGin data, 32040fe15e0SLoGin phantom: PhantomData, 32140fe15e0SLoGin } 32240fe15e0SLoGin } 32340fe15e0SLoGin 32440fe15e0SLoGin #[inline(always)] 32540fe15e0SLoGin pub fn data(&self) -> usize { 32640fe15e0SLoGin self.data 32740fe15e0SLoGin } 32840fe15e0SLoGin 32940fe15e0SLoGin /// 获取当前页表项指向的物理地址 33040fe15e0SLoGin /// 33140fe15e0SLoGin /// ## 返回值 33240fe15e0SLoGin /// 33340fe15e0SLoGin /// - Ok(PhysAddr) 如果当前页面存在于物理内存中, 返回物理地址 33440fe15e0SLoGin /// - Err(PhysAddr) 如果当前页表项不存在, 返回物理地址 33540fe15e0SLoGin #[inline(always)] 33640fe15e0SLoGin pub fn address(&self) -> Result<PhysAddr, PhysAddr> { 3377a29d4fcSLoGin let paddr: PhysAddr = { 3387a29d4fcSLoGin #[cfg(target_arch = "x86_64")] 3397a29d4fcSLoGin { 3407a29d4fcSLoGin PhysAddr::new(self.data & Arch::PAGE_ADDRESS_MASK) 3417a29d4fcSLoGin } 3427a29d4fcSLoGin 3437a29d4fcSLoGin #[cfg(target_arch = "riscv64")] 3447a29d4fcSLoGin { 345453452ccSLoGin let ppn = ((self.data & (!((1 << 10) - 1))) >> 10) & ((1 << 54) - 1); 3467a29d4fcSLoGin super::allocator::page_frame::PhysPageFrame::from_ppn(ppn).phys_address() 3477a29d4fcSLoGin } 3487a29d4fcSLoGin }; 34940fe15e0SLoGin 35040fe15e0SLoGin if self.present() { 35140fe15e0SLoGin Ok(paddr) 35240fe15e0SLoGin } else { 35340fe15e0SLoGin Err(paddr) 35440fe15e0SLoGin } 35540fe15e0SLoGin } 35640fe15e0SLoGin 35740fe15e0SLoGin #[inline(always)] 35840fe15e0SLoGin pub fn flags(&self) -> PageFlags<Arch> { 35940fe15e0SLoGin unsafe { PageFlags::from_data(self.data & Arch::ENTRY_FLAGS_MASK) } 36040fe15e0SLoGin } 36140fe15e0SLoGin 36240fe15e0SLoGin #[inline(always)] 36340fe15e0SLoGin pub fn set_flags(&mut self, flags: PageFlags<Arch>) { 36440fe15e0SLoGin self.data = (self.data & !Arch::ENTRY_FLAGS_MASK) | flags.data(); 36540fe15e0SLoGin } 36640fe15e0SLoGin 36740fe15e0SLoGin #[inline(always)] 36840fe15e0SLoGin pub fn present(&self) -> bool { 36940fe15e0SLoGin return self.data & Arch::ENTRY_FLAG_PRESENT != 0; 37040fe15e0SLoGin } 37140fe15e0SLoGin } 37240fe15e0SLoGin 37340fe15e0SLoGin /// 页表项的标志位 37440fe15e0SLoGin #[derive(Copy, Clone, Hash)] 37540fe15e0SLoGin pub struct PageFlags<Arch> { 37640fe15e0SLoGin data: usize, 37740fe15e0SLoGin phantom: PhantomData<Arch>, 37840fe15e0SLoGin } 37940fe15e0SLoGin 38040fe15e0SLoGin #[allow(dead_code)] 38140fe15e0SLoGin impl<Arch: MemoryManagementArch> PageFlags<Arch> { 38240fe15e0SLoGin #[inline(always)] 38340fe15e0SLoGin pub fn new() -> Self { 38440fe15e0SLoGin let mut r = unsafe { 38540fe15e0SLoGin Self::from_data( 38640fe15e0SLoGin Arch::ENTRY_FLAG_DEFAULT_PAGE 38740fe15e0SLoGin | Arch::ENTRY_FLAG_READONLY 38840fe15e0SLoGin | Arch::ENTRY_FLAG_NO_EXEC, 38940fe15e0SLoGin ) 39040fe15e0SLoGin }; 39140fe15e0SLoGin 39240fe15e0SLoGin #[cfg(target_arch = "x86_64")] 39340fe15e0SLoGin { 39440fe15e0SLoGin if crate::arch::mm::X86_64MMArch::is_xd_reserved() { 39540fe15e0SLoGin r = r.set_execute(true); 39640fe15e0SLoGin } 39740fe15e0SLoGin } 39840fe15e0SLoGin 39940fe15e0SLoGin return r; 40040fe15e0SLoGin } 40140fe15e0SLoGin 40240fe15e0SLoGin /// 根据ProtFlags生成PageFlags 40340fe15e0SLoGin /// 40440fe15e0SLoGin /// ## 参数 40540fe15e0SLoGin /// 40640fe15e0SLoGin /// - prot_flags: 页的保护标志 40740fe15e0SLoGin /// - user: 用户空间是否可访问 40840fe15e0SLoGin pub fn from_prot_flags(prot_flags: ProtFlags, user: bool) -> PageFlags<Arch> { 40940fe15e0SLoGin let flags: PageFlags<Arch> = PageFlags::new() 41040fe15e0SLoGin .set_user(user) 41140fe15e0SLoGin .set_execute(prot_flags.contains(ProtFlags::PROT_EXEC)) 41240fe15e0SLoGin .set_write(prot_flags.contains(ProtFlags::PROT_WRITE)); 41340fe15e0SLoGin 41440fe15e0SLoGin return flags; 41540fe15e0SLoGin } 41640fe15e0SLoGin 41740fe15e0SLoGin #[inline(always)] 41840fe15e0SLoGin pub fn data(&self) -> usize { 41940fe15e0SLoGin self.data 42040fe15e0SLoGin } 42140fe15e0SLoGin 42240fe15e0SLoGin #[inline(always)] 42340fe15e0SLoGin pub const unsafe fn from_data(data: usize) -> Self { 42440fe15e0SLoGin return Self { 425b5b571e0SLoGin data, 42640fe15e0SLoGin phantom: PhantomData, 42740fe15e0SLoGin }; 42840fe15e0SLoGin } 42940fe15e0SLoGin 43040fe15e0SLoGin /// 为新页表的页表项设置默认值 43140fe15e0SLoGin /// 43240fe15e0SLoGin /// 默认值为: 43340fe15e0SLoGin /// - present 43440fe15e0SLoGin /// - read only 43540fe15e0SLoGin /// - kernel space 43640fe15e0SLoGin /// - no exec 43740fe15e0SLoGin #[inline(always)] 43840fe15e0SLoGin pub fn new_page_table(user: bool) -> Self { 43940fe15e0SLoGin return unsafe { 4407a29d4fcSLoGin let r = { 4417a29d4fcSLoGin #[cfg(target_arch = "x86_64")] 4427a29d4fcSLoGin { 4437a29d4fcSLoGin Self::from_data(Arch::ENTRY_FLAG_DEFAULT_TABLE | Arch::ENTRY_FLAG_READWRITE) 4447a29d4fcSLoGin } 4457a29d4fcSLoGin 4467a29d4fcSLoGin #[cfg(target_arch = "riscv64")] 4477a29d4fcSLoGin { 4487a29d4fcSLoGin // riscv64指向下一级页表的页表项,不应设置R/W/X权限位 4497a29d4fcSLoGin Self::from_data(Arch::ENTRY_FLAG_DEFAULT_TABLE) 4507a29d4fcSLoGin } 4517a29d4fcSLoGin }; 45240fe15e0SLoGin if user { 45340fe15e0SLoGin r.set_user(true) 45440fe15e0SLoGin } else { 45540fe15e0SLoGin r 45640fe15e0SLoGin } 45740fe15e0SLoGin }; 45840fe15e0SLoGin } 45940fe15e0SLoGin 46040fe15e0SLoGin /// 取得当前页表项的所有权,更新当前页表项的标志位,并返回更新后的页表项。 46140fe15e0SLoGin /// 46240fe15e0SLoGin /// ## 参数 46340fe15e0SLoGin /// - flag 要更新的标志位的值 46440fe15e0SLoGin /// - value 如果为true,那么将flag对应的位设置为1,否则设置为0 46540fe15e0SLoGin /// 46640fe15e0SLoGin /// ## 返回值 46740fe15e0SLoGin /// 46840fe15e0SLoGin /// 更新后的页表项 46940fe15e0SLoGin #[inline(always)] 47040fe15e0SLoGin #[must_use] 47140fe15e0SLoGin pub fn update_flags(mut self, flag: usize, value: bool) -> Self { 47240fe15e0SLoGin if value { 47340fe15e0SLoGin self.data |= flag; 47440fe15e0SLoGin } else { 47540fe15e0SLoGin self.data &= !flag; 47640fe15e0SLoGin } 47740fe15e0SLoGin return self; 47840fe15e0SLoGin } 47940fe15e0SLoGin 48040fe15e0SLoGin /// 判断当前页表项是否存在指定的flag(只有全部flag都存在才返回true) 48140fe15e0SLoGin #[inline(always)] 48240fe15e0SLoGin pub fn has_flag(&self, flag: usize) -> bool { 48340fe15e0SLoGin return self.data & flag == flag; 48440fe15e0SLoGin } 48540fe15e0SLoGin 48640fe15e0SLoGin #[inline(always)] 48740fe15e0SLoGin pub fn present(&self) -> bool { 48840fe15e0SLoGin return self.has_flag(Arch::ENTRY_FLAG_PRESENT); 48940fe15e0SLoGin } 49040fe15e0SLoGin 49140fe15e0SLoGin /// 设置当前页表项的权限 49240fe15e0SLoGin /// 49340fe15e0SLoGin /// @param value 如果为true,那么将当前页表项的权限设置为用户态可访问 49440fe15e0SLoGin #[must_use] 49540fe15e0SLoGin #[inline(always)] 49640fe15e0SLoGin pub fn set_user(self, value: bool) -> Self { 49740fe15e0SLoGin return self.update_flags(Arch::ENTRY_FLAG_USER, value); 49840fe15e0SLoGin } 49940fe15e0SLoGin 50040fe15e0SLoGin /// 用户态是否可以访问当前页表项 50140fe15e0SLoGin #[inline(always)] 50240fe15e0SLoGin pub fn has_user(&self) -> bool { 50340fe15e0SLoGin return self.has_flag(Arch::ENTRY_FLAG_USER); 50440fe15e0SLoGin } 50540fe15e0SLoGin 50640fe15e0SLoGin /// 设置当前页表项的可写性, 如果为true,那么将当前页表项的权限设置为可写, 否则设置为只读 50740fe15e0SLoGin /// 50840fe15e0SLoGin /// ## 返回值 50940fe15e0SLoGin /// 51040fe15e0SLoGin /// 更新后的页表项. 51140fe15e0SLoGin /// 51240fe15e0SLoGin /// **请注意,**本函数会取得当前页表项的所有权,因此返回的页表项不是原来的页表项 51340fe15e0SLoGin #[must_use] 51440fe15e0SLoGin #[inline(always)] 51540fe15e0SLoGin pub fn set_write(self, value: bool) -> Self { 5167a29d4fcSLoGin #[cfg(target_arch = "x86_64")] 5177a29d4fcSLoGin { 51840fe15e0SLoGin // 有的架构同时具有可写和不可写的标志位,因此需要同时更新 51940fe15e0SLoGin return self 52040fe15e0SLoGin .update_flags(Arch::ENTRY_FLAG_READONLY, !value) 52140fe15e0SLoGin .update_flags(Arch::ENTRY_FLAG_READWRITE, value); 52240fe15e0SLoGin } 52340fe15e0SLoGin 5247a29d4fcSLoGin #[cfg(target_arch = "riscv64")] 5257a29d4fcSLoGin { 5267a29d4fcSLoGin if value { 5277a29d4fcSLoGin return self.update_flags(Arch::ENTRY_FLAG_READWRITE, true); 5287a29d4fcSLoGin } else { 5297a29d4fcSLoGin return self.update_flags(Arch::ENTRY_FLAG_READONLY, true); 5307a29d4fcSLoGin } 5317a29d4fcSLoGin } 5327a29d4fcSLoGin } 5337a29d4fcSLoGin 53440fe15e0SLoGin /// 当前页表项是否可写 53540fe15e0SLoGin #[inline(always)] 53640fe15e0SLoGin pub fn has_write(&self) -> bool { 53740fe15e0SLoGin // 有的架构同时具有可写和不可写的标志位,因此需要同时判断 53840fe15e0SLoGin return self.data & (Arch::ENTRY_FLAG_READWRITE | Arch::ENTRY_FLAG_READONLY) 53940fe15e0SLoGin == Arch::ENTRY_FLAG_READWRITE; 54040fe15e0SLoGin } 54140fe15e0SLoGin 54240fe15e0SLoGin /// 设置当前页表项的可执行性, 如果为true,那么将当前页表项的权限设置为可执行, 否则设置为不可执行 54340fe15e0SLoGin #[must_use] 54440fe15e0SLoGin #[inline(always)] 54540fe15e0SLoGin pub fn set_execute(self, mut value: bool) -> Self { 54640fe15e0SLoGin #[cfg(target_arch = "x86_64")] 54740fe15e0SLoGin { 54840fe15e0SLoGin // 如果xd位被保留,那么将可执行性设置为true 54940fe15e0SLoGin if crate::arch::mm::X86_64MMArch::is_xd_reserved() { 55040fe15e0SLoGin value = true; 55140fe15e0SLoGin } 55240fe15e0SLoGin } 55340fe15e0SLoGin 55440fe15e0SLoGin // 有的架构同时具有可执行和不可执行的标志位,因此需要同时更新 55540fe15e0SLoGin return self 55640fe15e0SLoGin .update_flags(Arch::ENTRY_FLAG_NO_EXEC, !value) 55740fe15e0SLoGin .update_flags(Arch::ENTRY_FLAG_EXEC, value); 55840fe15e0SLoGin } 55940fe15e0SLoGin 56040fe15e0SLoGin /// 当前页表项是否可执行 56140fe15e0SLoGin #[inline(always)] 56240fe15e0SLoGin pub fn has_execute(&self) -> bool { 56340fe15e0SLoGin // 有的架构同时具有可执行和不可执行的标志位,因此需要同时判断 56440fe15e0SLoGin return self.data & (Arch::ENTRY_FLAG_EXEC | Arch::ENTRY_FLAG_NO_EXEC) 56540fe15e0SLoGin == Arch::ENTRY_FLAG_EXEC; 56640fe15e0SLoGin } 56740fe15e0SLoGin 56840fe15e0SLoGin /// 设置当前页表项的缓存策略 56940fe15e0SLoGin /// 57040fe15e0SLoGin /// ## 参数 57140fe15e0SLoGin /// 57240fe15e0SLoGin /// - value: 如果为true,那么将当前页表项的缓存策略设置为不缓存。 57340fe15e0SLoGin #[inline(always)] 57440fe15e0SLoGin pub fn set_page_cache_disable(self, value: bool) -> Self { 57540fe15e0SLoGin return self.update_flags(Arch::ENTRY_FLAG_CACHE_DISABLE, value); 57640fe15e0SLoGin } 57740fe15e0SLoGin 57840fe15e0SLoGin /// 获取当前页表项的缓存策略 57940fe15e0SLoGin /// 58040fe15e0SLoGin /// ## 返回值 58140fe15e0SLoGin /// 58240fe15e0SLoGin /// 如果当前页表项的缓存策略为不缓存,那么返回true,否则返回false。 58340fe15e0SLoGin #[inline(always)] 58440fe15e0SLoGin pub fn has_page_cache_disable(&self) -> bool { 58540fe15e0SLoGin return self.has_flag(Arch::ENTRY_FLAG_CACHE_DISABLE); 58640fe15e0SLoGin } 58740fe15e0SLoGin 58840fe15e0SLoGin /// 设置当前页表项的写穿策略 58940fe15e0SLoGin /// 59040fe15e0SLoGin /// ## 参数 59140fe15e0SLoGin /// 59240fe15e0SLoGin /// - value: 如果为true,那么将当前页表项的写穿策略设置为写穿。 59340fe15e0SLoGin #[inline(always)] 59440fe15e0SLoGin pub fn set_page_write_through(self, value: bool) -> Self { 59540fe15e0SLoGin return self.update_flags(Arch::ENTRY_FLAG_WRITE_THROUGH, value); 59640fe15e0SLoGin } 59740fe15e0SLoGin 59840fe15e0SLoGin /// 获取当前页表项的写穿策略 59940fe15e0SLoGin /// 60040fe15e0SLoGin /// ## 返回值 60140fe15e0SLoGin /// 60240fe15e0SLoGin /// 如果当前页表项的写穿策略为写穿,那么返回true,否则返回false。 60340fe15e0SLoGin #[inline(always)] 60440fe15e0SLoGin pub fn has_page_write_through(&self) -> bool { 60540fe15e0SLoGin return self.has_flag(Arch::ENTRY_FLAG_WRITE_THROUGH); 60640fe15e0SLoGin } 60740fe15e0SLoGin 60840fe15e0SLoGin /// MMIO内存的页表项标志 60940fe15e0SLoGin #[inline(always)] 61040fe15e0SLoGin pub fn mmio_flags() -> Self { 61140fe15e0SLoGin return Self::new() 61240fe15e0SLoGin .set_user(false) 61340fe15e0SLoGin .set_write(true) 61440fe15e0SLoGin .set_execute(true) 61540fe15e0SLoGin .set_page_cache_disable(true) 61640fe15e0SLoGin .set_page_write_through(true); 61740fe15e0SLoGin } 61840fe15e0SLoGin } 61940fe15e0SLoGin 62040fe15e0SLoGin impl<Arch: MemoryManagementArch> fmt::Debug for PageFlags<Arch> { 62140fe15e0SLoGin fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 62240fe15e0SLoGin f.debug_struct("PageFlags") 62340fe15e0SLoGin .field("bits", &format_args!("{:#0x}", self.data)) 62440fe15e0SLoGin .field("present", &self.present()) 62540fe15e0SLoGin .field("has_write", &self.has_write()) 62640fe15e0SLoGin .field("has_execute", &self.has_execute()) 62740fe15e0SLoGin .field("has_user", &self.has_user()) 62840fe15e0SLoGin .finish() 62940fe15e0SLoGin } 63040fe15e0SLoGin } 63140fe15e0SLoGin 63240fe15e0SLoGin /// 页表映射器 63340fe15e0SLoGin #[derive(Hash)] 63440fe15e0SLoGin pub struct PageMapper<Arch, F> { 63540fe15e0SLoGin /// 页表类型 63640fe15e0SLoGin table_kind: PageTableKind, 63740fe15e0SLoGin /// 根页表物理地址 63840fe15e0SLoGin table_paddr: PhysAddr, 63940fe15e0SLoGin /// 页分配器 64040fe15e0SLoGin frame_allocator: F, 64140fe15e0SLoGin phantom: PhantomData<fn() -> Arch>, 64240fe15e0SLoGin } 64340fe15e0SLoGin 64440fe15e0SLoGin impl<Arch: MemoryManagementArch, F: FrameAllocator> PageMapper<Arch, F> { 64540fe15e0SLoGin /// 创建新的页面映射器 64640fe15e0SLoGin /// 64740fe15e0SLoGin /// ## 参数 64840fe15e0SLoGin /// - table_kind 页表类型 64940fe15e0SLoGin /// - table_paddr 根页表物理地址 65040fe15e0SLoGin /// - allocator 页分配器 65140fe15e0SLoGin /// 65240fe15e0SLoGin /// ## 返回值 65340fe15e0SLoGin /// 65440fe15e0SLoGin /// 页面映射器 65540fe15e0SLoGin pub unsafe fn new(table_kind: PageTableKind, table_paddr: PhysAddr, allocator: F) -> Self { 65640fe15e0SLoGin return Self { 65740fe15e0SLoGin table_kind, 65840fe15e0SLoGin table_paddr, 65940fe15e0SLoGin frame_allocator: allocator, 66040fe15e0SLoGin phantom: PhantomData, 66140fe15e0SLoGin }; 66240fe15e0SLoGin } 66340fe15e0SLoGin 66440fe15e0SLoGin /// 创建页表,并为这个页表创建页面映射器 66540fe15e0SLoGin pub unsafe fn create(table_kind: PageTableKind, mut allocator: F) -> Option<Self> { 66640fe15e0SLoGin let table_paddr = allocator.allocate_one()?; 66740fe15e0SLoGin // 清空页表 66840fe15e0SLoGin let table_vaddr = Arch::phys_2_virt(table_paddr)?; 66940fe15e0SLoGin Arch::write_bytes(table_vaddr, 0, Arch::PAGE_SIZE); 67040fe15e0SLoGin return Some(Self::new(table_kind, table_paddr, allocator)); 67140fe15e0SLoGin } 67240fe15e0SLoGin 67340fe15e0SLoGin /// 获取当前页表的页面映射器 67440fe15e0SLoGin #[inline(always)] 67540fe15e0SLoGin pub unsafe fn current(table_kind: PageTableKind, allocator: F) -> Self { 67640fe15e0SLoGin let table_paddr = Arch::table(table_kind); 67740fe15e0SLoGin return Self::new(table_kind, table_paddr, allocator); 67840fe15e0SLoGin } 67940fe15e0SLoGin 68040fe15e0SLoGin /// 判断当前页表分配器所属的页表是否是当前页表 68140fe15e0SLoGin #[inline(always)] 68240fe15e0SLoGin pub fn is_current(&self) -> bool { 68340fe15e0SLoGin return unsafe { self.table().phys() == Arch::table(self.table_kind) }; 68440fe15e0SLoGin } 68540fe15e0SLoGin 68640fe15e0SLoGin /// 将当前页表分配器所属的页表设置为当前页表 68740fe15e0SLoGin #[inline(always)] 68840fe15e0SLoGin pub unsafe fn make_current(&self) { 68940fe15e0SLoGin Arch::set_table(self.table_kind, self.table_paddr); 69040fe15e0SLoGin } 69140fe15e0SLoGin 69240fe15e0SLoGin /// 获取当前页表分配器所属的根页表的结构体 69340fe15e0SLoGin #[inline(always)] 69440fe15e0SLoGin pub fn table(&self) -> PageTable<Arch> { 69540fe15e0SLoGin // 由于只能通过new方法创建PageMapper,因此这里假定table_paddr是有效的 69640fe15e0SLoGin return unsafe { 69740fe15e0SLoGin PageTable::new(VirtAddr::new(0), self.table_paddr, Arch::PAGE_LEVELS - 1) 69840fe15e0SLoGin }; 69940fe15e0SLoGin } 70040fe15e0SLoGin 70140fe15e0SLoGin /// 获取当前PageMapper所对应的页分配器实例的引用 70240fe15e0SLoGin #[inline(always)] 70340fe15e0SLoGin #[allow(dead_code)] 70440fe15e0SLoGin pub fn allocator_ref(&self) -> &F { 70540fe15e0SLoGin return &self.frame_allocator; 70640fe15e0SLoGin } 70740fe15e0SLoGin 70840fe15e0SLoGin /// 获取当前PageMapper所对应的页分配器实例的可变引用 70940fe15e0SLoGin #[inline(always)] 71040fe15e0SLoGin pub fn allocator_mut(&mut self) -> &mut F { 71140fe15e0SLoGin return &mut self.frame_allocator; 71240fe15e0SLoGin } 71340fe15e0SLoGin 71440fe15e0SLoGin /// 从当前PageMapper的页分配器中分配一个物理页,并将其映射到指定的虚拟地址 71540fe15e0SLoGin pub unsafe fn map( 71640fe15e0SLoGin &mut self, 71740fe15e0SLoGin virt: VirtAddr, 71840fe15e0SLoGin flags: PageFlags<Arch>, 71940fe15e0SLoGin ) -> Option<PageFlush<Arch>> { 72040fe15e0SLoGin compiler_fence(Ordering::SeqCst); 72140fe15e0SLoGin let phys: PhysAddr = self.frame_allocator.allocate_one()?; 72240fe15e0SLoGin compiler_fence(Ordering::SeqCst); 72356cc4dbeSJomo 7246fc066acSJomo let mut page_manager_guard: SpinLockGuard<'static, PageManager> = 7256fc066acSJomo page_manager_lock_irqsave(); 7266fc066acSJomo if !page_manager_guard.contains(&phys) { 7276fc066acSJomo page_manager_guard.insert(phys, Page::new(false)) 7286fc066acSJomo } 7296fc066acSJomo 73040fe15e0SLoGin return self.map_phys(virt, phys, flags); 73140fe15e0SLoGin } 73240fe15e0SLoGin 73340fe15e0SLoGin /// 映射一个物理页到指定的虚拟地址 73440fe15e0SLoGin pub unsafe fn map_phys( 73540fe15e0SLoGin &mut self, 73640fe15e0SLoGin virt: VirtAddr, 73740fe15e0SLoGin phys: PhysAddr, 73840fe15e0SLoGin flags: PageFlags<Arch>, 73940fe15e0SLoGin ) -> Option<PageFlush<Arch>> { 74040fe15e0SLoGin // 验证虚拟地址和物理地址是否对齐 74140fe15e0SLoGin if !(virt.check_aligned(Arch::PAGE_SIZE) && phys.check_aligned(Arch::PAGE_SIZE)) { 74240fe15e0SLoGin kerror!( 74340fe15e0SLoGin "Try to map unaligned page: virt={:?}, phys={:?}", 74440fe15e0SLoGin virt, 74540fe15e0SLoGin phys 74640fe15e0SLoGin ); 74740fe15e0SLoGin return None; 74840fe15e0SLoGin } 7497a29d4fcSLoGin 75040fe15e0SLoGin let virt = VirtAddr::new(virt.data() & (!Arch::PAGE_NEGATIVE_MASK)); 75140fe15e0SLoGin 75240fe15e0SLoGin // TODO: 验证flags是否合法 75340fe15e0SLoGin 75440fe15e0SLoGin // 创建页表项 7557a29d4fcSLoGin let entry = PageEntry::new(phys, flags); 75640fe15e0SLoGin let mut table = self.table(); 75740fe15e0SLoGin loop { 75840fe15e0SLoGin let i = table.index_of(virt)?; 75940fe15e0SLoGin assert!(i < Arch::PAGE_ENTRY_NUM); 76040fe15e0SLoGin if table.level() == 0 { 76140fe15e0SLoGin // todo: 检查是否已经映射 76240fe15e0SLoGin // 现在不检查的原因是,刚刚启动系统时,内核会映射一些页。 763b5b571e0SLoGin if table.entry_mapped(i)? { 76440fe15e0SLoGin kwarn!("Page {:?} already mapped", virt); 76540fe15e0SLoGin } 7667a29d4fcSLoGin 76740fe15e0SLoGin compiler_fence(Ordering::SeqCst); 7687a29d4fcSLoGin 76940fe15e0SLoGin table.set_entry(i, entry); 77040fe15e0SLoGin compiler_fence(Ordering::SeqCst); 77140fe15e0SLoGin return Some(PageFlush::new(virt)); 77240fe15e0SLoGin } else { 77340fe15e0SLoGin let next_table = table.next_level_table(i); 77440fe15e0SLoGin if let Some(next_table) = next_table { 77540fe15e0SLoGin table = next_table; 77640fe15e0SLoGin // kdebug!("Mapping {:?} to next level table...", virt); 77740fe15e0SLoGin } else { 77840fe15e0SLoGin // 分配下一级页表 77940fe15e0SLoGin let frame = self.frame_allocator.allocate_one()?; 7807a29d4fcSLoGin 78140fe15e0SLoGin // 清空这个页帧 78240fe15e0SLoGin MMArch::write_bytes(MMArch::phys_2_virt(frame).unwrap(), 0, MMArch::PAGE_SIZE); 78340fe15e0SLoGin 78440fe15e0SLoGin // 设置页表项的flags 7857a29d4fcSLoGin let flags: PageFlags<Arch> = 78640fe15e0SLoGin PageFlags::new_page_table(virt.kind() == PageTableKind::User); 78740fe15e0SLoGin 78840fe15e0SLoGin // kdebug!("Flags: {:?}", flags); 78940fe15e0SLoGin 79040fe15e0SLoGin // 把新分配的页表映射到当前页表 7917a29d4fcSLoGin table.set_entry(i, PageEntry::new(frame, flags)); 79240fe15e0SLoGin 79340fe15e0SLoGin // 获取新分配的页表 79440fe15e0SLoGin table = table.next_level_table(i)?; 79540fe15e0SLoGin } 79640fe15e0SLoGin } 79740fe15e0SLoGin } 79840fe15e0SLoGin } 79940fe15e0SLoGin 80040fe15e0SLoGin /// 将物理地址映射到具有线性偏移量的虚拟地址 80140fe15e0SLoGin #[allow(dead_code)] 80240fe15e0SLoGin pub unsafe fn map_linearly( 80340fe15e0SLoGin &mut self, 80440fe15e0SLoGin phys: PhysAddr, 80540fe15e0SLoGin flags: PageFlags<Arch>, 80640fe15e0SLoGin ) -> Option<(VirtAddr, PageFlush<Arch>)> { 80740fe15e0SLoGin let virt: VirtAddr = Arch::phys_2_virt(phys)?; 80840fe15e0SLoGin return self.map_phys(virt, phys, flags).map(|flush| (virt, flush)); 80940fe15e0SLoGin } 81040fe15e0SLoGin 81140fe15e0SLoGin /// 修改虚拟地址的页表项的flags,并返回页表项刷新器 81240fe15e0SLoGin /// 81340fe15e0SLoGin /// 请注意,需要在修改完flags后,调用刷新器的flush方法,才能使修改生效 81440fe15e0SLoGin /// 81540fe15e0SLoGin /// ## 参数 81640fe15e0SLoGin /// - virt 虚拟地址 81740fe15e0SLoGin /// - flags 新的页表项的flags 81840fe15e0SLoGin /// 81940fe15e0SLoGin /// ## 返回值 82040fe15e0SLoGin /// 82140fe15e0SLoGin /// 如果修改成功,返回刷新器,否则返回None 82240fe15e0SLoGin pub unsafe fn remap( 82340fe15e0SLoGin &mut self, 82440fe15e0SLoGin virt: VirtAddr, 82540fe15e0SLoGin flags: PageFlags<Arch>, 82640fe15e0SLoGin ) -> Option<PageFlush<Arch>> { 82740fe15e0SLoGin return self 82840fe15e0SLoGin .visit(virt, |p1, i| { 82940fe15e0SLoGin let mut entry = p1.entry(i)?; 83040fe15e0SLoGin entry.set_flags(flags); 83140fe15e0SLoGin p1.set_entry(i, entry); 83240fe15e0SLoGin Some(PageFlush::new(virt)) 83340fe15e0SLoGin }) 83440fe15e0SLoGin .flatten(); 83540fe15e0SLoGin } 83640fe15e0SLoGin 83740fe15e0SLoGin /// 根据虚拟地址,查找页表,获取对应的物理地址和页表项的flags 83840fe15e0SLoGin /// 83940fe15e0SLoGin /// ## 参数 84040fe15e0SLoGin /// 84140fe15e0SLoGin /// - virt 虚拟地址 84240fe15e0SLoGin /// 84340fe15e0SLoGin /// ## 返回值 84440fe15e0SLoGin /// 84540fe15e0SLoGin /// 如果查找成功,返回物理地址和页表项的flags,否则返回None 84640fe15e0SLoGin pub fn translate(&self, virt: VirtAddr) -> Option<(PhysAddr, PageFlags<Arch>)> { 84740fe15e0SLoGin let entry: PageEntry<Arch> = self.visit(virt, |p1, i| unsafe { p1.entry(i) })??; 84840fe15e0SLoGin let paddr = entry.address().ok()?; 84940fe15e0SLoGin let flags = entry.flags(); 85040fe15e0SLoGin return Some((paddr, flags)); 85140fe15e0SLoGin } 85240fe15e0SLoGin 85340fe15e0SLoGin /// 取消虚拟地址的映射,释放页面,并返回页表项刷新器 85440fe15e0SLoGin /// 85540fe15e0SLoGin /// 请注意,需要在取消映射后,调用刷新器的flush方法,才能使修改生效 85640fe15e0SLoGin /// 85740fe15e0SLoGin /// ## 参数 85840fe15e0SLoGin /// 85940fe15e0SLoGin /// - virt 虚拟地址 86040fe15e0SLoGin /// - unmap_parents 是否在父页表内,取消空闲子页表的映射 86140fe15e0SLoGin /// 86240fe15e0SLoGin /// ## 返回值 86340fe15e0SLoGin /// 如果取消成功,返回刷新器,否则返回None 8642dd9f0c7SLoGin #[allow(dead_code)] 86540fe15e0SLoGin pub unsafe fn unmap(&mut self, virt: VirtAddr, unmap_parents: bool) -> Option<PageFlush<Arch>> { 86640fe15e0SLoGin let (paddr, _, flusher) = self.unmap_phys(virt, unmap_parents)?; 86740fe15e0SLoGin self.frame_allocator.free_one(paddr); 86840fe15e0SLoGin return Some(flusher); 86940fe15e0SLoGin } 87040fe15e0SLoGin 87140fe15e0SLoGin /// 取消虚拟地址的映射,并返回物理地址和页表项的flags 87240fe15e0SLoGin /// 87340fe15e0SLoGin /// ## 参数 87440fe15e0SLoGin /// 87540fe15e0SLoGin /// - vaddr 虚拟地址 87640fe15e0SLoGin /// - unmap_parents 是否在父页表内,取消空闲子页表的映射 87740fe15e0SLoGin /// 87840fe15e0SLoGin /// ## 返回值 87940fe15e0SLoGin /// 88040fe15e0SLoGin /// 如果取消成功,返回物理地址和页表项的flags,否则返回None 88140fe15e0SLoGin pub unsafe fn unmap_phys( 88240fe15e0SLoGin &mut self, 88340fe15e0SLoGin virt: VirtAddr, 88440fe15e0SLoGin unmap_parents: bool, 88540fe15e0SLoGin ) -> Option<(PhysAddr, PageFlags<Arch>, PageFlush<Arch>)> { 88640fe15e0SLoGin if !virt.check_aligned(Arch::PAGE_SIZE) { 88740fe15e0SLoGin kerror!("Try to unmap unaligned page: virt={:?}", virt); 88840fe15e0SLoGin return None; 88940fe15e0SLoGin } 89040fe15e0SLoGin 891b5b571e0SLoGin let table = self.table(); 892b5b571e0SLoGin return unmap_phys_inner(virt, &table, unmap_parents, self.allocator_mut()) 89340fe15e0SLoGin .map(|(paddr, flags)| (paddr, flags, PageFlush::<Arch>::new(virt))); 89440fe15e0SLoGin } 89540fe15e0SLoGin 89640fe15e0SLoGin /// 在页表中,访问虚拟地址对应的页表项,并调用传入的函数F 89740fe15e0SLoGin fn visit<T>( 89840fe15e0SLoGin &self, 89940fe15e0SLoGin virt: VirtAddr, 90040fe15e0SLoGin f: impl FnOnce(&mut PageTable<Arch>, usize) -> T, 90140fe15e0SLoGin ) -> Option<T> { 90240fe15e0SLoGin let mut table = self.table(); 90340fe15e0SLoGin unsafe { 90440fe15e0SLoGin loop { 90540fe15e0SLoGin let i = table.index_of(virt)?; 90640fe15e0SLoGin if table.level() == 0 { 90740fe15e0SLoGin return Some(f(&mut table, i)); 90840fe15e0SLoGin } else { 90940fe15e0SLoGin table = table.next_level_table(i)?; 91040fe15e0SLoGin } 91140fe15e0SLoGin } 91240fe15e0SLoGin } 91340fe15e0SLoGin } 91440fe15e0SLoGin } 91540fe15e0SLoGin 91640fe15e0SLoGin /// 取消页面映射,返回被取消映射的页表项的:【物理地址】和【flags】 91740fe15e0SLoGin /// 91840fe15e0SLoGin /// ## 参数 91940fe15e0SLoGin /// 92040fe15e0SLoGin /// - vaddr 虚拟地址 92140fe15e0SLoGin /// - table 页表 92240fe15e0SLoGin /// - unmap_parents 是否在父页表内,取消空闲子页表的映射 92340fe15e0SLoGin /// - allocator 页面分配器(如果页表从这个分配器分配,那么在取消映射时,也需要归还到这个分配器内) 92440fe15e0SLoGin /// 92540fe15e0SLoGin /// ## 返回值 92640fe15e0SLoGin /// 92740fe15e0SLoGin /// 如果取消成功,返回被取消映射的页表项的:【物理地址】和【flags】,否则返回None 92840fe15e0SLoGin unsafe fn unmap_phys_inner<Arch: MemoryManagementArch>( 92940fe15e0SLoGin vaddr: VirtAddr, 930840045afSLoGin table: &PageTable<Arch>, 93140fe15e0SLoGin unmap_parents: bool, 93240fe15e0SLoGin allocator: &mut impl FrameAllocator, 93340fe15e0SLoGin ) -> Option<(PhysAddr, PageFlags<Arch>)> { 93440fe15e0SLoGin // 获取页表项的索引 93540fe15e0SLoGin let i = table.index_of(vaddr)?; 93640fe15e0SLoGin 93740fe15e0SLoGin // 如果当前是最后一级页表,直接取消页面映射 93840fe15e0SLoGin if table.level() == 0 { 93940fe15e0SLoGin let entry = table.entry(i)?; 9407a29d4fcSLoGin table.set_entry(i, PageEntry::from_usize(0)); 94140fe15e0SLoGin return Some((entry.address().ok()?, entry.flags())); 94240fe15e0SLoGin } 94340fe15e0SLoGin 944b5b571e0SLoGin let subtable = table.next_level_table(i)?; 94540fe15e0SLoGin // 递归地取消映射 946b5b571e0SLoGin let result = unmap_phys_inner(vaddr, &subtable, unmap_parents, allocator)?; 94740fe15e0SLoGin 94840fe15e0SLoGin // TODO: This is a bad idea for architectures where the kernel mappings are done in the process tables, 94940fe15e0SLoGin // as these mappings may become out of sync 95040fe15e0SLoGin if unmap_parents { 95140fe15e0SLoGin // 如果子页表已经没有映射的页面了,就取消子页表的映射 95240fe15e0SLoGin 95340fe15e0SLoGin // 检查子页表中是否还有映射的页面 95440fe15e0SLoGin let x = (0..Arch::PAGE_ENTRY_NUM) 95540fe15e0SLoGin .map(|k| subtable.entry(k).expect("invalid page entry")) 95640fe15e0SLoGin .any(|e| e.present()); 95740fe15e0SLoGin if !x { 95840fe15e0SLoGin // 如果没有,就取消子页表的映射 9597a29d4fcSLoGin table.set_entry(i, PageEntry::from_usize(0)); 96040fe15e0SLoGin // 释放子页表 96140fe15e0SLoGin allocator.free_one(subtable.phys()); 96240fe15e0SLoGin } 96340fe15e0SLoGin } 96440fe15e0SLoGin 96540fe15e0SLoGin return Some(result); 96640fe15e0SLoGin } 96740fe15e0SLoGin 96840fe15e0SLoGin impl<Arch, F: Debug> Debug for PageMapper<Arch, F> { 96940fe15e0SLoGin fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 97040fe15e0SLoGin f.debug_struct("PageMapper") 97140fe15e0SLoGin .field("table_paddr", &self.table_paddr) 97240fe15e0SLoGin .field("frame_allocator", &self.frame_allocator) 97340fe15e0SLoGin .finish() 97440fe15e0SLoGin } 97540fe15e0SLoGin } 97640fe15e0SLoGin 97740fe15e0SLoGin /// 页表刷新器的trait 9787ae679ddSLoGin pub trait Flusher<Arch: MemoryManagementArch> { 97940fe15e0SLoGin /// 取消对指定的page flusher的刷新 98040fe15e0SLoGin fn consume(&mut self, flush: PageFlush<Arch>); 98140fe15e0SLoGin } 98240fe15e0SLoGin 98340fe15e0SLoGin /// 用于刷新某个虚拟地址的刷新器。这个刷新器一经产生,就必须调用flush()方法, 98440fe15e0SLoGin /// 否则会造成对页表的更改被忽略,这是不安全的 98540fe15e0SLoGin #[must_use = "The flusher must call the 'flush()', or the changes to page table will be unsafely ignored."] 9867ae679ddSLoGin pub struct PageFlush<Arch: MemoryManagementArch> { 98740fe15e0SLoGin virt: VirtAddr, 98840fe15e0SLoGin phantom: PhantomData<Arch>, 98940fe15e0SLoGin } 99040fe15e0SLoGin 99140fe15e0SLoGin impl<Arch: MemoryManagementArch> PageFlush<Arch> { 99240fe15e0SLoGin pub fn new(virt: VirtAddr) -> Self { 99340fe15e0SLoGin return Self { 99440fe15e0SLoGin virt, 99540fe15e0SLoGin phantom: PhantomData, 99640fe15e0SLoGin }; 99740fe15e0SLoGin } 99840fe15e0SLoGin 99940fe15e0SLoGin pub fn flush(self) { 100040fe15e0SLoGin unsafe { Arch::invalidate_page(self.virt) }; 100140fe15e0SLoGin } 100240fe15e0SLoGin 100340fe15e0SLoGin /// 忽略掉这个刷新器 100440fe15e0SLoGin pub unsafe fn ignore(self) { 100540fe15e0SLoGin mem::forget(self); 100640fe15e0SLoGin } 100740fe15e0SLoGin } 100840fe15e0SLoGin 10097ae679ddSLoGin impl<Arch: MemoryManagementArch> Drop for PageFlush<Arch> { 10107ae679ddSLoGin fn drop(&mut self) { 10117ae679ddSLoGin unsafe { 10127ae679ddSLoGin MMArch::invalidate_page(self.virt); 10137ae679ddSLoGin } 10147ae679ddSLoGin } 10157ae679ddSLoGin } 10167ae679ddSLoGin 101740fe15e0SLoGin /// 用于刷新整个页表的刷新器。这个刷新器一经产生,就必须调用flush()方法, 101840fe15e0SLoGin /// 否则会造成对页表的更改被忽略,这是不安全的 101940fe15e0SLoGin #[must_use = "The flusher must call the 'flush()', or the changes to page table will be unsafely ignored."] 102040fe15e0SLoGin pub struct PageFlushAll<Arch: MemoryManagementArch> { 102140fe15e0SLoGin phantom: PhantomData<fn() -> Arch>, 102240fe15e0SLoGin } 102340fe15e0SLoGin 102440fe15e0SLoGin #[allow(dead_code)] 102540fe15e0SLoGin impl<Arch: MemoryManagementArch> PageFlushAll<Arch> { 102640fe15e0SLoGin pub fn new() -> Self { 102740fe15e0SLoGin return Self { 102840fe15e0SLoGin phantom: PhantomData, 102940fe15e0SLoGin }; 103040fe15e0SLoGin } 103140fe15e0SLoGin 103240fe15e0SLoGin pub fn flush(self) { 103340fe15e0SLoGin unsafe { Arch::invalidate_all() }; 103440fe15e0SLoGin } 103540fe15e0SLoGin 103640fe15e0SLoGin /// 忽略掉这个刷新器 103740fe15e0SLoGin pub unsafe fn ignore(self) { 103840fe15e0SLoGin mem::forget(self); 103940fe15e0SLoGin } 104040fe15e0SLoGin } 104140fe15e0SLoGin 104240fe15e0SLoGin impl<Arch: MemoryManagementArch> Flusher<Arch> for PageFlushAll<Arch> { 104340fe15e0SLoGin /// 为page flush all 实现consume,消除对单个页面的刷新。(刷新整个页表了就不需要刷新单个页面了) 104440fe15e0SLoGin fn consume(&mut self, flush: PageFlush<Arch>) { 104540fe15e0SLoGin unsafe { flush.ignore() }; 104640fe15e0SLoGin } 104740fe15e0SLoGin } 104840fe15e0SLoGin 104940fe15e0SLoGin impl<Arch: MemoryManagementArch, T: Flusher<Arch> + ?Sized> Flusher<Arch> for &mut T { 105040fe15e0SLoGin /// 允许一个flusher consume掉另一个flusher 105140fe15e0SLoGin fn consume(&mut self, flush: PageFlush<Arch>) { 105240fe15e0SLoGin <T as Flusher<Arch>>::consume(self, flush); 105340fe15e0SLoGin } 105440fe15e0SLoGin } 105540fe15e0SLoGin 105640fe15e0SLoGin impl<Arch: MemoryManagementArch> Flusher<Arch> for () { 105740fe15e0SLoGin fn consume(&mut self, _flush: PageFlush<Arch>) {} 105840fe15e0SLoGin } 105940fe15e0SLoGin 106040fe15e0SLoGin impl<Arch: MemoryManagementArch> Drop for PageFlushAll<Arch> { 106140fe15e0SLoGin fn drop(&mut self) { 106240fe15e0SLoGin unsafe { 106340fe15e0SLoGin Arch::invalidate_all(); 106440fe15e0SLoGin } 106540fe15e0SLoGin } 106640fe15e0SLoGin } 106740fe15e0SLoGin 106840fe15e0SLoGin /// 未在当前CPU上激活的页表的刷新器 106940fe15e0SLoGin /// 107040fe15e0SLoGin /// 如果页表没有在当前cpu上激活,那么需要发送ipi到其他核心,尝试在其他核心上刷新页表 107140fe15e0SLoGin /// 107240fe15e0SLoGin /// TODO: 这个方式很暴力,也许把它改成在指定的核心上刷新页表会更好。(可以测试一下开销) 107340fe15e0SLoGin #[derive(Debug)] 107440fe15e0SLoGin pub struct InactiveFlusher; 107540fe15e0SLoGin 107640fe15e0SLoGin impl InactiveFlusher { 107740fe15e0SLoGin pub fn new() -> Self { 107840fe15e0SLoGin return Self {}; 107940fe15e0SLoGin } 108040fe15e0SLoGin } 108140fe15e0SLoGin 108240fe15e0SLoGin impl Flusher<MMArch> for InactiveFlusher { 108340fe15e0SLoGin fn consume(&mut self, flush: PageFlush<MMArch>) { 108440fe15e0SLoGin unsafe { 108540fe15e0SLoGin flush.ignore(); 108640fe15e0SLoGin } 108740fe15e0SLoGin } 108840fe15e0SLoGin } 108940fe15e0SLoGin 109040fe15e0SLoGin impl Drop for InactiveFlusher { 109140fe15e0SLoGin fn drop(&mut self) { 109240fe15e0SLoGin // 发送刷新页表的IPI 109340fe15e0SLoGin send_ipi(IpiKind::FlushTLB, IpiTarget::Other); 109440fe15e0SLoGin } 109540fe15e0SLoGin } 109640fe15e0SLoGin 109740fe15e0SLoGin /// # 把一个地址向下对齐到页大小 109840fe15e0SLoGin pub fn round_down_to_page_size(addr: usize) -> usize { 109940fe15e0SLoGin addr & !(MMArch::PAGE_SIZE - 1) 110040fe15e0SLoGin } 110140fe15e0SLoGin 110240fe15e0SLoGin /// # 把一个地址向上对齐到页大小 110340fe15e0SLoGin pub fn round_up_to_page_size(addr: usize) -> usize { 110440fe15e0SLoGin round_down_to_page_size(addr + MMArch::PAGE_SIZE - 1) 110540fe15e0SLoGin } 1106