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 940fe15e0SLoGin use crate::{ 1040fe15e0SLoGin arch::{interrupt::ipi::send_ipi, MMArch}, 1140fe15e0SLoGin exception::ipi::{IpiKind, IpiTarget}, 1240fe15e0SLoGin kerror, kwarn, 1340fe15e0SLoGin }; 1440fe15e0SLoGin 1540fe15e0SLoGin use super::{ 1640fe15e0SLoGin allocator::page_frame::FrameAllocator, syscall::ProtFlags, MemoryManagementArch, PageTableKind, 1740fe15e0SLoGin PhysAddr, VirtAddr, 1840fe15e0SLoGin }; 1940fe15e0SLoGin 2040fe15e0SLoGin #[derive(Debug)] 2140fe15e0SLoGin pub struct PageTable<Arch> { 2240fe15e0SLoGin /// 当前页表表示的虚拟地址空间的起始地址 2340fe15e0SLoGin base: VirtAddr, 2440fe15e0SLoGin /// 当前页表所在的物理地址 2540fe15e0SLoGin phys: PhysAddr, 2640fe15e0SLoGin /// 当前页表的层级(请注意,最顶级页表的level为[Arch::PAGE_LEVELS - 1]) 2740fe15e0SLoGin level: usize, 2840fe15e0SLoGin phantom: PhantomData<Arch>, 2940fe15e0SLoGin } 3040fe15e0SLoGin 3140fe15e0SLoGin #[allow(dead_code)] 3240fe15e0SLoGin impl<Arch: MemoryManagementArch> PageTable<Arch> { 3340fe15e0SLoGin pub unsafe fn new(base: VirtAddr, phys: PhysAddr, level: usize) -> Self { 3440fe15e0SLoGin Self { 3540fe15e0SLoGin base, 3640fe15e0SLoGin phys, 3740fe15e0SLoGin level, 3840fe15e0SLoGin phantom: PhantomData, 3940fe15e0SLoGin } 4040fe15e0SLoGin } 4140fe15e0SLoGin 4240fe15e0SLoGin /// 获取顶级页表 4340fe15e0SLoGin /// 4440fe15e0SLoGin /// ## 参数 4540fe15e0SLoGin /// 4640fe15e0SLoGin /// - table_kind 页表类型 4740fe15e0SLoGin /// 4840fe15e0SLoGin /// ## 返回值 4940fe15e0SLoGin /// 5040fe15e0SLoGin /// 返回顶级页表 5140fe15e0SLoGin pub unsafe fn top_level_table(table_kind: PageTableKind) -> Self { 5240fe15e0SLoGin return Self::new( 5340fe15e0SLoGin VirtAddr::new(0), 5440fe15e0SLoGin Arch::table(table_kind), 5540fe15e0SLoGin Arch::PAGE_LEVELS - 1, 5640fe15e0SLoGin ); 5740fe15e0SLoGin } 5840fe15e0SLoGin 5940fe15e0SLoGin /// 获取当前页表的物理地址 6040fe15e0SLoGin #[inline(always)] 6140fe15e0SLoGin pub fn phys(&self) -> PhysAddr { 6240fe15e0SLoGin self.phys 6340fe15e0SLoGin } 6440fe15e0SLoGin 6540fe15e0SLoGin /// 当前页表表示的虚拟地址空间的起始地址 6640fe15e0SLoGin #[inline(always)] 6740fe15e0SLoGin pub fn base(&self) -> VirtAddr { 6840fe15e0SLoGin self.base 6940fe15e0SLoGin } 7040fe15e0SLoGin 7140fe15e0SLoGin /// 获取当前页表的层级 7240fe15e0SLoGin #[inline(always)] 7340fe15e0SLoGin pub fn level(&self) -> usize { 7440fe15e0SLoGin self.level 7540fe15e0SLoGin } 7640fe15e0SLoGin 7740fe15e0SLoGin /// 获取当前页表自身所在的虚拟地址 7840fe15e0SLoGin #[inline(always)] 7940fe15e0SLoGin pub unsafe fn virt(&self) -> VirtAddr { 8040fe15e0SLoGin return Arch::phys_2_virt(self.phys).unwrap(); 8140fe15e0SLoGin } 8240fe15e0SLoGin 8340fe15e0SLoGin /// 获取第i个页表项所表示的虚拟内存空间的起始地址 8440fe15e0SLoGin pub fn entry_base(&self, i: usize) -> Option<VirtAddr> { 8540fe15e0SLoGin if i < Arch::PAGE_ENTRY_NUM { 8640fe15e0SLoGin let shift = self.level * Arch::PAGE_ENTRY_SHIFT + Arch::PAGE_SHIFT; 8740fe15e0SLoGin return Some(self.base.add(i << shift)); 8840fe15e0SLoGin } else { 8940fe15e0SLoGin return None; 9040fe15e0SLoGin } 9140fe15e0SLoGin } 9240fe15e0SLoGin 9340fe15e0SLoGin /// 获取当前页表的第i个页表项所在的虚拟地址(注意与entry_base进行区分) 9440fe15e0SLoGin pub unsafe fn entry_virt(&self, i: usize) -> Option<VirtAddr> { 9540fe15e0SLoGin if i < Arch::PAGE_ENTRY_NUM { 9640fe15e0SLoGin return Some(self.virt().add(i * Arch::PAGE_ENTRY_SIZE)); 9740fe15e0SLoGin } else { 9840fe15e0SLoGin return None; 9940fe15e0SLoGin } 10040fe15e0SLoGin } 10140fe15e0SLoGin 10240fe15e0SLoGin /// 获取当前页表的第i个页表项 10340fe15e0SLoGin pub unsafe fn entry(&self, i: usize) -> Option<PageEntry<Arch>> { 10440fe15e0SLoGin let entry_virt = self.entry_virt(i)?; 105*7a29d4fcSLoGin return Some(PageEntry::from_usize(Arch::read::<usize>(entry_virt))); 10640fe15e0SLoGin } 10740fe15e0SLoGin 10840fe15e0SLoGin /// 设置当前页表的第i个页表项 10940fe15e0SLoGin pub unsafe fn set_entry(&self, i: usize, entry: PageEntry<Arch>) -> Option<()> { 11040fe15e0SLoGin let entry_virt = self.entry_virt(i)?; 11140fe15e0SLoGin Arch::write::<usize>(entry_virt, entry.data()); 11240fe15e0SLoGin return Some(()); 11340fe15e0SLoGin } 11440fe15e0SLoGin 11540fe15e0SLoGin /// 判断当前页表的第i个页表项是否已经填写了值 11640fe15e0SLoGin /// 11740fe15e0SLoGin /// ## 参数 11840fe15e0SLoGin /// - Some(true) 如果已经填写了值 11940fe15e0SLoGin /// - Some(false) 如果未填写值 12040fe15e0SLoGin /// - None 如果i超出了页表项的范围 12140fe15e0SLoGin pub fn entry_mapped(&self, i: usize) -> Option<bool> { 12240fe15e0SLoGin let etv = unsafe { self.entry_virt(i) }?; 12340fe15e0SLoGin if unsafe { Arch::read::<usize>(etv) } != 0 { 12440fe15e0SLoGin return Some(true); 12540fe15e0SLoGin } else { 12640fe15e0SLoGin return Some(false); 12740fe15e0SLoGin } 12840fe15e0SLoGin } 12940fe15e0SLoGin 13040fe15e0SLoGin /// 根据虚拟地址,获取对应的页表项在页表中的下标 13140fe15e0SLoGin /// 13240fe15e0SLoGin /// ## 参数 13340fe15e0SLoGin /// 13440fe15e0SLoGin /// - addr: 虚拟地址 13540fe15e0SLoGin /// 13640fe15e0SLoGin /// ## 返回值 13740fe15e0SLoGin /// 13840fe15e0SLoGin /// 页表项在页表中的下标。如果addr不在当前页表所表示的虚拟地址空间中,则返回None 13940fe15e0SLoGin pub unsafe fn index_of(&self, addr: VirtAddr) -> Option<usize> { 14040fe15e0SLoGin let addr = VirtAddr::new(addr.data() & Arch::PAGE_ADDRESS_MASK); 14140fe15e0SLoGin let shift = self.level * Arch::PAGE_ENTRY_SHIFT + Arch::PAGE_SHIFT; 14240fe15e0SLoGin 14340fe15e0SLoGin let mask = (MMArch::PAGE_ENTRY_NUM << shift) - 1; 14440fe15e0SLoGin if addr < self.base || addr >= self.base.add(mask) { 14540fe15e0SLoGin return None; 14640fe15e0SLoGin } else { 14740fe15e0SLoGin return Some((addr.data() >> shift) & MMArch::PAGE_ENTRY_MASK); 14840fe15e0SLoGin } 14940fe15e0SLoGin } 15040fe15e0SLoGin 15140fe15e0SLoGin /// 获取第i个页表项指向的下一级页表 15240fe15e0SLoGin pub unsafe fn next_level_table(&self, index: usize) -> Option<Self> { 15340fe15e0SLoGin if self.level == 0 { 15440fe15e0SLoGin return None; 15540fe15e0SLoGin } 15640fe15e0SLoGin 15740fe15e0SLoGin // 返回下一级页表 15840fe15e0SLoGin return Some(PageTable::new( 15940fe15e0SLoGin self.entry_base(index)?, 16040fe15e0SLoGin self.entry(index)?.address().ok()?, 16140fe15e0SLoGin self.level - 1, 16240fe15e0SLoGin )); 16340fe15e0SLoGin } 16440fe15e0SLoGin } 16540fe15e0SLoGin 16640fe15e0SLoGin /// 页表项 16740fe15e0SLoGin #[derive(Copy, Clone)] 16840fe15e0SLoGin pub struct PageEntry<Arch> { 16940fe15e0SLoGin data: usize, 17040fe15e0SLoGin phantom: PhantomData<Arch>, 17140fe15e0SLoGin } 17240fe15e0SLoGin 17340fe15e0SLoGin impl<Arch> Debug for PageEntry<Arch> { 17440fe15e0SLoGin fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> { 17540fe15e0SLoGin f.write_fmt(format_args!("PageEntry({:#x})", self.data)) 17640fe15e0SLoGin } 17740fe15e0SLoGin } 17840fe15e0SLoGin 17940fe15e0SLoGin impl<Arch: MemoryManagementArch> PageEntry<Arch> { 18040fe15e0SLoGin #[inline(always)] 181*7a29d4fcSLoGin pub fn new(paddr: PhysAddr, flags: PageFlags<Arch>) -> Self { 182*7a29d4fcSLoGin Self { 183*7a29d4fcSLoGin data: MMArch::make_entry(paddr, flags.data()), 184*7a29d4fcSLoGin phantom: PhantomData, 185*7a29d4fcSLoGin } 186*7a29d4fcSLoGin } 187*7a29d4fcSLoGin #[inline(always)] 188*7a29d4fcSLoGin pub fn from_usize(data: usize) -> Self { 18940fe15e0SLoGin Self { 19040fe15e0SLoGin data, 19140fe15e0SLoGin phantom: PhantomData, 19240fe15e0SLoGin } 19340fe15e0SLoGin } 19440fe15e0SLoGin 19540fe15e0SLoGin #[inline(always)] 19640fe15e0SLoGin pub fn data(&self) -> usize { 19740fe15e0SLoGin self.data 19840fe15e0SLoGin } 19940fe15e0SLoGin 20040fe15e0SLoGin /// 获取当前页表项指向的物理地址 20140fe15e0SLoGin /// 20240fe15e0SLoGin /// ## 返回值 20340fe15e0SLoGin /// 20440fe15e0SLoGin /// - Ok(PhysAddr) 如果当前页面存在于物理内存中, 返回物理地址 20540fe15e0SLoGin /// - Err(PhysAddr) 如果当前页表项不存在, 返回物理地址 20640fe15e0SLoGin #[inline(always)] 20740fe15e0SLoGin pub fn address(&self) -> Result<PhysAddr, PhysAddr> { 208*7a29d4fcSLoGin let paddr: PhysAddr = { 209*7a29d4fcSLoGin #[cfg(target_arch = "x86_64")] 210*7a29d4fcSLoGin { 211*7a29d4fcSLoGin PhysAddr::new(self.data & Arch::PAGE_ADDRESS_MASK) 212*7a29d4fcSLoGin } 213*7a29d4fcSLoGin 214*7a29d4fcSLoGin #[cfg(target_arch = "riscv64")] 215*7a29d4fcSLoGin { 216*7a29d4fcSLoGin let ppn = ((self.data & (!((1 << 10) - 1))) >> 10) & ((1 << 44) - 1); 217*7a29d4fcSLoGin super::allocator::page_frame::PhysPageFrame::from_ppn(ppn).phys_address() 218*7a29d4fcSLoGin } 219*7a29d4fcSLoGin }; 22040fe15e0SLoGin 22140fe15e0SLoGin if self.present() { 22240fe15e0SLoGin Ok(paddr) 22340fe15e0SLoGin } else { 22440fe15e0SLoGin Err(paddr) 22540fe15e0SLoGin } 22640fe15e0SLoGin } 22740fe15e0SLoGin 22840fe15e0SLoGin #[inline(always)] 22940fe15e0SLoGin pub fn flags(&self) -> PageFlags<Arch> { 23040fe15e0SLoGin unsafe { PageFlags::from_data(self.data & Arch::ENTRY_FLAGS_MASK) } 23140fe15e0SLoGin } 23240fe15e0SLoGin 23340fe15e0SLoGin #[inline(always)] 23440fe15e0SLoGin pub fn set_flags(&mut self, flags: PageFlags<Arch>) { 23540fe15e0SLoGin self.data = (self.data & !Arch::ENTRY_FLAGS_MASK) | flags.data(); 23640fe15e0SLoGin } 23740fe15e0SLoGin 23840fe15e0SLoGin #[inline(always)] 23940fe15e0SLoGin pub fn present(&self) -> bool { 24040fe15e0SLoGin return self.data & Arch::ENTRY_FLAG_PRESENT != 0; 24140fe15e0SLoGin } 24240fe15e0SLoGin } 24340fe15e0SLoGin 24440fe15e0SLoGin /// 页表项的标志位 24540fe15e0SLoGin #[derive(Copy, Clone, Hash)] 24640fe15e0SLoGin pub struct PageFlags<Arch> { 24740fe15e0SLoGin data: usize, 24840fe15e0SLoGin phantom: PhantomData<Arch>, 24940fe15e0SLoGin } 25040fe15e0SLoGin 25140fe15e0SLoGin #[allow(dead_code)] 25240fe15e0SLoGin impl<Arch: MemoryManagementArch> PageFlags<Arch> { 25340fe15e0SLoGin #[inline(always)] 25440fe15e0SLoGin pub fn new() -> Self { 25540fe15e0SLoGin let mut r = unsafe { 25640fe15e0SLoGin Self::from_data( 25740fe15e0SLoGin Arch::ENTRY_FLAG_DEFAULT_PAGE 25840fe15e0SLoGin | Arch::ENTRY_FLAG_READONLY 25940fe15e0SLoGin | Arch::ENTRY_FLAG_NO_EXEC, 26040fe15e0SLoGin ) 26140fe15e0SLoGin }; 26240fe15e0SLoGin 26340fe15e0SLoGin #[cfg(target_arch = "x86_64")] 26440fe15e0SLoGin { 26540fe15e0SLoGin if crate::arch::mm::X86_64MMArch::is_xd_reserved() { 26640fe15e0SLoGin r = r.set_execute(true); 26740fe15e0SLoGin } 26840fe15e0SLoGin } 26940fe15e0SLoGin 27040fe15e0SLoGin return r; 27140fe15e0SLoGin } 27240fe15e0SLoGin 27340fe15e0SLoGin /// 根据ProtFlags生成PageFlags 27440fe15e0SLoGin /// 27540fe15e0SLoGin /// ## 参数 27640fe15e0SLoGin /// 27740fe15e0SLoGin /// - prot_flags: 页的保护标志 27840fe15e0SLoGin /// - user: 用户空间是否可访问 27940fe15e0SLoGin pub fn from_prot_flags(prot_flags: ProtFlags, user: bool) -> PageFlags<Arch> { 28040fe15e0SLoGin let flags: PageFlags<Arch> = PageFlags::new() 28140fe15e0SLoGin .set_user(user) 28240fe15e0SLoGin .set_execute(prot_flags.contains(ProtFlags::PROT_EXEC)) 28340fe15e0SLoGin .set_write(prot_flags.contains(ProtFlags::PROT_WRITE)); 28440fe15e0SLoGin 28540fe15e0SLoGin return flags; 28640fe15e0SLoGin } 28740fe15e0SLoGin 28840fe15e0SLoGin #[inline(always)] 28940fe15e0SLoGin pub fn data(&self) -> usize { 29040fe15e0SLoGin self.data 29140fe15e0SLoGin } 29240fe15e0SLoGin 29340fe15e0SLoGin #[inline(always)] 29440fe15e0SLoGin pub const unsafe fn from_data(data: usize) -> Self { 29540fe15e0SLoGin return Self { 29640fe15e0SLoGin data: data, 29740fe15e0SLoGin phantom: PhantomData, 29840fe15e0SLoGin }; 29940fe15e0SLoGin } 30040fe15e0SLoGin 30140fe15e0SLoGin /// 为新页表的页表项设置默认值 30240fe15e0SLoGin /// 30340fe15e0SLoGin /// 默认值为: 30440fe15e0SLoGin /// - present 30540fe15e0SLoGin /// - read only 30640fe15e0SLoGin /// - kernel space 30740fe15e0SLoGin /// - no exec 30840fe15e0SLoGin #[inline(always)] 30940fe15e0SLoGin pub fn new_page_table(user: bool) -> Self { 31040fe15e0SLoGin return unsafe { 311*7a29d4fcSLoGin let r = { 312*7a29d4fcSLoGin #[cfg(target_arch = "x86_64")] 313*7a29d4fcSLoGin { 314*7a29d4fcSLoGin Self::from_data(Arch::ENTRY_FLAG_DEFAULT_TABLE | Arch::ENTRY_FLAG_READWRITE) 315*7a29d4fcSLoGin } 316*7a29d4fcSLoGin 317*7a29d4fcSLoGin #[cfg(target_arch = "riscv64")] 318*7a29d4fcSLoGin { 319*7a29d4fcSLoGin // riscv64指向下一级页表的页表项,不应设置R/W/X权限位 320*7a29d4fcSLoGin Self::from_data(Arch::ENTRY_FLAG_DEFAULT_TABLE) 321*7a29d4fcSLoGin } 322*7a29d4fcSLoGin }; 32340fe15e0SLoGin if user { 32440fe15e0SLoGin r.set_user(true) 32540fe15e0SLoGin } else { 32640fe15e0SLoGin r 32740fe15e0SLoGin } 32840fe15e0SLoGin }; 32940fe15e0SLoGin } 33040fe15e0SLoGin 33140fe15e0SLoGin /// 取得当前页表项的所有权,更新当前页表项的标志位,并返回更新后的页表项。 33240fe15e0SLoGin /// 33340fe15e0SLoGin /// ## 参数 33440fe15e0SLoGin /// - flag 要更新的标志位的值 33540fe15e0SLoGin /// - value 如果为true,那么将flag对应的位设置为1,否则设置为0 33640fe15e0SLoGin /// 33740fe15e0SLoGin /// ## 返回值 33840fe15e0SLoGin /// 33940fe15e0SLoGin /// 更新后的页表项 34040fe15e0SLoGin #[inline(always)] 34140fe15e0SLoGin #[must_use] 34240fe15e0SLoGin pub fn update_flags(mut self, flag: usize, value: bool) -> Self { 34340fe15e0SLoGin if value { 34440fe15e0SLoGin self.data |= flag; 34540fe15e0SLoGin } else { 34640fe15e0SLoGin self.data &= !flag; 34740fe15e0SLoGin } 34840fe15e0SLoGin return self; 34940fe15e0SLoGin } 35040fe15e0SLoGin 35140fe15e0SLoGin /// 判断当前页表项是否存在指定的flag(只有全部flag都存在才返回true) 35240fe15e0SLoGin #[inline(always)] 35340fe15e0SLoGin pub fn has_flag(&self, flag: usize) -> bool { 35440fe15e0SLoGin return self.data & flag == flag; 35540fe15e0SLoGin } 35640fe15e0SLoGin 35740fe15e0SLoGin #[inline(always)] 35840fe15e0SLoGin pub fn present(&self) -> bool { 35940fe15e0SLoGin return self.has_flag(Arch::ENTRY_FLAG_PRESENT); 36040fe15e0SLoGin } 36140fe15e0SLoGin 36240fe15e0SLoGin /// 设置当前页表项的权限 36340fe15e0SLoGin /// 36440fe15e0SLoGin /// @param value 如果为true,那么将当前页表项的权限设置为用户态可访问 36540fe15e0SLoGin #[must_use] 36640fe15e0SLoGin #[inline(always)] 36740fe15e0SLoGin pub fn set_user(self, value: bool) -> Self { 36840fe15e0SLoGin return self.update_flags(Arch::ENTRY_FLAG_USER, value); 36940fe15e0SLoGin } 37040fe15e0SLoGin 37140fe15e0SLoGin /// 用户态是否可以访问当前页表项 37240fe15e0SLoGin #[inline(always)] 37340fe15e0SLoGin pub fn has_user(&self) -> bool { 37440fe15e0SLoGin return self.has_flag(Arch::ENTRY_FLAG_USER); 37540fe15e0SLoGin } 37640fe15e0SLoGin 37740fe15e0SLoGin /// 设置当前页表项的可写性, 如果为true,那么将当前页表项的权限设置为可写, 否则设置为只读 37840fe15e0SLoGin /// 37940fe15e0SLoGin /// ## 返回值 38040fe15e0SLoGin /// 38140fe15e0SLoGin /// 更新后的页表项. 38240fe15e0SLoGin /// 38340fe15e0SLoGin /// **请注意,**本函数会取得当前页表项的所有权,因此返回的页表项不是原来的页表项 38440fe15e0SLoGin #[must_use] 38540fe15e0SLoGin #[inline(always)] 38640fe15e0SLoGin pub fn set_write(self, value: bool) -> Self { 387*7a29d4fcSLoGin #[cfg(target_arch = "x86_64")] 388*7a29d4fcSLoGin { 38940fe15e0SLoGin // 有的架构同时具有可写和不可写的标志位,因此需要同时更新 39040fe15e0SLoGin return self 39140fe15e0SLoGin .update_flags(Arch::ENTRY_FLAG_READONLY, !value) 39240fe15e0SLoGin .update_flags(Arch::ENTRY_FLAG_READWRITE, value); 39340fe15e0SLoGin } 39440fe15e0SLoGin 395*7a29d4fcSLoGin #[cfg(target_arch = "riscv64")] 396*7a29d4fcSLoGin { 397*7a29d4fcSLoGin if value { 398*7a29d4fcSLoGin return self.update_flags(Arch::ENTRY_FLAG_READWRITE, true); 399*7a29d4fcSLoGin } else { 400*7a29d4fcSLoGin return self.update_flags(Arch::ENTRY_FLAG_READONLY, true); 401*7a29d4fcSLoGin } 402*7a29d4fcSLoGin } 403*7a29d4fcSLoGin } 404*7a29d4fcSLoGin 40540fe15e0SLoGin /// 当前页表项是否可写 40640fe15e0SLoGin #[inline(always)] 40740fe15e0SLoGin pub fn has_write(&self) -> bool { 40840fe15e0SLoGin // 有的架构同时具有可写和不可写的标志位,因此需要同时判断 40940fe15e0SLoGin return self.data & (Arch::ENTRY_FLAG_READWRITE | Arch::ENTRY_FLAG_READONLY) 41040fe15e0SLoGin == Arch::ENTRY_FLAG_READWRITE; 41140fe15e0SLoGin } 41240fe15e0SLoGin 41340fe15e0SLoGin /// 设置当前页表项的可执行性, 如果为true,那么将当前页表项的权限设置为可执行, 否则设置为不可执行 41440fe15e0SLoGin #[must_use] 41540fe15e0SLoGin #[inline(always)] 41640fe15e0SLoGin pub fn set_execute(self, mut value: bool) -> Self { 41740fe15e0SLoGin #[cfg(target_arch = "x86_64")] 41840fe15e0SLoGin { 41940fe15e0SLoGin // 如果xd位被保留,那么将可执行性设置为true 42040fe15e0SLoGin if crate::arch::mm::X86_64MMArch::is_xd_reserved() { 42140fe15e0SLoGin value = true; 42240fe15e0SLoGin } 42340fe15e0SLoGin } 42440fe15e0SLoGin 42540fe15e0SLoGin // 有的架构同时具有可执行和不可执行的标志位,因此需要同时更新 42640fe15e0SLoGin return self 42740fe15e0SLoGin .update_flags(Arch::ENTRY_FLAG_NO_EXEC, !value) 42840fe15e0SLoGin .update_flags(Arch::ENTRY_FLAG_EXEC, value); 42940fe15e0SLoGin } 43040fe15e0SLoGin 43140fe15e0SLoGin /// 当前页表项是否可执行 43240fe15e0SLoGin #[inline(always)] 43340fe15e0SLoGin pub fn has_execute(&self) -> bool { 43440fe15e0SLoGin // 有的架构同时具有可执行和不可执行的标志位,因此需要同时判断 43540fe15e0SLoGin return self.data & (Arch::ENTRY_FLAG_EXEC | Arch::ENTRY_FLAG_NO_EXEC) 43640fe15e0SLoGin == Arch::ENTRY_FLAG_EXEC; 43740fe15e0SLoGin } 43840fe15e0SLoGin 43940fe15e0SLoGin /// 设置当前页表项的缓存策略 44040fe15e0SLoGin /// 44140fe15e0SLoGin /// ## 参数 44240fe15e0SLoGin /// 44340fe15e0SLoGin /// - value: 如果为true,那么将当前页表项的缓存策略设置为不缓存。 44440fe15e0SLoGin #[inline(always)] 44540fe15e0SLoGin pub fn set_page_cache_disable(self, value: bool) -> Self { 44640fe15e0SLoGin return self.update_flags(Arch::ENTRY_FLAG_CACHE_DISABLE, value); 44740fe15e0SLoGin } 44840fe15e0SLoGin 44940fe15e0SLoGin /// 获取当前页表项的缓存策略 45040fe15e0SLoGin /// 45140fe15e0SLoGin /// ## 返回值 45240fe15e0SLoGin /// 45340fe15e0SLoGin /// 如果当前页表项的缓存策略为不缓存,那么返回true,否则返回false。 45440fe15e0SLoGin #[inline(always)] 45540fe15e0SLoGin pub fn has_page_cache_disable(&self) -> bool { 45640fe15e0SLoGin return self.has_flag(Arch::ENTRY_FLAG_CACHE_DISABLE); 45740fe15e0SLoGin } 45840fe15e0SLoGin 45940fe15e0SLoGin /// 设置当前页表项的写穿策略 46040fe15e0SLoGin /// 46140fe15e0SLoGin /// ## 参数 46240fe15e0SLoGin /// 46340fe15e0SLoGin /// - value: 如果为true,那么将当前页表项的写穿策略设置为写穿。 46440fe15e0SLoGin #[inline(always)] 46540fe15e0SLoGin pub fn set_page_write_through(self, value: bool) -> Self { 46640fe15e0SLoGin return self.update_flags(Arch::ENTRY_FLAG_WRITE_THROUGH, value); 46740fe15e0SLoGin } 46840fe15e0SLoGin 46940fe15e0SLoGin /// 获取当前页表项的写穿策略 47040fe15e0SLoGin /// 47140fe15e0SLoGin /// ## 返回值 47240fe15e0SLoGin /// 47340fe15e0SLoGin /// 如果当前页表项的写穿策略为写穿,那么返回true,否则返回false。 47440fe15e0SLoGin #[inline(always)] 47540fe15e0SLoGin pub fn has_page_write_through(&self) -> bool { 47640fe15e0SLoGin return self.has_flag(Arch::ENTRY_FLAG_WRITE_THROUGH); 47740fe15e0SLoGin } 47840fe15e0SLoGin 47940fe15e0SLoGin /// MMIO内存的页表项标志 48040fe15e0SLoGin #[inline(always)] 48140fe15e0SLoGin pub fn mmio_flags() -> Self { 48240fe15e0SLoGin return Self::new() 48340fe15e0SLoGin .set_user(false) 48440fe15e0SLoGin .set_write(true) 48540fe15e0SLoGin .set_execute(true) 48640fe15e0SLoGin .set_page_cache_disable(true) 48740fe15e0SLoGin .set_page_write_through(true); 48840fe15e0SLoGin } 48940fe15e0SLoGin } 49040fe15e0SLoGin 49140fe15e0SLoGin impl<Arch: MemoryManagementArch> fmt::Debug for PageFlags<Arch> { 49240fe15e0SLoGin fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 49340fe15e0SLoGin f.debug_struct("PageFlags") 49440fe15e0SLoGin .field("bits", &format_args!("{:#0x}", self.data)) 49540fe15e0SLoGin .field("present", &self.present()) 49640fe15e0SLoGin .field("has_write", &self.has_write()) 49740fe15e0SLoGin .field("has_execute", &self.has_execute()) 49840fe15e0SLoGin .field("has_user", &self.has_user()) 49940fe15e0SLoGin .finish() 50040fe15e0SLoGin } 50140fe15e0SLoGin } 50240fe15e0SLoGin 50340fe15e0SLoGin /// 页表映射器 50440fe15e0SLoGin #[derive(Hash)] 50540fe15e0SLoGin pub struct PageMapper<Arch, F> { 50640fe15e0SLoGin /// 页表类型 50740fe15e0SLoGin table_kind: PageTableKind, 50840fe15e0SLoGin /// 根页表物理地址 50940fe15e0SLoGin table_paddr: PhysAddr, 51040fe15e0SLoGin /// 页分配器 51140fe15e0SLoGin frame_allocator: F, 51240fe15e0SLoGin phantom: PhantomData<fn() -> Arch>, 51340fe15e0SLoGin } 51440fe15e0SLoGin 51540fe15e0SLoGin impl<Arch: MemoryManagementArch, F: FrameAllocator> PageMapper<Arch, F> { 51640fe15e0SLoGin /// 创建新的页面映射器 51740fe15e0SLoGin /// 51840fe15e0SLoGin /// ## 参数 51940fe15e0SLoGin /// - table_kind 页表类型 52040fe15e0SLoGin /// - table_paddr 根页表物理地址 52140fe15e0SLoGin /// - allocator 页分配器 52240fe15e0SLoGin /// 52340fe15e0SLoGin /// ## 返回值 52440fe15e0SLoGin /// 52540fe15e0SLoGin /// 页面映射器 52640fe15e0SLoGin pub unsafe fn new(table_kind: PageTableKind, table_paddr: PhysAddr, allocator: F) -> Self { 52740fe15e0SLoGin return Self { 52840fe15e0SLoGin table_kind, 52940fe15e0SLoGin table_paddr, 53040fe15e0SLoGin frame_allocator: allocator, 53140fe15e0SLoGin phantom: PhantomData, 53240fe15e0SLoGin }; 53340fe15e0SLoGin } 53440fe15e0SLoGin 53540fe15e0SLoGin /// 创建页表,并为这个页表创建页面映射器 53640fe15e0SLoGin pub unsafe fn create(table_kind: PageTableKind, mut allocator: F) -> Option<Self> { 53740fe15e0SLoGin let table_paddr = allocator.allocate_one()?; 53840fe15e0SLoGin // 清空页表 53940fe15e0SLoGin let table_vaddr = Arch::phys_2_virt(table_paddr)?; 54040fe15e0SLoGin Arch::write_bytes(table_vaddr, 0, Arch::PAGE_SIZE); 54140fe15e0SLoGin return Some(Self::new(table_kind, table_paddr, allocator)); 54240fe15e0SLoGin } 54340fe15e0SLoGin 54440fe15e0SLoGin /// 获取当前页表的页面映射器 54540fe15e0SLoGin #[inline(always)] 54640fe15e0SLoGin pub unsafe fn current(table_kind: PageTableKind, allocator: F) -> Self { 54740fe15e0SLoGin let table_paddr = Arch::table(table_kind); 54840fe15e0SLoGin return Self::new(table_kind, table_paddr, allocator); 54940fe15e0SLoGin } 55040fe15e0SLoGin 55140fe15e0SLoGin /// 判断当前页表分配器所属的页表是否是当前页表 55240fe15e0SLoGin #[inline(always)] 55340fe15e0SLoGin pub fn is_current(&self) -> bool { 55440fe15e0SLoGin return unsafe { self.table().phys() == Arch::table(self.table_kind) }; 55540fe15e0SLoGin } 55640fe15e0SLoGin 55740fe15e0SLoGin /// 将当前页表分配器所属的页表设置为当前页表 55840fe15e0SLoGin #[inline(always)] 55940fe15e0SLoGin pub unsafe fn make_current(&self) { 56040fe15e0SLoGin Arch::set_table(self.table_kind, self.table_paddr); 56140fe15e0SLoGin } 56240fe15e0SLoGin 56340fe15e0SLoGin /// 获取当前页表分配器所属的根页表的结构体 56440fe15e0SLoGin #[inline(always)] 56540fe15e0SLoGin pub fn table(&self) -> PageTable<Arch> { 56640fe15e0SLoGin // 由于只能通过new方法创建PageMapper,因此这里假定table_paddr是有效的 56740fe15e0SLoGin return unsafe { 56840fe15e0SLoGin PageTable::new(VirtAddr::new(0), self.table_paddr, Arch::PAGE_LEVELS - 1) 56940fe15e0SLoGin }; 57040fe15e0SLoGin } 57140fe15e0SLoGin 57240fe15e0SLoGin /// 获取当前PageMapper所对应的页分配器实例的引用 57340fe15e0SLoGin #[inline(always)] 57440fe15e0SLoGin #[allow(dead_code)] 57540fe15e0SLoGin pub fn allocator_ref(&self) -> &F { 57640fe15e0SLoGin return &self.frame_allocator; 57740fe15e0SLoGin } 57840fe15e0SLoGin 57940fe15e0SLoGin /// 获取当前PageMapper所对应的页分配器实例的可变引用 58040fe15e0SLoGin #[inline(always)] 58140fe15e0SLoGin pub fn allocator_mut(&mut self) -> &mut F { 58240fe15e0SLoGin return &mut self.frame_allocator; 58340fe15e0SLoGin } 58440fe15e0SLoGin 58540fe15e0SLoGin /// 从当前PageMapper的页分配器中分配一个物理页,并将其映射到指定的虚拟地址 58640fe15e0SLoGin pub unsafe fn map( 58740fe15e0SLoGin &mut self, 58840fe15e0SLoGin virt: VirtAddr, 58940fe15e0SLoGin flags: PageFlags<Arch>, 59040fe15e0SLoGin ) -> Option<PageFlush<Arch>> { 59140fe15e0SLoGin compiler_fence(Ordering::SeqCst); 59240fe15e0SLoGin let phys: PhysAddr = self.frame_allocator.allocate_one()?; 59340fe15e0SLoGin compiler_fence(Ordering::SeqCst); 59440fe15e0SLoGin return self.map_phys(virt, phys, flags); 59540fe15e0SLoGin } 59640fe15e0SLoGin 59740fe15e0SLoGin /// 映射一个物理页到指定的虚拟地址 59840fe15e0SLoGin pub unsafe fn map_phys( 59940fe15e0SLoGin &mut self, 60040fe15e0SLoGin virt: VirtAddr, 60140fe15e0SLoGin phys: PhysAddr, 60240fe15e0SLoGin flags: PageFlags<Arch>, 60340fe15e0SLoGin ) -> Option<PageFlush<Arch>> { 60440fe15e0SLoGin // 验证虚拟地址和物理地址是否对齐 60540fe15e0SLoGin if !(virt.check_aligned(Arch::PAGE_SIZE) && phys.check_aligned(Arch::PAGE_SIZE)) { 60640fe15e0SLoGin kerror!( 60740fe15e0SLoGin "Try to map unaligned page: virt={:?}, phys={:?}", 60840fe15e0SLoGin virt, 60940fe15e0SLoGin phys 61040fe15e0SLoGin ); 61140fe15e0SLoGin return None; 61240fe15e0SLoGin } 613*7a29d4fcSLoGin 61440fe15e0SLoGin let virt = VirtAddr::new(virt.data() & (!Arch::PAGE_NEGATIVE_MASK)); 61540fe15e0SLoGin 61640fe15e0SLoGin // TODO: 验证flags是否合法 61740fe15e0SLoGin 61840fe15e0SLoGin // 创建页表项 619*7a29d4fcSLoGin let entry = PageEntry::new(phys, flags); 62040fe15e0SLoGin let mut table = self.table(); 62140fe15e0SLoGin loop { 62240fe15e0SLoGin let i = table.index_of(virt)?; 62340fe15e0SLoGin assert!(i < Arch::PAGE_ENTRY_NUM); 62440fe15e0SLoGin if table.level() == 0 { 62540fe15e0SLoGin // todo: 检查是否已经映射 62640fe15e0SLoGin // 现在不检查的原因是,刚刚启动系统时,内核会映射一些页。 62740fe15e0SLoGin if table.entry_mapped(i)? == true { 62840fe15e0SLoGin kwarn!("Page {:?} already mapped", virt); 62940fe15e0SLoGin } 630*7a29d4fcSLoGin 63140fe15e0SLoGin compiler_fence(Ordering::SeqCst); 632*7a29d4fcSLoGin 63340fe15e0SLoGin table.set_entry(i, entry); 63440fe15e0SLoGin compiler_fence(Ordering::SeqCst); 63540fe15e0SLoGin return Some(PageFlush::new(virt)); 63640fe15e0SLoGin } else { 63740fe15e0SLoGin let next_table = table.next_level_table(i); 63840fe15e0SLoGin if let Some(next_table) = next_table { 63940fe15e0SLoGin table = next_table; 64040fe15e0SLoGin // kdebug!("Mapping {:?} to next level table...", virt); 64140fe15e0SLoGin } else { 64240fe15e0SLoGin // 分配下一级页表 64340fe15e0SLoGin let frame = self.frame_allocator.allocate_one()?; 644*7a29d4fcSLoGin 64540fe15e0SLoGin // 清空这个页帧 64640fe15e0SLoGin MMArch::write_bytes(MMArch::phys_2_virt(frame).unwrap(), 0, MMArch::PAGE_SIZE); 64740fe15e0SLoGin 64840fe15e0SLoGin // 设置页表项的flags 649*7a29d4fcSLoGin let flags: PageFlags<Arch> = 65040fe15e0SLoGin PageFlags::new_page_table(virt.kind() == PageTableKind::User); 65140fe15e0SLoGin 65240fe15e0SLoGin // kdebug!("Flags: {:?}", flags); 65340fe15e0SLoGin 65440fe15e0SLoGin // 把新分配的页表映射到当前页表 655*7a29d4fcSLoGin table.set_entry(i, PageEntry::new(frame, flags)); 65640fe15e0SLoGin 65740fe15e0SLoGin // 获取新分配的页表 65840fe15e0SLoGin table = table.next_level_table(i)?; 65940fe15e0SLoGin } 66040fe15e0SLoGin } 66140fe15e0SLoGin } 66240fe15e0SLoGin } 66340fe15e0SLoGin 66440fe15e0SLoGin /// 将物理地址映射到具有线性偏移量的虚拟地址 66540fe15e0SLoGin #[allow(dead_code)] 66640fe15e0SLoGin pub unsafe fn map_linearly( 66740fe15e0SLoGin &mut self, 66840fe15e0SLoGin phys: PhysAddr, 66940fe15e0SLoGin flags: PageFlags<Arch>, 67040fe15e0SLoGin ) -> Option<(VirtAddr, PageFlush<Arch>)> { 67140fe15e0SLoGin let virt: VirtAddr = Arch::phys_2_virt(phys)?; 67240fe15e0SLoGin return self.map_phys(virt, phys, flags).map(|flush| (virt, flush)); 67340fe15e0SLoGin } 67440fe15e0SLoGin 67540fe15e0SLoGin /// 修改虚拟地址的页表项的flags,并返回页表项刷新器 67640fe15e0SLoGin /// 67740fe15e0SLoGin /// 请注意,需要在修改完flags后,调用刷新器的flush方法,才能使修改生效 67840fe15e0SLoGin /// 67940fe15e0SLoGin /// ## 参数 68040fe15e0SLoGin /// - virt 虚拟地址 68140fe15e0SLoGin /// - flags 新的页表项的flags 68240fe15e0SLoGin /// 68340fe15e0SLoGin /// ## 返回值 68440fe15e0SLoGin /// 68540fe15e0SLoGin /// 如果修改成功,返回刷新器,否则返回None 68640fe15e0SLoGin pub unsafe fn remap( 68740fe15e0SLoGin &mut self, 68840fe15e0SLoGin virt: VirtAddr, 68940fe15e0SLoGin flags: PageFlags<Arch>, 69040fe15e0SLoGin ) -> Option<PageFlush<Arch>> { 69140fe15e0SLoGin return self 69240fe15e0SLoGin .visit(virt, |p1, i| { 69340fe15e0SLoGin let mut entry = p1.entry(i)?; 69440fe15e0SLoGin entry.set_flags(flags); 69540fe15e0SLoGin p1.set_entry(i, entry); 69640fe15e0SLoGin Some(PageFlush::new(virt)) 69740fe15e0SLoGin }) 69840fe15e0SLoGin .flatten(); 69940fe15e0SLoGin } 70040fe15e0SLoGin 70140fe15e0SLoGin /// 根据虚拟地址,查找页表,获取对应的物理地址和页表项的flags 70240fe15e0SLoGin /// 70340fe15e0SLoGin /// ## 参数 70440fe15e0SLoGin /// 70540fe15e0SLoGin /// - virt 虚拟地址 70640fe15e0SLoGin /// 70740fe15e0SLoGin /// ## 返回值 70840fe15e0SLoGin /// 70940fe15e0SLoGin /// 如果查找成功,返回物理地址和页表项的flags,否则返回None 71040fe15e0SLoGin pub fn translate(&self, virt: VirtAddr) -> Option<(PhysAddr, PageFlags<Arch>)> { 71140fe15e0SLoGin let entry: PageEntry<Arch> = self.visit(virt, |p1, i| unsafe { p1.entry(i) })??; 71240fe15e0SLoGin let paddr = entry.address().ok()?; 71340fe15e0SLoGin let flags = entry.flags(); 71440fe15e0SLoGin return Some((paddr, flags)); 71540fe15e0SLoGin } 71640fe15e0SLoGin 71740fe15e0SLoGin /// 取消虚拟地址的映射,释放页面,并返回页表项刷新器 71840fe15e0SLoGin /// 71940fe15e0SLoGin /// 请注意,需要在取消映射后,调用刷新器的flush方法,才能使修改生效 72040fe15e0SLoGin /// 72140fe15e0SLoGin /// ## 参数 72240fe15e0SLoGin /// 72340fe15e0SLoGin /// - virt 虚拟地址 72440fe15e0SLoGin /// - unmap_parents 是否在父页表内,取消空闲子页表的映射 72540fe15e0SLoGin /// 72640fe15e0SLoGin /// ## 返回值 72740fe15e0SLoGin /// 如果取消成功,返回刷新器,否则返回None 7282dd9f0c7SLoGin #[allow(dead_code)] 72940fe15e0SLoGin pub unsafe fn unmap(&mut self, virt: VirtAddr, unmap_parents: bool) -> Option<PageFlush<Arch>> { 73040fe15e0SLoGin let (paddr, _, flusher) = self.unmap_phys(virt, unmap_parents)?; 73140fe15e0SLoGin self.frame_allocator.free_one(paddr); 73240fe15e0SLoGin return Some(flusher); 73340fe15e0SLoGin } 73440fe15e0SLoGin 73540fe15e0SLoGin /// 取消虚拟地址的映射,并返回物理地址和页表项的flags 73640fe15e0SLoGin /// 73740fe15e0SLoGin /// ## 参数 73840fe15e0SLoGin /// 73940fe15e0SLoGin /// - vaddr 虚拟地址 74040fe15e0SLoGin /// - unmap_parents 是否在父页表内,取消空闲子页表的映射 74140fe15e0SLoGin /// 74240fe15e0SLoGin /// ## 返回值 74340fe15e0SLoGin /// 74440fe15e0SLoGin /// 如果取消成功,返回物理地址和页表项的flags,否则返回None 74540fe15e0SLoGin pub unsafe fn unmap_phys( 74640fe15e0SLoGin &mut self, 74740fe15e0SLoGin virt: VirtAddr, 74840fe15e0SLoGin unmap_parents: bool, 74940fe15e0SLoGin ) -> Option<(PhysAddr, PageFlags<Arch>, PageFlush<Arch>)> { 75040fe15e0SLoGin if !virt.check_aligned(Arch::PAGE_SIZE) { 75140fe15e0SLoGin kerror!("Try to unmap unaligned page: virt={:?}", virt); 75240fe15e0SLoGin return None; 75340fe15e0SLoGin } 75440fe15e0SLoGin 75540fe15e0SLoGin let mut table = self.table(); 75640fe15e0SLoGin return unmap_phys_inner(virt, &mut table, unmap_parents, self.allocator_mut()) 75740fe15e0SLoGin .map(|(paddr, flags)| (paddr, flags, PageFlush::<Arch>::new(virt))); 75840fe15e0SLoGin } 75940fe15e0SLoGin 76040fe15e0SLoGin /// 在页表中,访问虚拟地址对应的页表项,并调用传入的函数F 76140fe15e0SLoGin fn visit<T>( 76240fe15e0SLoGin &self, 76340fe15e0SLoGin virt: VirtAddr, 76440fe15e0SLoGin f: impl FnOnce(&mut PageTable<Arch>, usize) -> T, 76540fe15e0SLoGin ) -> Option<T> { 76640fe15e0SLoGin let mut table = self.table(); 76740fe15e0SLoGin unsafe { 76840fe15e0SLoGin loop { 76940fe15e0SLoGin let i = table.index_of(virt)?; 77040fe15e0SLoGin if table.level() == 0 { 77140fe15e0SLoGin return Some(f(&mut table, i)); 77240fe15e0SLoGin } else { 77340fe15e0SLoGin table = table.next_level_table(i)?; 77440fe15e0SLoGin } 77540fe15e0SLoGin } 77640fe15e0SLoGin } 77740fe15e0SLoGin } 77840fe15e0SLoGin } 77940fe15e0SLoGin 78040fe15e0SLoGin /// 取消页面映射,返回被取消映射的页表项的:【物理地址】和【flags】 78140fe15e0SLoGin /// 78240fe15e0SLoGin /// ## 参数 78340fe15e0SLoGin /// 78440fe15e0SLoGin /// - vaddr 虚拟地址 78540fe15e0SLoGin /// - table 页表 78640fe15e0SLoGin /// - unmap_parents 是否在父页表内,取消空闲子页表的映射 78740fe15e0SLoGin /// - allocator 页面分配器(如果页表从这个分配器分配,那么在取消映射时,也需要归还到这个分配器内) 78840fe15e0SLoGin /// 78940fe15e0SLoGin /// ## 返回值 79040fe15e0SLoGin /// 79140fe15e0SLoGin /// 如果取消成功,返回被取消映射的页表项的:【物理地址】和【flags】,否则返回None 79240fe15e0SLoGin unsafe fn unmap_phys_inner<Arch: MemoryManagementArch>( 79340fe15e0SLoGin vaddr: VirtAddr, 79440fe15e0SLoGin table: &mut PageTable<Arch>, 79540fe15e0SLoGin unmap_parents: bool, 79640fe15e0SLoGin allocator: &mut impl FrameAllocator, 79740fe15e0SLoGin ) -> Option<(PhysAddr, PageFlags<Arch>)> { 79840fe15e0SLoGin // 获取页表项的索引 79940fe15e0SLoGin let i = table.index_of(vaddr)?; 80040fe15e0SLoGin 80140fe15e0SLoGin // 如果当前是最后一级页表,直接取消页面映射 80240fe15e0SLoGin if table.level() == 0 { 80340fe15e0SLoGin let entry = table.entry(i)?; 804*7a29d4fcSLoGin table.set_entry(i, PageEntry::from_usize(0)); 80540fe15e0SLoGin return Some((entry.address().ok()?, entry.flags())); 80640fe15e0SLoGin } 80740fe15e0SLoGin 80840fe15e0SLoGin let mut subtable = table.next_level_table(i)?; 80940fe15e0SLoGin // 递归地取消映射 81040fe15e0SLoGin let result = unmap_phys_inner(vaddr, &mut subtable, unmap_parents, allocator)?; 81140fe15e0SLoGin 81240fe15e0SLoGin // TODO: This is a bad idea for architectures where the kernel mappings are done in the process tables, 81340fe15e0SLoGin // as these mappings may become out of sync 81440fe15e0SLoGin if unmap_parents { 81540fe15e0SLoGin // 如果子页表已经没有映射的页面了,就取消子页表的映射 81640fe15e0SLoGin 81740fe15e0SLoGin // 检查子页表中是否还有映射的页面 81840fe15e0SLoGin let x = (0..Arch::PAGE_ENTRY_NUM) 81940fe15e0SLoGin .map(|k| subtable.entry(k).expect("invalid page entry")) 82040fe15e0SLoGin .any(|e| e.present()); 82140fe15e0SLoGin if !x { 82240fe15e0SLoGin // 如果没有,就取消子页表的映射 823*7a29d4fcSLoGin table.set_entry(i, PageEntry::from_usize(0)); 82440fe15e0SLoGin // 释放子页表 82540fe15e0SLoGin allocator.free_one(subtable.phys()); 82640fe15e0SLoGin } 82740fe15e0SLoGin } 82840fe15e0SLoGin 82940fe15e0SLoGin return Some(result); 83040fe15e0SLoGin } 83140fe15e0SLoGin 83240fe15e0SLoGin impl<Arch, F: Debug> Debug for PageMapper<Arch, F> { 83340fe15e0SLoGin fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 83440fe15e0SLoGin f.debug_struct("PageMapper") 83540fe15e0SLoGin .field("table_paddr", &self.table_paddr) 83640fe15e0SLoGin .field("frame_allocator", &self.frame_allocator) 83740fe15e0SLoGin .finish() 83840fe15e0SLoGin } 83940fe15e0SLoGin } 84040fe15e0SLoGin 84140fe15e0SLoGin /// 页表刷新器的trait 8427ae679ddSLoGin pub trait Flusher<Arch: MemoryManagementArch> { 84340fe15e0SLoGin /// 取消对指定的page flusher的刷新 84440fe15e0SLoGin fn consume(&mut self, flush: PageFlush<Arch>); 84540fe15e0SLoGin } 84640fe15e0SLoGin 84740fe15e0SLoGin /// 用于刷新某个虚拟地址的刷新器。这个刷新器一经产生,就必须调用flush()方法, 84840fe15e0SLoGin /// 否则会造成对页表的更改被忽略,这是不安全的 84940fe15e0SLoGin #[must_use = "The flusher must call the 'flush()', or the changes to page table will be unsafely ignored."] 8507ae679ddSLoGin pub struct PageFlush<Arch: MemoryManagementArch> { 85140fe15e0SLoGin virt: VirtAddr, 85240fe15e0SLoGin phantom: PhantomData<Arch>, 85340fe15e0SLoGin } 85440fe15e0SLoGin 85540fe15e0SLoGin impl<Arch: MemoryManagementArch> PageFlush<Arch> { 85640fe15e0SLoGin pub fn new(virt: VirtAddr) -> Self { 85740fe15e0SLoGin return Self { 85840fe15e0SLoGin virt, 85940fe15e0SLoGin phantom: PhantomData, 86040fe15e0SLoGin }; 86140fe15e0SLoGin } 86240fe15e0SLoGin 86340fe15e0SLoGin pub fn flush(self) { 86440fe15e0SLoGin unsafe { Arch::invalidate_page(self.virt) }; 86540fe15e0SLoGin } 86640fe15e0SLoGin 86740fe15e0SLoGin /// 忽略掉这个刷新器 86840fe15e0SLoGin pub unsafe fn ignore(self) { 86940fe15e0SLoGin mem::forget(self); 87040fe15e0SLoGin } 87140fe15e0SLoGin } 87240fe15e0SLoGin 8737ae679ddSLoGin impl<Arch: MemoryManagementArch> Drop for PageFlush<Arch> { 8747ae679ddSLoGin fn drop(&mut self) { 8757ae679ddSLoGin unsafe { 8767ae679ddSLoGin MMArch::invalidate_page(self.virt); 8777ae679ddSLoGin } 8787ae679ddSLoGin } 8797ae679ddSLoGin } 8807ae679ddSLoGin 88140fe15e0SLoGin /// 用于刷新整个页表的刷新器。这个刷新器一经产生,就必须调用flush()方法, 88240fe15e0SLoGin /// 否则会造成对页表的更改被忽略,这是不安全的 88340fe15e0SLoGin #[must_use = "The flusher must call the 'flush()', or the changes to page table will be unsafely ignored."] 88440fe15e0SLoGin pub struct PageFlushAll<Arch: MemoryManagementArch> { 88540fe15e0SLoGin phantom: PhantomData<fn() -> Arch>, 88640fe15e0SLoGin } 88740fe15e0SLoGin 88840fe15e0SLoGin #[allow(dead_code)] 88940fe15e0SLoGin impl<Arch: MemoryManagementArch> PageFlushAll<Arch> { 89040fe15e0SLoGin pub fn new() -> Self { 89140fe15e0SLoGin return Self { 89240fe15e0SLoGin phantom: PhantomData, 89340fe15e0SLoGin }; 89440fe15e0SLoGin } 89540fe15e0SLoGin 89640fe15e0SLoGin pub fn flush(self) { 89740fe15e0SLoGin unsafe { Arch::invalidate_all() }; 89840fe15e0SLoGin } 89940fe15e0SLoGin 90040fe15e0SLoGin /// 忽略掉这个刷新器 90140fe15e0SLoGin pub unsafe fn ignore(self) { 90240fe15e0SLoGin mem::forget(self); 90340fe15e0SLoGin } 90440fe15e0SLoGin } 90540fe15e0SLoGin 90640fe15e0SLoGin impl<Arch: MemoryManagementArch> Flusher<Arch> for PageFlushAll<Arch> { 90740fe15e0SLoGin /// 为page flush all 实现consume,消除对单个页面的刷新。(刷新整个页表了就不需要刷新单个页面了) 90840fe15e0SLoGin fn consume(&mut self, flush: PageFlush<Arch>) { 90940fe15e0SLoGin unsafe { flush.ignore() }; 91040fe15e0SLoGin } 91140fe15e0SLoGin } 91240fe15e0SLoGin 91340fe15e0SLoGin impl<Arch: MemoryManagementArch, T: Flusher<Arch> + ?Sized> Flusher<Arch> for &mut T { 91440fe15e0SLoGin /// 允许一个flusher consume掉另一个flusher 91540fe15e0SLoGin fn consume(&mut self, flush: PageFlush<Arch>) { 91640fe15e0SLoGin <T as Flusher<Arch>>::consume(self, flush); 91740fe15e0SLoGin } 91840fe15e0SLoGin } 91940fe15e0SLoGin 92040fe15e0SLoGin impl<Arch: MemoryManagementArch> Flusher<Arch> for () { 92140fe15e0SLoGin fn consume(&mut self, _flush: PageFlush<Arch>) {} 92240fe15e0SLoGin } 92340fe15e0SLoGin 92440fe15e0SLoGin impl<Arch: MemoryManagementArch> Drop for PageFlushAll<Arch> { 92540fe15e0SLoGin fn drop(&mut self) { 92640fe15e0SLoGin unsafe { 92740fe15e0SLoGin Arch::invalidate_all(); 92840fe15e0SLoGin } 92940fe15e0SLoGin } 93040fe15e0SLoGin } 93140fe15e0SLoGin 93240fe15e0SLoGin /// 未在当前CPU上激活的页表的刷新器 93340fe15e0SLoGin /// 93440fe15e0SLoGin /// 如果页表没有在当前cpu上激活,那么需要发送ipi到其他核心,尝试在其他核心上刷新页表 93540fe15e0SLoGin /// 93640fe15e0SLoGin /// TODO: 这个方式很暴力,也许把它改成在指定的核心上刷新页表会更好。(可以测试一下开销) 93740fe15e0SLoGin #[derive(Debug)] 93840fe15e0SLoGin pub struct InactiveFlusher; 93940fe15e0SLoGin 94040fe15e0SLoGin impl InactiveFlusher { 94140fe15e0SLoGin pub fn new() -> Self { 94240fe15e0SLoGin return Self {}; 94340fe15e0SLoGin } 94440fe15e0SLoGin } 94540fe15e0SLoGin 94640fe15e0SLoGin impl Flusher<MMArch> for InactiveFlusher { 94740fe15e0SLoGin fn consume(&mut self, flush: PageFlush<MMArch>) { 94840fe15e0SLoGin unsafe { 94940fe15e0SLoGin flush.ignore(); 95040fe15e0SLoGin } 95140fe15e0SLoGin } 95240fe15e0SLoGin } 95340fe15e0SLoGin 95440fe15e0SLoGin impl Drop for InactiveFlusher { 95540fe15e0SLoGin fn drop(&mut self) { 95640fe15e0SLoGin // 发送刷新页表的IPI 95740fe15e0SLoGin send_ipi(IpiKind::FlushTLB, IpiTarget::Other); 95840fe15e0SLoGin } 95940fe15e0SLoGin } 96040fe15e0SLoGin 96140fe15e0SLoGin /// # 把一个地址向下对齐到页大小 96240fe15e0SLoGin pub fn round_down_to_page_size(addr: usize) -> usize { 96340fe15e0SLoGin addr & !(MMArch::PAGE_SIZE - 1) 96440fe15e0SLoGin } 96540fe15e0SLoGin 96640fe15e0SLoGin /// # 把一个地址向上对齐到页大小 96740fe15e0SLoGin pub fn round_up_to_page_size(addr: usize) -> usize { 96840fe15e0SLoGin round_down_to_page_size(addr + MMArch::PAGE_SIZE - 1) 96940fe15e0SLoGin } 970