[rCore学习笔记 032] 管理SV39多级页表

上一节:硬件
本节:软件实现
物理页帧管理

内核->空闲内存->物理页帧->分配->存放
可用物理页的分配和回收

Link文件中关于操作系统bin文件的内存设计

内容os\src\linker-qemu.ld:

1. OUTPUT_ARCH(riscv)
2. ENTRY(_start)
3. BASE_ADDRESS = 0x80200000;
5. SECTIONS
6. {
7.     . = BASE_ADDRESS;
8.     skernel = .;
10.     stext = .;
11.     .text : {
12.         *(.text.entry)
13.         . = ALIGN(4K);
14.         strampoline = .;
15.         *(.text.trampoline);
16.         . = ALIGN(4K);
17.         *(.text .text.*)
18.     }
20.     . = ALIGN(4K);
21.     etext = .;
22.     srodata = .;
23.     .rodata : {
24.         *(.rodata .rodata.*)
25.         *(.srodata .srodata.*)
26.     }
28.     . = ALIGN(4K);
29.     erodata = .;
30.     sdata = .;
31.     .data : {
32.         *(.data .data.*)
33.         *(.sdata .sdata.*)
34.     }
36.     . = ALIGN(4K);
37.     edata = .;
38.     sbss_with_stack = .;
39.     .bss : {
40.         *(.bss.stack)
41.         sbss = .;
42.         *(.bss .bss.*)
43.         *(.sbss .sbss.*)
44.     }
46.     . = ALIGN(4K);
47.     ebss = .;
48.     ekernel = .;
50.     /DISCARD/ : {
51.         *(.eh_frame)
52.     }
53. }

复制代码

可以看到我们可以分配的内从从ekernel开始,而从哪里结束取决于我们的物理设备,这里因为学习的是K210,那么选择的实际上是8MiB的内存,也就是从0x80000000到0x80800000.
这里在子模块os\src\boards\qemu.rs里有:

1. // os/src/config.rs
3. pub const MEMORY_END: usize = 0x80800000;

复制代码

那么我们在这里就是要实现一个页帧内存分配器来管理这段内存,首先我们先将初始地址和结束地址转换为页号:

实现代码:

1. // os\src\mm\frame_allocator.rs
2. pub struct StackFrameAllocator {
3.     current: usize,
4.     end: usize,
5.     recycled: Vec<usize>,
6. }
8. impl StackFrameAllocator {
9.     pub fn init(&mut self, l: PhysPageNum, r: PhysPageNum) {
10.         self.current = l.0;
11.         self.end = r.0;
12.     }
13. }
14. impl FrameAllocator for StackFrameAllocator {
15.     fn new() -> Self {
16.         Self {
17.             current: 0,
18.             end: 0,
19.             recycled: Vec::new(),
20.         }
21.     }
22.     fn alloc(&mut self) -> Option<PhysPageNum> {
23.         if let Some(ppn) = self.recycled.pop() {
24.             Some(ppn.into())
25.         } else if self.current == self.end {
26.             None
27.         } else {
28.             self.current += 1;
29.             Some((self.current - 1).into())
30.         }
31.     }
32.     fn dealloc(&mut self, ppn: PhysPageNum) {
33.         let ppn = ppn.0;
34.         // validity check
35.         if ppn >= self.current || self.recycled.iter().any(|&v| v == ppn) {
36.             panic!("Frame ppn={:#x} has not been allocated!", ppn);
37.         }
38.         // recycle
39.         self.recycled.push(ppn);
40.     }
41. }

复制代码

这里注意Vec的成功使用少不了前一部分的堆内存分配器.

为了保证每个物理页帧在被创建的时候清空页帧内容,在被销毁的时候能够自动回收.这里借用了RAII的思想.

RAII（Resource Acquisition Is Initialization） 资源和对象的声明周期一致的一种思想.
创建的时候初始化,Drop的时候进行回调
使用DropTrait来进行管理

为PhysPageNum创建一个包裹Tracker意为追踪器:

1. /// manage a frame which has the same lifecycle as the tracker
2. pub struct FrameTracker {
3.     pub ppn: PhysPageNum,
4. }
6. impl FrameTracker {
7.     pub fn new(ppn: PhysPageNum) -> Self {
8.         // page cleaning
9.         let bytes_array = ppn.get_bytes_array();
10.         for i in bytes_array {
11.             *i = 0;
12.         }
13.         Self { ppn }
14.     }
15. }
17. impl Debug for FrameTracker {
18.     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
19.         f.write_fmt(format_args!("FrameTracker:PPN={:#x}", self.ppn.0))
20.     }
21. }
23. impl Drop for FrameTracker {
24.     fn drop(&mut self) {
25.         frame_dealloc(self.ppn);
26.     }
27. }

复制代码

这里要注意,要想直接访问物理地址,必须是使用M特权级.
但是我们使用的是S和U特权级,因此,需要一个恒等映射来解决这个问题.
这里恒等映射,其实是存在一个小问题的因为我们物理地址正常是56位,但是虚拟地址是39位,理论上会出问题.
但是我们的内存从[0x8000_0000,0x8080_0000)恰好弥补了这一点,一共就涉及32位嘛.

如下图所示,恒等映射就是把PPN和VPN用下一节提到的map映射起来,可以看到8MiB的映射需要约16KiB的页表项(忽略一级和二级页表损耗), 这里总结下来就是原本大小除以512 就是页表项的损耗.

注意这个L1 3Bit,只能有000,001,010,011四种状态,要注意是左闭右开的区间,4*4KiB=16KiB.

建立和拆除虚实地址映射关系

实际上就是建立: 虚拟地址 -> 物理地址的接口和映射.

实现方法:

1. type FrameAllocatorImpl = StackFrameAllocator;
3. lazy_static! {
4.     /// frame allocator instance through lazy_static!
5.     pub static ref FRAME_ALLOCATOR: UPSafeCell<FrameAllocatorImpl> =
6.         unsafe { UPSafeCell::new(FrameAllocatorImpl::new()) };
7. }
9. /// initiate the frame allocator using `ekernel` and `MEMORY_END`
10. pub fn init_frame_allocator() {
11.     unsafe extern "C" {
12.         safe fn ekernel();
13.     }
14.     FRAME_ALLOCATOR.exclusive_access().init(
15.         PhysAddr::from(ekernel as usize).ceil(),
16.         PhysAddr::from(MEMORY_END).floor(),
17.     );
18. }
20. /// allocate a frame
21. pub fn frame_alloc() -> Option<FrameTracker> {
22.     FRAME_ALLOCATOR
23.         .exclusive_access()
24.         .alloc()
25.         .map(FrameTracker::new)
26. }
28. /// deallocate a frame
29. fn frame_dealloc(ppn: PhysPageNum) {
30.     FRAME_ALLOCATOR.exclusive_access().dealloc(ppn);
31. }

复制代码

对应的VPN转PPN的方法:

1. // os\src\mm\address.rs
2. impl PhysPageNum {
3.     pub fn get_pte_array(&self) -> &'static mut [PageTableEntry] {
4.         let pa: PhysAddr = (*self).into();
5.         unsafe { core::slice::from_raw_parts_mut(pa.0 as *mut PageTableEntry, 512) }
6.     }
7.     pub fn get_bytes_array(&self) -> &'static mut [u8] {
8.         let pa: PhysAddr = (*self).into();
9.         unsafe { core::slice::from_raw_parts_mut(pa.0 as *mut u8, 4096) }
10.     }
11.     pub fn get_mut<T>(&self) -> &'static mut T {
12.         let pa: PhysAddr = (*self).into();
13.         unsafe { (pa.0 as *mut T).as_mut().unwrap() }
14.     }
15. }

复制代码

同样地,如果只进行查找不进行创建,可以得到如下两个方法:

1. // os\src\mm\page_table.rs
2. fn find_pte_create(&mut self, vpn: VirtPageNum) -> Option<&mut PageTableEntry> {
3.         let idxs = vpn.indexes();
4.         let mut ppn = self.root_ppn;
5.         let mut result: Option<&mut PageTableEntry> = None;
6.         for (i, idx) in idxs.iter().enumerate() {
7.             let pte = &mut ppn.get_pte_array()[*idx];
8.             if i == 2 {
9.                 result = Some(pte);
10.                 break;
11.             }
12.             if !pte.is_valid() {
13.                 let frame = frame_alloc().unwrap();
14.                 *pte = PageTableEntry::new(frame.ppn, PTEFlags::V);
15.                 self.frames.push(frame);
16.             }
17.             ppn = pte.ppn();
18.         }
19.         result
20.     }

复制代码

总结

如果把kernel当作一个软件来看,基本的内存分配目前是如下图所示的:

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！