xref: /DragonOS/kernel/src/mm/page.rs (revision 7a29d4fcbcd89a226289c7bf541c2c78623de3ad)
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